---

yaml
---
r: 145255
b: refs/heads/try2
c: 4757631
h: refs/heads/master
i:
  145253: d295f2f
  145251: b58329a
  145247: 9563cea
v: v3

Author: jzelinskie

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3c0013134cecbe9592f02ed5c6a94c06effb19d4
+refs/heads/try2: 47576313695170013cfe07d57e81c2e879a14c14
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/platform.mk

@@ -343,7 +343,6 @@ CFG_PATH_MUNGE_mips-unknown-linux-gnu := true
 CFG_LDPATH_mips-unknown-linux-gnu :=
 CFG_RUN_mips-unknown-linux-gnu=
 CFG_RUN_TARG_mips-unknown-linux-gnu=
-RUSTC_FLAGS_mips-unknown-linux-gnu := --linker=$(CXX_mips-unknown-linux-gnu) --target-cpu mips32r2 --target-feature +mips32r2,+o32
 
 # i686-pc-mingw32 configuration
 CC_i686-pc-mingw32=$(CC)
@@ -481,7 +480,7 @@ define CFG_MAKE_TOOLCHAIN
         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2)        \
         $$(call CFG_INSTALL_NAME_$(1),$$(4))
 
-  ifeq ($$(findstring $(HOST_$(1)),arm mips),)
+  ifneq ($(HOST_$(1)),arm)
 
   # We're using llvm-mc as our assembler because it supports
   # .cfi pseudo-ops on mac
@@ -493,7 +492,7 @@ define CFG_MAKE_TOOLCHAIN
                     -o=$$(1)
   else
 
-  # For the ARM and MIPS crosses, use the toolchain assembler
+  # For the ARM crosses, use the toolchain assembler
   # XXX: We should be able to use the LLVM assembler
   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
 

branches/try2/mk/rt.mk

@@ -71,6 +71,7 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/lock_and_signal.cpp \
               rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
+              rt/rust_run_program.cpp \
               rt/rust_rng.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \

branches/try2/src/compiletest/compiletest.rs

@@ -17,6 +17,7 @@ extern mod extra;
 
 use std::os;
 use std::rt;
+use std::f64;
 
 use extra::getopts;
 use extra::getopts::groups::{optopt, optflag, reqopt};
@@ -130,7 +131,7 @@ pub fn parse_config(args: ~[~str]) -> config {
         ratchet_noise_percent:
             getopts::opt_maybe_str(matches,
                                    "ratchet-noise-percent").map_move(|s|
-                                                                     from_str::<f64>(s).unwrap()),
+                                                                     f64::from_str(s).unwrap()),
         runtool: getopts::opt_maybe_str(matches, "runtool"),
         rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
         jit: getopts::opt_present(matches, "jit"),

branches/try2/src/libextra/glob.rs

