---

yaml
---
r: 3568
b: refs/heads/master
c: 1e4f198
h: refs/heads/master
v: v3

Author: wilsonk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: fb10829aefbb7493c41ee1a5ec4c958692b33c28
+refs/heads/master: 1e4f198a1d94e82530456334fe90abd5bfc470b6

trunk/AUTHORS.txt

@@ -30,6 +30,5 @@ Paul Stansifer <[email protected]>
 Peter Hull <[email protected]>
 Ralph Giles <[email protected]>
 Rafael Ávila de Espíndola <[email protected]>
-Rob Arnold <[email protected]>
 Roy Frostig <[email protected]>
 Tim Chevalier <[email protected]>

trunk/Makefile.in

@@ -47,7 +47,6 @@ endif
 CFG_RUNTIME :=$(call CFG_LIB_NAME,rustrt)
 CFG_RUSTLLVM :=$(call CFG_LIB_NAME,rustllvm)
 CFG_STDLIB :=$(call CFG_LIB_NAME,std)
-CFG_LIBRUSTC :=$(call CFG_LIB_NAME,rustc)
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git

trunk/mk/fuzzer.mk

@@ -1,8 +1,19 @@
-# At the moment the fuzzer only exists in stage1.
+# At the moment the fuzzer only exists in stage2.  That's the first
+# stage built by the non-snapshot compiler so it seems a convenient
+# stage to work at.
 
 FUZZER_CRATE := $(S)src/fuzzer/fuzzer.rc
 FUZZER_INPUTS := $(wildcard $(addprefix $(S)src/fuzzer/, *.rs))
 
-stage1/fuzzer$(X): $(FUZZER_CRATE) $(FUZZER_INPUTS) $(SREQ1)
-	@$(call E, compile_and_link: $@)
-	$(STAGE1) -o $@ $<
+stage2/fuzzer.o: $(FUZZER_CRATE) $(FUZZER_INPUTS) $(SREQ1)
+	@$(call E, compile: $@)
+	$(STAGE1) -c -o $@ $<
+
+stage2/fuzzer$(X): stage2/fuzzer.o $(SREQ1)
+	@$(call E, link [gcc]: $@)
+	$(Q)gcc $(CFG_GCCISH_CFLAGS) rt/main.o stage2/glue.o -o $@ $< \
+      -Lstage2 -Lrustllvm -Lrt -lrustrt -lrustllvm -lstd -lm -lrustc
+	@# dsymutil sometimes fails or prints a warning, but the
+	@# program still runs.  Since it simplifies debugging other
+	@# programs, I\'ll live with the noise.
+	-$(Q)$(CFG_DSYMUTIL) $@

trunk/mk/stage1.mk

@@ -29,8 +29,3 @@ stage1/%.o: stage1/%.s
 stage1/%$(X): $(COMPILER_CRATE) $(COMPILER_INPUTS) $(SREQ0) stage0/intrinsics.bc
 	@$(call E, compile_and_link: $@)
 	$(STAGE0) -o $@ $<
-
-stage1/lib/$(CFG_LIBRUSTC): $(COMPILER_CRATE) $(COMPILER_INPUTS) $(SREQ1) \
-                            stage1/intrinsics.bc
-	@$(call E, compile_and_link: $@)
-	$(STAGE1) --shared -o $@ $<

trunk/src/comp/back/link.rs

@@ -332,7 +332,6 @@ fn build_link_meta(&session::session sess, &ast::crate c,
                     sha.input_str(len_and_str(name));
                 }
                 case (ast::meta_list(_, _)) {
-                    // FIXME (#607): Implement this
                     fail "unimplemented meta_item variant";
                 }
             }

trunk/src/comp/driver/rustc.rs

@@ -6,7 +6,6 @@ import front::parser;
 import front::token;
 import front::eval;
 import front::ast;
-import front::attr;
 import middle::trans;
 import middle::resolve;
 import middle::ty;
@@ -36,42 +35,22 @@ import back::link::output_type;
 
 tag pp_mode { ppm_normal; ppm_typed; ppm_identified; }
 
