---

yaml
---
r: 11189
b: refs/heads/master
c: 36d5074
h: refs/heads/master
i:
  11187: 1ae4180
v: v3

Author: tedhorst

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 54875908607aeba57477e117a08e5f8f3611bf76
+refs/heads/master: 36d5074f8f402c13354bf67dc90fcc30f870a0e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/configure

@@ -262,6 +262,7 @@ 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,10 +1,15 @@
+
+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,11 +158,18 @@ 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
-$$(LIBUV_LIB_$(1)): $$(wildcard \
-                     $$(S)src/libuv/* \
-                     $$(S)src/libuv/*/* \
-                     $$(S)src/libuv/*/*/* \
-                     $$(S)src/libuv/*/*/*/*)
+
+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)
 	$$(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

@@ -159,23 +159,22 @@ fn diagnosticcolor(lvl: level) -> u8 {
 
 fn print_diagnostic(topic: str, lvl: level, msg: str) {
     if str::is_not_empty(topic) {
-        io::stdout().write_str(#fmt["%s ", topic]);
+        io::stderr().write_str(#fmt["%s ", topic]);
     }
     if term::color_supported() {
-        term::fg(io::stdout(), diagnosticcolor(lvl));
+        term::fg(io::stderr(), diagnosticcolor(lvl));
     }
-    io::stdout().write_str(#fmt["%s:", diagnosticstr(lvl)]);
+    io::stderr().write_str(#fmt["%s:", diagnosticstr(lvl)]);
     if term::color_supported() {
-        term::reset(io::stdout());
+        term::reset(io::stderr());
     }
-    io::stdout().write_str(#fmt[" %s\n", msg]);
+    io::stderr().write_str(#fmt[" %s\n", msg]);
 }
 
 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);
@@ -203,10 +202,10 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
     }
     // Print the offending lines
     for line: uint in display_lines {
-        io::stdout().write_str(#fmt["%s:%u ", fm.name, line + 1u]);
+        io::stderr().write_str(#fmt["%s:%u ", fm.name, line + 1u]);
         let s = codemap::get_line(fm, line as int);
         if !str::ends_with(s, "\n") { s += "\n"; }
-        io::stdout().write_str(s);
+        io::stderr().write_str(s);
     }
     if elided {
         let last_line = display_lines[vec::len(display_lines) - 1u];
@@ -215,7 +214,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
         let out = "";
         while indent > 0u { out += " "; indent -= 1u; }
         out += "...\n";
-        io::stdout().write_str(out);
+        io::stderr().write_str(out);
     }
 
 
@@ -240,7 +239,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
             let width = hi.col - lo.col - 1u;
             while width > 0u { str::push_char(s, '~'); width -= 1u; }
         }
-        io::stdout().write_str(s + "\n");
+        io::stderr().write_str(s + "\n");
     }
 }
 

trunk/src/comp/syntax/codemap.rs

@@ -8,11 +8,8 @@ type file_pos = {ch: uint, byte: uint};
  * compiler.
  */
 
-enum file_substr {
-    fss_none,
-    fss_internal(span),
-    fss_external({filename: str, line: uint, col: uint})
-}
+type file_substr_ = {lo: uint, hi: uint, col: uint, line: uint};
+type file_substr = option<file_substr_>;
 
 type filemap =
     @{name: filename, substr: file_substr, src: @str,
@@ -36,14 +33,16 @@ 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, fss_none, src,
+    ret new_filemap_w_substr(filename, none, src,
                              start_pos_ch, start_pos_byte);
 }
 
-fn mk_substr_filename(cm: codemap, sp: span) -> str
+fn get_substr_info(cm: codemap, lo: uint, hi: uint)
+    -> (filename, file_substr_)
 {
-    let pos = lookup_char_pos(cm, sp.lo);
-    ret #fmt("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
+    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});
 }
 
 fn next_line(file: filemap, chpos: uint, byte_pos: uint) {
@@ -90,66 +89,26 @@ 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_no_adj(sp: span, cm: codemap) -> str {
+fn span_to_str(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::{qq_helper};
+import syntax::ext::qquote::{expand_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,6 +143,19 @@ 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)}
@@ -169,33 +182,23 @@ fn parse_item(p: parser) -> @ast::item {
     }
 }
 
-fn finish<T: qq_helper>
-    (ecx: ext_ctxt, body: ast::mac_body_, f: fn (p: parser) -> T)
+fn expand_qquote<N: qq_helper>
+    (ecx: ext_ctxt, sp: span, str: str, node: N)
     -> @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;
-
-    // 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 prev = 0u;
+    for {lo: lo, _} in cx.gather {
+        assert lo > prev;
+        prev = 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);
@@ -225,12 +228,8 @@ fn finish<T: qq_helper>
                        ["syntax", "parse", "parser",
                         "parse_from_source_str"],
                        [node.mk_parse_fn(cx,sp),
-                        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_str(cx,sp, "<anon>"),
+                        mk_path(cx,sp, ["option","none"]),
                         mk_unary(cx,sp, ast::box(ast::imm),
                                  mk_str(cx,sp, str2)),
                         mk_access_(cx,sp,
@@ -307,10 +306,6 @@ 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,13 +43,7 @@ impl reader for reader {
             let next = str::char_range_at(*self.src, self.pos);
             self.pos = next.next;
             self.curr = next.ch;
-        } else {
-            if (self.curr != -1 as char) {
-                self.col += 1u;
-                self.chpos += 1u;
-                self.curr = -1 as char;
-            }
-        }
+        } else { 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,fss_none};
+import codemap::span;
 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, fss_none, source);
+    let p = new_parser_from_source_str(sess, cfg, name, none, source);
     let r = parse_expr(p);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
@@ -2622,17 +2622,14 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T,
 {
     let p = new_parser_from_source_str(sess, cfg, name, ss, source);
     let r = f(p);
-    if !p.reader.is_eof() {
-        p.reader.fatal("expected end-of-string");
-    }
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
 }
 
 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, fss_none, source);
+    let p = new_parser_from_source_str(sess, cfg, name, 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/compiletest/runtest.rs

@@ -198,7 +198,7 @@ fn check_error_patterns(props: test_props,
 
     let next_err_idx = 0u;
     let next_err_pat = props.error_patterns[next_err_idx];
-    for line: str in str::split_byte(procres.stdout, '\n' as u8) {
+    for line: str in str::split_byte(procres.stderr, '\n' as u8) {
         if str::find(line, next_err_pat) > 0 {
             #debug("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
@@ -245,7 +245,7 @@ fn check_expected_errors(expected_errors: [errors::expected_error],
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
-    for line: str in str::split_byte(procres.stdout, '\n' as u8) {
+    for line: str in str::split_byte(procres.stderr, '\n' as u8) {
         let was_expected = false;
         vec::iteri(expected_errors) {|i, ee|
             if !found_flags[i] {

trunk/src/rt/rust_srv.cpp

@@ -25,11 +25,7 @@ rust_srv::realloc(void *p, size_t bytes) {
 
 void
 rust_srv::log(char const *msg) {
-    printf("rust: %s\n", msg);
-    // FIXME: flushing each time is expensive, but at the moment
-    // necessary to get output through before a rust_task::fail
-    // call. This should be changed.
-    fflush(stdout);
+    fprintf(stderr, "rust: %s\n", msg);
 }
 
 void