---

yaml
---
r: 6926
b: refs/heads/master
c: dcd771c
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 9587c672301663d46f8d97d34bb82cd0506f8454
+refs/heads/master: dcd771cd4815e43558210ad1fcc7d6a219afafa5

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_full(core::debug, "  Loaded package: " + src.name + "/" + name);
 }
 
 fn load_source_packages(&c: cargo, &src: source) {
-    log "Loading source: " + src.name;
+    log_full(core::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/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_full(core::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);
         }
     }
 

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;
@@ -140,9 +140,9 @@ fn contains(haystack: [@ast::meta_item], needle: @ast::meta_item) -> bool {
     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; }
+        if eq(item, needle) { #debug("found it!"); ret true; }
     }
-    log "found it not :(";
+    #debug("found it not :(");
     ret false;
 }
 

trunk/src/comp/front/test.rs

@@ -79,7 +79,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
    @ast::item {
 
     cx.path += [i.ident];
-    log #fmt["current path: %s", ast_util::path_name_i(cx.path)];
+    #debug("current path: %s", ast_util::path_name_i(cx.path));
 
     if is_test_fn(i) {
         alt i.node {
@@ -89,12 +89,12 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
                 "unsafe functions cannot be used for tests");
           }
           _ {
-            log "this is a test function";
+            #debug("this is a test function");
             let test = {span: i.span,
                         path: cx.path, ignore: is_ignored(cx, i),
                         should_fail: should_fail(i)};
             cx.testfns += [test];
-            log #fmt["have %u test functions", vec::len(cx.testfns)];
+            #debug("have %u test functions", vec::len(cx.testfns));
           }
         }
     }
@@ -177,7 +177,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
          node: item_,
          span: dummy_sp()};
 
-    log #fmt["Synthetic test module:\n%s\n", pprust::item_to_str(@item)];
+    #debug("Synthetic test module:\n%s\n", pprust::item_to_str(@item));
 
     ret @item;
 }
@@ -239,7 +239,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
 }
 
 fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
