---

yaml
---
r: 14184
b: refs/heads/try
c: 8e55d31
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: f9a63efb8214a36b13545b158bf27c1b6540b650
+refs/heads/try: 8e55d3130a1b8eab3b80c85e71a2a800fb9442f0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/comp/driver/diagnostic.rs

@@ -175,7 +175,6 @@ 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);

branches/try/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};

branches/try/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};

branches/try/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,19 +182,10 @@ 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;
     let prev = 0u;
@@ -194,7 +198,7 @@ fn finish<T: qq_helper>
     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);
@@ -224,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,
@@ -306,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;

branches/try/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(

branches/try/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;
@@ -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, 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;

branches/try/src/rt/rust_task_thread.cpp

@@ -13,13 +13,15 @@ pthread_key_t rust_task_thread::task_key;
 DWORD rust_task_thread::task_key;
 #endif
 
-const size_t C_STACK_SIZE = (1024*1024);
+const size_t SCHED_STACK_SIZE = 1024*100;
+const size_t C_STACK_SIZE = 1024*1024;
 
 bool rust_task_thread::tls_initialized = false;
 
 rust_task_thread::rust_task_thread(rust_scheduler *sched,
                                    rust_srv *srv,
                                    int id) :
+    rust_thread(SCHED_STACK_SIZE),
     ref_count(1),
     _log(srv, this),
     log_lvl(log_debug),

branches/try/src/rt/sync/rust_thread.cpp

@@ -1,7 +1,13 @@
 #include "globals.h"
 #include "rust_thread.h"
 
-rust_thread::rust_thread() : thread(0) {
+const size_t default_stack_sz = 1024*1024;
+
+rust_thread::rust_thread() : thread(0), stack_sz(default_stack_sz) {
+}
+
+rust_thread::rust_thread(size_t stack_sz)
+  : thread(0), stack_sz(stack_sz) {
 }
 
 rust_thread::~rust_thread() {
@@ -23,11 +29,11 @@ rust_thread_start(void *ptr) {
 void
 rust_thread::start() {
 #if defined(__WIN32__)
-   thread = CreateThread(NULL, 0, rust_thread_start, this, 0, NULL);
+   thread = CreateThread(NULL, stack_sz, rust_thread_start, this, 0, NULL);
 #else
    pthread_attr_t attr;
    pthread_attr_init(&attr);
-   pthread_attr_setstacksize(&attr, 1024 * 1024);
+   pthread_attr_setstacksize(&attr, stack_sz);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&thread, &attr, rust_thread_start, (void *) this);
 #endif

branches/try/src/rt/sync/rust_thread.h

@@ -5,13 +5,17 @@
  * Thread utility class. Derive and implement your own run() method.
  */
 class rust_thread {
-public:
+ private:
 #if defined(__WIN32__)
     HANDLE thread;
 #else
     pthread_t thread;
 #endif
+    size_t stack_sz;
+ public:
+
     rust_thread();
+    rust_thread(size_t stack_sz);
     virtual ~rust_thread();
 
     void start();

branches/try/src/rustdoc/attr_parser.rs

@@ -93,7 +93,7 @@ mod test {
             mutable byte_pos: 0u
         };
         let parser = parser::new_parser_from_source_str(
-            parse_sess, [], "-", codemap::fss_none, @source);
+            parse_sess, [], "-", none, @source);
 
         parser::parse_outer_attributes(parser)
     }

branches/try/src/test/compile-fail/qquote.rs

@@ -76,11 +76,6 @@ fn main() {
 
     let pat = #ast(pat){some(_)};
     check_pp(pat, pprust::print_pat, "some(_)");
-
-    // issue #1785
-    let x = #ast{1};
-    let test1 = #ast{1+$(x)};
-    check_pp(test1, pprust::print_expr, "1 + 1");
 }
 
 fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: str) {