---

yaml
---
r: 6943
b: refs/heads/master
c: 900bc12
h: refs/heads/master
i:
  6941: 286353c
  6939: f12056a
  6935: 258d8d6
  6927: 469fa4d
  6911: 3446f80
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: d812d06bc8d8f5c655b206838b64b133c83a7975
+refs/heads/master: 900bc1298df011bfb094858b11cdfd8d6b01418c

trunk/.gitignore

@@ -58,6 +58,7 @@ config.mk
 /rustllvm/
 /test/
 /build/
+/inst/
 /mingw-build/
 src/.DS_Store
 /stage0/

trunk/doc/rust.texi

@@ -3046,7 +3046,51 @@ Executing a @code{log} expression may, depending on runtime configuration,
 cause a value to be appended to an internal diagnostic logging buffer provided
 by the runtime or emitted to a system console. Log expressions are enabled or
 disabled dynamically at run-time on a per-task and per-item
-basis. @xref{Ref.Run.Log}.
+basis.  @xref{Ref.Run.Log}.
+
+Each @code{log} expression must be provided with a @emph{level} argument in
+addition to the value to log. The logging level is a @code{u32} value, where
+lower levels indicate more-urgent levels of logging. By default, the lowest
+four logging levels (@code{0_u32 ... 3_u32}) are predefined as the constants
+@code{error}, @code{warn}, @code{info} and @code{debug} in the @code{core}
+library.
+
+Additionally, the macros @code{#error}, @code{#warn}, @code{#info} and
+@code{#debug} are defined in the default syntax-extension namespace. These
+expand into calls to the logging facility composed with calls to the
+@code{#fmt} string formatting syntax-extension.
+
+The following examples all produce the same output, logged at the @code{error}
+logging level:
+
+@example
+// Full version, logging a value.
+log(core::error, "file not found: " + filename);
+
+// Log-level abbreviated, since core::* is imported by default.
+log(error, "file not found: " + filename);
+
+// Formatting the message using a format-string and #fmt
+log(error, #fmt("file not found: %s", filename));
+
+// Using the #error macro, that expands to the previous call.
+#error("file not found: %s", filename);
+@end example
+
+A @code{log} expression is @emph{not evaluated} when logging at the specified
+logging-level, module or task is disabled at runtime. This makes inactive
+@code{log} expressions very cheap; they should be used extensively in Rust
+code, as diagnostic aids, as they add little overhead beyond a single
+integer-compare and branch at runtime.
+
+Logging is presently implemented as a language built-in feature, as it makes
+use of compiler-provided logic for allocating the associated per-module
+logging-control structures visible to the runtime, and lazily evaluating
+arguments. In the future, as more of the supporting compiler-provided logic is
+moved into libraries, logging is likely to move to a component of the core
+library. It is best to use the macro forms of logging (@emph{#error},
+@emph{#debug}, etc.) to minimize disruption to code using the logging facility
+when it is changed.
 
 @example
 @end example

trunk/src/cargo/cargo.rs

@@ -203,7 +203,7 @@ fn try_parse_sources(filename: str, sources: map::hashmap<str, source>) {
         some(json::dict(_j)) {
             _j.items { |k, v|
                 sources.insert(k, parse_source(k, v));
-                log #fmt["source: %s", k];
+                #debug("source: %s", k);
             }
         }
         _ { fail "malformed sources.json"; }
@@ -269,11 +269,11 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         ref: ref,
         tags: tags
     });
-    log "  Loaded package: " + src.name + "/" + name;
+    log(debug, "  Loaded package: " + src.name + "/" + name);
 }
 
 fn load_source_packages(&c: cargo, &src: source) {
-    log "Loading source: " + src.name;
+    log(debug, "Loading source: " + src.name);
     let dir = fs::connect(c.sourcedir, src.name);
     let pkgfile = fs::connect(dir, "packages.json");
     if !fs::path_exists(pkgfile) { ret; }
@@ -356,7 +356,7 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
     if ri != -1 {
         name = str::slice(name, 0u, ri as uint);
     }
-    log #fmt["Installing: %s", name];
+    #debug("Installing: %s", name);
     let old = fs::list_dir(".");
     let p = run::program_output("rustc", [name + ".rc"]);
     if p.status != 0 {
@@ -370,22 +370,22 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
     for ct: str in created {
         if (exec_suffix != "" && str::ends_with(ct, exec_suffix)) ||
             (exec_suffix == "" && !str::starts_with(ct, "./lib")) {
-            log #fmt["  bin: %s", ct];
+            #debug("  bin: %s", ct);
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);
         } else {
-            log #fmt["  lib: %s", ct];
+            #debug("  lib: %s", ct);
             run::run_program("cp", [ct, c.libdir]);
         }
     }
 }
 
 fn install_source(c: cargo, path: str) {
-    log #fmt["source: %s", path];
+    #debug("source: %s", path);
     fs::change_dir(path);
     let contents = fs::list_dir(".");
 
-    log #fmt["contents: %s", str::connect(contents, ", ")];
+    #debug("contents: %s", str::connect(contents, ", "));
 
     let cratefiles =
         vec::filter::<str>(contents, { |n| str::ends_with(n, ".rc") });

trunk/src/cargo/sources.json

@@ -10,5 +10,8 @@
 	},
 	"brson": {
 		"url": "https://raw.github.com/brson/rust-packages/master/packages.json"
+	},
+	"erickt": {
+		"url": "https://raw.github.com/erickt/rust-packages/master/packages.json"
 	}
 }

trunk/src/comp/back/link.rs

@@ -588,15 +588,15 @@ fn link_binary(sess: session::session,
         let long_libname =
             std::os::dylib_filename(#fmt("%s-%s-%s",
                                          lm.name, lm.extras_hash, lm.vers));
-        log "link_meta.name: " + lm.name;
-        log "long_libname: " + long_libname;
-        log "out_filename: " + out_filename;
-        log "dirname(out_filename): " + fs::dirname(out_filename);
+        #debug("link_meta.name:  %s", lm.name);
+        #debug("long_libname: %s", long_libname);
+        #debug("out_filename: %s", out_filename);
+        #debug("dirname(out_filename): %s", fs::dirname(out_filename));
 
         fs::connect(fs::dirname(out_filename), long_libname)
     } else { out_filename };
 
-    log "output: " + output;
+    log(debug, "output: " + output);
 
     // The default library location, we need this to find the runtime.
     // The location of crates will be determined as needed.
@@ -670,7 +670,7 @@ fn link_binary(sess: session::session,
 
     gcc_args += rpath::get_rpath_flags(sess, output);
 
-    log #fmt("gcc link args: %s", str::connect(gcc_args, " "));
+    #debug("gcc link args: %s", str::connect(gcc_args, " "));
     // We run 'gcc' here
     let prog = run::program_output(prog, gcc_args);
     if 0 != prog.status {

trunk/src/comp/back/rpath.rs

@@ -21,7 +21,7 @@ fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
         ret [];
     }
 
-    log "preparing the RPATH!";
+    #debug("preparing the RPATH!");
 
     let cwd = os::getcwd();
     let sysroot = sess.filesearch().sysroot();
@@ -52,14 +52,14 @@ fn rpaths_to_flags(rpaths: [str]) -> [str] {
 fn get_rpaths(os: session::os, cwd: fs::path, sysroot: fs::path,
               output: fs::path, libs: [fs::path],
               target_triple: str) -> [str] {
-    log #fmt("cwd: %s", cwd);
-    log #fmt("sysroot: %s", sysroot);
-    log #fmt("output: %s", output);
-    log #fmt("libs:");
+    #debug("cwd: %s", cwd);
+    #debug("sysroot: %s", sysroot);
+    #debug("output: %s", output);
+    #debug("libs:");
     for libpath in libs {
-        log #fmt("    %s", libpath);
+        #debug("    %s", libpath);
     }
-    log #fmt("target_triple: %s", target_triple);
+    #debug("target_triple: %s", target_triple);
 
     // Use relative paths to the libraries. Binaries can be moved
     // as long as they maintain the relative relationship to the
@@ -74,9 +74,9 @@ fn get_rpaths(os: session::os, cwd: fs::path, sysroot: fs::path,
     let fallback_rpaths = [get_install_prefix_rpath(cwd, target_triple)];
 
     fn log_rpaths(desc: str, rpaths: [str]) {
-        log #fmt("%s rpaths:", desc);
+        #debug("%s rpaths:", desc);
         for rpath in rpaths {
-            log #fmt("    %s", rpath);
+            #debug("    %s", rpath);
         }
     }
 
@@ -117,8 +117,8 @@ fn get_rpath_relative_to_output(os: session::os,
 fn get_relative_to(abs1: fs::path, abs2: fs::path) -> fs::path {
     assert fs::path_is_absolute(abs1);
     assert fs::path_is_absolute(abs2);
-    log #fmt("finding relative path from %s to %s",
-             abs1, abs2);
+    #debug("finding relative path from %s to %s",
+           abs1, abs2);
     let normal1 = fs::normalize(abs1);
     let normal2 = fs::normalize(abs2);
     let split1 = str::split(normal1, os_fs::path_sep as u8);

trunk/src/comp/driver/driver.rs

@@ -105,8 +105,8 @@ fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
     let start = std::time::precise_time_s();
     let rv = thunk();
     let end = std::time::precise_time_s();
-    log_err #fmt["time: %s took %s s", what,
-                 float::to_str(end - start, 3u)];
+    #error("time: %s took %s s", what,
+           float::to_str(end - start, 3u));
     ret rv;
 }
 

trunk/src/comp/front/attr.rs

@@ -34,7 +34,7 @@ fn find_linkage_metas(attrs: [ast::attribute]) -> [@ast::meta_item] {
     for attr: ast::attribute in find_attrs_by_name(attrs, "link") {
         alt attr.node.value.node {
           ast::meta_list(_, items) { metas += items; }
-          _ { log "ignoring link attribute that has incorrect type"; }
+          _ { #debug("ignoring link attribute that has incorrect type"); }
         }
     }
     ret metas;
@@ -135,14 +135,14 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
 }
 
 fn contains(haystack: [@ast::meta_item], needle: @ast::meta_item) -> bool {
-    log #fmt["looking for %s",
-             syntax::print::pprust::meta_item_to_str(*needle)];
+    #debug("looking for %s",
+           syntax::print::pprust::meta_item_to_str(*needle));
     for item: @ast::meta_item in haystack {
-        log #fmt["looking in %s",
-                 syntax::print::pprust::meta_item_to_str(*item)];
-        if eq(item, needle) { log "found it!"; ret true; }
+        #debug("looking in %s",
+               syntax::print::pprust::meta_item_to_str(*item));
+        if eq(item, needle) { #debug("found it!"); ret true; }
     }
-    log "found it not :(";
+    #debug("found it not :(");
     ret false;
 }