-    log #fmt["building test vector from %u tests", vec::len(cx.testfns)];
+    #debug("building test vector from %u tests", vec::len(cx.testfns));
     let descs = [];
     for test: test in cx.testfns {
         let test_ = test; // Satisfy alias analysis
@@ -255,7 +255,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
     let span = test.span;
     let path = test.path;
 
-    log #fmt["encoding %s", ast_util::path_name_i(path)];
+    #debug("encoding %s", ast_util::path_name_i(path));
 
     let name_lit: ast::lit =
         nospan(ast::lit_str(ast_util::path_name_i(path)));

trunk/src/comp/lib/llvm.rs

@@ -1010,7 +1010,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
       12 { ret "Opaque"; }
       13 { ret "Vector"; }
       14 { ret "Metadata"; }
-      _ { log_err #fmt["unknown TypeKind %d", kind as int]; fail; }
+      _ { #error("unknown TypeKind %d", kind as int); fail; }
     }
 }
 

trunk/src/comp/metadata/creader.rs

@@ -107,15 +107,15 @@ fn metadata_matches(crate_data: @[u8], metas: [@ast::meta_item]) -> bool {
     log #fmt["matching %u metadata requirements against %u items",
              vec::len(metas), vec::len(linkage_metas)];
 
-    log #fmt("crate metadata:");
+    #debug("crate metadata:");
     for have: @ast::meta_item in linkage_metas {
-        log #fmt("  %s", pprust::meta_item_to_str(*have));
+        #debug("  %s", pprust::meta_item_to_str(*have));
     }
 
     for needed: @ast::meta_item in metas {
-        log #fmt["looking for %s", pprust::meta_item_to_str(*needed)];
+        #debug("looking for %s", pprust::meta_item_to_str(*needed));
         if !attr::contains(linkage_metas, needed) {
-            log #fmt["missing %s", pprust::meta_item_to_str(*needed)];
+            #debug("missing %s", pprust::meta_item_to_str(*needed));
             ret false;
         }
     }
@@ -175,26 +175,26 @@ fn find_library_crate_aux(sess: session::session,
     let suffix: str = nn.suffix;
 
     ret filesearch::search(filesearch, { |path|
-        log #fmt("inspecting file %s", path);
+        #debug("inspecting file %s", path);
         let f: str = fs::basename(path);
         if !(str::starts_with(f, prefix) && str::ends_with(f, suffix)) {
             log #fmt["skipping %s, doesn't look like %s*%s", path, prefix,
                      suffix];
             option::none
         } else {
-            log #fmt("%s is a candidate", path);
+            #debug("%s is a candidate", path);
             alt get_metadata_section(sess, path) {
               option::some(cvec) {
                 if !metadata_matches(cvec, metas) {
-                    log #fmt["skipping %s, metadata doesn't match", path];
+                    #debug("skipping %s, metadata doesn't match", path);
                     option::none
                 } else {
-                    log #fmt["found %s with matching metadata", path];
+                    #debug("found %s with matching metadata", path);
                     option::some({ident: path, data: cvec})
                 }
               }
               _ {
-                log #fmt("could not load metadata for %s", path);
+                #debug("could not load metadata for %s", path);
                 option::none
               }
             }
@@ -270,21 +270,21 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
 
 // Go through the crate metadata and load any crates that it references
 fn resolve_crate_deps(e: env, cdata: @[u8]) -> cstore::cnum_map {
-    log "resolving deps of external crate";
+    #debug("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
     let cnum_map = new_int_hash::<ast::crate_num>();
     for dep: decoder::crate_dep in decoder::get_crate_deps(cdata) {
         let extrn_cnum = dep.cnum;
         let cname = dep.ident;
-        log #fmt["resolving dep %s", cname];
+        #debug("resolving dep %s", cname);
         if e.crate_cache.contains_key(cname) {
-            log "already have it";
+            #debug("already have it");
             // We've already seen this crate
             let local_cnum = e.crate_cache.get(cname);
             cnum_map.insert(extrn_cnum, local_cnum);
         } else {
-            log "need to load it";
+            #debug("need to load it");
             // This is a new one so we've got to load it
             // FIXME: Need better error reporting than just a bogus span
             let fake_span = ast_util::dummy_sp();

trunk/src/comp/metadata/cstore.rs

@@ -127,16 +127,16 @@ fn get_dep_hashes(cstore: cstore) -> [str] {
     p(cstore).use_crate_map.values {|cnum|
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
-        log #fmt("Add hash[%s]: %s", cdata.name, hash);
+        #debug("Add hash[%s]: %s", cdata.name, hash);
         result += [{name: cdata.name, hash: hash}];
     };
     fn lteq(a: crate_hash, b: crate_hash) -> bool {
         ret a.name <= b.name;
     }
     let sorted = std::sort::merge_sort(lteq, result);
-    log "sorted:";
+    #debug("sorted:");
     for x in sorted {
-        log #fmt("  hash[%s]: %s", x.name, x.hash);
+        #debug("  hash[%s]: %s", x.name, x.hash);
     }
     fn mapper(ch: crate_hash) -> str { ret ch.hash; }
     ret vec::map(sorted, mapper);

trunk/src/comp/metadata/tydecode.rs

@@ -124,7 +124,7 @@ fn parse_constr_arg(st: @pstate, _sd: str_def) -> ast::fn_constr_arg {
             // FIXME
             ret ast::carg_ident((c as uint) - 48u);
         } else {
-            log_err "Lit args are unimplemented";
+            #error("Lit args are unimplemented");
             fail; // FIXME
         }
         /*
@@ -210,8 +210,8 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
               'c' { kind_copyable }
               'a' { kind_noncopyable }
               c {
-                log_err "unexpected char in encoded type param: ";
-                log_err c;
+                #error("unexpected char in encoded type param: ");
+                log_full(core::error, c);
                 fail
               }
             };
@@ -318,7 +318,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         assert (next(st) as char == ']');
         ret ty::mk_constr(st.tcx, tt, tcs);
       }
-      c { log_err "unexpected char in type string: "; log_err c; fail; }
+      c { #error("unexpected char in type string: %c", c); fail;}
     }
 }
 
@@ -393,7 +393,7 @@ fn parse_def_id(buf: [u8]) -> ast::def_id {
     let len = vec::len::<u8>(buf);
     while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; }
     if colon_idx == len {
-        log_err "didn't find ':' when parsing def id";
+        #error("didn't find ':' when parsing def id");
         fail;
     }
     let crate_part = vec::slice::<u8>(buf, 0u, colon_idx);

trunk/src/comp/middle/debuginfo.rs

@@ -714,9 +714,9 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
     let cx = fcx_ccx(fcx);
     let dbg_cx = option::get(cx.dbg_cx);
 
-    log "~~";
-    log fcx.id;
-    log cx.sess.span_str(fcx.sp);
+    #debug("~~");
+    log_full(core::debug, fcx.id);
+    log_full(core::debug, cx.sess.span_str(fcx.sp));
 
     let (ident, ret_ty, id) = alt cx.ast_map.get(fcx.id) {
       ast_map::node_item(item) {
@@ -746,8 +746,8 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
       }
     };
 
-    log ident;
-    log id;
+    log_full(core::debug, ident);
+    log_full(core::debug, id);
 
     let path = str::connect(fcx.lcx.path + [ident], "::");
 

trunk/src/comp/middle/fn_usage.rs

@@ -20,7 +20,7 @@ fn fn_usage_expr(expr: @ast::expr,
             alt ctx.tcx.def_map.find(expr.id) {
               some(ast::def_fn(_, ast::unsafe_fn.)) |
               some(ast::def_native_fn(_, ast::unsafe_fn.)) {
-                log_err ("expr=", expr_to_str(expr));
+                log_full(core::error, ("expr=", expr_to_str(expr)));
                 ctx.tcx.sess.span_fatal(
                     expr.span,
                     "unsafe functions can only be called");

trunk/src/comp/middle/resolve.rs

@@ -447,9 +447,9 @@ fn visit_fn_block_with_scope(_e: @env, decl: fn_decl, blk: ast::blk,
                              span: span, id: node_id,
                              sc: scopes, v: vt<scopes>) {
     let scope = scope_fn_expr(decl, id, []);
-    log ("scope=", scope);
+    log_full(core::debug, ("scope=", scope));
     visit::visit_fn_block(decl, blk, span, id, cons(scope, @sc), v);
-    log ("unscope");
+    log_full(core::debug, ("unscope"));
 }
 
 fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {