---

yaml
---
r: 6942
b: refs/heads/master
c: d812d06
h: refs/heads/master
v: v3

Author: Lenny222

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 47271ab4c85ecc4b7c3f1c079f8bc221a5d7ca0d
+refs/heads/master: d812d06bc8d8f5c655b206838b64b133c83a7975

trunk/.gitignore

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

trunk/doc/rust.texi

@@ -3046,51 +3046,7 @@ 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}.
-
-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.
+basis. @xref{Ref.Run.Log}.
 
 @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));
-                #debug("source: %s", k);
+                log #fmt["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(debug, "  Loaded package: " + src.name + "/" + name);
+    log "  Loaded package: " + src.name + "/" + name;
 }
 
 fn load_source_packages(&c: cargo, &src: source) {
-    log(debug, "Loading source: " + src.name);
+    log "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);
     }
-    #debug("Installing: %s", name);
+    log #fmt["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")) {
-            #debug("  bin: %s", ct);
+            log #fmt["  bin: %s", ct];
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);
         } else {
-            #debug("  lib: %s", ct);
+            log #fmt["  lib: %s", ct];
             run::run_program("cp", [ct, c.libdir]);
         }
     }
 }
 
 fn install_source(c: cargo, path: str) {
-    #debug("source: %s", path);
+    log #fmt["source: %s", path];
     fs::change_dir(path);
     let contents = fs::list_dir(".");
 
-    #debug("contents: %s", str::connect(contents, ", "));
+    log #fmt["contents: %s", str::connect(contents, ", ")];
 
     let cratefiles =
         vec::filter::<str>(contents, { |n| str::ends_with(n, ".rc") });

trunk/src/cargo/sources.json

@@ -10,8 +10,5 @@
 	},
 	"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));
-        #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));
+        log "link_meta.name: " + lm.name;
+        log "long_libname: " + long_libname;
+        log "out_filename: " + out_filename;
+        log "dirname(out_filename): " + fs::dirname(out_filename);
 
         fs::connect(fs::dirname(out_filename), long_libname)
     } else { out_filename };
 
-    log(debug, "output: " + output);
+    log "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);
 
-    #debug("gcc link args: %s", str::connect(gcc_args, " "));
+    log #fmt("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 [];
     }
 
-    #debug("preparing the RPATH!");
+    log "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] {
-    #debug("cwd: %s", cwd);
-    #debug("sysroot: %s", sysroot);
-    #debug("output: %s", output);
-    #debug("libs:");
+    log #fmt("cwd: %s", cwd);
+    log #fmt("sysroot: %s", sysroot);
+    log #fmt("output: %s", output);
+    log #fmt("libs:");
     for libpath in libs {
-        #debug("    %s", libpath);
+        log #fmt("    %s", libpath);
     }
-    #debug("target_triple: %s", target_triple);
+    log #fmt("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]) {
-        #debug("%s rpaths:", desc);
+        log #fmt("%s rpaths:", desc);
         for rpath in rpaths {
-            #debug("    %s", rpath);
+            log #fmt("    %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);
-    #debug("finding relative path from %s to %s",
-           abs1, abs2);
+    log #fmt("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();
-    #error("time: %s took %s s", what,
-           float::to_str(end - start, 3u));
+    log_err #fmt["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; }
-          _ { #debug("ignoring link attribute that has incorrect type"); }
+          _ { log "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 {
-    #debug("looking for %s",
-           syntax::print::pprust::meta_item_to_str(*needle));
+    log #fmt["looking for %s",
+             syntax::print::pprust::meta_item_to_str(*needle)];
     for item: @ast::meta_item in haystack {
-        #debug("looking in %s",
-               syntax::print::pprust::meta_item_to_str(*item));
-        if eq(item, needle) { #debug("found it!"); ret true; }
+        log #fmt["looking in %s",
+                 syntax::print::pprust::meta_item_to_str(*item)];
+        if eq(item, needle) { log "found it!"; ret true; }
     }
-    #debug("found it not :(");
+    log "found it not :(";
     ret false;
 }