---

yaml
---
r: 7380
b: refs/heads/master
c: f14ee0b
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 93be00f99594464fc753796395ce0cfb8ee790ea
+refs/heads/master: f14ee0b1b6c36528f14661a8f67d6808ba895978

trunk/Makefile.in

@@ -148,6 +148,12 @@ else
   endif
 endif
 
+ifeq ($(CFG_NODE),)
+  $(info cfg: no node found, omitting doc/tutorial/web)
+else
+  DOCS += doc/tutorial/web/index.html
+endif
+
 ifeq ($(CFG_NATURALDOCS),)
   $(info cfg: no naturaldocs found, omitting library doc build)
 else

trunk/configure

@@ -289,6 +289,7 @@ probe CFG_NATURALDOCS      naturaldocs
 probe CFG_LLNEXTGEN        LLnextgen
 probe CFG_PANDOC           pandoc
 probe CFG_PDFLATEX         pdflatex
+probe CFG_NODE             node
 
 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
@@ -363,6 +364,16 @@ then
     err "either clang or gcc is required"
 fi
 
+if [ ! -z "$CFG_PERF" ]
+then
+    HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
+    if [ -z "$HAVE_PERF_LOGFD" ];
+    then
+        CFG_PERF_WITH_LOGFD=1
+        putvar CFG_PERF_WITH_LOGFD
+    fi
+fi
+
 step_msg "making directories"
 
 for i in \

trunk/mk/docs.mk

@@ -42,6 +42,26 @@ doc/rust.pdf: doc/rust.tex
 
 endif
 
+ifdef CFG_NODE
+
+doc/tutorial/web/index.html: doc/tutorial/args.md \
+		doc/tutorial/control.md \
+		doc/tutorial/data.md \
+		doc/tutorial/ffi.md \
+		doc/tutorial/func.md \
+		doc/tutorial/generic.md \
+		doc/tutorial/iface.md \
+		doc/tutorial/index.md \
+		doc/tutorial/intro.md \
+		doc/tutorial/mod.md \
+		doc/tutorial/setup.md \
+		doc/tutorial/syntax.md \
+		doc/tutorial/task.md \
+		doc/tutorial/test.md
+	$(Q)cd doc/tutorial && $(CFG_NODE) build.js
+
+endif
+
 endif
 
 ifdef CFG_LLNEXTGEN

trunk/mk/platform.mk

@@ -58,7 +58,11 @@ ifneq ($(findstring linux,$(CFG_OSTYPE)),)
   CFG_LDENV := LD_LIBRARY_PATH
   CFG_DEF_SUFFIX := .linux.def
   ifdef CFG_PERF
-	CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
+    ifneq ($(CFG_PERF_WITH_LOGFD),)
+        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3 --log-fd 2
+    else
+        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
+    endif
   else
     ifdef CFG_VALGRIND
       CFG_PERF_TOOL :=\

trunk/src/comp/back/link.rs

@@ -445,7 +445,10 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
                 let name =
                     {
                         let os = str::split(fs::basename(output), '.' as u8);
-                        assert (vec::len(os) >= 2u);
+                        if (vec::len(os) < 2u) {
+                            sess.fatal(#fmt("Output file name %s doesn't\
+                              appear to have an extension", output));
+                        }
                         vec::pop(os);
                         str::connect(os, ".")
                     };

trunk/src/comp/back/upcall.rs

@@ -16,6 +16,7 @@ type upcalls =
      free: ValueRef,
      shared_malloc: ValueRef,
      shared_free: ValueRef,
+     memset: ValueRef,
      mark: ValueRef,
      create_shared_type_desc: ValueRef,
      free_shared_type_desc: ValueRef,
@@ -64,6 +65,7 @@ fn declare_upcalls(targ_cfg: @session::config,
                 T_ptr(T_i8())),
           shared_free:
               dv("shared_free", [T_ptr(T_i8())]),
+          memset: dv("memset", [T_ptr(T_i8()), T_i8(), T_i32(), T_i32()]),
           mark:
               d("mark", [T_ptr(T_i8())], int_t),
           create_shared_type_desc:

trunk/src/comp/driver/driver.rs

@@ -20,7 +20,7 @@ import back::{x86, x86_64};
 
 tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; }
 
-fn default_configuration(sess: session::session, argv0: str, input: str) ->
+fn default_configuration(sess: session, argv0: str, input: str) ->
    ast::crate_cfg {
     let libc =
         alt sess.targ_cfg.os {
@@ -48,7 +48,7 @@ fn default_configuration(sess: session::session, argv0: str, input: str) ->
          mk("build_input", input)];
 }
 
-fn build_configuration(sess: session::session, argv0: str, input: str) ->
+fn build_configuration(sess: session, argv0: str, input: str) ->
    ast::crate_cfg {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
@@ -76,31 +76,27 @@ fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg {
 
 fn input_is_stdin(filename: str) -> bool { filename == "-" }
 
-fn parse_input(sess: session::session, cfg: ast::crate_cfg, input: str) ->
-   @ast::crate {
-    if !input_is_stdin(input) {
+fn parse_input(sess: session, cfg: ast::crate_cfg, input: str)
+    -> {crate: @ast::crate, src: str} {
+    let src = get_input_str(sess, input);
+    let crate = if !input_is_stdin(input) {
         parser::parse_crate_from_file(input, cfg, sess.parse_sess)
-    } else { parse_input_src(sess, cfg, input).crate }
+    } else {
+        parser::parse_crate_from_source_str(input, src, cfg, sess.parse_sess)
+    };
+    {crate: crate, src: src}
 }
 
-fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str)
-   -> {crate: @ast::crate, src: str} {
-    let src_stream = if infile != "-" {
+fn get_input_str(sess: session, infile: str) -> str {
+    let stream = if !input_is_stdin(infile) {
         alt io::file_reader(infile) {
           result::ok(reader) { reader }
           result::err(e) {
             sess.fatal(e)
           }
         }
-    } else {
-        io::stdin()
-    };
-    let srcbytes = src_stream.read_whole_stream();
-    let src = str::unsafe_from_bytes(srcbytes);
-    let crate =
-        parser::parse_crate_from_source_str(infile, src, cfg,
-                                            sess.parse_sess);
-    ret {crate: crate, src: src};
+    } else { io::stdin() };
+    str::unsafe_from_bytes(stream.read_whole_stream())
 }
 
 fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
@@ -113,7 +109,7 @@ fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
     ret rv;
 }
 
-fn inject_libcore_reference(sess: session::session,
+fn inject_libcore_reference(sess: session,
                             crate: @ast::crate) -> @ast::crate {
 
     fn spanned<T: copy>(x: T) -> @ast::spanned<T> {
@@ -134,14 +130,22 @@ fn inject_libcore_reference(sess: session::session,
                  with crate.node} with *crate }
 }
 
+enum compile_upto {
+    cu_parse;
+    cu_expand;
+    cu_typeck;
+    cu_no_trans;
+    cu_everything;
+}
 
-fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
-                 outdir: option::t<str>, output: option::t<str>) {
-
+fn compile_upto(sess: session, cfg: ast::crate_cfg,
+                input: str, upto: compile_upto,
+                outputs: option::t<output_filenames>)
+    -> {crate: @ast::crate, tcx: option::t<ty::ctxt>, src: str} {
     let time_passes = sess.opts.time_passes;
-    let crate =
+    let {crate, src} =
         time(time_passes, "parsing", bind parse_input(sess, cfg, input));
-    if sess.opts.parse_only { ret; }
+    if upto == cu_parse { ret {crate: crate, tcx: none, src: src}; }
 
     sess.building_library =
         session::building_library(sess.opts.crate_type, crate);
@@ -156,6 +160,7 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
         time(time_passes, "expansion",
              bind syntax::ext::expand::expand_crate(sess, crate));
 
+    if upto == cu_expand { ret {crate: crate, tcx: none, src: src}; }
     if sess.opts.libcore {
         crate = inject_libcore_reference(sess, crate);
     }
@@ -177,6 +182,9 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
     let (method_map, dict_map) =
         time(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, impl_map, crate));
+
+    if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx), src: src}; }
+
     time(time_passes, "block-use checking",
          bind middle::block_use::check_crate(ty_cx, crate));
     time(time_passes, "function usage",
@@ -195,9 +203,9 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
         bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx));
     time(time_passes, "kind checking",
          bind kind::check_crate(ty_cx, method_map, last_uses, crate));
-    if sess.opts.no_trans { ret; }
 
-    let outputs = build_output_filenames(input, outdir, output, sess);
+    if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx), src: src}; }
+    let outputs = option::get(outputs);
 
     let (llmod, link_meta) =
         time(time_passes, "translation",
@@ -212,14 +220,25 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
         sess.opts.output_type != link::output_type_exe ||
             sess.opts.static && sess.building_library;
 
-    if stop_after_codegen { ret; }
+    if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx), src: src}; }
 
     time(time_passes, "Linking",
          bind link::link_binary(sess, outputs.obj_filename,
                                 outputs.out_filename, link_meta));