-fn default_configuration(session::session sess, str argv0, str input) ->
-    ast::crate_cfg {
+fn default_environment(session::session sess, str argv0, str input) ->
+   eval::env {
     auto libc =
         alt (sess.get_targ_cfg().os) {
             case (session::os_win32) { "msvcrt.dll" }
             case (session::os_macos) { "libc.dylib" }
             case (session::os_linux) { "libc.so.6" }
             case (_) { "libc.so" }
         };
-
-    auto mk = attr::mk_name_value_item;
-
     ret [ // Target bindings.
-         mk("target_os", std::os::target_os()),
-         mk("target_arch", "x86"),
-         mk("target_libc", libc),
+         tup("target_os", eval::val_str(std::os::target_os())),
+         tup("target_arch", eval::val_str("x86")),
+         tup("target_libc", eval::val_str(libc)),
          // Build bindings.
-         mk("build_compiler", argv0),
-         mk("build_input", input)];
-}
-
-fn build_configuration(session::session sess, str argv0,
-                       str input) -> ast::crate_cfg {
-    // Combine the configuration requested by the session (command line) with
-    // some default configuration items
-    ret sess.get_opts().cfg + default_configuration(sess, argv0, input);
-}
-
-// Convert strings provided as --cfg [cfgspec] into a crate_cfg
-fn parse_cfgspecs(&vec[str] cfgspecs) -> ast::crate_cfg {
-    // FIXME: It would be nice to use the parser to parse all varieties of
-    // meta_item here. At the moment we just support the meta_word variant.
-    fn to_meta_word(&str cfgspec) -> @ast::meta_item {
-        attr::mk_word_item(cfgspec)
-    }
-    ret vec::map(to_meta_word, cfgspecs);
+         tup("build_compiler", eval::val_str(argv0)),
+         tup("build_input", eval::val_str(input))];
 }
 
 fn parse_input(session::session sess, parser::parser p, str input) ->
@@ -94,10 +73,10 @@ fn time[T](bool do_it, str what, fn() -> T  thunk) -> T {
     ret rv;
 }
 
-fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
+fn compile_input(session::session sess, eval::env env, str input,
                  str output) {
     auto time_passes = sess.get_opts().time_passes;
-    auto p = parser::new_parser(sess, cfg, input, 0u, 0);
+    auto p = parser::new_parser(sess, env, input, 0u, 0);
     auto crate =
         time(time_passes, "parsing", bind parse_input(sess, p, input));
     if (sess.get_opts().output_type == link::output_type_none) { ret; }
@@ -125,9 +104,9 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
              bind link::write::run_passes(sess, llmod, output));
 }
 
-fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
-                      str input, pp_mode ppm) {
-    auto p = front::parser::new_parser(sess, cfg, input, 0u, 0);
+fn pretty_print_input(session::session sess, eval::env env, str input,
+                      pp_mode ppm) {
+    auto p = front::parser::new_parser(sess, env, input, 0u, 0);
     auto crate = parse_input(sess, p, input);
     auto mode;
     alt (ppm) {
@@ -177,7 +156,6 @@ options:
     --emit-llvm        produce an LLVM bitcode file
     --save-temps       write intermediate files in addition to normal output
     --stats            gather and report various compilation statistics
-    --cfg [cfgspec]    configure the compilation environment
     --time-passes      time the individual phases of the compiler
     --time-llvm-passes time the individual phases of the LLVM backend
     --sysroot <path>   override the system root (default: rustc's directory)
@@ -275,7 +253,6 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
             case (none) { get_default_sysroot(binary) }
             case (some(?s)) { s }
         };
-    auto cfg = parse_cfgspecs(getopts::opt_strs(match, "cfg"));
     let @session::options sopts =
         @rec(shared=shared,
              optimize=opt_level,
@@ -288,8 +265,7 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
              time_llvm_passes=time_llvm_passes,
              output_type=output_type,
              library_search_paths=library_search_paths,
-             sysroot=sysroot,
-             cfg=cfg);
+             sysroot=sysroot);
     ret sopts;
 }
 
@@ -299,7 +275,7 @@ fn build_session(@session::options sopts) -> session::session {
     auto target_crate_num = 0;
     auto sess =
         session::session(target_crate_num, target_cfg, sopts, crate_cache, [],
-                         [], [], front::codemap::new_codemap(), 0u);
+                         [], front::codemap::new_codemap(), 0u);
     ret sess;
 }
 
