---

yaml
---
r: 11187
b: refs/heads/master
c: 48eda22
h: refs/heads/master
i:
  11185: 69ead63
  11183: 47cfe4c
v: v3

Author: kevina

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 17110fb28bf7e73fbefc05a1d112e2203bd5e7de
+refs/heads/master: 48eda22835e58ec1f14f6333e444ccc8a32244b7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/configure

@@ -262,7 +262,6 @@ opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
-opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 opt manage-submodules 1 "let the build manage the git submodules"
 opt mingw-cross 0 "cross-compile for win32 using mingw"
 opt clang 0 "prefer clang to gcc for building the runtime"

trunk/mk/llvm.mk

@@ -1,15 +1,10 @@
-
-ifdef CFG_ENABLE_FAST_MAKE
-LLVM_DEPS := $(S)/.gitmodules
-else
 # Recursive wildcard function
 # http://blog.jgc.org/2011/07/gnu-make-recursive-wildcard-function.html
 rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) \
   $(filter $(subst *,%,$2),$d))
 
 # This is just a rough approximation of LLVM deps
 LLVM_DEPS=$(call rwildcard,$(CFG_LLVM_SRC_DIR),*cpp *hpp)
-endif
 
 define DEF_LLVM_RULES
 

trunk/mk/rt.mk

@@ -158,18 +158,11 @@ rt/$(1)/$(CFG_RUNTIME): $$(RUNTIME_OBJS_$(1)) $$(MKFILE_DEPS) \
 # FIXME: For some reason libuv's makefiles can't figure out the correct definition
 # of CC on the mingw I'm using, so we are explicitly using gcc. Also, we
 # have to list environment variables first on windows... mysterious