+    ret {crate: crate, tcx: some(ty_cx), src: src};
 }
 
-fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str,
+fn compile_input(sess: session, cfg: ast::crate_cfg, input: str,
+                 outdir: option::t<str>, output: option::t<str>) {
+
+    let upto = if sess.opts.parse_only { cu_parse }
+               else if sess.opts.no_trans { cu_no_trans }
+               else { cu_everything };
+    let outputs = build_output_filenames(input, outdir, output, sess);
+    compile_upto(sess, cfg, input, upto, some(outputs));
+}
+
+fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
                       ppm: pp_mode) {
     fn ann_paren_for_expr(node: pprust::ann_node) {
         alt node { pprust::node_expr(s, expr) { pprust::popen(s); } _ { } }
@@ -260,30 +279,23 @@ fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str,
     // to collect comments and literals, and we need to support reading
     // from stdin, we're going to just suck the source into a string
     // so both the parser and pretty-printer can use it.
-    let crate_src = parse_input_src(sess, cfg, input);
-    let crate = crate_src.crate;
-    let src = crate_src.src;
+    let upto = alt ppm {
+      ppm_expanded. { cu_expand }
+      ppm_typed. { cu_typeck }
+      _ { cu_parse }
+    };
+    let {crate, tcx, src} = compile_upto(sess, cfg, input, upto, none);
 
-    let ann;
+    let ann: pprust::pp_ann = pprust::no_ann();
     alt ppm {
-      ppm_expanded. {
-        crate = syntax::ext::expand::expand_crate(sess, crate);
-        ann = pprust::no_ann();
-      }
       ppm_typed. {
-        crate = syntax::ext::expand::expand_crate(sess, crate);
-        let amap = middle::ast_map::map_crate(*crate);
-        let {def_map, impl_map, _} =
-            resolve::resolve_crate(sess, amap, crate);
-        let freevars = freevars::annotate_freevars(def_map, crate);
-        let ty_cx = ty::mk_ctxt(sess, def_map, amap, freevars);
-        typeck::check_crate(ty_cx, impl_map, crate);
-        ann = {pre: ann_paren_for_expr, post: bind ann_typed_post(ty_cx, _)};
+        ann = {pre: ann_paren_for_expr,
+               post: bind ann_typed_post(option::get(tcx), _)};
       }
       ppm_identified. {
         ann = {pre: ann_paren_for_expr, post: ann_identified_post};
       }
-      ppm_normal. { ann = pprust::no_ann(); }
+      ppm_expanded. | ppm_normal. {}
     }
     pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
                         io::string_reader(src), io::stdout(), ann);
@@ -453,7 +465,7 @@ fn build_session_options(match: getopts::match,
 }
 
 fn build_session(sopts: @session::options, input: str,
-                 demitter: diagnostic::emitter) -> session::session {
+                 demitter: diagnostic::emitter) -> session {
     let target_cfg = build_target_config(sopts, demitter);
     let cstore = cstore::mk_cstore();
     let filesearch = filesearch::mk_filesearch(
@@ -480,7 +492,7 @@ fn build_session(sopts: @session::options, input: str,
       working_dir: fs::dirname(input)}
 }
 
-fn parse_pretty(sess: session::session, &&name: str) -> pp_mode {
+fn parse_pretty(sess: session, &&name: str) -> pp_mode {
     if str::eq(name, "normal") {
         ret ppm_normal;
     } else if str::eq(name, "expanded") {
@@ -509,11 +521,13 @@ fn opts() -> [getopts::opt] {
          optflag("warn-unused-imports")];
 }
 
+type output_filenames = @{out_filename: str, obj_filename:str};
+
 fn build_output_filenames(ifile: str,
                           odir: option::t<str>,
                           ofile: option::t<str>,
-                          sess: session::session)
-        -> @{out_filename: str, obj_filename:str} {
+                          sess: session)
+        -> output_filenames {
     let obj_path = "";
     let out_path: str = "";
     let sopts = sess.opts;
@@ -599,7 +613,7 @@ fn early_error(emitter: diagnostic::emitter, msg: str) -> ! {
     fail;
 }
 
-fn list_metadata(sess: session::session, path: str, out: io::writer) {
+fn list_metadata(sess: session, path: str, out: io::writer) {
     metadata::creader::list_file_metadata(sess, path, out);
 }