Move to single-uint file-position representation.

This makes passing them around cheaper. There is now a table (see
front/codemap.rs) that is needed to transform such an uint into an
actual filename/line/col location.

Also cleans up the span building in the parser a bit.

Author: marijnh

src/comp/driver/rustc.rs

@@ -62,7 +62,7 @@ impure fn compile_input(session.session sess,
                         bool parse_only,
                         vec[str] library_search_paths) {
     auto def = tup(0, 0);
-    auto p = parser.new_parser(sess, env, def, input);
+    auto p = parser.new_parser(sess, env, def, input, 0u);
     auto crate = parse_input(sess, p, input);
     if (parse_only) {ret;}
     crate = creader.read_crates(sess, crate, library_search_paths);
@@ -79,7 +79,7 @@ impure fn pretty_print_input(session.session sess,
                              eval.env env,
                              str input) {
     auto def = tup(0, 0);
-    auto p = front.parser.new_parser(sess, env, def, input);
+    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());
 }
@@ -125,7 +125,8 @@ impure fn main(vec[str] args) {
 
     auto crate_cache = common.new_int_hash[session.crate_metadata]();
     auto target_crate_num = 0;
-    auto sess = session.session(target_crate_num, target_cfg, crate_cache);
+    auto sess = session.session(target_crate_num, target_cfg, crate_cache,
+                                front.codemap.new_codemap());
 
     let option.t[str] input_file = none[str];
     let option.t[str] output_file = none[str];

src/comp/driver/session.rs

@@ -1,4 +1,5 @@
 import front.ast;
+import front.codemap;
 import util.common.span;
 import util.common.ty_mach;
 import std._uint;
@@ -25,7 +26,8 @@ type cfg = rec(os os,
 type crate_metadata = vec[u8];
 
 obj session(ast.crate_num cnum, cfg targ,
-            map.hashmap[int, crate_metadata] crates) {
+            map.hashmap[int, crate_metadata] crates,
+            codemap.codemap cm) {
 
     fn get_targ_cfg() -> cfg {
         ret targ;
@@ -36,10 +38,12 @@ obj session(ast.crate_num cnum, cfg targ,
     }
 
     fn span_err(span sp, str msg) {
+        auto lo = codemap.lookup_pos(cm, sp.lo);
+        auto hi = codemap.lookup_pos(cm, sp.hi);
         log #fmt("%s:%u:%u:%u:%u: error: %s",
-                 sp.filename,
-                 sp.lo.line, sp.lo.col,
-                 sp.hi.line, sp.hi.col,
+                 lo.filename,
+                 lo.line, lo.col,
+                 hi.line, hi.col,
                  msg);
         fail;
     }
@@ -50,10 +54,12 @@ obj session(ast.crate_num cnum, cfg targ,
     }
 
     fn span_warn(span sp, str msg) {
+        auto lo = codemap.lookup_pos(cm, sp.lo);
+        auto hi = codemap.lookup_pos(cm, sp.hi);
         log #fmt("%s:%u:%u:%u:%u: warning: %s",
-                 sp.filename,
-                 sp.lo.line, sp.lo.col,
-                 sp.hi.line, sp.hi.col,
+                 lo.filename,
+                 lo.line, lo.col,
+                 hi.line, hi.col,
                  msg);
     }
 
@@ -63,10 +69,12 @@ obj session(ast.crate_num cnum, cfg targ,
     }
 
     fn span_unimpl(span sp, str msg) {
+        auto lo = codemap.lookup_pos(cm, sp.lo);
+        auto hi = codemap.lookup_pos(cm, sp.hi);
         log #fmt("%s:%u:%u:%u:%u: error: unimplemented %s",
-                 sp.filename,
-                 sp.lo.line, sp.lo.col,
-                 sp.hi.line, sp.hi.col,
+                 lo.filename,
+                 lo.line, lo.col,
+                 hi.line, hi.col,
                  msg);
         fail;
     }
@@ -87,6 +95,14 @@ obj session(ast.crate_num cnum, cfg targ,
     fn has_external_crate(int num) -> bool {
         ret crates.contains_key(num);
     }
+
+    fn get_codemap() -> codemap.codemap {
+        ret cm;
+    }
+
+    fn lookup_pos(uint pos) -> codemap.loc {
+        ret codemap.lookup_pos(cm, pos);
+    }
 }
 
 

src/comp/front/codemap.rs

@@ -0,0 +1,65 @@
+import std._vec;
+
+/* A codemap is a thing that maps uints to file/line/column positions
+ * in a crate. This to make it possible to represent the positions
+ * with single-word things, rather than passing records all over the
+ * compiler.
+ */
+
+type filemap = @rec(str name,
+                    uint start_pos,
+                    mutable vec[uint] lines);
+type codemap = @rec(mutable vec[filemap] files);
+type loc = rec(str filename, uint line, uint col);
+
+fn new_codemap() -> codemap {
+    let vec[filemap] files = vec();
+    ret @rec(mutable files=files);
+}
+
+fn new_filemap(str filename, uint start_pos) -> filemap {
+    let vec[uint] lines = vec();
+    ret @rec(name=filename,
+             start_pos=start_pos,
+             mutable lines=lines);
+}
+
+fn next_line(filemap file, uint pos) {
+    _vec.push[uint](file.lines, pos);
+}
+
+fn lookup_pos(codemap map, uint pos) -> loc {
+    for (filemap f in map.files) {
+        if (f.start_pos < pos) {
+            auto line_num = 1u;
+            auto line_start = 0u;
+            // FIXME this can be a binary search if we need to be faster
+            for (uint line_start_ in f.lines) {
+                // FIXME duplicate code due to lack of working break
+                if (line_start_ > pos) {
+                    ret rec(filename=f.name,
+                            line=line_num,
+                            col=pos-line_start);
+                }
+                line_start = line_start_;
+                line_num += 1u;
+            }
+            ret rec(filename=f.name,
+                    line=line_num,
+                    col=pos-line_start);
+        }
+    }
+    log #fmt("Failed to find a location for character %u", pos);
+    fail;
+}
+
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+//