Give the lexer a session so that it can fail more informatively

brson · brson · commit a459bcd12722 · 2011-05-11T23:04:16.000-04:00
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
@@ -123,7 +123,7 @@ fn pretty_print_input(session.session sess,
     auto def = tup(ast.local_crate, 0);
     auto p = front.parser.new_parser(sess, env, def, input, 0u);
     auto crate = front.parser.parse_crate_from_source_file(p);
-    pretty.pprust.print_file(crate.node.module, input, std.IO.stdout());
+    pretty.pprust.print_file(sess, crate.node.module, input, std.IO.stdout());
 }
 
 fn version(str argv0) {
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
@@ -7,6 +7,7 @@ import std.Map.hashmap;
 import std.Option;
 import std.Option.some;
 import std.Option.none;
+import driver.session.session;
 import util.common;
 import util.common.new_str_hash;
 
@@ -24,11 +25,14 @@ state type reader = state obj {
     fn get_keywords() -> hashmap[str,token.token];
     fn get_reserved() -> hashmap[str,()];
     fn get_filemap() -> codemap.filemap;
+    fn err(str m);
 };
 
-fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)
-    -> reader {
-    state obj reader(str file,
+fn new_reader(session sess, IO.reader rdr, str filename,
+              codemap.filemap filemap) -> reader {
+
+    state obj reader(session sess,
+                     str file,
                      uint len,
                      mutable uint pos,
                      mutable char ch,
@@ -98,10 +102,14 @@ fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)
         fn get_filemap() -> codemap.filemap {
             ret fm;
         }
+
+        fn err(str m) {
+            sess.span_err(rec(lo=chpos, hi=chpos), m);
+        }
     }
     auto file = Str.unsafe_from_bytes(rdr.read_whole_stream());
     let vec[str] strs = vec();
-    auto rd = reader(file, Str.byte_len(file), 0u, -1 as char,
+    auto rd = reader(sess, file, Str.byte_len(file), 0u, -1 as char,
                      filemap.start_pos, filemap.start_pos,
                      strs, keyword_table(),
                      reserved_word_table(),
@@ -333,7 +341,7 @@ fn consume_block_comment(reader rdr) {
             }
         }
         if (rdr.is_eof()) {
-            log_err "unterminated block comment";
+            rdr.err("unterminated block comment");
             fail;
         }
     }
@@ -371,7 +379,7 @@ fn scan_exponent(reader rdr) -> Option.t[str] {
             ret(some(res + exponent));
         }
         else {
-            log_err ("scan_exponent: bad fp literal");
+            rdr.err("scan_exponent: bad fp literal");
             fail;
         }
     }
@@ -550,7 +558,7 @@ fn scan_numeric_escape(reader rdr) -> char {
         case ('u') { n_hex_digits = 4; }
         case ('U') { n_hex_digits = 8; }
         case (?c) {
-            log_err #fmt("unknown numeric character escape: %d", c as int);
+            rdr.err(#fmt("unknown numeric character escape: %d", c as int));
             fail;
         }
     }
@@ -562,7 +570,7 @@ fn scan_numeric_escape(reader rdr) -> char {
 
     while (n_hex_digits != 0) {
         if (!is_hex_digit(n)) {
-            log_err #fmt("illegal numeric character escape: %d", n as int);
+            rdr.err(#fmt("illegal numeric character escape: %d", n as int));
             fail;
         }
         accum_int *= 16;
@@ -603,7 +611,7 @@ fn next_token(reader rdr) -> token.token {
 
         auto rsvd = rdr.get_reserved();
         if (rsvd.contains_key(accum_str)) {
-            log_err #fmt("reserved keyword: %s", accum_str);
+            rdr.err(#fmt("reserved keyword: %s", accum_str));
             fail;
         }
 
@@ -726,16 +734,16 @@ fn next_token(reader rdr) -> token.token {
                     case ('U') { c2 = scan_numeric_escape(rdr); }
 
                     case (?c2) {
-                        log_err #fmt("unknown character escape: %d",
-                                     c2 as int);
+                        rdr.err(#fmt("unknown character escape: %d",
+                                     c2 as int));
                         fail;
                     }
                 }
                 rdr.bump();
             }
 
             if (rdr.next() != '\'') {
-                log_err "unterminated character constant";
+                rdr.err("unterminated character constant");
                 fail;
             }
             rdr.bump(); // advance curr to closing '
@@ -786,8 +794,8 @@ fn next_token(reader rdr) -> token.token {
                             }
 
                             case (?c2) {
-                                log_err #fmt("unknown string escape: %d",
-                                             c2 as int);
+                                rdr.err(#fmt("unknown string escape: %d",
+                                             c2 as int));
                                 fail;
                             }
                         }
@@ -853,7 +861,7 @@ fn next_token(reader rdr) -> token.token {
         }
 
         case (?c) {
-            log_err #fmt("unkown start of token: %d", c as int);
+            rdr.err(#fmt("unkown start of token: %d", c as int));
             fail;
         }
     }
@@ -917,16 +925,19 @@ fn read_block_comment(reader rdr) -> cmnt {
             Str.push_char(val, rdr.curr());
             rdr.bump();
         }
-        if (rdr.is_eof()) {fail;}
+        if (rdr.is_eof()) {
+            rdr.err("Unexpected end of file in block comment");
+            fail;
+        }
     }
     ret rec(val=cmnt_block(lines),
             pos=p,
             space_after=consume_whitespace(rdr) > 1u);
 }
 