@@ -137,6 +137,16 @@ fn list_dir_sorted(path: &Path) -> ~[Path] {
 /**
  * A compiled Unix shell style pattern.
  */
+#[cfg(stage0)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
+pub struct Pattern {
+    priv tokens: ~[PatternToken]
+}
+
+/**
+ * A compiled Unix shell style pattern.
+ */
+#[cfg(not(stage0))]
 #[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
 pub struct Pattern {
     priv tokens: ~[PatternToken]
@@ -455,10 +465,39 @@ fn is_sep(c: char) -> bool {
     }
 }
 
+/**
+ * Configuration options to modify the behaviour of `Pattern::matches_with(..)`
+ */
+#[cfg(stage0)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
+pub struct MatchOptions {
+
+    /**
+     * Whether or not patterns should be matched in a case-sensitive manner. This
+     * currently only considers upper/lower case relationships between ASCII characters,
+     * but in future this might be extended to work with Unicode.
+     */
+    case_sensitive: bool,
+
+    /**
+     * If this is true then path-component separator characters (e.g. `/` on Posix)
+     * must be matched by a literal `/`, rather than by `*` or `?` or `[...]`
+     */
+    require_literal_separator: bool,
+
+    /**
+     * If this is true then paths that contain components that start with a `.` will
+     * not match unless the `.` appears literally in the pattern: `*`, `?` or `[...]`
+     * will not match. This is useful because such files are conventionally considered
+     * hidden on Unix systems and it might be desirable to skip them when listing files.
+     */
+    require_literal_leading_dot: bool
+}
 
 /**
  * Configuration options to modify the behaviour of `Pattern::matches_with(..)`
  */
+#[cfg(not(stage0))]
 #[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
 pub struct MatchOptions {
 

branches/try2/src/libextra/num/bigint.rs

@@ -115,8 +115,8 @@ impl TotalOrd for BigUint {
         if s_len > o_len { return Greater;  }
 
         for (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
-            cond!((self_i < other_i) { return Less; }
-                  (self_i > other_i) { return Greater; })
+            if self_i < other_i { return Less; }
+            if self_i > other_i { return Greater; }
         }
         return Equal;
     }

branches/try2/src/libextra/rl.rs

@@ -13,6 +13,25 @@ use std::libc::{c_char, c_int};
 use std::{local_data, str, rt};
 use std::unstable::finally::Finally;
 
+#[cfg(stage0)]
+pub mod rustrt {
+    use std::libc::{c_char, c_int};
+
+    extern {
+        fn linenoise(prompt: *c_char) -> *c_char;
+        fn linenoiseHistoryAdd(line: *c_char) -> c_int;
+        fn linenoiseHistorySetMaxLen(len: c_int) -> c_int;
+        fn linenoiseHistorySave(file: *c_char) -> c_int;
+        fn linenoiseHistoryLoad(file: *c_char) -> c_int;
+        fn linenoiseSetCompletionCallback(callback: *u8);
+        fn linenoiseAddCompletion(completions: *(), line: *c_char);
+
+        fn rust_take_linenoise_lock();
+        fn rust_drop_linenoise_lock();
+    }
+}
+
+#[cfg(not(stage0))]
 pub mod rustrt {
     use std::libc::{c_char, c_int};
 
@@ -90,7 +109,7 @@ pub fn read(prompt: &str) -> Option<~str> {
 
 pub type CompletionCb = @fn(~str, @fn(~str));
 
-local_data_key!(complete_key: CompletionCb)
+static complete_key: local_data::Key<CompletionCb> = &local_data::Key;
 
 /// Bind to the main completion callback in the current task.
 ///

branches/try2/src/librustc/back/link.rs

@@ -190,7 +190,7 @@ pub mod jit {
 
     // The stage1 compiler won't work, but that doesn't really matter. TLS
     // changed only very recently to allow storage of owned values.
-    local_data_key!(engine_key: ~Engine)
+    static engine_key: local_data::Key<~Engine> = &local_data::Key;
 
     fn set_engine(engine: ~Engine) {
         local_data::set(engine_key, engine)

branches/try2/src/librustc/front/test.rs

@@ -293,6 +293,50 @@ fn mk_std(cx: &TestCtxt) -> ast::view_item {
     }
 }
 
+#[cfg(stage0)]
+fn mk_test_module(cx: &TestCtxt) -> @ast::item {
+
+    // Link to extra
+    let view_items = ~[mk_std(cx)];
+
+    // A constant vector of test descriptors.
+    let tests = mk_tests(cx);
+
+    // The synthesized main function which will call the console test runner
+    // with our list of tests
+    let ext_cx = cx.ext_cx;
+    let mainfn = (quote_item!(
+        pub fn main() {
+            #[main];
+            extra::test::test_main_static(::std::os::args(), TESTS);
+        }
+    )).unwrap();
+
+    let testmod = ast::_mod {
+        view_items: view_items,
+        items: ~[mainfn, tests],
+    };
+    let item_ = ast::item_mod(testmod);
+
+    // This attribute tells resolve to let us call unexported functions
+    let resolve_unexported_attr =
+        attr::mk_attr(attr::mk_word_item(@"!resolve_unexported"));
+
+    let item = ast::item {
+        ident: cx.sess.ident_of("__test"),
+        attrs: ~[resolve_unexported_attr],
+        id: ast::DUMMY_NODE_ID,
+        node: item_,
+        vis: ast::public,
+        span: dummy_sp(),
+     };
+
+    debug!("Synthetic test module:\n%s\n",
+           pprust::item_to_str(@item.clone(), cx.sess.intr()));
+
+    return @item;
+}
+#[cfg(not(stage0))]
 fn mk_test_module(cx: &TestCtxt) -> @ast::item {
 
     // Link to extra
@@ -363,6 +407,21 @@ fn path_node_global(ids: ~[ast::Ident]) -> ast::Path {
     }
 }
 
+#[cfg(stage0)]
+fn mk_tests(cx: &TestCtxt) -> @ast::item {
+
+    let ext_cx = cx.ext_cx;
+
+    // The vector of test_descs for this crate
+    let test_descs = mk_test_descs(cx);
+
+    (quote_item!(
+        pub static TESTS : &'static [self::extra::test::TestDescAndFn] =
+            $test_descs
+        ;
+    )).unwrap()
+}
+#[cfg(not(stage0))]
 fn mk_tests(cx: &TestCtxt) -> @ast::item {
     // The vector of test_descs for this crate
     let test_descs = mk_test_descs(cx);
@@ -402,6 +461,63 @@ fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
     }
 }
 
+#[cfg(stage0)]
+fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
+    let span = test.span;
+    let path = test.path.clone();
+
+    let ext_cx = cx.ext_cx;
+
+    debug!("encoding %s", ast_util::path_name_i(path));
+
+    let name_lit: ast::lit =
+        nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
+
+    let name_expr = @ast::Expr {
+          id: ast::DUMMY_NODE_ID,
+          node: ast::ExprLit(@name_lit),
+          span: span
+    };
+
+    let fn_path = path_node_global(path);
+
+    let fn_expr = @ast::Expr {
+        id: ast::DUMMY_NODE_ID,
+        node: ast::ExprPath(fn_path),
+        span: span,
+    };
+
+    let t_expr = if test.bench {
+        quote_expr!( self::extra::test::StaticBenchFn($fn_expr) )
+    } else {
+        quote_expr!( self::extra::test::StaticTestFn($fn_expr) )
+    };
+
+    let ignore_expr = if test.ignore {
+        quote_expr!( true )
+    } else {
+        quote_expr!( false )
+    };
+
+    let fail_expr = if test.should_fail {
+        quote_expr!( true )
+    } else {
+        quote_expr!( false )
+    };
+
+    let e = quote_expr!(
+        self::extra::test::TestDescAndFn {
+            desc: self::extra::test::TestDesc {
+                name: self::extra::test::StaticTestName($name_expr),
+                ignore: $ignore_expr,
+                should_fail: $fail_expr
+            },
+            testfn: $t_expr,
+        }
+    );
+    e
+}
+#[cfg(not(stage0))]
 fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
     let span = test.span;
     let path = test.path.clone();

branches/try2/src/librustc/middle/const_eval.rs

@@ -19,6 +19,7 @@ use syntax::visit;
 use syntax::visit::Visitor;
 use syntax::ast::*;
 
+use std::float;
 use std::hashmap::{HashMap, HashSet};
 
 //
@@ -475,9 +476,9 @@ pub fn lit_to_const(lit: &lit) -> const_val {
       lit_int(n, _) => const_int(n),
       lit_uint(n, _) => const_uint(n),
       lit_int_unsuffixed(n) => const_int(n),
-      lit_float(n, _) => const_float(from_str::<float>(n).unwrap() as f64),
+      lit_float(n, _) => const_float(float::from_str(n).unwrap() as f64),
       lit_float_unsuffixed(n) =>
-        const_float(from_str::<float>(n).unwrap() as f64),
+        const_float(float::from_str(n).unwrap() as f64),
       lit_nil => const_int(0i64),
       lit_bool(b) => const_bool(b)
     }

branches/try2/src/librustc/middle/trans/base.rs

@@ -92,7 +92,7 @@ use syntax::visit::Visitor;
 
 pub use middle::trans::context::task_llcx;
 
-local_data_key!(task_local_insn_key: @~[&'static str])
+static task_local_insn_key: local_data::Key<@~[&'static str]> = &local_data::Key;
 
 pub fn with_insn_ctxt(blk: &fn(&[&'static str])) {
     let opt = local_data::get(task_local_insn_key, |k| k.map_move(|k| *k));
@@ -2388,12 +2388,38 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
     let et = ccx.sess.entry_type.unwrap();
     match et {
         session::EntryMain => {
-            create_entry_fn(ccx, main_llfn, true);
+            let llfn = create_main(ccx, main_llfn);
+            create_entry_fn(ccx, llfn, true);
         }
         session::EntryStart => create_entry_fn(ccx, main_llfn, false),
         session::EntryNone => {}    // Do nothing.
     }
 
+    fn create_main(ccx: @mut CrateContext, main_llfn: ValueRef) -> ValueRef {
+        let nt = ty::mk_nil();
+        let llfty = type_of_rust_fn(ccx, [], nt);
+        let llfdecl = decl_fn(ccx.llmod, "_rust_main",
+                              lib::llvm::CCallConv, llfty);
+
+        let fcx = new_fn_ctxt(ccx, ~[], llfdecl, nt, None);
+
+        // the args vector built in create_entry_fn will need
+        // be updated if this assertion starts to fail.
+        assert!(!fcx.caller_expects_out_pointer);
+
+        let bcx = fcx.entry_bcx.unwrap();
+        // Call main.
+        let llenvarg = unsafe {
+            let env_arg = fcx.env_arg_pos();
+            llvm::LLVMGetParam(llfdecl, env_arg as c_uint)
+        };
+        let args = ~[llenvarg];
+        Call(bcx, main_llfn, args, []);
+
+        finish_fn(fcx, bcx);
+        return llfdecl;
+    }
+
     fn create_entry_fn(ccx: @mut CrateContext,
                        rust_main: ValueRef,
                        use_start_lang_item: bool) {
@@ -2634,7 +2660,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                             foreign::register_foreign_item_fn(ccx, abis, &path, ni)
                         }
                         ast::foreign_item_static(*) => {
-                            let ident = foreign::link_name(ccx, ni);
+                            let ident = token::ident_to_str(&ni.ident);
                             let g = do ident.with_c_str |buf| {
                                 unsafe {
                                     let ty = type_of(ccx, ty);

branches/try2/src/librustc/middle/trans/context.rs

@@ -287,7 +287,7 @@ impl Drop for CrateContext {
     }
 }
 
-local_data_key!(task_local_llcx_key: @ContextRef)
+static task_local_llcx_key: local_data::Key<@ContextRef> = &local_data::Key;
 
 pub fn task_llcx() -> ContextRef {
     let opt = local_data::get(task_local_llcx_key, |k| k.map_move(|k| *k));