@@ -322,7 +298,7 @@ fn main(vec[str] args) {
          optflag("c"), optopt("o"), optflag("g"), optflag("save-temps"),
          optopt("sysroot"), optflag("stats"), optflag("time-passes"),
          optflag("time-llvm-passes"), optflag("no-typestate"),
-         optflag("noverify"), optmulti("cfg")];
+         optflag("noverify")];
     auto binary = vec::shift[str](args);
     auto binary_dir = fs::dirname(binary);
     auto match =
@@ -361,15 +337,15 @@ fn main(vec[str] args) {
     }
     auto ifile = match.free.(0);
     let str saved_out_filename = "";
-    auto cfg = build_configuration(sess, binary, ifile);
+    auto env = default_environment(sess, binary, ifile);
     auto pretty =
         option::map[str,
                     pp_mode](bind parse_pretty(sess, _),
                              getopts::opt_default(match, "pretty", "normal"));
     auto ls = opt_present(match, "ls");
     alt (pretty) {
         case (some[pp_mode](?ppm)) {
-            pretty_print_input(sess, cfg, ifile, ppm);
+            pretty_print_input(sess, env, ifile, ppm);
             ret;
         }
         case (none[pp_mode]) {/* continue */ }
@@ -395,7 +371,7 @@ fn main(vec[str] args) {
                 case (link::output_type_exe) { parts += ["o"]; }
             }
             auto ofile = str::connect(parts, ".");
-            compile_input(sess, cfg, ifile, ofile);
+            compile_input(sess, env, ifile, ofile);
         }
         case (some(?ofile)) {
             // FIXME: what about windows? This will create a foo.exe.o.
@@ -410,7 +386,7 @@ fn main(vec[str] args) {
                 }
                 case (_) { temp_filename = ofile; }
             }
-            compile_input(sess, cfg, ifile, temp_filename);
+            compile_input(sess, env, ifile, temp_filename);
         }
     }
 
@@ -430,11 +406,16 @@ fn main(vec[str] args) {
              saved_out_filename, saved_out_filename + ".o"];
         auto shared_cmd;
 
-        auto os = sess.get_targ_cfg().os;
-        if (os == session::os_macos) {
+        alt (sess.get_targ_cfg().os) {
+            case (session::os_win32) {
+                shared_cmd = "-shared";
+            }
+            case (session::os_macos) {
                 shared_cmd = "-dynamiclib";
-        } else {
+            }
+            case (session::os_linux) {
                 shared_cmd = "-shared";
+            }
         }
 
         // Converts a library file name into a gcc -l argument
@@ -460,7 +441,7 @@ fn main(vec[str] args) {
                 case (_) { rmext(filename) }
             };
         }