-fn gather_comments(str path) -> vec[cmnt] {
+fn gather_comments(session sess, str path) -> vec[cmnt] {
     auto srdr = IO.file_reader(path);
-    auto rdr = new_reader(srdr, path, codemap.new_filemap(path, 0u));
+    auto rdr = new_reader(sess, srdr, path, codemap.new_filemap(path, 0u));
     let vec[cmnt] comments = vec();
     while (!rdr.is_eof()) {
         while (true) {
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
@@ -142,7 +142,7 @@ fn new_parser(session.session sess,
     auto srdr = IO.file_reader(path);
     auto filemap = codemap.new_filemap(path, pos);
     Vec.push[codemap.filemap](sess.get_codemap().files, filemap);
-    auto rdr = lexer.new_reader(srdr, path, filemap);
+    auto rdr = lexer.new_reader(sess, srdr, path, filemap);
     // Make sure npos points at first actual token.
     lexer.consume_any_whitespace(rdr);
     auto npos = rdr.get_chpos();
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
@@ -2,6 +2,7 @@ import std.Vec;
 import std.Str;
 import std.IO;
 import std.Option;
+import driver.session.session;
 import front.ast;
 import front.lexer;
 import util.common;
@@ -15,8 +16,8 @@ type ps = @rec(pp.ps s,
                Option.t[vec[lexer.cmnt]] comments,
                mutable uint cur_cmnt);
 
-fn print_file(ast._mod _mod, str filename, IO.writer out) {
-    auto cmnts = lexer.gather_comments(filename);
+fn print_file(session sess, ast._mod _mod, str filename, IO.writer out) {
+    auto cmnts = lexer.gather_comments(sess, filename);
     auto s = @rec(s=pp.mkstate(out, default_columns),
                   comments=Option.some[vec[lexer.cmnt]](cmnts),
                   mutable cur_cmnt=0u);

Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ fn pretty_print_input(session.session sess,`
`123`	`123`	`auto def = tup(ast.local_crate, 0);`
`124`	`124`	`auto p = front.parser.new_parser(sess, env, def, input, 0u);`
`125`	`125`	`auto crate = front.parser.parse_crate_from_source_file(p);`
`126`		`- pretty.pprust.print_file(crate.node.module, input, std.IO.stdout());`
	`126`	`+ pretty.pprust.print_file(sess, crate.node.module, input, std.IO.stdout());`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`fn version(str argv0) {`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ import std.Map.hashmap;`
`7`	`7`	`import std.Option;`
`8`	`8`	`import std.Option.some;`
`9`	`9`	`import std.Option.none;`
	`10`	`+import driver.session.session;`
`10`	`11`	`import util.common;`
`11`	`12`	`import util.common.new_str_hash;`
`12`	`13`
`@@ -24,11 +25,14 @@ state type reader = state obj {`
`24`	`25`	`fn get_keywords() -> hashmap[str,token.token];`
`25`	`26`	`fn get_reserved() -> hashmap[str,()];`
`26`	`27`	`fn get_filemap() -> codemap.filemap;`
	`28`	`+ fn err(str m);`
`27`	`29`	`};`
`28`	`30`
`29`		`-fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)`
`30`		`- -> reader {`
`31`		`- state obj reader(str file,`
	`31`	`+fn new_reader(session sess, IO.reader rdr, str filename,`
	`32`	`+ codemap.filemap filemap) -> reader {`
	`33`	`+`
	`34`	`+ state obj reader(session sess,`
	`35`	`+ str file,`
`32`	`36`	`uint len,`
`33`	`37`	`mutable uint pos,`
`34`	`38`	`mutable char ch,`
`@@ -98,10 +102,14 @@ fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)`
`98`	`102`	`fn get_filemap() -> codemap.filemap {`
`99`	`103`	`ret fm;`
`100`	`104`	`}`
	`105`	`+`
	`106`	`+ fn err(str m) {`
	`107`	`+ sess.span_err(rec(lo=chpos, hi=chpos), m);`
	`108`	`+ }`
`101`	`109`	`}`
`102`	`110`	`auto file = Str.unsafe_from_bytes(rdr.read_whole_stream());`
`103`	`111`	`let vec[str] strs = vec();`
`104`		`- auto rd = reader(file, Str.byte_len(file), 0u, -1 as char,`
	`112`	`+ auto rd = reader(sess, file, Str.byte_len(file), 0u, -1 as char,`
`105`	`113`	`filemap.start_pos, filemap.start_pos,`
`106`	`114`	`strs, keyword_table(),`
`107`	`115`	`reserved_word_table(),`
`@@ -333,7 +341,7 @@ fn consume_block_comment(reader rdr) {`
`333`	`341`	`}`
`334`	`342`	`}`
`335`	`343`	`if (rdr.is_eof()) {`
`336`		`- log_err "unterminated block comment";`
	`344`	`+ rdr.err("unterminated block comment");`
`337`	`345`	`fail;`
`338`	`346`	`}`
`339`	`347`	`}`
`@@ -371,7 +379,7 @@ fn scan_exponent(reader rdr) -> Option.t[str] {`
`371`	`379`	`ret(some(res + exponent));`
`372`	`380`	`}`
`373`	`381`	`else {`
`374`		`- log_err ("scan_exponent: bad fp literal");`
	`382`	`+ rdr.err("scan_exponent: bad fp literal");`
`375`	`383`	`fail;`
`376`	`384`	`}`
`377`	`385`	`}`
`@@ -550,7 +558,7 @@ fn scan_numeric_escape(reader rdr) -> char {`
`550`	`558`	`case ('u') { n_hex_digits = 4; }`
`551`	`559`	`case ('U') { n_hex_digits = 8; }`
`552`	`560`	`case (?c) {`
`553`		`- log_err #fmt("unknown numeric character escape: %d", c as int);`
	`561`	`+ rdr.err(#fmt("unknown numeric character escape: %d", c as int));`
`554`	`562`	`fail;`
`555`	`563`	`}`
`556`	`564`	`}`
`@@ -562,7 +570,7 @@ fn scan_numeric_escape(reader rdr) -> char {`
`562`	`570`
`563`	`571`	`while (n_hex_digits != 0) {`
`564`	`572`	`if (!is_hex_digit(n)) {`
`565`		`- log_err #fmt("illegal numeric character escape: %d", n as int);`
	`573`	`+ rdr.err(#fmt("illegal numeric character escape: %d", n as int));`
`566`	`574`	`fail;`
`567`	`575`	`}`
`568`	`576`	`accum_int *= 16;`
`@@ -603,7 +611,7 @@ fn next_token(reader rdr) -> token.token {`
`603`	`611`
`604`	`612`	`auto rsvd = rdr.get_reserved();`
`605`	`613`	`if (rsvd.contains_key(accum_str)) {`
`606`		`- log_err #fmt("reserved keyword: %s", accum_str);`
	`614`	`+ rdr.err(#fmt("reserved keyword: %s", accum_str));`
`607`	`615`	`fail;`
`608`	`616`	`}`
`609`	`617`
`@@ -726,16 +734,16 @@ fn next_token(reader rdr) -> token.token {`
`726`	`734`	`case ('U') { c2 = scan_numeric_escape(rdr); }`
`727`	`735`
`728`	`736`	`case (?c2) {`
`729`		`- log_err #fmt("unknown character escape: %d",`
`730`		`- c2 as int);`
	`737`	`+ rdr.err(#fmt("unknown character escape: %d",`
	`738`	`+ c2 as int));`
`731`	`739`	`fail;`
`732`	`740`	`}`
`733`	`741`	`}`
`734`	`742`	`rdr.bump();`
`735`	`743`	`}`
`736`	`744`
`737`	`745`	`if (rdr.next() != '\'') {`
`738`		`- log_err "unterminated character constant";`
	`746`	`+ rdr.err("unterminated character constant");`
`739`	`747`	`fail;`
`740`	`748`	`}`
`741`	`749`	`rdr.bump(); // advance curr to closing '`
`@@ -786,8 +794,8 @@ fn next_token(reader rdr) -> token.token {`
`786`	`794`	`}`
`787`	`795`
`788`	`796`	`case (?c2) {`
`789`		`- log_err #fmt("unknown string escape: %d",`
`790`		`- c2 as int);`
	`797`	`+ rdr.err(#fmt("unknown string escape: %d",`
	`798`	`+ c2 as int));`
`791`	`799`	`fail;`
`792`	`800`	`}`
`793`	`801`	`}`
`@@ -853,7 +861,7 @@ fn next_token(reader rdr) -> token.token {`
`853`	`861`	`}`
`854`	`862`
`855`	`863`	`case (?c) {`
`856`		`- log_err #fmt("unkown start of token: %d", c as int);`
	`864`	`+ rdr.err(#fmt("unkown start of token: %d", c as int));`
`857`	`865`	`fail;`
`858`	`866`	`}`
`859`	`867`	`}`
`@@ -917,16 +925,19 @@ fn read_block_comment(reader rdr) -> cmnt {`
`917`	`925`	`Str.push_char(val, rdr.curr());`
`918`	`926`	`rdr.bump();`
`919`	`927`	`}`
`920`		`- if (rdr.is_eof()) {fail;}`
	`928`	`+ if (rdr.is_eof()) {`
	`929`	`+ rdr.err("Unexpected end of file in block comment");`
	`930`	`+ fail;`
	`931`	`+ }`
`921`	`932`	`}`
`922`	`933`	`ret rec(val=cmnt_block(lines),`
`923`	`934`	`pos=p,`
`924`	`935`	`space_after=consume_whitespace(rdr) > 1u);`
`925`	`936`	`}`
`926`	`937`
`927`		`-fn gather_comments(str path) -> vec[cmnt] {`
	`938`	`+fn gather_comments(session sess, str path) -> vec[cmnt] {`
`928`	`939`	`auto srdr = IO.file_reader(path);`
`929`		`- auto rdr = new_reader(srdr, path, codemap.new_filemap(path, 0u));`
	`940`	`+ auto rdr = new_reader(sess, srdr, path, codemap.new_filemap(path, 0u));`
`930`	`941`	`let vec[cmnt] comments = vec();`
`931`	`942`	`while (!rdr.is_eof()) {`
`932`	`943`	`while (true) {`