-
-ifdef CFG_ENABLE_FAST_MAKE
-LIBUV_DEPS := $$(S)/.gitmodules
-else
-LIBUV_DEPS := $$(wildcard \
-              $$(S)src/libuv/* \
-              $$(S)src/libuv/*/* \
-              $$(S)src/libuv/*/*/* \
-              $$(S)src/libuv/*/*/*/*)
-endif
-
-$$(LIBUV_LIB_$(1)): $$(LIBUV_DEPS)
+$$(LIBUV_LIB_$(1)): $$(wildcard \
+                     $$(S)src/libuv/* \
+                     $$(S)src/libuv/*/* \
+                     $$(S)src/libuv/*/*/* \
+                     $$(S)src/libuv/*/*/*/*)
 	$$(Q)$$(MAKE) -C $$(S)mk/libuv/$$(LIBUV_ARCH_$(1))/$$(LIBUV_OSTYPE_$(1)) \
 		CFLAGS="$$(LIBUV_FLAGS_$$(HOST_$(1)))" \
         LDFLAGS="$$(LIBUV_FLAGS_$$(HOST_$(1)))" \

trunk/src/comp/driver/diagnostic.rs

@@ -175,6 +175,7 @@ fn emit(cmsp: option<(codemap::codemap, span)>,
         msg: str, lvl: level) {
     alt cmsp {
       some((cm, sp)) {
+        let sp = codemap::adjust_span(cm,sp);
         let ss = codemap::span_to_str(sp, cm);
         let lines = codemap::span_to_lines(sp, cm);
         print_diagnostic(ss, lvl, msg);

trunk/src/comp/syntax/codemap.rs

@@ -8,8 +8,11 @@ type file_pos = {ch: uint, byte: uint};
  * compiler.
  */
 
-type file_substr_ = {lo: uint, hi: uint, col: uint, line: uint};
-type file_substr = option<file_substr_>;
+enum file_substr {
+    fss_none,
+    fss_internal(span),
+    fss_external({filename: str, line: uint, col: uint})
+}
 
 type filemap =
     @{name: filename, substr: file_substr, src: @str,
@@ -33,16 +36,14 @@ fn new_filemap_w_substr(filename: filename, substr: file_substr,
 fn new_filemap(filename: filename, src: @str,
                start_pos_ch: uint, start_pos_byte: uint)
     -> filemap {
-    ret new_filemap_w_substr(filename, none, src,
+    ret new_filemap_w_substr(filename, fss_none, src,
                              start_pos_ch, start_pos_byte);
 }
 
-fn get_substr_info(cm: codemap, lo: uint, hi: uint)
-    -> (filename, file_substr_)
+fn mk_substr_filename(cm: codemap, sp: span) -> str
 {
-    let pos = lookup_char_pos(cm, lo);
-    let name = #fmt("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
-    ret (name, {lo: lo, hi: hi, col: pos.col, line: pos.line});
+    let pos = lookup_char_pos(cm, sp.lo);
+    ret #fmt("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
 }
 
 fn next_line(file: filemap, chpos: uint, byte_pos: uint) {
@@ -89,26 +90,66 @@ fn lookup_byte_pos(map: codemap, pos: uint) -> loc {
     ret lookup_pos(map, pos, lookup);
 }
 
+fn lookup_char_pos_adj(map: codemap, pos: uint)
+    -> {filename: str, line: uint, col: uint, file: option<filemap>}
+{
+    let loc = lookup_char_pos(map, pos);
+    alt (loc.file.substr) {
+      fss_none {
+        {filename: loc.file.name, line: loc.line, col: loc.col,
+         file: some(loc.file)}
+      }
+      fss_internal(sp) {
+        lookup_char_pos_adj(map, sp.lo + (pos - loc.file.start_pos.ch))
+      }
+      fss_external(eloc) {
+        {filename: eloc.filename,
+         line: eloc.line + loc.line - 1u,
+         col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
+         file: none}
+      }
+    }
+}
+
+fn adjust_span(map: codemap, sp: span) -> span {
+    fn lookup(pos: file_pos) -> uint { ret pos.ch; }
+    let line = lookup_line(map, sp.lo, lookup);
+    alt (line.fm.substr) {
+      fss_none {sp}
+      fss_internal(s) {
+        adjust_span(map, {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
+                          hi: s.lo + (sp.hi - line.fm.start_pos.ch),
+                          expn_info: sp.expn_info})}
+      fss_external(_) {sp}
+    }
+}
+
 enum expn_info_ {
     expanded_from({call_site: span,
                    callie: {name: str, span: option<span>}})
 }
 type expn_info = option<@expn_info_>;
 type span = {lo: uint, hi: uint, expn_info: expn_info};
 
-fn span_to_str(sp: span, cm: codemap) -> str {
+fn span_to_str_no_adj(sp: span, cm: codemap) -> str {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     ret #fmt("%s:%u:%u: %u:%u", lo.file.name,
              lo.line, lo.col, hi.line, hi.col)
 }
 
+fn span_to_str(sp: span, cm: codemap) -> str {
+    let lo = lookup_char_pos_adj(cm, sp.lo);
+    let hi = lookup_char_pos_adj(cm, sp.hi);
+    ret #fmt("%s:%u:%u: %u:%u", lo.filename,
+             lo.line, lo.col, hi.line, hi.col)
+}
+
 type file_lines = {file: filemap, lines: [uint]};
 
 fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
-    // FIXME: Check for filemap?
     let lines = [];
     uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
     ret @{file: lo.file, lines: lines};

trunk/src/comp/syntax/ext/expand.rs

@@ -5,7 +5,7 @@ import std::map::hashmap;
 import syntax::ast::{crate, expr_, expr_mac, mac_invoc};
 import syntax::fold::*;
 import syntax::ext::base::*;
-import syntax::ext::qquote::{expand_qquote,qq_helper};
+import syntax::ext::qquote::{qq_helper};
 import syntax::parse::parser::parse_expr_from_source_str;
 
 import codemap::{span, expanded_from};

trunk/src/comp/syntax/ext/qquote.rs

@@ -143,19 +143,6 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
         }
     }
     let body = get_mac_body(ecx,_sp,body);
-    fn finish<T: qq_helper>(ecx: ext_ctxt, body: ast::mac_body_,
-                            f: fn (p: parser) -> T)
-        -> @ast::expr
-    {
-        let cm = ecx.session().parse_sess.cm;
-        let str = @codemap::span_to_snippet(body.span, cm);
-        let (fname, ss) = codemap::get_substr_info
-            (cm, body.span.lo, body.span.hi);
-        let node = parse_from_source_str
-            (f, fname, some(ss), str,
-             ecx.session().opts.cfg, ecx.session().parse_sess);
-        ret expand_qquote(ecx, node.span(), *str, node);
-    }
 
     ret alt what {
       "expr" {finish(ecx, body, parser::parse_expr)}
@@ -182,23 +169,33 @@ fn parse_item(p: parser) -> @ast::item {
     }
 }
 
-fn expand_qquote<N: qq_helper>
-    (ecx: ext_ctxt, sp: span, str: str, node: N)
+fn finish<T: qq_helper>
+    (ecx: ext_ctxt, body: ast::mac_body_, f: fn (p: parser) -> T)
     -> @ast::expr
 {
+    let cm = ecx.session().parse_sess.cm;
+    let str = @codemap::span_to_snippet(body.span, cm);
+    let fname = codemap::mk_substr_filename(cm, body.span);
+    let node = parse_from_source_str
+        (f, fname, codemap::fss_internal(body.span), str,
+         ecx.session().opts.cfg, ecx.session().parse_sess);
+    let loc = codemap::lookup_char_pos(cm, body.span.lo);
+
+    let sp = node.span();
     let qcx = gather_anti_quotes(sp.lo, node);
     let cx = qcx;
-    let prev = 0u;
-    for {lo: lo, _} in cx.gather {
-        assert lo > prev;
-        prev = lo;
+
+    // assert that the vector is sorted by position:
+    uint::range(1u, vec::len(cx.gather)) {|i|
+        assert cx.gather[i-1u].lo < cx.gather[i].lo;
     }
+
     let str2 = "";
     enum state {active, skip(uint), blank};
     let state = active;
     let i = 0u, j = 0u;
     let g_len = vec::len(cx.gather);
-    str::chars_iter(str) {|ch|
+    str::chars_iter(*str) {|ch|
         if (j < g_len && i == cx.gather[j].lo) {
             assert ch == '$';
             let repl = #fmt("$%u ", j);
@@ -228,8 +225,12 @@ fn expand_qquote<N: qq_helper>
                        ["syntax", "parse", "parser",
                         "parse_from_source_str"],
                        [node.mk_parse_fn(cx,sp),
-                        mk_str(cx,sp, "<anon>"),
-                        mk_path(cx,sp, ["option","none"]),
+                        mk_str(cx,sp, fname),
+                        mk_call(cx,sp,
+                                ["syntax","ext","qquote", "mk_file_substr"],
+                                [mk_str(cx,sp, loc.file.name),
+                                 mk_uint(cx,sp, loc.line),
+                                 mk_uint(cx,sp, loc.col)]),
                         mk_unary(cx,sp, ast::box(ast::imm),
                                  mk_str(cx,sp, str2)),
                         mk_access_(cx,sp,
@@ -306,6 +307,10 @@ fn print_expr(expr: @ast::expr) {
     stdout.write_str("\n");
 }
 
+fn mk_file_substr(fname: str, line: uint, col: uint) -> codemap::file_substr {
+    codemap::fss_external({filename: fname, line: line, col: col})
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;

trunk/src/comp/syntax/parse/lexer.rs

@@ -43,7 +43,13 @@ impl reader for reader {
             let next = str::char_range_at(*self.src, self.pos);
             self.pos = next.next;
             self.curr = next.ch;
-        } else { self.curr = -1 as char; }
+        } else {
+            if (self.curr != -1 as char) {
+                self.col += 1u;
+                self.chpos += 1u;
+                self.curr = -1 as char;
+            }
+        }
     }
     fn fatal(m: str) -> ! {
         self.span_diagnostic.span_fatal(

trunk/src/comp/syntax/parse/parser.rs

@@ -2,7 +2,7 @@ import std::{io, fs};
 import either::{left, right};
 import std::map::{hashmap, new_str_hash};
 import token::can_begin_expr;
-import codemap::span;
+import codemap::{span,fss_none};
 import util::interner;
 import ast::{node_id, spanned};
 import ast_util::{mk_sp, ident_to_path};
@@ -2607,7 +2607,7 @@ fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
 
 fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                               sess: parse_sess) -> @ast::expr {
-    let p = new_parser_from_source_str(sess, cfg, name, none, source);
+    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
     let r = parse_expr(p);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
@@ -2629,7 +2629,7 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T,
 
 fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                                sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_source_str(sess, cfg, name, none, source);
+    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
     let r = parse_crate_mod(p, cfg);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;

trunk/src/rt/rust_stack.cpp

@@ -3,15 +3,17 @@
 #include "vg/valgrind.h"
 #include "vg/memcheck.h"
 
+// A value that goes at the end of the stack and must not be touched
+const uint8_t stack_canary[] = {0xAB, 0xCD, 0xAB, 0xCD,
+                                0xAB, 0xCD, 0xAB, 0xCD,
+                                0xAB, 0xCD, 0xAB, 0xCD,
+                                0xAB, 0xCD, 0xAB, 0xCD};
+
 void
-register_valgrind_stack(stk_seg *stk) {
+config_valgrind_stack(stk_seg *stk) {
     stk->valgrind_id =
         VALGRIND_STACK_REGISTER(&stk->data[0],
                                 stk->end);
-}
-
-void
-prepare_valgrind_stack(stk_seg *stk) {
 #ifndef NVALGRIND
     // Establish that the stack is accessible.  This must be done when reusing
     // old stack segments, since the act of popping the stack previously
@@ -23,7 +25,7 @@ prepare_valgrind_stack(stk_seg *stk) {
 }
 
 void
-deregister_valgrind_stack(stk_seg *stk) {
+unconfig_valgrind_stack(stk_seg *stk) {
     VALGRIND_STACK_DEREGISTER(stk->valgrind_id);
 }
 

trunk/src/rt/rust_stack.h

@@ -13,49 +13,31 @@ struct stk_seg {
     uint8_t data[];
 };
 
-// A value that goes at the end of the stack and must not be touched
-const uint8_t stack_canary[] = {0xAB, 0xCD, 0xAB, 0xCD,
-                                0xAB, 0xCD, 0xAB, 0xCD,
-                                0xAB, 0xCD, 0xAB, 0xCD,
-                                0xAB, 0xCD, 0xAB, 0xCD};
-
-// Used by create_stack
-void
-register_valgrind_stack(stk_seg *stk);
-
-// Used by destroy_stack
-void
-deregister_valgrind_stack(stk_seg *stk);
-
-// Used by create_stack
-void
-add_stack_canary(stk_seg *stk);
-
 template <class T>
 stk_seg *
 create_stack(T allocer, size_t sz) {
-  size_t total_sz = sizeof(stk_seg) + sz + sizeof(stack_canary);
+  size_t total_sz = sizeof(stk_seg) + sz;
   stk_seg *stk = (stk_seg *)allocer->malloc(total_sz, "stack");
   memset(stk, 0, sizeof(stk_seg));
   stk->end = (uintptr_t) &stk->data[sz];
-  add_stack_canary(stk);
-  register_valgrind_stack(stk);
   return stk;
 }
 
 template <class T>
 void
 destroy_stack(T allocer, stk_seg *stk) {
-  deregister_valgrind_stack(stk);
   allocer->free(stk);
 }
 
-// Must be called before each time a stack is reused to tell valgrind
-// that the stack is accessible.
 void
-prepare_valgrind_stack(stk_seg *stk);
+config_valgrind_stack(stk_seg *stk);
+
+void
+unconfig_valgrind_stack(stk_seg *stk);
+
+void
+add_stack_canary(stk_seg *stk);
 
-// Run a sanity check
 void
 check_stack_canary(stk_seg *stk);