---

yaml
---
r: 3569
b: refs/heads/master
c: 5c9fb0b
h: refs/heads/master
i:
  3567: 0c3b199
v: v3

Author: graydon

[refs]

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

trunk/AUTHORS.txt

@@ -30,5 +30,6 @@ 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,6 +47,7 @@ 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,19 +1,8 @@
-# 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.
+# At the moment the fuzzer only exists in stage1.
 
 FUZZER_CRATE := $(S)src/fuzzer/fuzzer.rc
 FUZZER_INPUTS := $(wildcard $(addprefix $(S)src/fuzzer/, *.rs))
 
-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) $@
+stage1/fuzzer$(X): $(FUZZER_CRATE) $(FUZZER_INPUTS) $(SREQ1)
+	@$(call E, compile_and_link: $@)
+	$(STAGE1) -o $@ $<

trunk/mk/stage1.mk

@@ -29,3 +29,8 @@ 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,6 +332,7 @@ 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,6 +6,7 @@ import front::parser;
 import front::token;
 import front::eval;
 import front::ast;
+import front::attr;
 import middle::trans;
 import middle::resolve;
 import middle::ty;
@@ -35,22 +36,42 @@ import back::link::output_type;
 
 tag pp_mode { ppm_normal; ppm_typed; ppm_identified; }
 
-fn default_environment(session::session sess, str argv0, str input) ->
-   eval::env {
+fn default_configuration(session::session sess, str argv0, str input) ->
+    ast::crate_cfg {
     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.
-         tup("target_os", eval::val_str(std::os::target_os())),
-         tup("target_arch", eval::val_str("x86")),
-         tup("target_libc", eval::val_str(libc)),
+         mk("target_os", std::os::target_os()),
+         mk("target_arch", "x86"),
+         mk("target_libc", libc),
          // Build bindings.
-         tup("build_compiler", eval::val_str(argv0)),
-         tup("build_input", eval::val_str(input))];
+         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);
 }
 
 fn parse_input(session::session sess, parser::parser p, str input) ->
@@ -73,10 +94,10 @@ fn time[T](bool do_it, str what, fn() -> T  thunk) -> T {
     ret rv;
 }
 
-fn compile_input(session::session sess, eval::env env, str input,
+fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
                  str output) {
     auto time_passes = sess.get_opts().time_passes;
-    auto p = parser::new_parser(sess, env, input, 0u, 0);
+    auto p = parser::new_parser(sess, cfg, 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; }
@@ -104,9 +125,9 @@ fn compile_input(session::session sess, eval::env env, str input,
              bind link::write::run_passes(sess, llmod, output));
 }
 
-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);
+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);
     auto crate = parse_input(sess, p, input);
     auto mode;
     alt (ppm) {
@@ -156,6 +177,7 @@ 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)
@@ -253,6 +275,7 @@ 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,
@@ -265,7 +288,8 @@ 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);
+             sysroot=sysroot,
+             cfg=cfg);
     ret sopts;
 }
 
@@ -275,7 +299,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;
 }
 
@@ -298,7 +322,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")];
+         optflag("noverify"), optmulti("cfg")];
     auto binary = vec::shift[str](args);
     auto binary_dir = fs::dirname(binary);
     auto match =
@@ -337,15 +361,15 @@ fn main(vec[str] args) {
     }
     auto ifile = match.free.(0);
     let str saved_out_filename = "";
-    auto env = default_environment(sess, binary, ifile);
+    auto cfg = build_configuration(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, env, ifile, ppm);
+            pretty_print_input(sess, cfg, ifile, ppm);
             ret;
         }
         case (none[pp_mode]) {/* continue */ }
@@ -371,7 +395,7 @@ fn main(vec[str] args) {
                 case (link::output_type_exe) { parts += ["o"]; }
             }
             auto ofile = str::connect(parts, ".");
-            compile_input(sess, env, ifile, ofile);
+            compile_input(sess, cfg, ifile, ofile);
         }
         case (some(?ofile)) {
             // FIXME: what about windows? This will create a foo.exe.o.
@@ -386,7 +410,7 @@ fn main(vec[str] args) {
                 }
                 case (_) { temp_filename = ofile; }
             }
-            compile_input(sess, env, ifile, temp_filename);
+            compile_input(sess, cfg, ifile, temp_filename);
         }
     }
 
@@ -406,16 +430,11 @@ fn main(vec[str] args) {
              saved_out_filename, saved_out_filename + ".o"];
         auto shared_cmd;
 
-        alt (sess.get_targ_cfg().os) {
-            case (session::os_win32) {
-                shared_cmd = "-shared";
-            }
-            case (session::os_macos) {
+        auto os = sess.get_targ_cfg().os;
+        if (os == session::os_macos) {
                 shared_cmd = "-dynamiclib";
-            }
-            case (session::os_linux) {
+        } else {
                 shared_cmd = "-shared";
-            }
         }
 
         // Converts a library file name into a gcc -l argument
@@ -441,7 +460,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 != "") {
@@ -451,6 +470,7 @@ 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];
@@ -459,9 +479,8 @@ fn main(vec[str] args) {
         if (sopts.shared) {
             gcc_args += [shared_cmd];
         } else {
-            // FIXME: having -Lrustllvm hardcoded in here is hack
-            // FIXME: same for -lm
-            gcc_args += ["-Lrustllvm", "-lm", main];
+            // FIXME: why do we hardcode -lm?
+            gcc_args += ["-lm", main];
         }
         // We run 'gcc' here
 

trunk/src/comp/driver/session.rs

@@ -10,6 +10,7 @@ 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; }
 
@@ -34,7 +35,10 @@ type options =
         bool time_llvm_passes,
         back::link::output_type output_type,
         vec[str] library_search_paths,
-        str sysroot);
+        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);
 
 type crate_metadata = rec(str name, vec[u8] data);
 
@@ -68,6 +72,7 @@ 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; }
@@ -127,18 +132,25 @@ 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_library(&str lib) {
+    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 {
         if (lib == "") {
-            ret;
+            ret false;
         }
         // 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;
+                ret false;
             }
         }
         used_libraries += [lib];
+        ret true;
     }
     fn get_used_libraries() -> vec[str] {
        ret used_libraries;

trunk/src/comp/front/ast.rs

@@ -88,12 +88,6 @@ 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]);
@@ -116,13 +110,15 @@ type block = spanned[block_];
 
 type block_ = rec(vec[@stmt] stmts, option::t[@expr] expr, node_id id);
 
-type pat = spanned[pat_];
+type pat = rec(node_id id,
+               pat_ node,
+               span span);
 
 tag pat_ {
-    pat_wild(node_id);
-    pat_bind(ident, node_id);
-    pat_lit(@lit, node_id);
-    pat_tag(path, vec[@pat], node_id);
+    pat_wild;
+    pat_bind(ident);
+    pat_lit(@lit);
+    pat_tag(path, vec[@pat]);
 }
 
 tag mutability { mut; imm; maybe_mut; }
@@ -281,7 +277,7 @@ tag expr_ {
     expr_index(@expr, @expr);
     expr_path(path);
     expr_ext(path, vec[@expr], option::t[str], @expr);
-    expr_fail(option::t[str]);
+    expr_fail(option::t[@expr]);
     expr_break;
     expr_cont;
     expr_ret(option::t[@expr]);
@@ -604,6 +600,19 @@ 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