-
+        
         for (str cratepath in sess.get_used_crate_files()) {
             auto dir = fs::dirname(cratepath);
             if (dir != "") {
@@ -470,7 +451,6 @@ fn main(vec[str] args) {
             gcc_args += ["-l" + libarg];
         }
 
-        gcc_args += sess.get_used_link_args();
         auto used_libs = sess.get_used_libraries();
         for (str l in used_libs) {
             gcc_args += ["-l" + l];
@@ -479,8 +459,9 @@ fn main(vec[str] args) {
         if (sopts.shared) {
             gcc_args += [shared_cmd];
         } else {
-            // FIXME: why do we hardcode -lm?
-            gcc_args += ["-lm", main];
+            // FIXME: having -Lrustllvm hardcoded in here is hack
+            // FIXME: same for -lm
+            gcc_args += ["-Lrustllvm", "-lm", main];
         }
         // We run 'gcc' here
 

trunk/src/comp/driver/session.rs

@@ -10,7 +10,6 @@ import std::map;
 import std::option;
 import std::option::some;
 import std::option::none;
-import std::str;
 
 tag os { os_win32; os_macos; os_linux; }
 
@@ -35,10 +34,7 @@ type options =
         bool time_llvm_passes,
         back::link::output_type output_type,
         vec[str] library_search_paths,
-        str sysroot,
-        // The crate config requested for the session, which may be combined
-        // with additional crate configurations during the compile process
-        ast::crate_cfg cfg);
+        str sysroot);
 
 type crate_metadata = rec(str name, vec[u8] data);
 
@@ -72,7 +68,6 @@ obj session(ast::crate_num cnum,
             map::hashmap[int, crate_metadata] crates,
             mutable vec[str] used_crate_files,
             mutable vec[str] used_libraries,
-            mutable vec[str] used_link_args,
             codemap::codemap cm,
             mutable uint err_count) {
     fn get_targ_cfg() -> @config { ret targ_cfg; }
@@ -132,25 +127,18 @@ obj session(ast::crate_num cnum,
         crates.insert(num, metadata);
     }
     fn has_external_crate(int num) -> bool { ret crates.contains_key(num); }
-    fn add_used_link_args(&str args) {
-        used_link_args += str::split(args, ' ' as u8);
-    }
-    fn get_used_link_args() -> vec[str] {
-        ret used_link_args;
-    }
-    fn add_used_library(&str lib) -> bool {
+    fn add_used_library(&str lib) {
         if (lib == "") {
-            ret false;
+            ret;
         }
         // A program has a small number of libraries, so a vector is probably
         // a good data structure in here.
         for (str l in used_libraries) {
             if (l == lib) {
-                ret false;
+                ret;
             }
         }
         used_libraries += [lib];
-        ret true;
     }
     fn get_used_libraries() -> vec[str] {
        ret used_libraries;

trunk/src/comp/front/ast.rs

@@ -88,6 +88,12 @@ type crate_ = rec(vec[@crate_directive] directives,
                   crate_cfg config);
 
 tag crate_directive_ {
+    cdir_expr(@expr);
+
+    // FIXME: cdir_let should be eliminated
+    // and redirected to the use of const stmt_decls inside
+    // crate directive blocks.
+    cdir_let(ident, @expr, vec[@crate_directive]);
     cdir_src_mod(ident, option::t[filename], vec[attribute]);
     cdir_dir_mod(ident, option::t[filename],
                  vec[@crate_directive], vec[attribute]);
@@ -110,15 +116,13 @@ type block = spanned[block_];
 
 type block_ = rec(vec[@stmt] stmts, option::t[@expr] expr, node_id id);
 
-type pat = rec(node_id id,
-               pat_ node,
-               span span);
+type pat = spanned[pat_];
 
 tag pat_ {
-    pat_wild;
-    pat_bind(ident);
-    pat_lit(@lit);
-    pat_tag(path, vec[@pat]);
+    pat_wild(node_id);
+    pat_bind(ident, node_id);
+    pat_lit(@lit, node_id);
+    pat_tag(path, vec[@pat], node_id);
 }
 
 tag mutability { mut; imm; maybe_mut; }
@@ -277,7 +281,7 @@ tag expr_ {
     expr_index(@expr, @expr);
     expr_path(path);
     expr_ext(path, vec[@expr], option::t[str], @expr);
-    expr_fail(option::t[@expr]);
+    expr_fail(option::t[str]);
     expr_break;
     expr_cont;
     expr_ret(option::t[@expr]);
@@ -600,19 +604,6 @@ fn ternary_to_if(&@expr e) -> @ast::expr {
     }
 }
 
-// Path stringification
-fn path_to_str(&ast::path pth) -> str {
-    auto result = str::connect(pth.node.idents, "::");
-    if (vec::len[@ast::ty](pth.node.types) > 0u) {
-        fn f(&@ast::ty t) -> str { ret pretty::pprust::ty_to_str(*t); }
-        result += "[";
-        result += str::connect(vec::map(f, pth.node.types), ",");
-        result += "]";
-    }
-    ret result;
-}
-
-
 //
 // Local Variables:
 // mode: rust