diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs index 99109f5d489..3c56cdd9f61 100644 --- a/src/cargo/cargo.rs +++ b/src/cargo/cargo.rs @@ -203,7 +203,7 @@ fn try_parse_sources(filename: str, sources: map::hashmap) { 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) { 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::(contents, { |n| str::ends_with(n, ".rc") }); diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index 95afc2b55cb..e7359fb2cdf 100644 --- a/src/comp/back/link.rs +++ b/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 { diff --git a/src/comp/back/rpath.rs b/src/comp/back/rpath.rs index 1e32794da5f..1339e30bacf 100644 --- a/src/comp/back/rpath.rs +++ b/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); } } diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs index 6992c731205..98460ae2a92 100644 --- a/src/comp/front/attr.rs +++ b/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; } diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs index a01f17c14df..d2e73508f6c 100644 --- a/src/comp/front/test.rs +++ b/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; } @@ -242,7 +242,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 @@ -258,7 +258,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))); diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs index c0fe027f39b..25617066515 100644 --- a/src/comp/lib/llvm.rs +++ b/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; } } } diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs index 9f74f7afece..e61c7743eed 100644 --- a/src/comp/metadata/creader.rs +++ b/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::(); 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(); diff --git a/src/comp/metadata/cstore.rs b/src/comp/metadata/cstore.rs index ae7119fbeed..b85051ea09a 100644 --- a/src/comp/metadata/cstore.rs +++ b/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); diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index 5f87016866a..56a38ec14b4 100644 --- a/src/comp/metadata/tydecode.rs +++ b/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::(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::(buf, 0u, colon_idx); diff --git a/src/comp/middle/debuginfo.rs b/src/comp/middle/debuginfo.rs index 19b1578b29a..957250da9fc 100644 --- a/src/comp/middle/debuginfo.rs +++ b/src/comp/middle/debuginfo.rs @@ -714,9 +714,9 @@ fn create_function(fcx: @fn_ctxt) -> @metadata { 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 { } }; - log ident; - log id; + log_full(core::debug, ident); + log_full(core::debug, id); let path = str::connect(fcx.lcx.path + [ident], "::"); diff --git a/src/comp/middle/fn_usage.rs b/src/comp/middle/fn_usage.rs index 1bf9533f080..71fabffe9bc 100644 --- a/src/comp/middle/fn_usage.rs +++ b/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"); diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 384b44a24cf..3fb9c4a3798 100644 --- a/src/comp/middle/resolve.rs +++ b/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) { 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) { diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 786ab1886c8..b9741645231 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -1122,7 +1122,7 @@ fn set_glue_inlining(cx: @local_ctxt, f: ValueRef, t: ty::t) { fn declare_tydesc(cx: @local_ctxt, sp: span, t: ty::t, ty_params: [uint], is_obj_body: bool) -> @tydesc_info { - log "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t); + log_full(core::debug, "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t)); let ccx = cx.ccx; let llsize; let llalign; @@ -1158,7 +1158,7 @@ fn declare_tydesc(cx: @local_ctxt, sp: span, t: ty::t, ty_params: [uint], mutable cmp_glue: none::, ty_params: ty_params, is_obj_body: is_obj_body}; - log "--- declare_tydesc " + ty_to_str(cx.ccx.tcx, t); + log_full(core::debug, "--- declare_tydesc " + ty_to_str(cx.ccx.tcx, t)); ret info; } @@ -5713,16 +5713,16 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, // Translate the metadata. write_metadata(cx.ccx, crate); if ccx.sess.get_opts().stats { - log_err "--- trans stats ---"; - log_err #fmt["n_static_tydescs: %u", ccx.stats.n_static_tydescs]; - log_err #fmt["n_derived_tydescs: %u", ccx.stats.n_derived_tydescs]; - log_err #fmt["n_glues_created: %u", ccx.stats.n_glues_created]; - log_err #fmt["n_null_glues: %u", ccx.stats.n_null_glues]; - log_err #fmt["n_real_glues: %u", ccx.stats.n_real_glues]; + #error("--- trans stats ---"); + #error("n_static_tydescs: %u", ccx.stats.n_static_tydescs); + #error("n_derived_tydescs: %u", ccx.stats.n_derived_tydescs); + #error("n_glues_created: %u", ccx.stats.n_glues_created); + #error("n_null_glues: %u", ccx.stats.n_null_glues); + #error("n_real_glues: %u", ccx.stats.n_real_glues); for timing: {ident: str, time: int} in *ccx.stats.fn_times { - log_err #fmt["time: %s took %d ms", timing.ident, timing.time]; + #error("time: %s took %d ms", timing.ident, timing.time); } } ret (llmod, link_meta); diff --git a/src/comp/middle/trans_build.rs b/src/comp/middle/trans_build.rs index 5a9c0773147..021917f3d3e 100644 --- a/src/comp/middle/trans_build.rs +++ b/src/comp/middle/trans_build.rs @@ -516,7 +516,7 @@ fn add_span_comment(bcx: @block_ctxt, sp: span, text: str) { let ccx = bcx_ccx(bcx); if (!ccx.sess.get_opts().no_asm_comments) { let s = text + " (" + ccx.sess.span_str(sp) + ")"; - log s; + log_full(core::debug, s); add_comment(bcx, s); } } diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs index 389fbf1c76d..2cf7549da49 100644 --- a/src/comp/middle/tstate/annotate.rs +++ b/src/comp/middle/tstate/annotate.rs @@ -15,12 +15,12 @@ fn collect_ids_block(b: blk, rs: @mutable [node_id]) { *rs += [b.node.id]; } fn collect_ids_stmt(s: @stmt, rs: @mutable [node_id]) { alt s.node { stmt_decl(_, id) { - log "node_id " + int::str(id); + log_full(core::debug, "node_id " + int::str(id)); log_stmt(*s);; *rs += [id]; } stmt_expr(_, id) { - log "node_id " + int::str(id); + log_full(core::debug, "node_id " + int::str(id)); log_stmt(*s);; *rs += [id]; } @@ -44,7 +44,7 @@ fn node_ids_in_fn(body: blk, rs: @mutable [node_id]) { fn init_vecs(ccx: crate_ctxt, node_ids: [node_id], len: uint) { for i: node_id in node_ids { - log int::str(i) + " |-> " + uint::str(len); + log_full(core::debug, int::str(i) + " |-> " + uint::str(len)); add_node(ccx, i, empty_ann(len)); } } diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs index c2d1732c86e..6d38e2fe3a5 100644 --- a/src/comp/middle/tstate/auxiliary.rs +++ b/src/comp/middle/tstate/auxiliary.rs @@ -77,7 +77,9 @@ fn tritv_to_str(fcx: fn_ctxt, v: tritv::t) -> str { ret s; } -fn log_tritv(fcx: fn_ctxt, v: tritv::t) { log tritv_to_str(fcx, v); } +fn log_tritv(fcx: fn_ctxt, v: tritv::t) { + log_full(core::debug, tritv_to_str(fcx, v)); +} fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t) -> str { @@ -91,7 +93,9 @@ fn first_difference_string(fcx: fn_ctxt, expected: tritv::t, actual: tritv::t) ret s; } -fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) { log_err tritv_to_str(fcx, v); } +fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) { + log_full(core::error, tritv_to_str(fcx, v)); +} fn tos(v: [uint]) -> str { let rslt = ""; @@ -103,51 +107,51 @@ fn tos(v: [uint]) -> str { ret rslt; } -fn log_cond(v: [uint]) { log tos(v); } +fn log_cond(v: [uint]) { log_full(core::debug, tos(v)); } -fn log_cond_err(v: [uint]) { log_err tos(v); } +fn log_cond_err(v: [uint]) { log_full(core::error, tos(v)); } fn log_pp(pp: pre_and_post) { let p1 = tritv::to_vec(pp.precondition); let p2 = tritv::to_vec(pp.postcondition); - log "pre:"; + #debug("pre:"); log_cond(p1); - log "post:"; + #debug("post:"); log_cond(p2); } fn log_pp_err(pp: pre_and_post) { let p1 = tritv::to_vec(pp.precondition); let p2 = tritv::to_vec(pp.postcondition); - log_err "pre:"; + #error("pre:"); log_cond_err(p1); - log_err "post:"; + #error("post:"); log_cond_err(p2); } fn log_states(pp: pre_and_post_state) { let p1 = tritv::to_vec(pp.prestate); let p2 = tritv::to_vec(pp.poststate); - log "prestate:"; + #debug("prestate:"); log_cond(p1); - log "poststate:"; + #debug("poststate:"); log_cond(p2); } fn log_states_err(pp: pre_and_post_state) { let p1 = tritv::to_vec(pp.prestate); let p2 = tritv::to_vec(pp.poststate); - log_err "prestate:"; + #error("prestate:"); log_cond_err(p1); - log_err "poststate:"; + #error("poststate:"); log_cond_err(p2); } -fn print_ident(i: ident) { log " " + i + " "; } +fn print_ident(i: ident) { log_full(core::debug, " " + i + " "); } fn print_idents(&idents: [ident]) { if vec::len::(idents) == 0u { ret; } - log "an ident: " + vec::pop::(idents); + log_full(core::debug, "an ident: " + vec::pop::(idents)); print_idents(idents); } @@ -303,7 +307,7 @@ fn get_ts_ann(ccx: crate_ctxt, i: node_id) -> option::t { fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { alt get_ts_ann(ccx, id) { none. { - log_err "node_id_to_ts_ann: no ts_ann for node_id " + int::str(id); + #error("node_id_to_ts_ann: no ts_ann for node_id %d", id); fail; } some(t) { ret t; } @@ -311,12 +315,12 @@ fn node_id_to_ts_ann(ccx: crate_ctxt, id: node_id) -> ts_ann { } fn node_id_to_poststate(ccx: crate_ctxt, id: node_id) -> poststate { - log "node_id_to_poststate"; + #debug("node_id_to_poststate"); ret node_id_to_ts_ann(ccx, id).states.poststate; } fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { - log "stmt_to_ann"; + #debug("stmt_to_ann"); alt s.node { stmt_decl(_, id) { ret node_id_to_ts_ann(ccx, id); } stmt_expr(_, id) { ret node_id_to_ts_ann(ccx, id); } @@ -326,14 +330,14 @@ fn stmt_to_ann(ccx: crate_ctxt, s: stmt) -> ts_ann { /* fails if e has no annotation */ fn expr_states(ccx: crate_ctxt, e: @expr) -> pre_and_post_state { - log "expr_states"; + #debug("expr_states"); ret node_id_to_ts_ann(ccx, e.id).states; } /* fails if e has no annotation */ fn expr_pp(ccx: crate_ctxt, e: @expr) -> pre_and_post { - log "expr_pp"; + #debug("expr_pp"); ret node_id_to_ts_ann(ccx, e.id).conditions; } @@ -344,7 +348,7 @@ fn stmt_pp(ccx: crate_ctxt, s: stmt) -> pre_and_post { /* fails if b has no annotation */ fn block_pp(ccx: crate_ctxt, b: blk) -> pre_and_post { - log "block_pp"; + #debug("block_pp"); ret node_id_to_ts_ann(ccx, b.node.id).conditions; } @@ -359,7 +363,7 @@ fn clear_precond(ccx: crate_ctxt, id: node_id) { } fn block_states(ccx: crate_ctxt, b: blk) -> pre_and_post_state { - log "block_states"; + #debug("block_states"); ret node_id_to_ts_ann(ccx, b.node.id).states; } @@ -420,43 +424,43 @@ fn block_poststate(ccx: crate_ctxt, b: blk) -> poststate { } fn set_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { - log "set_prestate_ann"; + #debug("set_prestate_ann"); ret set_prestate(node_id_to_ts_ann(ccx, id), pre); } fn extend_prestate_ann(ccx: crate_ctxt, id: node_id, pre: prestate) -> bool { - log "extend_prestate_ann"; + #debug("extend_prestate_ann"); ret extend_prestate(node_id_to_ts_ann(ccx, id).states.prestate, pre); } fn set_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { - log "set_poststate_ann"; + #debug("set_poststate_ann"); ret set_poststate(node_id_to_ts_ann(ccx, id), post); } fn extend_poststate_ann(ccx: crate_ctxt, id: node_id, post: poststate) -> bool { - log "extend_poststate_ann"; + #debug("extend_poststate_ann"); ret extend_poststate(node_id_to_ts_ann(ccx, id).states.poststate, post); } fn set_pre_and_post(ccx: crate_ctxt, id: node_id, pre: precond, post: postcond) { - log "set_pre_and_post"; + #debug("set_pre_and_post"); let t = node_id_to_ts_ann(ccx, id); set_precondition(t, pre); set_postcondition(t, post); } fn copy_pre_post(ccx: crate_ctxt, id: node_id, sub: @expr) { - log "set_pre_and_post"; + #debug("set_pre_and_post"); let p = expr_pp(ccx, sub); copy_pre_post_(ccx, id, p.precondition, p.postcondition); } fn copy_pre_post_(ccx: crate_ctxt, id: node_id, pre: prestate, post: poststate) { - log "set_pre_and_post"; + #debug("set_pre_and_post"); let t = node_id_to_ts_ann(ccx, id); set_precondition(t, pre); set_postcondition(t, post); @@ -499,7 +503,7 @@ fn constraints_expr(cx: ty::ctxt, e: @expr) -> [@ty::constr] { fn node_id_to_def_strict(cx: ty::ctxt, id: node_id) -> def { alt cx.def_map.find(id) { none. { - log_err "node_id_to_def: node_id " + int::str(id) + " has no def"; + #error("node_id_to_def: node_id %d has no def", id); fail; } some(d) { ret d; } @@ -546,7 +550,8 @@ fn match_args(fcx: fn_ctxt, occs: @mutable [pred_args], log "match_args: looking at " + constr_args_to_str(fn (i: inst) -> str { ret i.ident; }, occ); for pd: pred_args in *occs { - log "match_args: candidate " + pred_args_to_str(pd); + log_full(core::debug, + "match_args: candidate " + pred_args_to_str(pd)); fn eq(p: inst, q: inst) -> bool { ret p.node == q.node; } if ty::args_eq(eq, pd.node.args, occ) { ret pd.node.bit_num; } } @@ -750,7 +755,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_] { } } _ { - // log_err "##"; + // #error("##"); rslt += [c.node]; } } @@ -760,7 +765,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_] { for (constr_arg_general_ p in rslt) { alt (p) { case (carg_ident(?p)) { - log_err p._0; + log_full(core::error, p._0); } case (_) {} } @@ -975,7 +980,7 @@ fn args_mention(args: [@constr_arg_use], q: fn([T], node_id) -> bool, alt (a.node) { case (carg_ident(?p1)) { auto res = q(s, p1._1); - log_err (res); + log_full(core::error, (res)); res } case (_) { false } diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs index ac21c592951..10f5cfa10fe 100644 --- a/src/comp/middle/tstate/bitvectors.rs +++ b/src/comp/middle/tstate/bitvectors.rs @@ -158,7 +158,7 @@ fn relax_precond_block(fcx: fn_ctxt, i: node_id, b: blk) { } fn gen_poststate(fcx: fn_ctxt, id: node_id, c: tsconstr) -> bool { - log "gen_poststate"; + #debug("gen_poststate"); ret set_in_poststate(bit_num(fcx, c), node_id_to_ts_ann(fcx.ccx, id).states); } @@ -174,7 +174,7 @@ fn kill_all_prestate(fcx: fn_ctxt, id: node_id) { fn kill_poststate(fcx: fn_ctxt, id: node_id, c: tsconstr) -> bool { - log "kill_poststate"; + #debug("kill_poststate"); ret clear_in_poststate(bit_num(fcx, c), node_id_to_ts_ann(fcx.ccx, id).states); } @@ -203,7 +203,7 @@ fn clear_in_poststate_expr(fcx: fn_ctxt, e: @expr, t: poststate) { } fn kill_poststate_(fcx: fn_ctxt, c: tsconstr, post: poststate) -> bool { - log "kill_poststate_"; + #debug("kill_poststate_"); ret clear_in_poststate_(bit_num(fcx, c), post); } diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs index 72b5d6fbab3..ea5d666f0f0 100644 --- a/src/comp/middle/tstate/ck.rs +++ b/src/comp/middle/tstate/ck.rs @@ -74,7 +74,7 @@ fn check_states_stmt(s: @stmt, fcx: fn_ctxt, v: visit::vt) { log("check_states_stmt:"); - log print::pprust::stmt_to_str(*s); + log_full(core::debug, print::pprust::stmt_to_str(*s)); log("prec = "); log_tritv(fcx, prec); log("pres = "); diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs index 125a165b9aa..f73c325ccf0 100644 --- a/src/comp/middle/tstate/collect_locals.rs +++ b/src/comp/middle/tstate/collect_locals.rs @@ -13,7 +13,7 @@ type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt}; fn collect_local(loc: @local, cx: ctxt, v: visit::vt) { pat_bindings(loc.node.pat) {|p| let ident = alt p.node { pat_bind(id, _) { id } }; - log "collect_local: pushing " + ident;; + log_full(core::debug, "collect_local: pushing " + ident);; *cx.cs += [respan(loc.span, ninit(p.id, ident))]; }; visit::visit_local(loc, cx, v); @@ -65,7 +65,8 @@ fn find_locals(tcx: ty::ctxt, fn add_constraint(tcx: ty::ctxt, c: sp_constr, next: uint, tbl: constr_map) -> uint { - log constraint_to_str(tcx, c) + " |-> " + uint::str(next); + log_full(core::debug, + constraint_to_str(tcx, c) + " |-> " + uint::str(next)); alt c.node { ninit(id, i) { tbl.insert(local_def(id), cinit(next, c.span, i)); } npred(p, d_id, args) { diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs index c47d0db6ece..db2c6a7d9ba 100644 --- a/src/comp/middle/tstate/pre_post_conditions.rs +++ b/src/comp/middle/tstate/pre_post_conditions.rs @@ -17,12 +17,12 @@ import syntax::codemap::span; import util::ppaux::fn_ident_to_string; fn find_pre_post_mod(_m: _mod) -> _mod { - log "implement find_pre_post_mod!"; + #debug("implement find_pre_post_mod!"); fail; } fn find_pre_post_native_mod(_m: native_mod) -> native_mod { - log "implement find_pre_post_native_mod"; + #debug("implement find_pre_post_native_mod"); fail; } @@ -86,7 +86,7 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) { be the union of all postconditions for */ fn find_pre_post_exprs(fcx: fn_ctxt, args: [@expr], id: node_id) { if vec::len::<@expr>(args) > 0u { - log "find_pre_post_exprs: oper ="; + #debug("find_pre_post_exprs: oper ="); log_expr(*args[0]); } fn do_one(fcx: fn_ctxt, e: @expr) { find_pre_post_expr(fcx, e); } @@ -276,7 +276,7 @@ fn handle_var(fcx: fn_ctxt, rslt: pre_and_post, id: node_id, name: ident) { } fn handle_var_def(fcx: fn_ctxt, rslt: pre_and_post, def: def, name: ident) { - log ("handle_var_def: ", def, name); + log_full(core::debug, ("handle_var_def: ", def, name)); alt def { def_local(d_id, _) | def_arg(d_id, _) { use_var(fcx, d_id.node); @@ -302,7 +302,7 @@ fn find_pre_post_expr_fn_upvars(fcx: fn_ctxt, e: @expr) { let rslt = expr_pp(fcx.ccx, e); clear_pp(rslt); for def in *freevars::get_freevars(fcx.ccx.tcx, e.id) { - log ("handle_var_def: def=", def); + log_full(core::debug, ("handle_var_def: def=", def)); handle_var_def(fcx, rslt, def.def, "upvar"); } } @@ -358,7 +358,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { vec::iter(cap_clause.moves, use_cap_item); vec::iter(cap_clause.moves) { |cap_item| - log ("forget_in_postcond: ", cap_item); + log_full(core::debug, ("forget_in_postcond: ", cap_item)); forget_in_postcond(fcx, e.id, cap_item.id); } } @@ -565,7 +565,7 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) { } fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) { - log "stmt ="; + #debug("stmt ="); log_stmt(s); alt s.node { stmt_decl(adecl, id) { @@ -678,9 +678,9 @@ fn find_pre_post_block(fcx: fn_ctxt, b: blk) { fn do_one_(fcx: fn_ctxt, s: @stmt) { find_pre_post_stmt(fcx, *s); /* - log_err "pre_post for stmt:"; + #error("pre_post for stmt:"); log_stmt_err(*s); - log_err "is:"; + #error("is:"); log_pp_err(stmt_pp(fcx.ccx, *s)); */ } diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs index b48f8dc61f1..a0f264e921a 100644 --- a/src/comp/middle/tstate/states.rs +++ b/src/comp/middle/tstate/states.rs @@ -468,7 +468,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { } expr_while(test, body) { /* - log_err "in a while loop:"; + #error("in a while loop:"); log_expr_err(*e); aux::log_tritv_err(fcx, block_poststate(fcx.ccx, body)); aux::log_tritv_err(fcx, pres); @@ -476,7 +476,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool { let loop_pres = intersect_states(block_poststate(fcx.ccx, body), pres); // aux::log_tritv_err(fcx, loop_pres); - // log_err "---------------"; + // #error("---------------"); let changed = set_prestate_ann(fcx.ccx, e.id, loop_pres) | @@ -621,14 +621,14 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { let stmt_ann = stmt_to_ann(fcx.ccx, *s); /* - log_err ("[" + fcx.name + "]"); - log_err "*At beginning: stmt = "; + log_full(core::error, ("[" + fcx.name + "]")); + #error("*At beginning: stmt = "); log_stmt_err(*s); - log_err "*prestate = "; + #error("*prestate = "); log_tritv_err(fcx, stmt_ann.states.prestate); - log_err "*poststate ="; + #error("*poststate ="); log_tritv_err(fcx, stmt_ann.states.poststate); - log_err "pres = "; + #error("pres = "); log_tritv_err(fcx, pres); */ @@ -646,14 +646,14 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { set_poststate(stmt_ann, c_and_p.post) | c_and_p.changed; /* - log_err "Summary: stmt = "; + #error("Summary: stmt = "); log_stmt_err(*s); - log_err "prestate = "; + #error("prestate = "); log_tritv_err(fcx, stmt_ann.states.prestate); - log_err "poststate ="; + #error("poststate ="); log_tritv_err(fcx, stmt_ann.states.poststate); - log_err "changed ="; - log_err changed; + #error("changed ="); + log_full(core::error, changed); */ ret changed; @@ -671,7 +671,7 @@ fn find_pre_post_state_stmt(fcx: fn_ctxt, pres: prestate, s: @stmt) -> bool { set_poststate(stmt_ann, expr_poststate(fcx.ccx, ex)); /* - log_err "Finally:"; + #error("Finally:"); log_stmt_err(*s); log_err("prestate = "); log_err(bitv::to_str(stmt_ann.states.prestate)); @@ -718,16 +718,16 @@ fn find_pre_post_state_block(fcx: fn_ctxt, pres0: prestate, b: blk) -> bool { /* - log_err "For block:"; + #error("For block:"); log_block_err(b); - log_err "poststate = "; + #error("poststate = "); log_states_err(block_states(fcx.ccx, b)); - log_err "pres0:"; + #error("pres0:"); log_tritv_err(fcx, pres0); - log_err "post:"; + #error("post:"); log_tritv_err(fcx, post); - log_err "changed = "; - log_err changed; + #error("changed = "); + log_full(core::error, changed); */ ret changed; @@ -773,8 +773,8 @@ fn find_pre_post_state_fn(fcx: fn_ctxt, } /* - log_err "find_pre_post_state_fn"; - log_err changed; + #error("find_pre_post_state_fn"); + log_full(core::error, changed); fcx.ccx.tcx.sess.span_note(f_body.span, fcx.name); */ diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 25c8d948a40..593720f4d6f 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -1535,7 +1535,7 @@ fn is_pred_ty(cx: ctxt, fty: t) -> bool { fn ty_var_id(cx: ctxt, typ: t) -> int { alt struct(cx, typ) { ty::ty_var(vid) { ret vid; } - _ { log_err "ty_var_id called on non-var ty"; fail; } + _ { #error("ty_var_id called on non-var ty"); fail; } } } @@ -2450,7 +2450,7 @@ mod unify { none. { typespec = ""; } some(typ) { typespec = " =" + ty_to_str(tcx, typ); } } - log_err #fmt["set %u:%s%s", i, typespec, sets]; + #error("set %u:%s%s", i, typespec, sets); i += 1u; } } diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 400411fa68a..f9faa39dbf6 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -1530,7 +1530,8 @@ fn check_expr_fn_with_unifier(fcx: @fn_ctxt, fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier, expected: ty::t) -> bool { - //log_err "typechecking expr " + syntax::print::pprust::expr_to_str(expr); + #debug("typechecking expr %s", + syntax::print::pprust::expr_to_str(expr)); // A generic function to factor out common logic from call and bind // expressions. diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs index 3700ce2edfa..b91c19644bb 100644 --- a/src/comp/syntax/ext/fmt.rs +++ b/src/comp/syntax/ext/fmt.rs @@ -28,8 +28,8 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: @ast::expr, expr_to_str(cx, args[0], "first argument to #fmt must be a " + "string literal."); let fmtspan = args[0].span; - log "Format string:"; - log fmt; + #debug("Format string:"); + log_full(core::debug, fmt); fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: str) -> ! { cx.span_fatal(sp, msg); } @@ -252,53 +252,57 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr]) } fn log_conv(c: conv) { alt c.param { - some(p) { log "param: " + int::to_str(p, 10u); } - _ { log "param: none"; } + some(p) { log_full(core::debug, "param: " + int::to_str(p, 10u)); } + _ { #debug("param: none"); } } for f: flag in c.flags { alt f { - flag_left_justify. { log "flag: left justify"; } - flag_left_zero_pad. { log "flag: left zero pad"; } - flag_space_for_sign. { log "flag: left space pad"; } - flag_sign_always. { log "flag: sign always"; } - flag_alternate. { log "flag: alternate"; } + flag_left_justify. { #debug("flag: left justify"); } + flag_left_zero_pad. { #debug("flag: left zero pad"); } + flag_space_for_sign. { #debug("flag: left space pad"); } + flag_sign_always. { #debug("flag: sign always"); } + flag_alternate. { #debug("flag: alternate"); } } } alt c.width { - count_is(i) { log "width: count is " + int::to_str(i, 10u); } + count_is(i) { log_full(core::debug, + "width: count is " + int::to_str(i, 10u)); } count_is_param(i) { - log "width: count is param " + int::to_str(i, 10u); + log_full(core::debug, + "width: count is param " + int::to_str(i, 10u)); } - count_is_next_param. { log "width: count is next param"; } - count_implied. { log "width: count is implied"; } + count_is_next_param. { #debug("width: count is next param"); } + count_implied. { #debug("width: count is implied"); } } alt c.precision { - count_is(i) { log "prec: count is " + int::to_str(i, 10u); } + count_is(i) { log_full(core::debug, + "prec: count is " + int::to_str(i, 10u)); } count_is_param(i) { - log "prec: count is param " + int::to_str(i, 10u); + log_full(core::debug, + "prec: count is param " + int::to_str(i, 10u)); } - count_is_next_param. { log "prec: count is next param"; } - count_implied. { log "prec: count is implied"; } + count_is_next_param. { #debug("prec: count is next param"); } + count_implied. { #debug("prec: count is implied"); } } alt c.ty { - ty_bool. { log "type: bool"; } - ty_str. { log "type: str"; } - ty_char. { log "type: char"; } + ty_bool. { #debug("type: bool"); } + ty_str. { #debug("type: str"); } + ty_char. { #debug("type: char"); } ty_int(s) { alt s { - signed. { log "type: signed"; } - unsigned. { log "type: unsigned"; } + signed. { #debug("type: signed"); } + unsigned. { #debug("type: unsigned"); } } } - ty_bits. { log "type: bits"; } + ty_bits. { #debug("type: bits"); } ty_hex(cs) { alt cs { - case_upper. { log "type: uhex"; } - case_lower. { log "type: lhex"; } + case_upper. { #debug("type: uhex"); } + case_lower. { #debug("type: lhex"); } } } - ty_octal. { log "type: octal"; } - ty_float. { log "type: float"; } + ty_octal. { #debug("type: octal"); } + ty_float. { #debug("type: float"); } } } let fmt_sp = args[0].span; @@ -318,7 +322,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span, pieces: [piece], args: [@ast::expr]) "not enough arguments to #fmt " + "for the given format string"); } - log "Building conversion:"; + #debug("Building conversion:"); log_conv(conv); let arg_expr = args[n]; let c_expr = make_new_conv(cx, fmt_sp, conv, arg_expr); diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs index 2b0fcab9b8e..904b7698118 100644 --- a/src/comp/syntax/parse/eval.rs +++ b/src/comp/syntax/parse/eval.rs @@ -29,7 +29,7 @@ fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str, fn eval_crate_directives_to_mod(cx: ctx, cdirs: [@ast::crate_directive], prefix: str, suffix: option::t) -> (ast::_mod, [ast::attribute]) { - log #fmt("eval crate prefix: %s", prefix); + #debug("eval crate prefix: %s", prefix); log #fmt("eval crate suffix: %s", option::from_maybe("none", suffix)); let (cview_items, citems, cattrs) @@ -72,9 +72,9 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option::t) } let modpath = companion_file(prefix, suffix); - log #fmt("looking for companion mod %s", modpath); + #debug("looking for companion mod %s", modpath); if file_exists(modpath) { - log "found companion mod"; + #debug("found companion mod"); let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, cx.chpos, cx.byte_pos, SOURCE_FILE); let inner_attrs = parse_inner_attrs_and_next(p0); diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs index 3529a512a89..9821f7bdfa9 100644 --- a/src/comp/syntax/parse/lexer.rs +++ b/src/comp/syntax/parse/lexer.rs @@ -560,7 +560,7 @@ fn consume_non_eol_whitespace(rdr: reader) { } fn push_blank_line_comment(rdr: reader, &comments: [cmnt]) { - log ">>> blank-line comment"; + #debug(">>> blank-line comment"); let v: [str] = []; comments += [{style: blank_line, lines: v, pos: rdr.get_chpos()}]; } @@ -575,16 +575,16 @@ fn consume_whitespace_counting_blank_lines(rdr: reader, &comments: [cmnt]) { } fn read_line_comments(rdr: reader, code_to_the_left: bool) -> cmnt { - log ">>> line comments"; + #debug(">>> line comments"); let p = rdr.get_chpos(); let lines: [str] = []; while rdr.curr() == '/' && rdr.next() == '/' { let line = read_one_line_comment(rdr); - log line; + log_full(core::debug, line); lines += [line]; consume_non_eol_whitespace(rdr); } - log "<<< line comments"; + #debug("<<< line comments"); ret {style: if code_to_the_left { trailing } else { isolated }, lines: lines, pos: p}; @@ -603,12 +603,12 @@ fn trim_whitespace_prefix_and_push_line(&lines: [str], s: str, col: uint) { s1 = str::slice(s, col, str::byte_len(s)); } else { s1 = ""; } } else { s1 = s; } - log "pushing line: " + s1; + log_full(core::debug, "pushing line: " + s1); lines += [s1]; } fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt { - log ">>> block comment"; + #debug(">>> block comment"); let p = rdr.get_chpos(); let lines: [str] = []; let col: uint = rdr.get_col(); @@ -617,7 +617,7 @@ fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt { let curr_line = "/*"; let level: int = 1; while level > 0 { - log #fmt["=== block comment level %d", level]; + #debug("=== block comment level %d", level); if rdr.is_eof() { rdr.err("unterminated block comment"); fail; } if rdr.curr() == '\n' { trim_whitespace_prefix_and_push_line(lines, curr_line, col); @@ -648,7 +648,7 @@ fn read_block_comment(rdr: reader, code_to_the_left: bool) -> cmnt { if !rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u { style = mixed; } - log "<<< block comment"; + #debug("<<< block comment"); ret {style: style, lines: lines, pos: p}; } @@ -658,13 +658,13 @@ fn peeking_at_comment(rdr: reader) -> bool { } fn consume_comment(rdr: reader, code_to_the_left: bool, &comments: [cmnt]) { - log ">>> consume comment"; + #debug(">>> consume comment"); if rdr.curr() == '/' && rdr.next() == '/' { comments += [read_line_comments(rdr, code_to_the_left)]; } else if rdr.curr() == '/' && rdr.next() == '*' { comments += [read_block_comment(rdr, code_to_the_left)]; } else { fail; } - log "<<< consume comment"; + #debug("<<< consume comment"); } fn is_lit(t: token::token) -> bool { @@ -707,7 +707,7 @@ fn gather_comments_and_literals(cm: codemap::codemap, path: str, if is_lit(tok.tok) { literals += [{lit: rdr.get_str_from(tok.bpos), pos: tok.chpos}]; } - log "tok: " + token::to_str(rdr, tok.tok); + log_full(core::debug, "tok: " + token::to_str(rdr, tok.tok)); first_read = false; } ret {cmnts: comments, lits: literals}; diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs index b870f9f93da..556ce0b774a 100644 --- a/src/comp/syntax/print/pp.rs +++ b/src/comp/syntax/print/pp.rs @@ -101,7 +101,7 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer { // fall behind. let n: uint = 3u * linewidth; - log #fmt["mk_printer %u", linewidth]; + #debug("mk_printer %u", linewidth); let token: [mutable token] = vec::init_elt_mut(EOF, n); let size: [mutable int] = vec::init_elt_mut(0, n); let scan_stack: [mutable uint] = vec::init_elt_mut(0u, n); @@ -241,7 +241,7 @@ obj printer(out: io::writer, fn replace_last_token(t: token) { token[right] = t; } fn pretty_print(t: token) { - log #fmt["pp [%u,%u]", left, right]; + #debug("pp [%u,%u]", left, right); alt t { EOF. { if !scan_stack_empty { @@ -257,17 +257,17 @@ obj printer(out: io::writer, left = 0u; right = 0u; } else { self.advance_right(); } - log #fmt["pp BEGIN/buffer [%u,%u]", left, right]; + #debug("pp BEGIN/buffer [%u,%u]", left, right); token[right] = t; size[right] = -right_total; self.scan_push(right); } END. { if scan_stack_empty { - log #fmt["pp END/print [%u,%u]", left, right]; + #debug("pp END/print [%u,%u]", left, right); self.print(t, 0); } else { - log #fmt["pp END/buffer [%u,%u]", left, right]; + #debug("pp END/buffer [%u,%u]", left, right); self.advance_right(); token[right] = t; size[right] = -1; @@ -281,7 +281,7 @@ obj printer(out: io::writer, left = 0u; right = 0u; } else { self.advance_right(); } - log #fmt["pp BREAK/buffer [%u,%u]", left, right]; + #debug("pp BREAK/buffer [%u,%u]", left, right); self.check_stack(0); self.scan_push(right); token[right] = t; @@ -290,10 +290,10 @@ obj printer(out: io::writer, } STRING(s, len) { if scan_stack_empty { - log #fmt["pp STRING/print [%u,%u]", left, right]; + #debug("pp STRING/print [%u,%u]", left, right); self.print(t, len); } else { - log #fmt["pp STRING/buffer [%u,%u]", left, right]; + #debug("pp STRING/buffer [%u,%u]", left, right); self.advance_right(); token[right] = t; size[right] = len; @@ -311,7 +311,7 @@ obj printer(out: io::writer, right_total - left_total, space]; if !scan_stack_empty { if left == scan_stack[bottom] { - log #fmt["setting %u to infinity and popping", left]; + #debug("setting %u to infinity and popping", left); size[self.scan_pop_bottom()] = size_infinity; } } @@ -320,7 +320,7 @@ obj printer(out: io::writer, } } fn scan_push(x: uint) { - log #fmt["scan_push %u", x]; + #debug("scan_push %u", x); if scan_stack_empty { scan_stack_empty = false; } else { top += 1u; top %= buf_len; assert (top != bottom); } @@ -349,7 +349,7 @@ obj printer(out: io::writer, assert (right != left); } fn advance_left(x: token, L: int) { - log #fmt["advnce_left [%u,%u], sizeof(%u)=%d", left, right, left, L]; + #debug("advnce_left [%u,%u], sizeof(%u)=%d", left, right, left, L); if L >= 0 { self.print(x, L); alt x { @@ -388,13 +388,13 @@ obj printer(out: io::writer, } } fn print_newline(amount: int) { - log #fmt["NEWLINE %d", amount]; + #debug("NEWLINE %d", amount); out.write_str("\n"); pending_indentation = 0; self.indent(amount); } fn indent(amount: int) { - log #fmt["INDENT %d", amount]; + #debug("INDENT %d", amount); pending_indentation += amount; } fn top() -> print_stack_elt { @@ -413,20 +413,20 @@ obj printer(out: io::writer, fn print(x: token, L: int) { log #fmt["print %s %d (remaining line space=%d)", tok_str(x), L, space]; - log buf_str(token, size, left, right, 6u); + log_full(core::debug, buf_str(token, size, left, right, 6u)); alt x { BEGIN(b) { if L > space { let col = margin - space + b.offset; - log #fmt["print BEGIN -> push broken block at col %d", col]; + #debug("print BEGIN -> push broken block at col %d", col); print_stack += [{offset: col, pbreak: broken(b.breaks)}]; } else { - log "print BEGIN -> push fitting block"; + #debug("print BEGIN -> push fitting block"); print_stack += [{offset: 0, pbreak: fits}]; } } END. { - log "print END -> pop END"; + #debug("print END -> pop END"); assert (vec::len(print_stack) != 0u); vec::pop(print_stack); } @@ -434,22 +434,22 @@ obj printer(out: io::writer, let top = self.top(); alt top.pbreak { fits. { - log "print BREAK in fitting block"; + #debug("print BREAK in fitting block"); space -= b.blank_space; self.indent(b.blank_space); } broken(consistent.) { - log "print BREAK in consistent block"; + #debug("print BREAK in consistent block"); self.print_newline(top.offset + b.offset); space = margin - (top.offset + b.offset); } broken(inconsistent.) { if L > space { - log "print BREAK w/ newline in inconsistent"; + #debug("print BREAK w/ newline in inconsistent"); self.print_newline(top.offset + b.offset); space = margin - (top.offset + b.offset); } else { - log "print BREAK w/o newline in inconsistent"; + #debug("print BREAK w/o newline in inconsistent"); self.indent(b.blank_space); space -= b.blank_space; } @@ -457,7 +457,7 @@ obj printer(out: io::writer, } } STRING(s, len) { - log "print STRING"; + #debug("print STRING"); assert (L == len); // assert L <= space; diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs index 6c436dbe8fb..206cd7156e8 100644 --- a/src/comp/util/common.rs +++ b/src/comp/util/common.rs @@ -35,31 +35,49 @@ fn field_exprs(fields: [ast::field]) -> [@ast::expr] { ret es; } -fn log_expr(e: ast::expr) { log print::pprust::expr_to_str(@e); } +fn log_expr(e: ast::expr) { + log_full(core::debug, print::pprust::expr_to_str(@e)); +} -fn log_expr_err(e: ast::expr) { log_err print::pprust::expr_to_str(@e); } +fn log_expr_err(e: ast::expr) { + log_full(core::error, print::pprust::expr_to_str(@e)); +} -fn log_ty_err(t: @ty) { log_err print::pprust::ty_to_str(t); } +fn log_ty_err(t: @ty) { + log_full(core::error, print::pprust::ty_to_str(t)); +} -fn log_pat_err(p: @pat) { log_err print::pprust::pat_to_str(p); } +fn log_pat_err(p: @pat) { + log_full(core::error, print::pprust::pat_to_str(p)); +} -fn log_block(b: ast::blk) { log print::pprust::block_to_str(b); } +fn log_block(b: ast::blk) { + log_full(core::debug, print::pprust::block_to_str(b)); +} -fn log_block_err(b: ast::blk) { log_err print::pprust::block_to_str(b); } +fn log_block_err(b: ast::blk) { + log_full(core::error, print::pprust::block_to_str(b)); +} -fn log_item_err(i: @ast::item) { log_err print::pprust::item_to_str(i); } +fn log_item_err(i: @ast::item) { + log_full(core::error, print::pprust::item_to_str(i)); +} fn log_fn(f: ast::_fn, name: ast::ident, params: [ast::ty_param]) { - log print::pprust::fun_to_str(f, name, params); + log_full(core::debug, print::pprust::fun_to_str(f, name, params)); } fn log_fn_err(f: ast::_fn, name: ast::ident, params: [ast::ty_param]) { - log_err print::pprust::fun_to_str(f, name, params); + log_full(core::error, print::pprust::fun_to_str(f, name, params)); } -fn log_stmt(st: ast::stmt) { log print::pprust::stmt_to_str(st); } +fn log_stmt(st: ast::stmt) { + log_full(core::debug, print::pprust::stmt_to_str(st)); +} -fn log_stmt_err(st: ast::stmt) { log_err print::pprust::stmt_to_str(st); } +fn log_stmt_err(st: ast::stmt) { + log_full(core::error, print::pprust::stmt_to_str(st)); +} fn has_nonlocal_exits(b: ast::blk) -> bool { let has_exits = @mutable false; diff --git a/src/comp/util/filesearch.rs b/src/comp/util/filesearch.rs index de07a213a3f..b7942ce8f48 100644 --- a/src/comp/util/filesearch.rs +++ b/src/comp/util/filesearch.rs @@ -50,22 +50,22 @@ fn mk_filesearch(maybe_sysroot: option::t, } let sysroot = get_sysroot(maybe_sysroot); - log #fmt("using sysroot = %s", sysroot); + #debug("using sysroot = %s", sysroot); ret filesearch_impl(sysroot, addl_lib_search_paths, target_triple); } // FIXME #1001: This can't be an obj method fn search(filesearch: filesearch, pick: pick) -> option::t { for lib_search_path in filesearch.lib_search_paths() { - log #fmt["searching %s", lib_search_path]; + #debug("searching %s", lib_search_path); for path in fs::list_dir(lib_search_path) { - log #fmt["testing %s", path]; + #debug("testing %s", path); let maybe_picked = pick(path); if option::is_some(maybe_picked) { - log #fmt("picked %s", path); + #debug("picked %s", path); ret maybe_picked; } else { - log #fmt("rejected %s", path); + #debug("rejected %s", path); } } } diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 3f7ae912e9f..d720c036d95 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -135,12 +135,12 @@ type tests_and_conv_fn = { }; fn make_tests(cx: cx) -> tests_and_conv_fn { - log #fmt["making tests from %s", cx.config.src_base]; + #debug("making tests from %s", cx.config.src_base); let configport = port::<[u8]>(); let tests = []; for file: str in fs::list_dir(cx.config.src_base) { let file = file; - log #fmt["inspecting file %s", file]; + #debug("inspecting file %s", file); if is_test(cx.config, file) { tests += [make_test(cx, file, configport)]; } diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 1295f2ed5ae..a97253119fb 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -24,7 +24,7 @@ fn run(cx: cx, -_testfile: [u8]) { // We're going to be dumping a lot of info. Start on a new line. io::stdout().write_str("\n\n"); } - log #fmt["running %s", testfile]; + #debug("running %s", testfile); let props = load_props(testfile); alt cx.config.mode { mode_compile_fail. { run_cfail_test(cx, props, testfile); } @@ -194,10 +194,10 @@ fn check_error_patterns(props: test_props, testfile: str, procres: procres) { let next_err_pat = props.error_patterns[next_err_idx]; for line: str in str::split(procres.stdout, '\n' as u8) { if str::find(line, next_err_pat) > 0 { - log #fmt["found error pattern %s", next_err_pat]; + #debug("found error pattern %s", next_err_pat); next_err_idx += 1u; if next_err_idx == vec::len(props.error_patterns) { - log "found all error patterns"; + #debug("found all error patterns"); ret; } next_err_pat = props.error_patterns[next_err_idx]; diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index bc830048979..651bef07109 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -33,6 +33,6 @@ fn path_div() -> str { ":" } fn path_div() -> str { ";" } fn logv(config: config, s: str) { - log s; + log_full(core::debug, s); if config.verbose { io::stdout().write_line(s); } } diff --git a/src/fuzzer/ast_match.rs b/src/fuzzer/ast_match.rs index 46d9613fbc7..26e6b6792ee 100644 --- a/src/fuzzer/ast_match.rs +++ b/src/fuzzer/ast_match.rs @@ -23,5 +23,5 @@ fn main() { assert (!vec_equal([5, 5], [4, 5], builtin_equal)); assert (vec_equal([5, 5], [5, 5], builtin_equal)); - log_err "Pass"; + #error("Pass"); } diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 43208bbcb0c..8343acaffb8 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -236,15 +236,15 @@ fn check_variants_T( replacer: fn(ast::crate, uint, T, test_mode) -> ast::crate, cx: context ) { - log_err #fmt("%s contains %u %s objects", filename, vec::len(things), thing_label); + #error("%s contains %u %s objects", filename, vec::len(things), thing_label); let L = vec::len(things); if L < 100u { under(float::min(L, 20u)) {|i| - log_err "Replacing... #" + uint::str(i); + log_full(core::error, "Replacing... #" + uint::str(i)); under(float::min(L, 30u)) {|j| - log_err "With... " + stringifier(@things[j]); + log_full(core::error, "With... " + stringifier(@things[j])); let crate2 = @replacer(crate, i, things[j], cx.mode); // It would be best to test the *crate* for stability, but testing the // string for stability is easier and ok for now. @@ -298,8 +298,8 @@ fn check_whole_compiler(code: str, suggested_filename_prefix: str, allow_running removeDirIfExists(suggested_filename_prefix + ".dSYM"); } failed(s) { - log_err "check_whole_compiler failure: " + s; - log_err "Saved as: " + filename; + log_full(core::error, "check_whole_compiler failure: " + s); + log_full(core::error, "Saved as: " + filename); } } } @@ -320,7 +320,7 @@ fn check_running(exe_filename: str) -> happiness { let p = std::run::program_output("/Users/jruderman/scripts/timed_run_rust_program.py", [exe_filename]); let comb = p.out + "\n" + p.err; if str::byte_len(comb) > 1u { - log_err "comb comb comb: " + comb; + log_full(core::error, "comb comb comb: " + comb); } if contains(comb, "Assertion failed: (0), function alloc, file ../src/rt/rust_obstack.cpp") { @@ -358,7 +358,7 @@ fn check_compiling(filename: str) -> happiness { let p = std::run::program_output("bash", ["-c", "DYLD_LIBRARY_PATH=/Users/jruderman/code/rust/build/stage0/lib:/Users/jruderman/code/rust/build/rustllvm/ /Users/jruderman/code/rust/build/stage1/rustc " + filename]); - //log_err #fmt("Status: %d", p.status); + //#error("Status: %d", p.status); if p.err != "" { if contains(p.err, "Ptr must be a pointer to Val type") { known_bug("https://github.com/graydon/rust/issues/897") @@ -369,7 +369,7 @@ fn check_compiling(filename: str) -> happiness { } else if contains(p.err, "cast() argument of incompatible type!") { known_bug("https://github.com/graydon/rust/issues/973") } else { - log_err "Stderr: " + p.err; + log_full(core::error, "Stderr: " + p.err); failed("Unfamiliar error message") } } else if p.status == 0 { @@ -382,7 +382,7 @@ fn check_compiling(filename: str) -> happiness { } else if contains(p.out, "trans_rec expected a rec but found _|_") { known_bug("https://github.com/graydon/rust/issues/924") } else if contains(p.out, "Assertion") && contains(p.out, "failed") { - log_err "Stdout: " + p.out; + log_full(core::error, "Stdout: " + p.out); failed("Looks like an llvm assertion failure") } else if contains(p.out, "internal compiler error fail called with unsupported type _|_") { @@ -396,14 +396,14 @@ fn check_compiling(filename: str) -> happiness { } else if contains(p.out, "internal compiler error unimplemented") { known_bug("Something unimplemented") } else if contains(p.out, "internal compiler error") { - log_err "Stdout: " + p.out; + log_full(core::error, "Stdout: " + p.out); failed("internal compiler error") } else if contains(p.out, "error:") { cleanly_rejected("rejected with span_error") } else { - log_err p.status; - log_err "!Stdout: " + p.out; + log_full(core::error, p.status); + log_full(core::error, "!Stdout: " + p.out); failed("What happened?") } } @@ -500,9 +500,9 @@ fn check_roundtrip_convergence(code: str, maxIters: uint) { } if old == new { - log_err #fmt["Converged after %u iterations", i]; + #error("Converged after %u iterations", i); } else { - log_err #fmt["Did not converge after %u iterations!", i]; + #error("Did not converge after %u iterations!", i); write_file("round-trip-a.rs", old); write_file("round-trip-b.rs", new); std::run::run_program("diff", @@ -513,12 +513,12 @@ fn check_roundtrip_convergence(code: str, maxIters: uint) { } fn check_convergence(files: [str]) { - log_err #fmt["pp convergence tests: %u files", vec::len(files)]; + #error("pp convergence tests: %u files", vec::len(files)); for file in files { if !file_might_not_converge(file) { let s = result::get(io::read_whole_file_str(file)); if !content_might_not_converge(s) { - log_err #fmt["pp converge: %s", file]; + #error("pp converge: %s", file); // Change from 7u to 2u once https://github.com/graydon/rust/issues/850 is fixed check_roundtrip_convergence(s, 7u); } @@ -543,7 +543,7 @@ fn check_variants(files: [str], cx: context) { cont; } - log_err "check_variants: " + file; + log_full(core::error, "check_variants: " + file); let sess = @{cm: codemap::new_codemap(), mutable next_id: 0}; let crate = parser::parse_crate_from_source_str( @@ -559,7 +559,7 @@ fn check_variants(files: [str], cx: context) { fn main(args: [str]) { if vec::len(args) != 2u { - log_err #fmt["usage: %s ", args[0]]; + #error("usage: %s ", args[0]); ret; } let files = []; @@ -570,7 +570,7 @@ fn main(args: [str]) { check_variants(files, { mode: tm_converge }); check_variants(files, { mode: tm_run }); - log_err "Fuzzer done"; + #error("Fuzzer done"); } // Local Variables: diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs index 8fbdcc1e96a..84ea81f9fce 100644 --- a/src/fuzzer/ivec_fuzz.rs +++ b/src/fuzzer/ivec_fuzz.rs @@ -91,9 +91,9 @@ fn vec_to_str(v: [int]) -> str { } fn show_edits(a: [int], xs: [int]) { - log_err "=== Edits of " + vec_to_str(a) + " ==="; + log_full(core::error, "=== Edits of " + vec_to_str(a) + " ==="); let b = vec_edits(a, xs); - ix(0u, 1u, len(b)) {|i| log_err vec_to_str(b[i]); } + ix(0u, 1u, len(b)) {|i| log_full(core::error, vec_to_str(b[i])); } } fn demo_edits() { diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs index a3194568882..1dc1df2a7a3 100644 --- a/src/fuzzer/rand_util.rs +++ b/src/fuzzer/rand_util.rs @@ -69,13 +69,13 @@ fn main() { let r = rand::mk_rng(); - log_err under(r, 5u); - log_err choice(r, [10, 20, 30]); - log_err if unlikely(r, 5u) { "unlikely" } else { "likely" }; + log_full(core::error, under(r, 5u)); + log_full(core::error, choice(r, [10, 20, 30])); + log_full(core::error, if unlikely(r, 5u) { "unlikely" } else { "likely" }); let a = [mutable 1, 2, 3]; shuffle(r, a); - log_err a; + log_full(core::error, a); let i = 0u; let v = [ @@ -86,8 +86,8 @@ fn main() let w = weighted_vec(v); while i < 1000u { - log_err "Immed: " + weighted_choice(r, v); - log_err "Fast: " + choice(r, w); + log_full(core::error, "Immed: " + weighted_choice(r, v)); + log_full(core::error, "Fast: " + choice(r, w)); i += 1u; } } diff --git a/src/libcore/core.rs b/src/libcore/core.rs index 6e3120df17a..2b0306609e1 100644 --- a/src/libcore/core.rs +++ b/src/libcore/core.rs @@ -16,3 +16,13 @@ const error : u32 = 0_u32; const warn : u32 = 1_u32; const info : u32 = 2_u32; const debug : u32 = 3_u32; + +// A curious inner-module that's not exported that contains the binding +// 'core' so that macro-expanded references to core::error and such +// can be resolved within libcore. +mod core { + const error : u32 = 0_u32; + const warn : u32 = 1_u32; + const info : u32 = 2_u32; + const debug : u32 = 3_u32; +} \ No newline at end of file diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs index 14a014e891a..74826310066 100644 --- a/src/libcore/extfmt.rs +++ b/src/libcore/extfmt.rs @@ -19,7 +19,7 @@ combinations at the moment. Example: -log #fmt("hello, %s!", "world"); +#debug("hello, %s!", "world"); */ diff --git a/src/libcore/int.rs b/src/libcore/int.rs index 2ab299800ad..1ab22b3e06c 100644 --- a/src/libcore/int.rs +++ b/src/libcore/int.rs @@ -105,7 +105,7 @@ buf must not be empty */ fn parse_buf(buf: [u8], radix: uint) -> int { if vec::len::(buf) == 0u { - log_err "parse_buf(): buf is empty"; + #error("parse_buf(): buf is empty"); fail; } let i = vec::len::(buf) - 1u; diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 080c7ffc1cf..3b31832a9b7 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -287,7 +287,7 @@ Example: > let i = 0; > while i < len(s) { > let {ch, next} = char_range_at(s, i); -> log ch; +> log_full(core::debug, ch); > i = next; > } diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 4d527cbe061..05f953861f7 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -22,7 +22,7 @@ Tasks may execute in parallel and are scheduled automatically by the runtime. Example: > spawn("Hello, World", fn (&&msg: str) { -> log msg; +> log_full(core::debug, msg); > }); */ @@ -145,7 +145,7 @@ fn sleep(time_in_us: uint) { let killed = false; // FIXME: uncomment this when extfmt is moved to core // in a snapshot. - // log #fmt("yielding for %u us", time_in_us); + // #debug("yielding for %u us", time_in_us); rusti::task_sleep(task, time_in_us, killed); if killed { fail "killed"; diff --git a/src/libcore/u64.rs b/src/libcore/u64.rs index 0e1a330c663..9483af9b634 100644 --- a/src/libcore/u64.rs +++ b/src/libcore/u64.rs @@ -71,7 +71,7 @@ Parse a string as an unsigned integer. */ fn from_str(buf: str, radix: u64) -> u64 { if str::byte_len(buf) == 0u { - log_err "parse_buf(): buf is empty"; + #error("parse_buf(): buf is empty"); fail; } let i = str::byte_len(buf) - 1u; diff --git a/src/libcore/uint.rs b/src/libcore/uint.rs index ae1ba628aa6..aa38a6d40dc 100644 --- a/src/libcore/uint.rs +++ b/src/libcore/uint.rs @@ -167,7 +167,7 @@ buf must not be empty */ fn parse_buf(buf: [u8], radix: uint) -> uint { if vec::len::(buf) == 0u { - log_err "parse_buf(): buf is empty"; + #error("parse_buf(): buf is empty"); fail; } let i = vec::len::(buf) - 1u; diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 4448ee79d19..e5f841831f6 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -36,7 +36,7 @@ fn vint_at(data: [u8], start: uint) -> {val: uint, next: uint} { (data[start + 2u] as uint) << 8u | (data[start + 3u] as uint), next: start + 4u}; - } else { log_err "vint too big"; fail; } + } else { #error("vint too big"); fail; } } fn new_doc(data: @[u8]) -> doc { @@ -67,7 +67,7 @@ fn get_doc(d: doc, tg: uint) -> doc { alt maybe_get_doc(d, tg) { some(d) { ret d; } none. { - log_err "failed to find block with tag " + uint::to_str(tg, 10u); + #error("failed to find block with tag %u", tg); fail; } } @@ -133,7 +133,7 @@ fn write_sized_vint(w: io::buf_writer, n: uint, size: uint) { [0x10u8 | (n >> 24u as u8), n >> 16u & 0xffu as u8, n >> 8u & 0xffu as u8, n & 0xffu as u8]; } - _ { log_err "vint to write too big"; fail; } + _ { #error("vint to write too big"); fail; } } w.write(buf); } @@ -143,7 +143,7 @@ fn write_vint(w: io::buf_writer, n: uint) { if n < 0x4000u { write_sized_vint(w, n, 2u); ret; } if n < 0x200000u { write_sized_vint(w, n, 3u); ret; } if n < 0x10000000u { write_sized_vint(w, n, 4u); ret; } - log_err "vint to write too big"; + #error("vint to write too big"); fail; } diff --git a/src/libstd/extfmt.rs b/src/libstd/extfmt.rs index 14a014e891a..74826310066 100644 --- a/src/libstd/extfmt.rs +++ b/src/libstd/extfmt.rs @@ -19,7 +19,7 @@ combinations at the moment. Example: -log #fmt("hello, %s!", "world"); +#debug("hello, %s!", "world"); */ diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 1e354d825ae..bf70e89fb7c 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -306,7 +306,7 @@ fn getopts(args: [str], opts: [opt]) -> result { fn opt_vals(m: match, nm: str) -> [optval] { ret alt find_opt(m.opts, mkname(nm)) { some(id) { m.vals[id] } - none. { log_err "No option '" + nm + "' defined."; fail } + none. { #error("No option '%s' defined", nm); fail } }; } diff --git a/src/libstd/io.rs b/src/libstd/io.rs index a4e12e5db87..9719b8578e3 100644 --- a/src/libstd/io.rs +++ b/src/libstd/io.rs @@ -227,7 +227,7 @@ obj byte_buf_reader(bbuf: byte_buf) { bbuf.pos += 1u; ret b as int; } - fn unread_byte(_byte: int) { log_err "TODO: unread_byte"; fail; } + fn unread_byte(_byte: int) { #error("TODO: unread_byte"); fail; } fn eof() -> bool { ret bbuf.pos == vec::len::(bbuf.buf); } fn seek(offset: int, whence: seek_style) { let pos = bbuf.pos; @@ -268,7 +268,7 @@ obj FILE_writer(f: os::libc::FILE, res: option::t<@FILE_res>) { let len = vec::len::(v); let vbuf = vec::unsafe::to_ptr::(v); let nout = os::libc::fwrite(vbuf, len, 1u, f); - if nout < 1u { log_err "error dumping buffer"; } + if nout < 1u { #error("error dumping buffer"); } } fn seek(offset: int, whence: seek_style) { assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0i32); @@ -291,19 +291,19 @@ obj fd_buf_writer(fd: fd_t, res: option::t<@fd_res>) { vbuf = ptr::offset(vec::unsafe::to_ptr::(v), count); let nout = os::libc::write(fd, vbuf, len); if nout < 0 { - log_err "error dumping buffer"; - log_err sys::last_os_error(); + #error("error dumping buffer"); + log_full(core::error, sys::last_os_error()); fail; } count += nout as uint; } } fn seek(_offset: int, _whence: seek_style) { - log_err "need 64-bit native calls for seek, sorry"; + #error("need 64-bit native calls for seek, sorry"); fail; } fn tell() -> uint { - log_err "need 64-bit native calls for tell, sorry"; + #error("need 64-bit native calls for tell, sorry"); fail; } @@ -334,7 +334,7 @@ fn file_buf_writer(path: str, os::libc_constants::S_IWUSR) }); ret if fd < 0i32 { - log_err sys::last_os_error(); + log_full(core::error, sys::last_os_error()); result::err("error opening " + path) } else { result::ok(fd_buf_writer(fd, option::some(@fd_res(fd)))) diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index d57f553b68f..5ba1366ccb5 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -56,7 +56,7 @@ If the key does not exist in the map */ fn get(m: smallintmap, key: uint) -> T { alt find(m, key) { - none. { log_err "smallintmap::get(): key not present"; fail; } + none. { #error("smallintmap::get(): key not present"); fail; } some(v) { ret v; } } } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index e04e5ec0b20..4c0a52116cc 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -231,7 +231,7 @@ fn run_tests(opts: test_opts, tests: [test_desc], // provide a great user experience because you might sit waiting for the // result of a particular test for an unusually long amount of time. let concurrency = get_concurrency(); - log #fmt["using %u test tasks", concurrency]; + #debug("using %u test tasks", concurrency); let total = vec::len(filtered_tests); let run_idx = 0u; let wait_idx = 0u; diff --git a/src/libstd/uv.rs b/src/libstd/uv.rs index 7dac5f6d51b..a12fdc8cecc 100644 --- a/src/libstd/uv.rs +++ b/src/libstd/uv.rs @@ -111,7 +111,7 @@ fn unref(loop: *loop_t) { fn sanity_check() { fn check_size(t: str, uv: ctypes::size_t, rust: ctypes::size_t) { - log #fmt("size of %s: uv: %u, rust: %u", t, uv, rust); + #debug("size of %s: uv: %u, rust: %u", t, uv, rust); assert uv == rust; } check_size("idle_t", diff --git a/src/snapshots.txt b/src/snapshots.txt index 986bf8c11f5..e532681c8db 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,9 +1,16 @@ +S 2011-12-22 3b61064 + winnt-i386 800fdc0e15f6917ff4318812edac611ca0162b5e + linux-i386 468d13787022414aeb7f8ca755a4559691728a49 + macos-i386 acaf9f2b0588993d50339905e3343226e464aace + linux-x86_64 51af1a655a1552c4699fea6bf603326c1ba9f05c + macos-x86_64 a898937ea8e36e271b5d2df4caa21ef5268de7d5 + S 2011-12-19 edf6e1e winnt-i386 7a358117e123ad3d16fa66106819ec0daf5a6aba linux-i386 87b9a54e2e165b5c800236f49ee58522c8664226 macos-i386 be1da455be1aad6305185d120dd3594413ae66de - macos-x86_64 520f5af26e71a74d492d4d4d943974dd5404f798 linux-x86_64 ef255409d0cc6079d0a13d5bb7d436832dd294bc + macos-x86_64 520f5af26e71a74d492d4d4d943974dd5404f798 S 2011-12-14 5b35c9c winnt-i386 1ffa2c58ff2f35a058e3da755febb173917b95ff diff --git a/src/test/bench/99bob-iter.rs b/src/test/bench/99bob-iter.rs index 500cb44758c..aec0422f5bf 100644 --- a/src/test/bench/99bob-iter.rs +++ b/src/test/bench/99bob-iter.rs @@ -47,10 +47,10 @@ fn ninetynine(it: block(int)) { fn main() { ninetynine {|n| - log sub(b1(), n); - log sub(b2(), n - 1); - log ""; + log_full(core::debug, sub(b1(), n)); + log_full(core::debug, sub(b2(), n - 1)); + #debug(""); }; - log b7(); - log b8(); + log_full(core::debug, b7()); + log_full(core::debug, b8()); } diff --git a/src/test/bench/99bob-pattern.rs b/src/test/bench/99bob-pattern.rs index 4feeda28b1b..325f148df33 100644 --- a/src/test/bench/99bob-pattern.rs +++ b/src/test/bench/99bob-pattern.rs @@ -19,21 +19,19 @@ fn show(b: bottle) { "99 bottles of beer on the wall."; } single. { - log "1 bottle of beer on the wall, 1 bottle of beer,"; + #debug("1 bottle of beer on the wall, 1 bottle of beer,"); log "Take one down and pass it around, " + "no more bottles of beer on the wall."; } dual. { - log "2 bottles of beer on the wall, 2 bottles of beer,"; + #debug("2 bottles of beer on the wall, 2 bottles of beer,"); log "Take one down and pass it around, " + "1 bottle of beer on the wall."; } multiple(n) { - let nb: str = int::to_str(n, 10u); - let mb: str = int::to_str(n - 1, 10u); - log nb + " bottles of beer on the wall, " + nb + " bottles of beer,"; - log "Take one down and pass it around, " + mb + - " bottles of beer on the wall."; + #debug("%d bottles of beer on the wall, %d bottles of beer,", n, n); + #debug("Take one down and pass it around, \ + %d bottles of beer on the wall.", n-1); } } } @@ -55,5 +53,5 @@ fn more(b: bottle) -> bool { alt b { none. { ret false; } _ { ret true; } } } fn main() { let b: bottle = multiple(99); let running: bool = true; - while running { show(b); log ""; running = more(b); b = next(b); } + while running { show(b); #debug(""); running = more(b); b = next(b); } } diff --git a/src/test/bench/99bob-simple.rs b/src/test/bench/99bob-simple.rs index ac21780a62d..51439a8bd97 100644 --- a/src/test/bench/99bob-simple.rs +++ b/src/test/bench/99bob-simple.rs @@ -42,7 +42,11 @@ fn sub(t: str, n: int) -> str { /* Straightforward counter */ fn main() { let n: int = 99; - while n > 0 { log sub(b1(), n); log sub(b2(), n - 1); log ""; n -= 1; } - log b7(); - log sub(b8(), 99); + while n > 0 { + log_full(core::debug, sub(b1(), n)); + log_full(core::debug, sub(b2(), n - 1)); + #debug(""); n -= 1; + } + log_full(core::debug, b7()); + log_full(core::debug, sub(b8(), 99)); } diff --git a/src/test/bench/99bob-tail.rs b/src/test/bench/99bob-tail.rs index b4c50a87809..cda58a34a3c 100644 --- a/src/test/bench/99bob-tail.rs +++ b/src/test/bench/99bob-tail.rs @@ -8,32 +8,32 @@ import str; fn main() { fn multiple(n: int) { - let nb: str = int::to_str(n, 10u); - let mb: str = int::to_str(n - 1, 10u); - log nb + " bottles of beer on the wall, " + nb + " bottles of beer,"; - log "Take one down and pass it around, " + mb + - " bottles of beer on the wall."; - log ""; + #debug("%d bottles of beer on the wall, %d bottles of beer,", n, n); + #debug("Take one down and pass it around, %d \ + bottles of beer on the wall.", n-1); + #debug(""); if n > 3 { be multiple(n - 1); } else { be dual(); } } fn dual() { - log "2 bottles of beer on the wall, 2 bottles of beer,"; - log "Take one down and pass it around, 1 bottle of beer on the wall."; - log ""; + #debug("2 bottles of beer on the wall, 2 bottles of beer,"); + #debug("Take one down and pass it around, \ + 1 bottle of beer on the wall."); + #debug(""); be single(); } fn single() { - log "1 bottle of beer on the wall, 1 bottle of beer,"; + #debug("1 bottle of beer on the wall, 1 bottle of beer,"); log "Take one down and pass it around, " + "no more bottles of beer on the wall."; - log ""; + #debug(""); be none(); } fn none() { - log "No more bottles of beer on the wall, no more bottles of beer,"; + #debug("No more bottles of beer on the wall, \ + no more bottles of beer,"); log "Go to the store and buy some more, " + "99 bottles of beer on the wall."; - log ""; + #debug(""); } multiple(99); } diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs index ea9f8341d4d..1e4283443b9 100644 --- a/src/test/bench/shootout-fannkuchredux.rs +++ b/src/test/bench/shootout-fannkuchredux.rs @@ -43,7 +43,7 @@ fn fannkuch(n: int) -> int { let go = true; while go { - if r == n { log checksum; ret flips; } + if r == n { log_full(core::debug, checksum); ret flips; } let p0 = perm1[0]; i = 0; while i < r { let j = i + 1; perm1[i] = perm1[j]; i = j; } @@ -58,5 +58,5 @@ fn fannkuch(n: int) -> int { fn main(args: [str]) { let n = 7; - log #fmt["Pfannkuchen(%d) = %d", n, fannkuch(n)]; + #debug("Pfannkuchen(%d) = %d", n, fannkuch(n)); } diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index d8bba3d0725..97bec11f43f 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -44,25 +44,31 @@ fn select_random(r: u32, genelist: [aminoacids]) -> char { } fn make_random_fasta(id: str, desc: str, genelist: [aminoacids], n: int) { - log ">" + id + " " + desc; + log_full(core::debug, ">" + id + " " + desc); let rng = myrandom(std::rand::mk_rng().next()); let op: str = ""; uint::range(0u, n as uint) {|i| str::push_byte(op, select_random(rng.next(100u32), genelist) as u8); - if str::byte_len(op) >= LINE_LENGTH() { log op; op = ""; } + if str::byte_len(op) >= LINE_LENGTH() { + log_full(core::debug, op); + op = ""; + } } - if str::byte_len(op) > 0u { log op; } + if str::byte_len(op) > 0u { log_full(core::debug, op); } } fn make_repeat_fasta(id: str, desc: str, s: str, n: int) { - log ">" + id + " " + desc; + log_full(core::debug, ">" + id + " " + desc); let op: str = ""; let sl: uint = str::byte_len(s); uint::range(0u, n as uint) {|i| str::push_byte(op, s[i % sl]); - if str::byte_len(op) >= LINE_LENGTH() { log op; op = ""; } + if str::byte_len(op) >= LINE_LENGTH() { + log_full(core::debug, op); + op = ""; + } } - if str::byte_len(op) > 0u { log op; } + if str::byte_len(op) > 0u { log_full(core::debug, op); } } fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; } diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index a4b5f2588d4..b9624ecb9e6 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -14,6 +14,6 @@ fn fib(n: int) -> int { fn main() { assert (fib(8) == 21); assert (fib(15) == 610); - log fib(8); - log fib(15); + log_full(core::debug, fib(8)); + log_full(core::debug, fib(15)); } diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index cf4daa6b2ec..72c98a4c3be 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -20,11 +20,11 @@ fn main() { for n: int in inputs { - log NBodySystem::energy(bodies); + log_full(core::debug, NBodySystem::energy(bodies)); let i: int = 0; while i < n { NBodySystem::advance(bodies, 0.01); i += 1; } - log NBodySystem::energy(bodies); + log_full(core::debug, NBodySystem::energy(bodies)); } } diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 76680d9cd50..5c008c49019 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -72,7 +72,7 @@ fn stress_task(&&id: int) { let n = 15; assert (fib(n) == fib(n)); i += 1; - log_err #fmt["%d: Completed %d iterations", id, i]; + #error("%d: Completed %d iterations", id, i); } } @@ -87,7 +87,7 @@ fn stress(num_tasks: int) { fn main(argv: [str]) { if vec::len(argv) == 1u { assert (fib(8) == 21); - log fib(8); + log_full(core::debug, fib(8)); } else { // Interactive mode! Wooo!!!! let opts = parse_opts(argv); diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index a40fa80ad17..dcab0e8bde5 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -88,7 +88,7 @@ mod map_reduce { send V>(-map: mapper, -ctrl: chan>, -input: K1) { - // log_err "map_task " + input; + // log_full(core::error, "map_task " + input); let intermediates = treemap::init(); fn emit 0 { alt recv(p) { emit_val(v) { - // log_err #fmt("received %d", v); + // #error("received %d", v); ret some(v); } done. { - // log_err "all done"; + // #error("all done"); is_done = true; } ref. { ref_count += 1; } @@ -167,19 +167,20 @@ mod map_reduce { while num_mappers > 0 { alt recv(ctrl) { mapper_done. { - // log_err "received mapper terminated."; + // #error("received mapper terminated."); num_mappers -= 1; } find_reducer(k, cc) { let c; - // log_err "finding reducer for " + k; + // log_full(core::error, "finding reducer for " + k); alt treemap::find(reducers, k) { some(_c) { - // log_err "reusing existing reducer for " + k; + // log_full(core::error, + // "reusing existing reducer for " + k); c = _c; } none. { - // log_err "creating new reducer for " + k; + // log_full(core::error, "creating new reducer for " + k); let p = port(); let r = reduce, kk = k; tasks += @@ -228,7 +229,8 @@ fn main(argv: [str]) { let elapsed = stop - start; elapsed /= 1000000u64; - log_err "MapReduce completed in " + u64::str(elapsed) + "ms"; + log_full(core::error, "MapReduce completed in " + + u64::str(elapsed) + "ms"); } fn read_word(r: io::reader) -> option { diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs index a310bc152f8..a05ce493ddf 100644 --- a/src/test/bench/task-perf-word-count.rs +++ b/src/test/bench/task-perf-word-count.rs @@ -78,7 +78,7 @@ mod map_reduce { fn map_task(args: (chan, str)) { let (ctrl, input) = args; - // log_err "map_task " + input; + // log_full(core::error, "map_task " + input); let intermediates = map::new_str_hash(); fn emit(im: map::hashmap>, @@ -120,11 +120,11 @@ mod map_reduce { while !state.is_done || state.ref_count > 0 { alt recv(p) { emit_val(v) { - // log_err #fmt("received %d", v); + // #error("received %d", v); ret some(v); } done. { - // log_err "all done"; + // #error("all done"); state.is_done = true; } ref. { state.ref_count += 1; } @@ -153,19 +153,20 @@ mod map_reduce { while num_mappers > 0 { alt recv(ctrl) { mapper_done. { - // log_err "received mapper terminated."; + // #error("received mapper terminated."); num_mappers -= 1; } find_reducer(k, cc) { let c; - // log_err "finding reducer for " + k; + // log_full(core::error, "finding reducer for " + k); alt reducers.find(k) { some(_c) { - // log_err "reusing existing reducer for " + k; + // log_full(core::error, + // "reusing existing reducer for " + k); c = _c; } none. { - // log_err "creating new reducer for " + k; + // log_full(core::error, "creating new reducer for " + k); let p = port(); tasks += [task::spawn_joinable((k, chan(p)), reduce_task)]; @@ -200,7 +201,8 @@ fn main(argv: [str]) { let elapsed = stop - start; elapsed /= 1000000u64; - log_err "MapReduce completed in " + u64::str(elapsed) + "ms"; + log_full(core::error, "MapReduce completed in " + + u64::str(elapsed) + "ms"); } fn read_word(r: io::reader) -> option { diff --git a/src/test/compile-fail/alt-join.rs b/src/test/compile-fail/alt-join.rs index 246d186b06c..a950cc117e3 100644 --- a/src/test/compile-fail/alt-join.rs +++ b/src/test/compile-fail/alt-join.rs @@ -7,6 +7,6 @@ fn my_fail() -> ! { fail; } fn main() { alt true { false { my_fail(); } true { } } - log x; + log_full(core::debug, x); let x: int; } diff --git a/src/test/compile-fail/and-init.rs b/src/test/compile-fail/and-init.rs index 75e63ab2cc6..6b966f4964d 100644 --- a/src/test/compile-fail/and-init.rs +++ b/src/test/compile-fail/and-init.rs @@ -3,6 +3,6 @@ fn main() { let i: int; - log false && { i = 5; true }; - log i; + log_full(core::debug, false && { i = 5; true }); + log_full(core::debug, i); } diff --git a/src/test/compile-fail/anon-obj-overriding-wrong-type.rs b/src/test/compile-fail/anon-obj-overriding-wrong-type.rs index 5f8fa86e1c1..eeeae1793b7 100644 --- a/src/test/compile-fail/anon-obj-overriding-wrong-type.rs +++ b/src/test/compile-fail/anon-obj-overriding-wrong-type.rs @@ -18,5 +18,5 @@ fn main() { my_a }; - log_err my_b.foo(); + log_full(core::error, my_b.foo()); } diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index 5729b4e190b..16c83c56a9e 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -7,11 +7,11 @@ fn main() { let a: clam = {x: @1, y: @2}; let b: clam = {x: @10, y: @20}; let z: int = a.x + b.y; - log z; + log_full(core::debug, z); assert (z == 21); let forty: fish = {a: @40}; let two: fish = {a: @2}; let answer: int = forty.a + two.a; - log answer; + log_full(core::debug, answer); assert (answer == 42); } diff --git a/src/test/compile-fail/bad-bang-ann-2.rs b/src/test/compile-fail/bad-bang-ann-2.rs index 011358ac10c..375eadac779 100644 --- a/src/test/compile-fail/bad-bang-ann-2.rs +++ b/src/test/compile-fail/bad-bang-ann-2.rs @@ -2,6 +2,6 @@ // Tests that a function with a ! annotation always actually fails // error-pattern: some control paths may return -fn bad_bang(i: uint) -> ! { log 3; } +fn bad_bang(i: uint) -> ! { log_full(core::debug, 3); } fn main() { bad_bang(5u); } diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs index 5bfae32d97a..0ef523e753d 100644 --- a/src/test/compile-fail/bad-const-type.rs +++ b/src/test/compile-fail/bad-const-type.rs @@ -1,4 +1,4 @@ // error-pattern:expected str but found int const i: str = 10; -fn main() { log i; } +fn main() { log_full(core::debug, i); } diff --git a/src/test/compile-fail/bad-env-capture.rs b/src/test/compile-fail/bad-env-capture.rs index 8e8441e55ac..340a38e4993 100644 --- a/src/test/compile-fail/bad-env-capture.rs +++ b/src/test/compile-fail/bad-env-capture.rs @@ -1,6 +1,6 @@ // error-pattern: attempted dynamic environment-capture fn foo() { let x: int; - fn bar() { log x; } + fn bar() { log_full(core::debug, x); } } fn main() { foo(); } diff --git a/src/test/compile-fail/bad-env-capture2.rs b/src/test/compile-fail/bad-env-capture2.rs index 40a0a39e7c6..420aaa280c2 100644 --- a/src/test/compile-fail/bad-env-capture2.rs +++ b/src/test/compile-fail/bad-env-capture2.rs @@ -1,5 +1,5 @@ // error-pattern: attempted dynamic environment-capture fn foo(x: int) { - fn bar() { log x; } + fn bar() { log_full(core::debug, x); } } fn main() { foo(2); } diff --git a/src/test/compile-fail/bad-env-capture3.rs b/src/test/compile-fail/bad-env-capture3.rs index 1ff3602ee88..4b2e2c74ffd 100644 --- a/src/test/compile-fail/bad-env-capture3.rs +++ b/src/test/compile-fail/bad-env-capture3.rs @@ -1,7 +1,7 @@ // error-pattern: attempted dynamic environment-capture obj foo(x: int) { fn mth() { - fn bar() { log x; } + fn bar() { log_full(core::debug, x); } } } diff --git a/src/test/compile-fail/bad-expr-path.rs b/src/test/compile-fail/bad-expr-path.rs index c5a66696c49..ad9e147deeb 100644 --- a/src/test/compile-fail/bad-expr-path.rs +++ b/src/test/compile-fail/bad-expr-path.rs @@ -2,4 +2,4 @@ mod m1 { } -fn main(args: [str]) { log m1::a; } +fn main(args: [str]) { log_full(core::debug, m1::a); } diff --git a/src/test/compile-fail/bad-expr-path2.rs b/src/test/compile-fail/bad-expr-path2.rs index c597ba8b99e..273f93bac22 100644 --- a/src/test/compile-fail/bad-expr-path2.rs +++ b/src/test/compile-fail/bad-expr-path2.rs @@ -4,4 +4,4 @@ mod m1 { mod a { } } -fn main(args: [str]) { log m1::a; } +fn main(args: [str]) { log_full(core::debug, m1::a); } diff --git a/src/test/compile-fail/block-coerce-no.rs b/src/test/compile-fail/block-coerce-no.rs index 37d56439c11..1a41ece08c0 100644 --- a/src/test/compile-fail/block-coerce-no.rs +++ b/src/test/compile-fail/block-coerce-no.rs @@ -10,4 +10,7 @@ fn coerce(b: block()) -> fn() { } -fn main() { let i = 8; let f = coerce(block () { log_err i; }); f(); } +fn main() { + let i = 8; + let f = coerce(block () { log_full(core::error, i); }); + f(); } diff --git a/src/test/compile-fail/block-copy.rs b/src/test/compile-fail/block-copy.rs index 313e86511d1..7afefb0f36f 100644 --- a/src/test/compile-fail/block-copy.rs +++ b/src/test/compile-fail/block-copy.rs @@ -1,4 +1,8 @@ // error-pattern: block type can only appear fn lol(f: block()) -> block() { ret f; } -fn main() { let i = 8; let f = lol(block () { log_err i; }); f(); } +fn main() { + let i = 8; + let f = lol(block () { log_full(core::error, i); }); + f(); +} diff --git a/src/test/compile-fail/block-require-return.rs b/src/test/compile-fail/block-require-return.rs index f7d895ac383..1bff806ab46 100644 --- a/src/test/compile-fail/block-require-return.rs +++ b/src/test/compile-fail/block-require-return.rs @@ -1,3 +1,3 @@ // error-pattern: not all control paths return fn force(f: block() -> int) -> int { f() } -fn main() { log_err force({|| }); } +fn main() { log_full(core::error, force({|| })); } diff --git a/src/test/compile-fail/block-uninit.rs b/src/test/compile-fail/block-uninit.rs index 7ad58e45a43..68870a1b876 100644 --- a/src/test/compile-fail/block-uninit.rs +++ b/src/test/compile-fail/block-uninit.rs @@ -1,4 +1,4 @@ // error-pattern: Unsatisfied precondition constraint fn force(f: block()) { f(); } -fn main() { let x: int; force(block () { log_err x; }); } +fn main() { let x: int; force(block () { log_full(core::error, x); }); } diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs index e590a6b32b4..1eadbee5497 100644 --- a/src/test/compile-fail/bogus-tag.rs +++ b/src/test/compile-fail/bogus-tag.rs @@ -6,6 +6,9 @@ tag color { rgb(int, int, int); rgba(int, int, int, int); } fn main() { let red: color = rgb(255, 0, 0); - alt red { rgb(r, g, b) { log "rgb"; } hsl(h, s, l) { log "hsl"; } } + alt red { + rgb(r, g, b) { #debug("rgb"); } + hsl(h, s, l) { #debug("hsl"); } + } } diff --git a/src/test/compile-fail/break-uninit.rs b/src/test/compile-fail/break-uninit.rs index 9a82a95ade2..a7a6a92fd7c 100644 --- a/src/test/compile-fail/break-uninit.rs +++ b/src/test/compile-fail/break-uninit.rs @@ -6,9 +6,9 @@ fn foo() -> int { do { i = 0; break; x = 0; } while x != 0 - log x; + log_full(core::debug, x); ret 17; } -fn main() { log foo(); } +fn main() { log_full(core::debug, foo()); } diff --git a/src/test/compile-fail/break-uninit2.rs b/src/test/compile-fail/break-uninit2.rs index d1fda52fae6..3547f565451 100644 --- a/src/test/compile-fail/break-uninit2.rs +++ b/src/test/compile-fail/break-uninit2.rs @@ -6,9 +6,9 @@ fn foo() -> int { do { i = 0; break; x = 0; } while 1 != 2 - log x; + log_full(core::debug, x); ret 17; } -fn main() { log foo(); } +fn main() { log_full(core::debug, foo()); } diff --git a/src/test/compile-fail/constrained-type-missing-check.rs b/src/test/compile-fail/constrained-type-missing-check.rs index cf88ea18008..912a7f27dcc 100644 --- a/src/test/compile-fail/constrained-type-missing-check.rs +++ b/src/test/compile-fail/constrained-type-missing-check.rs @@ -12,5 +12,5 @@ fn main() { let a: int = 1; let b: int = 2; let c: ordered_range = {low: a, high: b}; - log c.low; + log_full(core::debug, c.low); } diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs index 46807e05252..546dbbd411d 100644 --- a/src/test/compile-fail/copy-a-resource.rs +++ b/src/test/compile-fail/copy-a-resource.rs @@ -2,4 +2,4 @@ resource foo(i: int) { } -fn main() { let x <- foo(10); let y = x; log_err x; } +fn main() { let x <- foo(10); let y = x; log_full(core::error, x); } diff --git a/src/test/compile-fail/dead-code-be.rs b/src/test/compile-fail/dead-code-be.rs index f2faedb7434..68334f0fda0 100644 --- a/src/test/compile-fail/dead-code-be.rs +++ b/src/test/compile-fail/dead-code-be.rs @@ -3,7 +3,7 @@ // error-pattern: dead -fn f(caller: str) { log caller; } +fn f(caller: str) { log_full(core::debug, caller); } -fn main() { be f("main"); log "Paul is dead"; } +fn main() { be f("main"); #debug("Paul is dead"); } diff --git a/src/test/compile-fail/dead-code-ret.rs b/src/test/compile-fail/dead-code-ret.rs index 3cfed81fc09..f7f530dc90a 100644 --- a/src/test/compile-fail/dead-code-ret.rs +++ b/src/test/compile-fail/dead-code-ret.rs @@ -3,7 +3,7 @@ // error-pattern: dead -fn f(caller: str) { log caller; } +fn f(caller: str) { log_full(core::debug, caller); } -fn main() { ret f("main"); log "Paul is dead"; } +fn main() { ret f("main"); #debug("Paul is dead"); } diff --git a/src/test/compile-fail/direct-obj-fn-call.rs b/src/test/compile-fail/direct-obj-fn-call.rs index cb6557dea8c..fc893dea438 100644 --- a/src/test/compile-fail/direct-obj-fn-call.rs +++ b/src/test/compile-fail/direct-obj-fn-call.rs @@ -1,7 +1,7 @@ // error-pattern: attempted access of field hello obj x() { - fn hello() { log "hello"; } + fn hello() { #debug("hello"); } } fn main() { x.hello(); } diff --git a/src/test/compile-fail/do-while-constraints.rs b/src/test/compile-fail/do-while-constraints.rs index f7d03b89354..479908a8d3c 100644 --- a/src/test/compile-fail/do-while-constraints.rs +++ b/src/test/compile-fail/do-while-constraints.rs @@ -4,7 +4,7 @@ fn main() { let y: int = 42; let x: int; do { - log y; + log_full(core::debug, y); do { do { do { x <- y; } while true } while true } while true } while true } diff --git a/src/test/compile-fail/do-while-pred-constraints.rs b/src/test/compile-fail/do-while-pred-constraints.rs index 60d8dd4fae1..8bf03564393 100644 --- a/src/test/compile-fail/do-while-pred-constraints.rs +++ b/src/test/compile-fail/do-while-pred-constraints.rs @@ -1,6 +1,6 @@ // error-pattern: Unsatisfied precondition constraint (for example, even(y -fn print_even(y: int) : even(y) { log y; } +fn print_even(y: int) : even(y) { log_full(core::debug, y); } pure fn even(y: int) -> bool { true } diff --git a/src/test/compile-fail/does-nothing.rs b/src/test/compile-fail/does-nothing.rs index 09671b7149a..c861b460e47 100644 --- a/src/test/compile-fail/does-nothing.rs +++ b/src/test/compile-fail/does-nothing.rs @@ -1,3 +1,3 @@ // error-pattern: unresolved name: this_does_nothing_what_the -fn main() { log "doing"; this_does_nothing_what_the; log "boing"; } +fn main() { #debug("doing"); this_does_nothing_what_the; #debug("boing"); } diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs index 55d33160d34..13163fa32f2 100644 --- a/src/test/compile-fail/export.rs +++ b/src/test/compile-fail/export.rs @@ -1,8 +1,8 @@ // error-pattern: unresolved name mod foo { export x; - fn x(y: int) { log y; } - fn z(y: int) { log y; } + fn x(y: int) { log_full(core::debug, y); } + fn z(y: int) { log_full(core::debug, y); } } fn main() { foo::z(10); } diff --git a/src/test/compile-fail/export2.rs b/src/test/compile-fail/export2.rs index 28919efdd49..ab8744e722a 100644 --- a/src/test/compile-fail/export2.rs +++ b/src/test/compile-fail/export2.rs @@ -9,7 +9,7 @@ mod foo { mod bar { export y; - fn x() { log "x"; } + fn x() { #debug("x"); } fn y() { } } diff --git a/src/test/compile-fail/fn-constraint.rs b/src/test/compile-fail/fn-constraint.rs index 3b9221587ac..e5fac40b8fb 100644 --- a/src/test/compile-fail/fn-constraint.rs +++ b/src/test/compile-fail/fn-constraint.rs @@ -5,5 +5,5 @@ import str::*; fn main() { let a: uint = 4u; let b: uint = 1u; - log_err safe_slice("kitties", a, b); + log_full(core::error, safe_slice("kitties", a, b)); } diff --git a/src/test/compile-fail/fn-expr-type-state.rs b/src/test/compile-fail/fn-expr-type-state.rs index 935542e85e7..9c998682fc3 100644 --- a/src/test/compile-fail/fn-expr-type-state.rs +++ b/src/test/compile-fail/fn-expr-type-state.rs @@ -3,5 +3,5 @@ fn main() { // Typestate should work even in a lambda. we should reject this program. let f = fn () -> int { let i: int; ret i; }; - log_err f(); + log_full(core::error, f()); } diff --git a/src/test/compile-fail/fn-expr-typestate-2.rs b/src/test/compile-fail/fn-expr-typestate-2.rs index d4f49f96466..5f2e6db0e8b 100644 --- a/src/test/compile-fail/fn-expr-typestate-2.rs +++ b/src/test/compile-fail/fn-expr-typestate-2.rs @@ -1,3 +1,6 @@ // error-pattern:Unsatisfied precondition -fn main() { let j = fn () -> int { let i: int; ret i; }(); log_err j; } +fn main() { + let j = fn () -> int { let i: int; ret i; }(); + log_full(core::error, j); +} diff --git a/src/test/compile-fail/for-loop-decl.rs b/src/test/compile-fail/for-loop-decl.rs index 9292981d4f4..dd67ceabff9 100644 --- a/src/test/compile-fail/for-loop-decl.rs +++ b/src/test/compile-fail/for-loop-decl.rs @@ -16,4 +16,4 @@ fn bitv_to_str(enclosing: fn_info, v: bitv::t) -> str { ret s; } -fn main() { log "OK"; } +fn main() { #debug("OK"); } diff --git a/src/test/compile-fail/if-check-precond-fail.rs b/src/test/compile-fail/if-check-precond-fail.rs index aed84faacc3..69dedb57955 100644 --- a/src/test/compile-fail/if-check-precond-fail.rs +++ b/src/test/compile-fail/if-check-precond-fail.rs @@ -5,7 +5,7 @@ pure fn even(x: uint) -> bool { } else if x == 2u { ret true; } else { ret even(x - 2u); } } -fn print_even(x: uint) : even(x) { log x; } +fn print_even(x: uint) : even(x) { log_full(core::debug, x); } fn foo(x: uint) { if check even(x) { fail; } else { print_even(x); } } diff --git a/src/test/compile-fail/if-without-else-result.rs b/src/test/compile-fail/if-without-else-result.rs index 6d3408c3fc6..6c560ffb41d 100644 --- a/src/test/compile-fail/if-without-else-result.rs +++ b/src/test/compile-fail/if-without-else-result.rs @@ -2,5 +2,5 @@ fn main() { let a = if true { true }; - log a; + log_full(core::debug, a); } \ No newline at end of file diff --git a/src/test/compile-fail/import-glob-0.rs b/src/test/compile-fail/import-glob-0.rs index d0cbcf57ad3..bde9dd5f19e 100644 --- a/src/test/compile-fail/import-glob-0.rs +++ b/src/test/compile-fail/import-glob-0.rs @@ -7,10 +7,10 @@ mod module_of_many_things { export f2; export f4; - fn f1() { log "f1"; } - fn f2() { log "f2"; } - fn f3() { log "f3"; } - fn f4() { log "f4"; } + fn f1() { #debug("f1"); } + fn f2() { #debug("f2"); } + fn f3() { #debug("f3"); } + fn f4() { #debug("f4"); } } diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs index c9595777c27..588b0d5848e 100644 --- a/src/test/compile-fail/import-glob-circular.rs +++ b/src/test/compile-fail/import-glob-circular.rs @@ -5,7 +5,7 @@ mod circ1 { export f1; export f2; export common; - fn f1() { log "f1"; } + fn f1() { #debug("f1"); } fn common() -> uint { ret 0u; } } @@ -14,7 +14,7 @@ mod circ2 { export f1; export f2; export common; - fn f2() { log "f2"; } + fn f2() { #debug("f2"); } fn common() -> uint { ret 1u; } } diff --git a/src/test/compile-fail/import-glob-multiple.rs b/src/test/compile-fail/import-glob-multiple.rs index 55a8878381d..f05b862cba6 100644 --- a/src/test/compile-fail/import-glob-multiple.rs +++ b/src/test/compile-fail/import-glob-multiple.rs @@ -4,13 +4,13 @@ import mod1::*; import mod2::*; mod mod1 { - fn f1() { log "f1"; } + fn f1() { #debug("f1"); } fn common1() { log "common" } fn common2() { log "common" } } mod mod2 { - fn f2() { log "f1"; } + fn f2() { #debug("f1"); } fn common1() { log "common" } fn common2() { log "common" } } diff --git a/src/test/compile-fail/import.rs b/src/test/compile-fail/import.rs index 0d01c188701..b789a25e7a7 100644 --- a/src/test/compile-fail/import.rs +++ b/src/test/compile-fail/import.rs @@ -2,6 +2,6 @@ import zed::bar; import zed::baz; mod zed { - fn bar() { log "bar"; } + fn bar() { #debug("bar"); } } fn main(args: [str]) { bar(); } diff --git a/src/test/compile-fail/import2.rs b/src/test/compile-fail/import2.rs index 89532f61fb1..ef81ebfcb4b 100644 --- a/src/test/compile-fail/import2.rs +++ b/src/test/compile-fail/import2.rs @@ -2,6 +2,6 @@ import baz::zed::bar; mod baz { } mod zed { - fn bar() { log "bar3"; } + fn bar() { #debug("bar3"); } } fn main(args: [str]) { bar(); } diff --git a/src/test/compile-fail/import3.rs b/src/test/compile-fail/import3.rs index 680804c97b0..35a9c587373 100644 --- a/src/test/compile-fail/import3.rs +++ b/src/test/compile-fail/import3.rs @@ -1,4 +1,4 @@ // error-pattern: unresolved modulename import main::bar; -fn main(args: [str]) { log "foo"; } +fn main(args: [str]) { #debug("foo"); } diff --git a/src/test/compile-fail/import4.rs b/src/test/compile-fail/import4.rs index 107125ba331..aed46fb1232 100644 --- a/src/test/compile-fail/import4.rs +++ b/src/test/compile-fail/import4.rs @@ -3,4 +3,4 @@ mod a { import foo = b::foo; export foo; } mod b { import foo = a::foo; export foo; } -fn main(args: [str]) { log "loop"; } +fn main(args: [str]) { #debug("loop"); } diff --git a/src/test/compile-fail/import5.rs b/src/test/compile-fail/import5.rs index 75e5dfe8322..85a77411e68 100644 --- a/src/test/compile-fail/import5.rs +++ b/src/test/compile-fail/import5.rs @@ -1,7 +1,7 @@ // error-pattern:unresolved import mod m1 { - fn foo() { log "foo"; } + fn foo() { #debug("foo"); } } mod m2 { diff --git a/src/test/compile-fail/lambda-mutate-nested.rs b/src/test/compile-fail/lambda-mutate-nested.rs index 1fcdd37f271..8b5da1c196a 100644 --- a/src/test/compile-fail/lambda-mutate-nested.rs +++ b/src/test/compile-fail/lambda-mutate-nested.rs @@ -6,10 +6,10 @@ fn f2(x: block()) { x(); } fn main() { let i = 0; let ctr = lambda () -> int { f2({|| i = i + 1; }); ret i; }; - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err i; + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, i); } diff --git a/src/test/compile-fail/lambda-mutate.rs b/src/test/compile-fail/lambda-mutate.rs index 3d7199e4b1d..c5b90f9edde 100644 --- a/src/test/compile-fail/lambda-mutate.rs +++ b/src/test/compile-fail/lambda-mutate.rs @@ -3,10 +3,10 @@ fn main() { let i = 0; let ctr = lambda () -> int { i = i + 1; ret i; }; - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err ctr(); - log_err i; + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, ctr()); + log_full(core::error, i); } diff --git a/src/test/compile-fail/move-arg.rs b/src/test/compile-fail/move-arg.rs index d8d4c1926dd..fd5566e5c32 100644 --- a/src/test/compile-fail/move-arg.rs +++ b/src/test/compile-fail/move-arg.rs @@ -1,4 +1,4 @@ // error-pattern: Unsatisfied precondition constraint fn test(-foo: int) { assert (foo == 10); } -fn main() { let x = 10; test(x); log x; } +fn main() { let x = 10; test(x); log_full(core::debug, x); } diff --git a/src/test/compile-fail/no-constraint-prop.rs b/src/test/compile-fail/no-constraint-prop.rs index 59f5b8435d1..8cae7c2fc36 100644 --- a/src/test/compile-fail/no-constraint-prop.rs +++ b/src/test/compile-fail/no-constraint-prop.rs @@ -16,5 +16,5 @@ fn main() { // the next statement, since it's not true in the // prestate. let d <- a; - log safe_slice("kitties", b, d); + log_full(core::debug, safe_slice("kitties", b, d)); } diff --git a/src/test/compile-fail/nonscalar-cast.rs b/src/test/compile-fail/nonscalar-cast.rs index ab920550f44..95de145e52e 100644 --- a/src/test/compile-fail/nonscalar-cast.rs +++ b/src/test/compile-fail/nonscalar-cast.rs @@ -4,5 +4,5 @@ use std; import std::os; fn main() { - log { x: 1 } as int; + log_full(core::debug, { x: 1 } as int); } diff --git a/src/test/compile-fail/nonsense-constraints.rs b/src/test/compile-fail/nonsense-constraints.rs index b7c5614f176..527644907f0 100644 --- a/src/test/compile-fail/nonsense-constraints.rs +++ b/src/test/compile-fail/nonsense-constraints.rs @@ -10,4 +10,4 @@ fn enum_chars(start: u8, end: u8) : uint::le(start, end) -> [char] { ret r; } -fn main() { log enum_chars('a' as u8, 'z' as u8); } +fn main() { log_full(core::debug, enum_chars('a' as u8, 'z' as u8)); } diff --git a/src/test/compile-fail/or-init.rs b/src/test/compile-fail/or-init.rs index 8103864c154..54ab6c3c1b7 100644 --- a/src/test/compile-fail/or-init.rs +++ b/src/test/compile-fail/or-init.rs @@ -3,6 +3,6 @@ fn main() { let i: int; - log false || { i = 5; true }; - log i; + log_full(core::debug, false || { i = 5; true }); + log_full(core::debug, i); } diff --git a/src/test/compile-fail/oversized-literal.rs b/src/test/compile-fail/oversized-literal.rs index 30b61811b04..c189c97ded9 100644 --- a/src/test/compile-fail/oversized-literal.rs +++ b/src/test/compile-fail/oversized-literal.rs @@ -1,3 +1,3 @@ // error-pattern:literal out of range -fn main() { log 300u8; } +fn main() { log_full(core::debug, 300u8); } diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs index 705a662e14d..3484a14f084 100644 --- a/src/test/compile-fail/pattern-tyvar.rs +++ b/src/test/compile-fail/pattern-tyvar.rs @@ -7,6 +7,13 @@ import option::some; tag bar { t1((), option::t<[int]>); t2; } -fn foo(t: bar) { alt t { t1(_, some::(x)) { log x; } _ { fail; } } } +fn foo(t: bar) { + alt t { + t1(_, some::(x)) { + log_full(core::debug, x); + } + _ { fail; } + } +} fn main() { } diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs index 3d6c6f0c6eb..a7c7d06cb5f 100644 --- a/src/test/compile-fail/pinned-deep-copy.rs +++ b/src/test/compile-fail/pinned-deep-copy.rs @@ -10,7 +10,7 @@ fn main() { // Can't do this copy let x = ~~~{y: r(i)}; let z = x; - log x; + log_full(core::debug, x); } - log_err *i; + log_full(core::error, *i); } \ No newline at end of file diff --git a/src/test/compile-fail/rec-missing-fields.rs b/src/test/compile-fail/rec-missing-fields.rs index 50bcf32dd7f..523641698d3 100644 --- a/src/test/compile-fail/rec-missing-fields.rs +++ b/src/test/compile-fail/rec-missing-fields.rs @@ -6,4 +6,4 @@ type point = {x: int, y: int}; -fn main() { let p: point = {x: 10}; log p.y; } +fn main() { let p: point = {x: 10}; log_full(core::debug, p.y); } diff --git a/src/test/compile-fail/record-with-resource.rs b/src/test/compile-fail/record-with-resource.rs index e4e743a7ad0..ff6a197abf8 100644 --- a/src/test/compile-fail/record-with-resource.rs +++ b/src/test/compile-fail/record-with-resource.rs @@ -1,13 +1,13 @@ // error-pattern: copying a noncopyable value resource my_resource(x: int) { - log_err x; + log_full(core::error, x); } fn main() { { let a = {x: 0, y: my_resource(20)}; let b = {x: 2 with a}; - log_err (a, b); + log_full(core::error, (a, b)); } } diff --git a/src/test/compile-fail/reference-in-loop.rs b/src/test/compile-fail/reference-in-loop.rs index a873fbf4358..a21523d0763 100644 --- a/src/test/compile-fail/reference-in-loop.rs +++ b/src/test/compile-fail/reference-in-loop.rs @@ -4,7 +4,7 @@ fn main() { let x = []; let &y = x; while true { - log_err y; + log_full(core::error, y); x = [1]; } } diff --git a/src/test/compile-fail/sendfn-is-not-a-lambda.rs b/src/test/compile-fail/sendfn-is-not-a-lambda.rs index 696f237c9f1..4cc76c93a17 100644 --- a/src/test/compile-fail/sendfn-is-not-a-lambda.rs +++ b/src/test/compile-fail/sendfn-is-not-a-lambda.rs @@ -6,5 +6,5 @@ fn test(f: lambda(uint) -> uint) -> uint { fn main() { let f = sendfn(x: uint) -> uint { ret 4u; }; - log test(f); + log_full(core::debug, test(f)); } \ No newline at end of file diff --git a/src/test/compile-fail/unbalanced-comment.rs b/src/test/compile-fail/unbalanced-comment.rs index c9d3e0c9b6a..52b49723691 100644 --- a/src/test/compile-fail/unbalanced-comment.rs +++ b/src/test/compile-fail/unbalanced-comment.rs @@ -7,5 +7,5 @@ */ fn main() { - log "hello, world."; + #debug("hello, world."); } diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs index 6bde4cbc6a4..4cf50b119f8 100644 --- a/src/test/compile-fail/unique-pinned-nocopy.rs +++ b/src/test/compile-fail/unique-pinned-nocopy.rs @@ -6,5 +6,5 @@ resource r(b: bool) { fn main() { let i <- ~r(true); let j = i; - log i; + log_full(core::debug, i); } \ No newline at end of file diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs index 0b16c513350..9fa456aaacb 100644 --- a/src/test/compile-fail/unique-vec-res.rs +++ b/src/test/compile-fail/unique-vec-res.rs @@ -14,6 +14,6 @@ fn main() { let r1 <- [~r(i1)]; let r2 <- [~r(i2)]; f(r1, r2); - log (r2, *i1); - log (r1, *i2); + log_full(core::debug, (r2, *i1)); + log_full(core::debug, (r1, *i2)); } \ No newline at end of file diff --git a/src/test/compile-fail/unsafe-alias-2.rs b/src/test/compile-fail/unsafe-alias-2.rs index 23daa8bba16..94b95e190bd 100644 --- a/src/test/compile-fail/unsafe-alias-2.rs +++ b/src/test/compile-fail/unsafe-alias-2.rs @@ -4,5 +4,5 @@ fn whoknows(x: @mutable {mutable x: int}) { x.x = 10; } fn main() { let box = @mutable {mutable x: 1}; - alt *box { x { whoknows(box); log_err x; } } + alt *box { x { whoknows(box); log_full(core::error, x); } } } diff --git a/src/test/compile-fail/unsafe-alias.rs b/src/test/compile-fail/unsafe-alias.rs index 3e5233460b7..2b71a5e72d8 100644 --- a/src/test/compile-fail/unsafe-alias.rs +++ b/src/test/compile-fail/unsafe-alias.rs @@ -1,6 +1,6 @@ // error-pattern:may alias with argument -fn foo(x: {mutable x: int}, f: fn@()) { log x; } +fn foo(x: {mutable x: int}, f: fn@()) { log_full(core::debug, x); } fn whoknows(x: @mutable {mutable x: int}) { *x = {mutable x: 10}; } diff --git a/src/test/compile-fail/unsafe-alt.rs b/src/test/compile-fail/unsafe-alt.rs index 864ba50298b..e19edcfddc7 100644 --- a/src/test/compile-fail/unsafe-alt.rs +++ b/src/test/compile-fail/unsafe-alt.rs @@ -4,5 +4,5 @@ tag foo { left({mutable x: int}); right(bool); } fn main() { let x = left({mutable x: 10}); - alt x { left(i) { x = right(false); log i; } _ { } } + alt x { left(i) { x = right(false); log_full(core::debug, i); } _ { } } } diff --git a/src/test/compile-fail/unsafe-for.rs b/src/test/compile-fail/unsafe-for.rs index 11d8d894269..caaab6d8977 100644 --- a/src/test/compile-fail/unsafe-for.rs +++ b/src/test/compile-fail/unsafe-for.rs @@ -2,5 +2,5 @@ fn main() { let v: [mutable {mutable x: int}] = [mutable {mutable x: 1}]; - for x in v { v[0] = {mutable x: 2}; log x; } + for x in v { v[0] = {mutable x: 2}; log_full(core::debug, x); } } diff --git a/src/test/compile-fail/unsafe-mutable-alias.rs b/src/test/compile-fail/unsafe-mutable-alias.rs index f6b52bef34b..f740d7d7592 100644 --- a/src/test/compile-fail/unsafe-mutable-alias.rs +++ b/src/test/compile-fail/unsafe-mutable-alias.rs @@ -5,4 +5,4 @@ fn f(a: {mutable x: int}, &b: {mutable x: int}) -> int { ret a.x + b.x; } -fn main() { let i = {mutable x: 4}; log f(i, i); } +fn main() { let i = {mutable x: 4}; log_full(core::debug, f(i, i)); } diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs index 00e65f40240..26decd8baeb 100644 --- a/src/test/compile-fail/unsupported-cast.rs +++ b/src/test/compile-fail/unsupported-cast.rs @@ -4,5 +4,5 @@ use std; import std::os; fn main() { - log 1.0 as os::libc::FILE; // Can't cast float to native. + log_full(core::debug, 1.0 as os::libc::FILE); // Can't cast float to native. } diff --git a/src/test/compile-fail/use-after-move.rs b/src/test/compile-fail/use-after-move.rs index 3fb1827441e..e0a06d73acc 100644 --- a/src/test/compile-fail/use-after-move.rs +++ b/src/test/compile-fail/use-after-move.rs @@ -1,2 +1,2 @@ // error-pattern: Unsatisfied precondition constraint (for example, init(x -fn main() { let x = @5; let y <- x; log *x; } +fn main() { let x = @5; let y <- x; log_full(core::debug, *x); } diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs index e625ef138d4..dfd34aa1168 100644 --- a/src/test/compile-fail/use-after-send.rs +++ b/src/test/compile-fail/use-after-send.rs @@ -1,12 +1,16 @@ // error-pattern: Unsatisfied precondition constraint -fn send(ch: _chan, -data: T) { log ch; log data; fail; } +fn send(ch: _chan, -data: T) { + log_full(core::debug, ch); + log_full(core::debug, data); + fail; +} type _chan = int; -// Tests that "log message;" is flagged as using +// Tests that "log_full(core::debug, message);" is flagged as using // message after the send deinitializes it fn test00_start(ch: _chan, message: int, count: int) { send(ch, message); - log message; + log_full(core::debug, message); } fn main() { fail; } diff --git a/src/test/compile-fail/use-uninit-2.rs b/src/test/compile-fail/use-uninit-2.rs index 4d35567ea4f..abbca6008fc 100644 --- a/src/test/compile-fail/use-uninit-2.rs +++ b/src/test/compile-fail/use-uninit-2.rs @@ -1,5 +1,5 @@ // error-pattern:Unsatisfied precondition -fn foo(x: int) { log x; } +fn foo(x: int) { log_full(core::debug, x); } fn main() { let x: int; if 1 > 2 { x = 10; } foo(x); } diff --git a/src/test/compile-fail/use-uninit-3.rs b/src/test/compile-fail/use-uninit-3.rs index 5b7c619f36f..e731ba4f083 100644 --- a/src/test/compile-fail/use-uninit-3.rs +++ b/src/test/compile-fail/use-uninit-3.rs @@ -1,5 +1,13 @@ // error-pattern:Unsatisfied precondition -fn foo(x: int) { log x; } +fn foo(x: int) { log_full(core::debug, x); } -fn main() { let x: int; if 1 > 2 { log "whoops"; } else { x = 10; } foo(x); } +fn main() { + let x: int; + if 1 > 2 { + #debug("whoops"); + } else { + x = 10; + } + foo(x); +} diff --git a/src/test/compile-fail/use-uninit.rs b/src/test/compile-fail/use-uninit.rs index 75e60bdbce3..5fac7d3ee6b 100644 --- a/src/test/compile-fail/use-uninit.rs +++ b/src/test/compile-fail/use-uninit.rs @@ -1,5 +1,5 @@ // error-pattern:Unsatisfied precondition -fn foo(x: int) { log x; } +fn foo(x: int) { log_full(core::debug, x); } fn main() { let x: int; foo(x); } diff --git a/src/test/compile-fail/vec-field.rs b/src/test/compile-fail/vec-field.rs index 9e2c54003fe..c376441163d 100644 --- a/src/test/compile-fail/vec-field.rs +++ b/src/test/compile-fail/vec-field.rs @@ -3,7 +3,7 @@ fn f() { let v = [1]; - log v.some_field_name; //type error + log_full(core::debug, v.some_field_name); //type error } fn main() { } diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs index 818080a6e55..d2fb07bd1f7 100644 --- a/src/test/compile-fail/vec-res-add.rs +++ b/src/test/compile-fail/vec-res-add.rs @@ -7,5 +7,5 @@ fn main() { let i <- [r(0)]; let j <- [r(1)]; let k = i + j; - log j; + log_full(core::debug, j); } diff --git a/src/test/compile-fail/while-loop-constraints.rs b/src/test/compile-fail/while-loop-constraints.rs index 557ff099cbf..15cb4ab9902 100644 --- a/src/test/compile-fail/while-loop-constraints.rs +++ b/src/test/compile-fail/while-loop-constraints.rs @@ -3,5 +3,12 @@ fn main() { let y: int = 42; let x: int; - while true { log y; while true { while true { while true { x <- y; } } } } + while true { + log_full(core::debug, y); + while true { + while true { + while true { x <- y; } + } + } + } } diff --git a/src/test/compile-fail/while-loop-pred-constraints.rs b/src/test/compile-fail/while-loop-pred-constraints.rs index bf761b31199..6ea21de7f58 100644 --- a/src/test/compile-fail/while-loop-pred-constraints.rs +++ b/src/test/compile-fail/while-loop-pred-constraints.rs @@ -1,6 +1,6 @@ // error-pattern: Unsatisfied precondition constraint (for example, even(y -fn print_even(y: int) : even(y) { log y; } +fn print_even(y: int) : even(y) { log_full(core::debug, y); } pure fn even(y: int) -> bool { true } diff --git a/src/test/run-fail/binop-fail-2.rs b/src/test/run-fail/binop-fail-2.rs index 0a8b78cc034..2203adbd7a7 100644 --- a/src/test/run-fail/binop-fail-2.rs +++ b/src/test/run-fail/binop-fail-2.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log_err s; fail "quux"; } +fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; } fn main() { 3u == my_err("bye"); } diff --git a/src/test/run-fail/binop-fail.rs b/src/test/run-fail/binop-fail.rs index 062c04ff67a..d8aefe7d6df 100644 --- a/src/test/run-fail/binop-fail.rs +++ b/src/test/run-fail/binop-fail.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log_err s; fail "quux"; } +fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; } fn main() { my_err("bye") == 3u; } diff --git a/src/test/run-fail/fail-arg.rs b/src/test/run-fail/fail-arg.rs index e657bf7d9a6..bdb8ecc9453 100644 --- a/src/test/run-fail/fail-arg.rs +++ b/src/test/run-fail/fail-arg.rs @@ -1,4 +1,4 @@ // error-pattern:woe -fn f(a: int) { log a; } +fn f(a: int) { log_full(core::debug, a); } fn main() { f(fail "woe"); } diff --git a/src/test/run-fail/fn-constraint.rs b/src/test/run-fail/fn-constraint.rs index 87d082c47a9..6f466ea1f64 100644 --- a/src/test/run-fail/fn-constraint.rs +++ b/src/test/run-fail/fn-constraint.rs @@ -7,5 +7,5 @@ fn main() { let a: uint = 4u; let b: uint = 1u; check (le(a, b)); - log_err safe_slice("kitties", a, b); + log_full(core::error, safe_slice("kitties", a, b)); } diff --git a/src/test/run-fail/if-check-fail.rs b/src/test/run-fail/if-check-fail.rs index 2af0b111f8e..0bf23e4a93c 100644 --- a/src/test/run-fail/if-check-fail.rs +++ b/src/test/run-fail/if-check-fail.rs @@ -5,6 +5,12 @@ pure fn even(x: uint) -> bool { } else if x == 2u { ret true; } else { ret even(x - 2u); } } -fn foo(x: uint) { if check even(x) { log x; } else { fail "Number is odd"; } } +fn foo(x: uint) { + if check even(x) { + log_full(core::debug, x); + } else { + fail "Number is odd"; + } +} fn main() { foo(3u); } diff --git a/src/test/run-fail/if-cond-bot.rs b/src/test/run-fail/if-cond-bot.rs index 32c698652e7..a9877ab4b7a 100644 --- a/src/test/run-fail/if-cond-bot.rs +++ b/src/test/run-fail/if-cond-bot.rs @@ -1,3 +1,3 @@ // error-pattern:quux -fn my_err(s: str) -> ! { log_err s; fail "quux"; } +fn my_err(s: str) -> ! { log_full(core::error, s); fail "quux"; } fn main() { if my_err("bye") { } } diff --git a/src/test/run-pass/acyclic-unwind.rs b/src/test/run-pass/acyclic-unwind.rs index 0b6b58fee26..0954d68ad33 100644 --- a/src/test/run-pass/acyclic-unwind.rs +++ b/src/test/run-pass/acyclic-unwind.rs @@ -17,7 +17,7 @@ fn f(c: comm::_chan) { while true { // spin waiting for the parent to kill us. - log "child waiting to die..."; + #debug("child waiting to die..."); // while waiting to die, the messages we are // sending to the channel are never received @@ -35,5 +35,5 @@ fn main() { // synchronize on event from child. i = p.recv(); - log "parent exiting, killing child"; + #debug("parent exiting, killing child"); } diff --git a/src/test/run-pass/alt-bot.rs b/src/test/run-pass/alt-bot.rs index 47340e04735..314483ca534 100644 --- a/src/test/run-pass/alt-bot.rs +++ b/src/test/run-pass/alt-bot.rs @@ -2,5 +2,5 @@ fn main() { let i: int = alt some::(3) { none::. { fail } some::(_) { 5 } }; - log i; + log_full(core::debug, i); } diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs index 6b2ae3ffa9c..e1ed1ac6c0b 100644 --- a/src/test/run-pass/alt-join.rs +++ b/src/test/run-pass/alt-join.rs @@ -16,4 +16,4 @@ fn foo(y: option::t) { ret; } -fn main() { log "hello"; foo::(some::(5)); } +fn main() { #debug("hello"); foo::(some::(5)); } diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs index 1447b48d515..8d8a6517a7d 100644 --- a/src/test/run-pass/alt-pattern-drop.rs +++ b/src/test/run-pass/alt-pattern-drop.rs @@ -13,12 +13,12 @@ fn foo(s: @int) { alt x { make_t(y) { - log y; // ref up then down + log_full(core::debug, y); // ref up then down } - _ { log "?"; fail; } + _ { #debug("?"); fail; } } - log dbg::refcount(s); + log_full(core::debug, dbg::refcount(s)); assert (dbg::refcount(s) == count + 1u); } @@ -27,6 +27,6 @@ fn main() { foo(s); // ref up then down - log dbg::refcount(s); + log_full(core::debug, dbg::refcount(s)); assert (dbg::refcount(s) == 1u); } diff --git a/src/test/run-pass/alt-pattern-lit.rs b/src/test/run-pass/alt-pattern-lit.rs index 1f544495d88..afc72c80afa 100644 --- a/src/test/run-pass/alt-pattern-lit.rs +++ b/src/test/run-pass/alt-pattern-lit.rs @@ -1,7 +1,10 @@ fn altlit(f: int) -> int { - alt f { 10 { log "case 10"; ret 20; } 11 { log "case 11"; ret 22; } } + alt f { + 10 { #debug("case 10"); ret 20; } + 11 { #debug("case 11"); ret 22; } + } } fn main() { assert (altlit(10) == 20); assert (altlit(11) == 22); } diff --git a/src/test/run-pass/alt-pattern-no-type-params.rs b/src/test/run-pass/alt-pattern-no-type-params.rs index 994e9f147e4..1cd5aa85758 100644 --- a/src/test/run-pass/alt-pattern-no-type-params.rs +++ b/src/test/run-pass/alt-pattern-no-type-params.rs @@ -1,7 +1,7 @@ tag maybe { nothing; just(T); } fn foo(x: maybe) { - alt x { nothing. { log_err "A"; } just(a) { log_err "B"; } } + alt x { nothing. { #error("A"); } just(a) { #error("B"); } } } fn main() { } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index 6a3606d6dc3..f25c78b03e4 100644 --- a/src/test/run-pass/alt-tag.rs +++ b/src/test/run-pass/alt-tag.rs @@ -11,9 +11,9 @@ tag color { fn process(c: color) -> int { let x: int; alt c { - rgb(r, _, _) { log "rgb"; log r; x = r; } - rgba(_, _, _, a) { log "rgba"; log a; x = a; } - hsl(_, s, _) { log "hsl"; log s; x = s; } + rgb(r, _, _) { #debug("rgb"); log_full(core::debug, r); x = r; } + rgba(_, _, _, a) { #debug("rgba"); log_full(core::debug, a); x = a; } + hsl(_, s, _) { #debug("hsl"); log_full(core::debug, s); x = s; } } ret x; } diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs index 0bb536086ba..c4b544c7c68 100644 --- a/src/test/run-pass/argv.rs +++ b/src/test/run-pass/argv.rs @@ -1,5 +1,5 @@ fn main(args: [str]) { let vs: [str] = ["hi", "there", "this", "is", "a", "vec"]; let vvs: [[str]] = [args, vs]; - for vs: [str] in vvs { for s: str in vs { log s; } } + for vs: [str] in vvs { for s: str in vs { log_full(core::debug, s); } } } diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs index 7c77d25e4c0..1649900305a 100644 --- a/src/test/run-pass/arith-0.rs +++ b/src/test/run-pass/arith-0.rs @@ -1,3 +1,7 @@ -fn main() { let a: int = 10; log a; assert (a * (a - 1) == 90); } +fn main() { + let a: int = 10; + log_full(core::debug, a); + assert (a * (a - 1) == 90); +} diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs index b9d61493ecf..d1c6ac117a3 100644 --- a/src/test/run-pass/arith-1.rs +++ b/src/test/run-pass/arith-1.rs @@ -18,6 +18,6 @@ fn main() { assert (i32_b << 1 == i32_b << 1); assert (i32_b >> 1 == i32_b >> 1); assert (i32_b & i32_b << 1 == 0); - log i32_b | i32_b << 1; + log_full(core::debug, i32_b | i32_b << 1); assert (i32_b | i32_b << 1 == 0x30303030); } diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs index e701427a8a3..5c963b6cc51 100644 --- a/src/test/run-pass/auto-instantiate.rs +++ b/src/test/run-pass/auto-instantiate.rs @@ -4,4 +4,7 @@ // -*- rust -*- fn f(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; } -fn main() { log f({x: 3, y: 4, z: 5}, 4).a.x; log f(5, 6).a; } +fn main() { + log_full(core::debug, f({x: 3, y: 4, z: 5}, 4).a.x); + log_full(core::debug, f(5, 6).a); +} diff --git a/src/test/run-pass/autoderef-objfn.rs b/src/test/run-pass/autoderef-objfn.rs index 430293989a0..930fbe545b5 100644 --- a/src/test/run-pass/autoderef-objfn.rs +++ b/src/test/run-pass/autoderef-objfn.rs @@ -3,7 +3,7 @@ // -*- rust -*- obj clam() { - fn chowder() { log "in clam chowder"; } + fn chowder() { #debug("in clam chowder"); } } fn foo(c: @clam) { c.chowder(); } diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs index ec6b45cef01..1afb2cbd1ff 100644 --- a/src/test/run-pass/basic-1.rs +++ b/src/test/run-pass/basic-1.rs @@ -16,15 +16,15 @@ fn main() { let n: int = 0; n = recv(p); n = recv(p); - // log "Finished."; + // #debug("Finished."); } fn b(c: chan) { - // log "task b0"; - // log "task b1"; - // log "task b2"; - // log "task b3"; - // log "task b4"; - // log "task b5"; + // #debug("task b0"); + // #debug("task b1"); + // #debug("task b2"); + // #debug("task b3"); + // #debug("task b4"); + // #debug("task b5"); send(c, 10); } diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs index b1de773f02d..077109d616a 100644 --- a/src/test/run-pass/basic-2.rs +++ b/src/test/run-pass/basic-2.rs @@ -7,7 +7,7 @@ import comm::chan; import comm::recv; import task; -fn a(c: chan) { log "task a0"; log "task a1"; send(c, 10); } +fn a(c: chan) { #debug("task a0"); #debug("task a1"); send(c, 10); } fn main() { let p = comm::port(); @@ -16,14 +16,14 @@ fn main() { let n: int = 0; n = recv(p); n = recv(p); - log "Finished."; + #debug("Finished."); } fn b(c: chan) { - log "task b0"; - log "task b1"; - log "task b2"; - log "task b2"; - log "task b3"; + #debug("task b0"); + #debug("task b1"); + #debug("task b2"); + #debug("task b2"); + #debug("task b3"); send(c, 10); } diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs index e162b3aba85..6affd11366e 100644 --- a/src/test/run-pass/basic.rs +++ b/src/test/run-pass/basic.rs @@ -9,18 +9,23 @@ import task; fn a(c: chan) { if true { - log "task a"; - log "task a"; - log "task a"; - log "task a"; - log "task a"; + #debug("task a"); + #debug("task a"); + #debug("task a"); + #debug("task a"); + #debug("task a"); } send(c, 10); } fn k(x: int) -> int { ret 15; } -fn g(x: int, y: str) -> int { log x; log y; let z: int = k(1); ret z; } +fn g(x: int, y: str) -> int { + log_full(core::debug, x); + log_full(core::debug, y); + let z: int = k(1); + ret z; +} fn main() { let n: int = 2 + 3 * 7; @@ -30,21 +35,21 @@ fn main() { task::spawn(chan(p), b); let x: int = 10; x = g(n, s); - log x; + log_full(core::debug, x); n = recv(p); n = recv(p); // FIXME: use signal-channel for this. - log "children finished, root finishing"; + #debug("children finished, root finishing"); } fn b(c: chan) { if true { - log "task b"; - log "task b"; - log "task b"; - log "task b"; - log "task b"; - log "task b"; + #debug("task b"); + #debug("task b"); + #debug("task b"); + #debug("task b"); + #debug("task b"); + #debug("task b"); } send(c, 10); } diff --git a/src/test/run-pass/bind-generic.rs b/src/test/run-pass/bind-generic.rs index 882a54f603b..6a0c1ea4633 100644 --- a/src/test/run-pass/bind-generic.rs +++ b/src/test/run-pass/bind-generic.rs @@ -1,6 +1,6 @@ fn wrapper3(i: T, j: int) { - log i; - log j; + log_full(core::debug, i); + log_full(core::debug, j); // This is a regression test that the spawn3 thunk to wrapper3 // correctly finds the value of j assert j == 123456789; diff --git a/src/test/run-pass/bind-parameterized-args-2.rs b/src/test/run-pass/bind-parameterized-args-2.rs index c4d3b51cc28..981ce0c9f21 100644 --- a/src/test/run-pass/bind-parameterized-args-2.rs +++ b/src/test/run-pass/bind-parameterized-args-2.rs @@ -1,5 +1,5 @@ fn main() { - fn echo(c: int, x: fn(T)) { log_err "wee"; } + fn echo(c: int, x: fn(T)) { #error("wee"); } let y = bind echo(42, _); diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index d6b4f291ddc..cbf936429a3 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -18,8 +18,8 @@ fn general() { a ^= b; b ^= a; a = a ^ b; - log a; - log b; + log_full(core::debug, a); + log_full(core::debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); diff --git a/src/test/run-pass/block-explicit-types.rs b/src/test/run-pass/block-explicit-types.rs index 1ed2e207f18..71bd75d03b6 100644 --- a/src/test/run-pass/block-explicit-types.rs +++ b/src/test/run-pass/block-explicit-types.rs @@ -1,4 +1,4 @@ fn main() { fn as_buf(s: str, f: block(str) -> T) -> T { f(s) } - as_buf("foo", {|foo: str| -> () log_err foo;}); + as_buf("foo", {|foo: str| -> () log_full(core::error, foo);}); } diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs index 7b10e124c64..2a2f754ca86 100644 --- a/src/test/run-pass/block-iter-1.rs +++ b/src/test/run-pass/block-iter-1.rs @@ -3,7 +3,13 @@ fn iter_vec(v: [T], f: block(T)) { for x: T in v { f(x); } } fn main() { let v = [1, 2, 3, 4, 5, 6, 7]; let odds = 0; - iter_vec(v, {|i| log_err i; if i % 2 == 1 { odds += 1; } log_err odds; }); - log_err odds; + iter_vec(v, {|i| + log_full(core::error, i); + if i % 2 == 1 { + odds += 1; + } + log_full(core::error, odds); + }); + log_full(core::error, odds); assert (odds == 4); } diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs index f80cd270440..d5d3d45160f 100644 --- a/src/test/run-pass/block-iter-2.rs +++ b/src/test/run-pass/block-iter-2.rs @@ -3,7 +3,12 @@ fn iter_vec(v: [T], f: block(T)) { for x: T in v { f(x); } } fn main() { let v = [1, 2, 3, 4, 5]; let sum = 0; - iter_vec(v, {|i| iter_vec(v, {|j| log_err i * j; sum += i * j; }); }); - log_err sum; + iter_vec(v, {|i| + iter_vec(v, {|j| + log_full(core::error, i * j); + sum += i * j; + }); + }); + log_full(core::error, sum); assert (sum == 225); } diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs index 07eebc19297..7569d78b42d 100644 --- a/src/test/run-pass/block-vec-map2.rs +++ b/src/test/run-pass/block-vec-map2.rs @@ -6,6 +6,6 @@ fn main() { vec::map2([1, 2, 3, 4, 5], [true, false, false, true, true], {|i, b| if b { -i } else { i } }); - log_err v; + log_full(core::error, v); assert (v == [-1, 2, 3, -4, -5]); } diff --git a/src/test/run-pass/box-inside-if.rs b/src/test/run-pass/box-inside-if.rs index de88a538fee..caa70c953af 100644 --- a/src/test/run-pass/box-inside-if.rs +++ b/src/test/run-pass/box-inside-if.rs @@ -9,7 +9,7 @@ fn is_odd(n: int) -> bool { ret true; } fn length_is_even(vs: @int) -> bool { ret true; } fn foo(acc: int, n: int) { - if is_odd(n) && length_is_even(some_box(1)) { log_err "bloop"; } + if is_odd(n) && length_is_even(some_box(1)) { #error("bloop"); } } fn main() { foo(67, 5); } diff --git a/src/test/run-pass/box-inside-if2.rs b/src/test/run-pass/box-inside-if2.rs index 8b18c36fbed..437a167cd6a 100644 --- a/src/test/run-pass/box-inside-if2.rs +++ b/src/test/run-pass/box-inside-if2.rs @@ -9,7 +9,7 @@ fn is_odd(n: int) -> bool { ret true; } fn length_is_even(vs: @int) -> bool { ret true; } fn foo(acc: int, n: int) { - if is_odd(n) || length_is_even(some_box(1)) { log_err "bloop"; } + if is_odd(n) || length_is_even(some_box(1)) { #error("bloop"); } } fn main() { foo(67, 5); } diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index 56bcbb717ad..61f932bb939 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -7,6 +7,6 @@ fn unbox(b: box) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box = {c: @foo}; - log "see what's in our box"; + #debug("see what's in our box"); assert (unbox::(bfoo) == foo); } diff --git a/src/test/run-pass/bug-862.rs b/src/test/run-pass/bug-862.rs index 0c4c49a0a3d..4b6193f312c 100644 --- a/src/test/run-pass/bug-862.rs +++ b/src/test/run-pass/bug-862.rs @@ -4,4 +4,4 @@ fn f(i: int, j: int) : p(j) -> int { j } fn g(i: int, j: int) : p(j) -> int { f(i, j) } -fn main() { let x = 1; check (p(x)); log g(x, x); } +fn main() { let x = 1; check (p(x)); log_full(core::debug, g(x, x)); } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index 0962a182acd..033b6f26fd8 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -11,13 +11,13 @@ fn main() { let p = comm::port(); let t = task::spawn(chan(p), child); let y = recv(p); - log_err "received"; - log_err y; + #error("received"); + log_full(core::error, y); assert (y == 10); } fn child(c: chan) { - log_err "sending"; + #error("sending"); send(c, 10); log_err "value sent" } diff --git a/src/test/run-pass/command-line-args.rs b/src/test/run-pass/command-line-args.rs index efd5d2bb04c..19251a2b97e 100644 --- a/src/test/run-pass/command-line-args.rs +++ b/src/test/run-pass/command-line-args.rs @@ -1,3 +1,3 @@ -fn main(args: [str]) { log args[0]; } +fn main(args: [str]) { log_full(core::debug, args[0]); } diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs index 1b14e7ab7f5..4345170818e 100644 --- a/src/test/run-pass/complex.rs +++ b/src/test/run-pass/complex.rs @@ -25,4 +25,9 @@ fn foo(x: int) -> int { ret 0; } -fn main() { let x: int = 2 + 2; log x; log "hello, world"; log 10; } +fn main() { + let x: int = 2 + 2; + log_full(core::debug, x); + #debug("hello, world"); + log_full(core::debug, 10); +} diff --git a/src/test/run-pass/const.rs b/src/test/run-pass/const.rs index b96ae6f7360..bfc75cf68d7 100644 --- a/src/test/run-pass/const.rs +++ b/src/test/run-pass/const.rs @@ -2,4 +2,4 @@ const i: int = 10; -fn main() { log i; } +fn main() { log_full(core::debug, i); } diff --git a/src/test/run-pass/constraint-prop-expr-move.rs b/src/test/run-pass/constraint-prop-expr-move.rs index a83ef3e6f55..001268e5fd6 100644 --- a/src/test/run-pass/constraint-prop-expr-move.rs +++ b/src/test/run-pass/constraint-prop-expr-move.rs @@ -8,5 +8,5 @@ fn main() { let c: uint = 17u; check (le(a, b)); c <- a; - log safe_slice("kitties", c, b); + log_full(core::debug, safe_slice("kitties", c, b)); } diff --git a/src/test/run-pass/constraint-prop-move.rs b/src/test/run-pass/constraint-prop-move.rs index b551a0653d0..52d3a355127 100644 --- a/src/test/run-pass/constraint-prop-move.rs +++ b/src/test/run-pass/constraint-prop-move.rs @@ -7,5 +7,5 @@ fn main() { let b: uint = 4u; check (le(a, b)); let c <- a; - log safe_slice("kitties", c, b); + log_full(core::debug, safe_slice("kitties", c, b)); } diff --git a/src/test/run-pass/constraint-prop-swap.rs b/src/test/run-pass/constraint-prop-swap.rs index 45d04643627..16dd8b8fbe2 100644 --- a/src/test/run-pass/constraint-prop-swap.rs +++ b/src/test/run-pass/constraint-prop-swap.rs @@ -7,5 +7,5 @@ fn main() { let b: uint = 1u; check (le(b, a)); b <-> a; - log safe_slice("kitties", a, b); + log_full(core::debug, safe_slice("kitties", a, b)); } diff --git a/src/test/run-pass/constraint-prop.rs b/src/test/run-pass/constraint-prop.rs index e2e486cbd49..089047d6eed 100644 --- a/src/test/run-pass/constraint-prop.rs +++ b/src/test/run-pass/constraint-prop.rs @@ -7,5 +7,5 @@ fn main() { let b: uint = 4u; check (le(a, b)); let c = b; - log safe_slice("kitties", a, c); + log_full(core::debug, safe_slice("kitties", a, c)); } diff --git a/src/test/run-pass/dead-code-one-arm-if.rs b/src/test/run-pass/dead-code-one-arm-if.rs index 5aedb18282b..f79072068da 100644 --- a/src/test/run-pass/dead-code-one-arm-if.rs +++ b/src/test/run-pass/dead-code-one-arm-if.rs @@ -2,4 +2,4 @@ // -*- rust -*- -fn main() { if 1 == 1 { ret; } log "Paul is dead"; } +fn main() { if 1 == 1 { ret; } #debug("Paul is dead"); } diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs index 33d7f48dfe0..0f494131ab8 100644 --- a/src/test/run-pass/deref-lval.rs +++ b/src/test/run-pass/deref-lval.rs @@ -1,3 +1,3 @@ -fn main() { let x = @mutable 5; *x = 1000; log *x; } +fn main() { let x = @mutable 5; *x = 1000; log_full(core::debug, *x); } diff --git a/src/test/run-pass/export-non-interference2.rs b/src/test/run-pass/export-non-interference2.rs index c32f718c4d1..007e25a251c 100644 --- a/src/test/run-pass/export-non-interference2.rs +++ b/src/test/run-pass/export-non-interference2.rs @@ -6,7 +6,7 @@ mod foo { fn y() { x(); } } - fn x() { log "x"; } + fn x() { #debug("x"); } } fn main() { foo::bar::y(); } diff --git a/src/test/run-pass/export-non-interference3.rs b/src/test/run-pass/export-non-interference3.rs index 14fba5d40c3..161ab05e266 100644 --- a/src/test/run-pass/export-non-interference3.rs +++ b/src/test/run-pass/export-non-interference3.rs @@ -7,7 +7,7 @@ mod foo { mod bar { export x; - fn x() { log "x"; } + fn x() { #debug("x"); } } fn main() { foo::x(); } diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs index 2e689b5f07d..768a75878f4 100644 --- a/src/test/run-pass/expr-block-generic-box1.rs +++ b/src/test/run-pass/expr-block-generic-box1.rs @@ -11,8 +11,8 @@ fn test_generic(expected: @T, eq: compare) { fn test_box() { fn compare_box(b1: @bool, b2: @bool) -> bool { - log *b1; - log *b2; + log_full(core::debug, *b1); + log_full(core::debug, *b2); ret *b1 == *b2; } let eq = bind compare_box(_, _); diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs index 436689f68aa..6c61cf619a1 100644 --- a/src/test/run-pass/expr-block-generic-unique1.rs +++ b/src/test/run-pass/expr-block-generic-unique1.rs @@ -10,8 +10,8 @@ fn test_generic(expected: ~T, eq: compare) { fn test_box() { fn compare_box(b1: ~bool, b2: ~bool) -> bool { - log *b1; - log *b2; + log_full(core::debug, *b1); + log_full(core::debug, *b2); ret *b1 == *b2; } let eq = bind compare_box(_, _); diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index 95af3b8a6b6..4baf413b4c9 100644 --- a/src/test/run-pass/fact.rs +++ b/src/test/run-pass/fact.rs @@ -3,26 +3,26 @@ // -*- rust -*- fn f(x: int) -> int { - // log "in f:"; + // #debug("in f:"); - log x; + log_full(core::debug, x); if x == 1 { - // log "bottoming out"; + // #debug("bottoming out"); ret 1; } else { - // log "recurring"; + // #debug("recurring"); let y: int = x * f(x - 1); - // log "returned"; + // #debug("returned"); - log y; + log_full(core::debug, y); ret y; } } fn main() { assert (f(5) == 120); - // log "all done"; + // #debug("all done"); } diff --git a/src/test/run-pass/float-signature.rs b/src/test/run-pass/float-signature.rs index 8eb940d8883..f0085418fdb 100644 --- a/src/test/run-pass/float-signature.rs +++ b/src/test/run-pass/float-signature.rs @@ -4,5 +4,5 @@ fn main() { fn foo(n: float) -> float { ret n + 0.12345; } let n: float = 0.1; let m: float = foo(n); - log m; + log_full(core::debug, m); } diff --git a/src/test/run-pass/float.rs b/src/test/run-pass/float.rs index a0b4a32d41a..a57e897f506 100644 --- a/src/test/run-pass/float.rs +++ b/src/test/run-pass/float.rs @@ -2,9 +2,9 @@ fn main() { let pi = 3.1415927; - log -pi * (pi + 2.0 / pi) - pi * 5.0; + log_full(core::debug, -pi * (pi + 2.0 / pi) - pi * 5.0); if pi == 5.0 || pi < 10.0 || pi <= 2.0 || pi != 22.0 / 7.0 || pi >= 10.0 || pi > 1.0 { - log "yes"; + #debug("yes"); } } diff --git a/src/test/run-pass/fn-bare-item.rs b/src/test/run-pass/fn-bare-item.rs index 24a4a48eea6..2baea9846ab 100644 --- a/src/test/run-pass/fn-bare-item.rs +++ b/src/test/run-pass/fn-bare-item.rs @@ -1,5 +1,5 @@ fn f() { - log "This is a bare function"; + #debug("This is a bare function"); } fn main() { diff --git a/src/test/run-pass/fn-constraint.rs b/src/test/run-pass/fn-constraint.rs index 0a7db451cfb..5a3486538ae 100644 --- a/src/test/run-pass/fn-constraint.rs +++ b/src/test/run-pass/fn-constraint.rs @@ -6,5 +6,5 @@ fn main() { let a: uint = 1u; let b: uint = 4u; check (le(a, b)); - log safe_slice("kitties", a, b); + log_full(core::debug, safe_slice("kitties", a, b)); } diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs index fe9c42a1738..947e0a0a345 100644 --- a/src/test/run-pass/foreach-put-structured.rs +++ b/src/test/run-pass/foreach-put-structured.rs @@ -11,8 +11,8 @@ fn main() { let j: int = 0; pairs() {|p| let (_0, _1) = p; - log _0; - log _1; + log_full(core::debug, _0); + log_full(core::debug, _1); assert (_0 + 10 == i); i += 1; j = _1; diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs index 8aefb2a7635..81b26a42e1b 100644 --- a/src/test/run-pass/foreach-simple-outer-slot.rs +++ b/src/test/run-pass/foreach-simple-outer-slot.rs @@ -4,13 +4,13 @@ // -*- rust -*- fn main() { let sum: int = 0; - first_ten {|i| log "main"; log i; sum = sum + i; }; - log "sum"; - log sum; + first_ten {|i| #debug("main"); log_full(core::debug, i); sum = sum + i; }; + #debug("sum"); + log_full(core::debug, sum); assert (sum == 45); } fn first_ten(it: block(int)) { let i: int = 0; - while i < 10 { log "first_ten"; it(i); i = i + 1; } + while i < 10 { #debug("first_ten"); it(i); i = i + 1; } } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index 470815996ce..1927895c4a0 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -5,6 +5,6 @@ fn id(t: T) -> T { ret t; } fn main() { let expected = @100; let actual = id::<@int>(expected); - log *actual; + log_full(core::debug, *actual); assert (*expected == *actual); } diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 1ca044ef162..afab511d0fe 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -5,6 +5,6 @@ fn id(t: T) -> T { ret t; } fn main() { let expected = ~100; let actual = id::<~int>(expected); - log *actual; + log_full(core::debug, *actual); assert (*expected == *actual); } diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index 05f311167cf..a38673c5e20 100644 --- a/src/test/run-pass/generic-derived-type.rs +++ b/src/test/run-pass/generic-derived-type.rs @@ -11,8 +11,8 @@ fn f(t: T) -> {a: T, b: T} { fn main() { let b = f::(10); - log b.a; - log b.b; + log_full(core::debug, b.a); + log_full(core::debug, b.b); assert (b.a == 10); assert (b.b == 10); } diff --git a/src/test/run-pass/generic-fn-box.rs b/src/test/run-pass/generic-fn-box.rs index ca90cbfd65e..51fd9d266a9 100644 --- a/src/test/run-pass/generic-fn-box.rs +++ b/src/test/run-pass/generic-fn-box.rs @@ -2,4 +2,4 @@ fn f(x: @T) -> @T { ret x; } -fn main() { let x = f(@3); log *x; } +fn main() { let x = f(@3); log_full(core::debug, *x); } diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs index 49cc7600315..1da5e7ecbec 100644 --- a/src/test/run-pass/generic-fn-unique.rs +++ b/src/test/run-pass/generic-fn-unique.rs @@ -1,4 +1,4 @@ fn f(x: ~T) -> ~T { ret x; } -fn main() { let x = f(~3); log *x; } +fn main() { let x = f(~3); log_full(core::debug, *x); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index 63350c44273..64c7d969f23 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -14,14 +14,14 @@ fn main() { let p: triple = {x: 65, y: 66, z: 67}; let q: triple = {x: 68, y: 69, z: 70}; y = id::(x); - log y; + log_full(core::debug, y); assert (x == y); b = id::(a); - log b; + log_full(core::debug, b); assert (a == b); q = id::(p); x = p.z; y = q.z; - log y; + log_full(core::debug, y); assert (x == y); } diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs index 5aa6769da64..d3d8c4cc98b 100644 --- a/src/test/run-pass/generic-obj-with-derived-type.rs +++ b/src/test/run-pass/generic-obj-with-derived-type.rs @@ -8,10 +8,10 @@ fn main() { type rgb = {x: u8, y: u8, z: u8}; let h: handle = handle::({x: 1 as u8, y: 2 as u8, z: 3 as u8}); - log "constructed object"; - log h.get().x; - log h.get().y; - log h.get().z; + #debug("constructed object"); + log_full(core::debug, h.get().x); + log_full(core::debug, h.get().y); + log_full(core::debug, h.get().z); assert (h.get().x == 1 as u8); assert (h.get().y == 2 as u8); assert (h.get().z == 3 as u8); diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs index fa90e5863b6..0b503e50f1f 100644 --- a/src/test/run-pass/generic-obj.rs +++ b/src/test/run-pass/generic-obj.rs @@ -12,10 +12,10 @@ obj buf(data: {_0: T, _1: T, _2: T}) { fn main() { let b: buf = buf::({_0: 1, _1: 2, _2: 3}); - log "constructed object"; - log b.get(0); - log b.get(1); - log b.get(2); + #debug("constructed object"); + log_full(core::debug, b.get(0)); + log_full(core::debug, b.get(1)); + log_full(core::debug, b.get(2)); assert (b.get(0) == 1); assert (b.get(1) == 2); assert (b.get(2) == 3); diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs index d6f8dad88bc..469dc200845 100644 --- a/src/test/run-pass/generic-tag-alt.rs +++ b/src/test/run-pass/generic-tag-alt.rs @@ -4,7 +4,7 @@ tag foo { arm(T); } fn altfoo(f: foo) { let hit = false; - alt f { arm::(x) { log "in arm"; hit = true; } } + alt f { arm::(x) { #debug("in arm"); hit = true; } } assert (hit); } diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs index cd9b0144166..ba7f5858b4e 100644 --- a/src/test/run-pass/generic-tag-values.rs +++ b/src/test/run-pass/generic-tag-values.rs @@ -6,9 +6,14 @@ tag noption { some(T); } fn main() { let nop: noption = some::(5); - alt nop { some::(n) { log n; assert (n == 5); } } + alt nop { some::(n) { log_full(core::debug, n); assert (n == 5); } } let nop2: noption<{x: int, y: int}> = some({x: 17, y: 42}); alt nop2 { - some(t) { log t.x; log t.y; assert (t.x == 17); assert (t.y == 42); } + some(t) { + log_full(core::debug, t.x); + log_full(core::debug, t.y); + assert (t.x == 17); + assert (t.y == 42); + } } } diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs index 9dbc5a55d20..954fde38d4d 100644 --- a/src/test/run-pass/generic-temporary.rs +++ b/src/test/run-pass/generic-temporary.rs @@ -2,7 +2,7 @@ fn mk() -> int { ret 1; } -fn chk(&&a: int) { log a; assert (a == 1); } +fn chk(&&a: int) { log_full(core::debug, a); assert (a == 1); } fn apply(produce: fn() -> T, consume: fn(T)) { consume(produce()); } diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index 7134c96d4e2..38cf67b3baa 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -1,7 +1,7 @@ fn get_third(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; } fn main() { - log get_third((1, 2, 3)); + log_full(core::debug, get_third((1, 2, 3))); assert (get_third((1, 2, 3)) == 3); assert (get_third((5u8, 6u8, 7u8)) == 7u8); } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index 32bcecc5ee3..204fa517302 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -48,11 +48,11 @@ mod map_reduce { some(_c) { c = _c } none. { let p = port(); - log_err "sending find_reducer"; + #error("sending find_reducer"); send(ctrl, find_reducer(str::bytes(key), chan(p))); - log_err "receiving"; + #error("receiving"); c = recv(p); - log_err c; + log_full(core::error, c); im.insert(key, c); } } diff --git a/src/test/run-pass/hello.rs b/src/test/run-pass/hello.rs index fa917bd4902..018830de4c9 100644 --- a/src/test/run-pass/hello.rs +++ b/src/test/run-pass/hello.rs @@ -2,4 +2,4 @@ // -*- rust -*- -fn main() { log "hello, world."; } +fn main() { #debug("hello, world."); } diff --git a/src/test/run-pass/if-bot.rs b/src/test/run-pass/if-bot.rs index 35452a2ba6d..78acc18e643 100644 --- a/src/test/run-pass/if-bot.rs +++ b/src/test/run-pass/if-bot.rs @@ -1,3 +1,6 @@ -fn main() { let i: int = if false { fail } else { 5 }; log i; } +fn main() { + let i: int = if false { fail } else { 5 }; + log_full(core::debug, i); +} diff --git a/src/test/run-pass/if-check-precond.rs b/src/test/run-pass/if-check-precond.rs index 5f3715273ae..58b61be0b05 100644 --- a/src/test/run-pass/if-check-precond.rs +++ b/src/test/run-pass/if-check-precond.rs @@ -4,7 +4,7 @@ pure fn even(x: uint) -> bool { } else if x == 2u { ret true; } else { ret even(x - 2u); } } -fn print_even(x: uint) : even(x) { log x; } +fn print_even(x: uint) : even(x) { log_full(core::debug, x); } fn foo(x: uint) { if check even(x) { print_even(x); } else { fail; } } diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs index 508bc8385cf..af41543041b 100644 --- a/src/test/run-pass/if-check.rs +++ b/src/test/run-pass/if-check.rs @@ -4,6 +4,12 @@ pure fn even(x: uint) -> bool { } else if x == 2u { ret true; } else { ret even(x - 2u); } } -fn foo(x: uint) { if check even(x) { log x; } else { fail; } } +fn foo(x: uint) { + if check even(x) { + log_full(core::debug, x); + } else { + fail; + } +} fn main() { foo(2u); } diff --git a/src/test/run-pass/import-glob-0.rs b/src/test/run-pass/import-glob-0.rs index 51144e492ce..1ea6ceae22c 100644 --- a/src/test/run-pass/import-glob-0.rs +++ b/src/test/run-pass/import-glob-0.rs @@ -5,10 +5,10 @@ mod module_of_many_things { export f1; export f2; export f4; - fn f1() { log "f1"; } - fn f2() { log "f2"; } - fn f3() { log "f3"; } - fn f4() { log "f4"; } + fn f1() { #debug("f1"); } + fn f2() { #debug("f2"); } + fn f3() { #debug("f3"); } + fn f4() { #debug("f4"); } } mod dug { @@ -17,8 +17,8 @@ mod dug { mod and { mod too { mod deep { - fn nameless_fear() { log "Boo!"; } - fn also_redstone() { log "Whatever."; } + fn nameless_fear() { #debug("Boo!"); } + fn also_redstone() { #debug("Whatever."); } } } } diff --git a/src/test/run-pass/import-glob-1.rs b/src/test/run-pass/import-glob-1.rs index 24a15e284d4..5542f3b633a 100644 --- a/src/test/run-pass/import-glob-1.rs +++ b/src/test/run-pass/import-glob-1.rs @@ -32,7 +32,7 @@ mod a2 { mod b2 { // | fn word_traveler() { // | - log "ahoy!"; // -/ + #debug("ahoy!"); // -/ } // } // } diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs index 534e00f4f5d..16a132c1d5d 100644 --- a/src/test/run-pass/import-in-block.rs +++ b/src/test/run-pass/import-in-block.rs @@ -3,9 +3,9 @@ use std; fn main() { import vec; import vec::to_mut; - log vec::len(to_mut([1, 2])); + log_full(core::debug, vec::len(to_mut([1, 2]))); { import vec::*; - log len([2]); + log_full(core::debug, len([2])); } } diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs index ffd84fda952..68a7d6877d1 100644 --- a/src/test/run-pass/import.rs +++ b/src/test/run-pass/import.rs @@ -1,5 +1,5 @@ mod foo { - fn x(y: int) { log y; } + fn x(y: int) { log_full(core::debug, y); } } mod bar { diff --git a/src/test/run-pass/import2.rs b/src/test/run-pass/import2.rs index 5b287cd7ddd..660f4f63147 100644 --- a/src/test/run-pass/import2.rs +++ b/src/test/run-pass/import2.rs @@ -2,7 +2,7 @@ import zed::bar; mod zed { - fn bar() { log "bar"; } + fn bar() { #debug("bar"); } } fn main() { bar(); } diff --git a/src/test/run-pass/import3.rs b/src/test/run-pass/import3.rs index 9732385d0ad..e4cddbe082f 100644 --- a/src/test/run-pass/import3.rs +++ b/src/test/run-pass/import3.rs @@ -4,7 +4,7 @@ import zed::bar; mod baz { mod zed { - fn bar() { log "bar2"; } + fn bar() { #debug("bar2"); } } } diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs index 9e263b73413..42a0bc0fb73 100644 --- a/src/test/run-pass/import4.rs +++ b/src/test/run-pass/import4.rs @@ -2,7 +2,7 @@ import zed::bar; mod zed { - fn bar() { log "bar"; } + fn bar() { #debug("bar"); } } fn main(args: [str]) { let zed = 42; bar(); } diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs index 9f3ec6d2b45..f1b0c5daac9 100644 --- a/src/test/run-pass/import5.rs +++ b/src/test/run-pass/import5.rs @@ -3,7 +3,7 @@ mod foo { import zed::bar; export bar; mod zed { - fn bar() { log "foo"; } + fn bar() { #debug("foo"); } } } diff --git a/src/test/run-pass/import6.rs b/src/test/run-pass/import6.rs index 33898c35a35..232f83b5497 100644 --- a/src/test/run-pass/import6.rs +++ b/src/test/run-pass/import6.rs @@ -2,7 +2,7 @@ import bar::baz; import foo::zed; mod foo { mod zed { - fn baz() { log "baz"; } + fn baz() { #debug("baz"); } } } mod bar { diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs index 40c3d2357bf..3bc5daaa63d 100644 --- a/src/test/run-pass/import7.rs +++ b/src/test/run-pass/import7.rs @@ -2,7 +2,7 @@ import bar::baz; import foo::zed; mod foo { mod zed { - fn baz() { log "baz"; } + fn baz() { #debug("baz"); } } } mod bar { diff --git a/src/test/run-pass/import8.rs b/src/test/run-pass/import8.rs index 884dcebacdf..fdaca253e54 100644 --- a/src/test/run-pass/import8.rs +++ b/src/test/run-pass/import8.rs @@ -3,7 +3,7 @@ import foo::x; import z = foo::x; mod foo { - fn x(y: int) { log y; } + fn x(y: int) { log_full(core::debug, y); } } fn main() { x(10); z(10); } diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs index 6fcc0a79af0..c6a843cde09 100644 --- a/src/test/run-pass/inner-module.rs +++ b/src/test/run-pass/inner-module.rs @@ -4,7 +4,7 @@ // -*- rust -*- mod inner { mod inner2 { - fn hello() { log "hello, modular world"; } + fn hello() { #debug("hello, modular world"); } } fn hello() { inner2::hello(); } } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index ed17e36bcb2..81bad1e91d1 100644 --- a/src/test/run-pass/integral-indexing.rs +++ b/src/test/run-pass/integral-indexing.rs @@ -10,11 +10,11 @@ fn main() { assert (v[3i8] == 3); assert (v[3u32] == 3); assert (v[3i32] == 3); - log v[3u8]; + log_full(core::debug, v[3u8]); assert (s[3u] == 'd' as u8); assert (s[3u8] == 'd' as u8); assert (s[3i8] == 'd' as u8); assert (s[3u32] == 'd' as u8); assert (s[3i32] == 'd' as u8); - log s[3u8]; + log_full(core::debug, s[3u8]); } diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs index e10048d850f..e30e9cf7ecd 100644 --- a/src/test/run-pass/issue-507.rs +++ b/src/test/run-pass/issue-507.rs @@ -29,7 +29,7 @@ fn main() { let x: int = recv(p); - log x; + log_full(core::debug, x); assert (x == 42); diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs index c23411d88ca..29c5bfecf27 100644 --- a/src/test/run-pass/issue-687.rs +++ b/src/test/run-pass/issue-687.rs @@ -20,18 +20,21 @@ fn packager(&&args: (chan>, chan)) { let p: port<[u8]> = port(); send(cb, chan(p)); while true { - log "waiting for bytes"; + #debug("waiting for bytes"); let data = recv(p); - log "got bytes"; - if vec::len(data) == 0u { log "got empty bytes, quitting"; break; } - log "sending non-empty buffer of length"; - log vec::len(data); + #debug("got bytes"); + if vec::len(data) == 0u { + #debug("got empty bytes, quitting"); + break; + } + #debug("sending non-empty buffer of length"); + log_full(core::debug, vec::len(data)); send(msg, received(data)); - log "sent non-empty buffer"; + #debug("sent non-empty buffer"); } - log "sending closed message"; + #debug("sending closed message"); send(msg, closed); - log "sent closed message"; + #debug("sent closed message"); } fn main() { @@ -45,10 +48,10 @@ fn main() { while true { let msg = recv(p); alt msg { - closed. { log "Got close message"; break; } + closed. { #debug("Got close message"); break; } received(data) { - log "Got data. Length is:"; - log vec::len::(data); + #debug("Got data. Length is:"); + log_full(core::debug, vec::len::(data)); } } } diff --git a/src/test/run-pass/issue-898.rs b/src/test/run-pass/issue-898.rs index 6169a4f6b57..a03e7eaece8 100644 --- a/src/test/run-pass/issue-898.rs +++ b/src/test/run-pass/issue-898.rs @@ -3,7 +3,7 @@ fn even(&&e: int) -> bool { } fn log_if(c: fn(T)->bool, e: T) { - if c(e) { log e; } + if c(e) { log_full(core::debug, e); } } fn main() { diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs index affdbd06f17..56206422c2e 100644 --- a/src/test/run-pass/istr.rs +++ b/src/test/run-pass/istr.rs @@ -1,6 +1,6 @@ fn test_stack_assign() { let s: str = "a"; - log s; + log_full(core::debug, s); let t: str = "a"; assert (s == t); let u: str = "b"; @@ -17,7 +17,7 @@ fn test_heap_assign() { assert (s != u); } -fn test_heap_log() { let s = "a big ol' string"; log s; } +fn test_heap_log() { let s = "a big ol' string"; log_full(core::debug, s); } fn test_stack_add() { assert ("a" + "b" == "ab"); @@ -39,7 +39,7 @@ fn test_append() { let s = "a"; s += "b"; - log s; + log_full(core::debug, s); assert (s == "ab"); let s = "c"; diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs index 0700b5d5311..d549b247933 100644 --- a/src/test/run-pass/iter-range.rs +++ b/src/test/run-pass/iter-range.rs @@ -9,5 +9,5 @@ fn range(a: int, b: int, it: block(int)) { fn main() { let sum: int = 0; range(0, 100) {|x| sum += x; } - log sum; + log_full(core::debug, sum); } diff --git a/src/test/run-pass/join.rs b/src/test/run-pass/join.rs index afcb43edfbe..7652eb3e1d7 100644 --- a/src/test/run-pass/join.rs +++ b/src/test/run-pass/join.rs @@ -6,10 +6,10 @@ import task::*; fn main() { let other = spawn_joinable((), child); - log_err "1"; + #error("1"); yield(); join(other); - log_err "3"; + #error("3"); } -fn child(&&_i: ()) { log_err "2"; } +fn child(&&_i: ()) { #error("2"); } diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs index 7bfba99baac..3ccf97aba52 100644 --- a/src/test/run-pass/lambda-infer-unresolved.rs +++ b/src/test/run-pass/lambda-infer-unresolved.rs @@ -2,6 +2,6 @@ // resolved when we finish typechecking the lambda. fn main() { let e = @{mutable refs: [], n: 0}; - let f = lambda () { log_err e.n; }; + let f = lambda () { log_full(core::error, e.n); }; e.refs += [1]; } diff --git a/src/test/run-pass/lambda-no-leak.rs b/src/test/run-pass/lambda-no-leak.rs index 3c5e1d825ab..17d0eda392b 100644 --- a/src/test/run-pass/lambda-no-leak.rs +++ b/src/test/run-pass/lambda-no-leak.rs @@ -2,6 +2,6 @@ fn force(f: fn@()) { f() } fn main() { let x = 7; - lambda () { log_err x; }; - force(lambda () { log_err x; }); + lambda () { log_full(core::error, x); }; + force(lambda () { log_full(core::error, x); }); } diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs index 0fa03511e34..9aef748ce09 100644 --- a/src/test/run-pass/lazy-and-or.rs +++ b/src/test/run-pass/lazy-and-or.rs @@ -6,7 +6,7 @@ fn main() { let x = 1 == 2 || 3 == 3; assert (x); let y: int = 10; - log x || incr(y); + log_full(core::debug, x || incr(y)); assert (y == 10); if true && x { assert (true); } else { assert (false); } } diff --git a/src/test/run-pass/lazy-init.rs b/src/test/run-pass/lazy-init.rs index b5f53400229..fb0a9979c64 100644 --- a/src/test/run-pass/lazy-init.rs +++ b/src/test/run-pass/lazy-init.rs @@ -1,5 +1,5 @@ -fn foo(x: int) { log x; } +fn foo(x: int) { log_full(core::debug, x); } fn main() { let x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); } diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs index 80687497366..5bf47adcf06 100644 --- a/src/test/run-pass/lazychan.rs +++ b/src/test/run-pass/lazychan.rs @@ -10,14 +10,14 @@ fn main() { task::spawn(chan(p), child); y = recv(p); - log "received 1"; - log y; + #debug("received 1"); + log_full(core::debug, y); assert (y == 10); task::spawn(chan(p), child); y = recv(p); - log "received 2"; - log y; + #debug("received 2"); + log_full(core::debug, y); assert (y == 10); } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 319ce032d8d..de87837a31a 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -3,8 +3,8 @@ fn main() { let x = [1, 2, 3]; let y = 0; - for i: int in x { log i; y += i; } - log y; + for i: int in x { log_full(core::debug, i); y += i; } + log_full(core::debug, y); assert (y == 6); let s = "hello there"; let i: int = 0; @@ -17,8 +17,8 @@ fn main() { // ... i += 1; - log i; - log c; + log_full(core::debug, i); + log_full(core::debug, c); } assert (i == 11); } diff --git a/src/test/run-pass/log-err-phi.rs b/src/test/run-pass/log-err-phi.rs index 0317f90573b..305f84d766c 100644 --- a/src/test/run-pass/log-err-phi.rs +++ b/src/test/run-pass/log-err-phi.rs @@ -1,3 +1,3 @@ -fn main() { if false { log_err "foo" + "bar"; } } +fn main() { if false { log_full(core::error, "foo" + "bar"); } } diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs index d45417e20e3..88603bd1f7b 100644 --- a/src/test/run-pass/log-linearized.rs +++ b/src/test/run-pass/log-linearized.rs @@ -14,7 +14,7 @@ fn mk() -> smallintmap { fn f() { let sim = mk::(); - log_err sim; + log_full(core::error, sim); } fn main() { diff --git a/src/test/run-pass/main-ivec.rs b/src/test/run-pass/main-ivec.rs index b279bc92a2b..c4d74b65171 100644 --- a/src/test/run-pass/main-ivec.rs +++ b/src/test/run-pass/main-ivec.rs @@ -1 +1 @@ -fn main(args: [str]) { for s in args { log s; } } +fn main(args: [str]) { for s in args { log_full(core::debug, s); } } diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs index e8c6ae14fa1..feb95f7e363 100644 --- a/src/test/run-pass/many.rs +++ b/src/test/run-pass/many.rs @@ -20,7 +20,7 @@ fn main() { let p = comm::port(); let child = task::spawn((comm::chan(p), 200), sub); let y = comm::recv(p); - log "transmission complete"; - log y; + #debug("transmission complete"); + log_full(core::debug, y); assert (y == 200); } diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs index 3d57531c8c6..05ebb5ac50f 100644 --- a/src/test/run-pass/maybe-mutable.rs +++ b/src/test/run-pass/maybe-mutable.rs @@ -10,7 +10,7 @@ fn len(v: [const int]) -> uint { fn main() { let v0 = [1, 2, 3, 4, 5]; - log len(v0); + log_full(core::debug, len(v0)); let v1 = [mutable 1, 2, 3, 4, 5]; - log len(v1); + log_full(core::debug, len(v1)); } diff --git a/src/test/run-pass/multi-src/bar.rs b/src/test/run-pass/multi-src/bar.rs index 949a34bb1c2..f851522bf52 100644 --- a/src/test/run-pass/multi-src/bar.rs +++ b/src/test/run-pass/multi-src/bar.rs @@ -1,3 +1,3 @@ -fn other() { log "yes"; } +fn other() { #debug("yes"); } diff --git a/src/test/run-pass/multi-src/foo.rs b/src/test/run-pass/multi-src/foo.rs index 2c38317bf1d..9f12fd12c6e 100644 --- a/src/test/run-pass/multi-src/foo.rs +++ b/src/test/run-pass/multi-src/foo.rs @@ -1,3 +1,3 @@ -fn main() { log "hello, multi-file world."; bar::other(); } +fn main() { #debug("hello, multi-file world."); bar::other(); } diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index 942efdadc06..596103af7fc 100644 --- a/src/test/run-pass/mutable-alias-vec.rs +++ b/src/test/run-pass/mutable-alias-vec.rs @@ -11,6 +11,6 @@ fn main() { grow(v); grow(v); let len = vec::len::(v); - log len; + log_full(core::debug, len); assert (len == 3 as uint); } diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs index d10b4f05693..c07b4ab97a6 100644 --- a/src/test/run-pass/nested-alts.rs +++ b/src/test/run-pass/nested-alts.rs @@ -6,9 +6,9 @@ fn foo() { some::(x) { let bar; alt none:: { none::. { bar = 5; } _ { baz(); } } - log bar; + log_full(core::debug, bar); } - none::. { log "hello"; } + none::. { #debug("hello"); } } } diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs index cf19630146f..c0d0528674b 100644 --- a/src/test/run-pass/nested-pattern.rs +++ b/src/test/run-pass/nested-pattern.rs @@ -10,8 +10,8 @@ tag t { foo(int, uint); bar(int, option::t); } fn nested(o: t) { alt o { - bar(i, some::(_)) { log_err "wrong pattern matched"; fail; } - _ { log_err "succeeded"; } + bar(i, some::(_)) { #error("wrong pattern matched"); fail; } + _ { #error("succeeded"); } } } diff --git a/src/test/run-pass/obj-recursion.rs b/src/test/run-pass/obj-recursion.rs index 3c4346af32e..c37a03ed838 100644 --- a/src/test/run-pass/obj-recursion.rs +++ b/src/test/run-pass/obj-recursion.rs @@ -6,7 +6,7 @@ type adder = }; obj leaf_adder(x: int) { - fn add() { log "leaf"; log x; } + fn add() { #debug("leaf"); log_full(core::debug, x); } } obj delegate_adder(a: adder) { diff --git a/src/test/run-pass/obj-self-2.rs b/src/test/run-pass/obj-self-2.rs index d0c450aaeba..cf321594586 100644 --- a/src/test/run-pass/obj-self-2.rs +++ b/src/test/run-pass/obj-self-2.rs @@ -2,7 +2,7 @@ fn main() { obj foo() { - fn m1(i: int) { let i = i + 1; log "hi!"; } + fn m1(i: int) { let i = i + 1; #debug("hi!"); } fn m2(i: int) { let i = i + 1; self.m1(i); } } let a = foo(); diff --git a/src/test/run-pass/obj-self.rs b/src/test/run-pass/obj-self.rs index c6a1b141558..588135c9121 100644 --- a/src/test/run-pass/obj-self.rs +++ b/src/test/run-pass/obj-self.rs @@ -2,7 +2,7 @@ fn main() { obj foo() { - fn m1() { log "hi!"; } + fn m1() { #debug("hi!"); } fn m2() { self.m1(); } } let a = foo(); diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs index 1ce8cbc46bf..1670febe0e4 100644 --- a/src/test/run-pass/obj-with-vec.rs +++ b/src/test/run-pass/obj-with-vec.rs @@ -5,6 +5,6 @@ fn main() { fn get(i: int) -> u8 { ret data[i]; } } let b = buf([1 as u8, 2 as u8, 3 as u8]); - log b.get(1); + log_full(core::debug, b.get(1)); assert (b.get(1) == 2 as u8); } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index b38a6313f54..96214d9669f 100644 --- a/src/test/run-pass/opeq.rs +++ b/src/test/run-pass/opeq.rs @@ -5,15 +5,15 @@ fn main() { let x: int = 1; x *= 2; - log x; + log_full(core::debug, x); assert (x == 2); x += 3; - log x; + log_full(core::debug, x); assert (x == 5); x *= x; - log x; + log_full(core::debug, x); assert (x == 25); x /= 5; - log x; + log_full(core::debug, x); assert (x == 5); } diff --git a/src/test/run-pass/over-constrained-vregs.rs b/src/test/run-pass/over-constrained-vregs.rs index 98f4ab7a6d8..064d1e47347 100644 --- a/src/test/run-pass/over-constrained-vregs.rs +++ b/src/test/run-pass/over-constrained-vregs.rs @@ -2,4 +2,11 @@ // Regression test for issue #152. -fn main() { let b: uint = 1u; while b <= 32u { 0u << b; b <<= 1u; log b; } } +fn main() { + let b: uint = 1u; + while b <= 32u { + 0u << b; + b <<= 1u; + log_full(core::debug, b); + } +} diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs index 4d48c09175a..8d68a5e7c4c 100644 --- a/src/test/run-pass/paren-free.rs +++ b/src/test/run-pass/paren-free.rs @@ -1,5 +1,5 @@ fn main() { let x = true; if x { let i = 10; while i > 0 { i -= 1; } } - alt x { true { log "right"; } false { log "wrong"; } } + alt x { true { #debug("right"); } false { #debug("wrong"); } } } diff --git a/src/test/run-pass/parse-fail.rs b/src/test/run-pass/parse-fail.rs index 0b4e959c9ee..b9bcc80e486 100644 --- a/src/test/run-pass/parse-fail.rs +++ b/src/test/run-pass/parse-fail.rs @@ -2,6 +2,6 @@ // -*- rust -*- -fn dont_call_me() { fail; log 1; } +fn dont_call_me() { fail; log_full(core::debug, 1); } fn main() { } diff --git a/src/test/run-pass/pass-by-copy.rs b/src/test/run-pass/pass-by-copy.rs index 61cdd01ba21..b9eecbed2f1 100644 --- a/src/test/run-pass/pass-by-copy.rs +++ b/src/test/run-pass/pass-by-copy.rs @@ -1,5 +1,5 @@ -fn magic(+x: {a: @int}) { log x; } -fn magic2(+x: @int) { log x; } +fn magic(+x: {a: @int}) { log_full(core::debug, x); } +fn magic2(+x: @int) { log_full(core::debug, x); } fn main() { let a = {a: @10}, b = @10; diff --git a/src/test/run-pass/preempt.rs b/src/test/run-pass/preempt.rs index 196f54c1449..5511225086d 100644 --- a/src/test/run-pass/preempt.rs +++ b/src/test/run-pass/preempt.rs @@ -2,21 +2,21 @@ // This checks that preemption works. fn starve_main(alive: chan) { - log "signalling main"; + #debug("signalling main"); alive <| 1; - log "starving main"; + #debug("starving main"); let i: int = 0; while true { i += 1; } } fn main() { let alive: port = port(); - log "main started"; + #debug("main started"); let s: task = spawn starve_main(chan(alive)); let i: int; - log "main waiting for alive signal"; + #debug("main waiting for alive signal"); alive |> i; - log "main got alive signal"; - while i < 50 { log "main iterated"; i += 1; } - log "main completed"; + #debug("main got alive signal"); + while i < 50 { #debug("main iterated"); i += 1; } + #debug("main completed"); } diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs index c23c359d621..73ada106f43 100644 --- a/src/test/run-pass/rec-auto.rs +++ b/src/test/run-pass/rec-auto.rs @@ -4,4 +4,8 @@ // -*- rust -*- // Issue #50. -fn main() { let x = {foo: "hello", bar: "world"}; log x.foo; log x.bar; } +fn main() { + let x = {foo: "hello", bar: "world"}; + log_full(core::debug, x.foo); + log_full(core::debug, x.bar); +} diff --git a/src/test/run-pass/reference-branch.rs b/src/test/run-pass/reference-branch.rs index 7c5d0c660f7..56f70a64576 100644 --- a/src/test/run-pass/reference-branch.rs +++ b/src/test/run-pass/reference-branch.rs @@ -5,5 +5,5 @@ fn main() { let x = []; let &y = x; if true { x = [1]; } - else { log_err y; } + else { log_full(core::error, y); } } diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs index 2c597da4173..9348dcd50c2 100644 --- a/src/test/run-pass/resource-assign-is-not-copy.rs +++ b/src/test/run-pass/resource-assign-is-not-copy.rs @@ -7,7 +7,7 @@ fn main() { let a = r(i); let b = (a, 10); let (c, _d) = b; - log c; + log_full(core::debug, c); } assert *i == 1; } diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs index 55a4c5922c3..e3609bf1d76 100644 --- a/src/test/run-pass/ret-bang.rs +++ b/src/test/run-pass/ret-bang.rs @@ -2,7 +2,7 @@ // -*- rust -*- -fn my_err(s: str) -> ! { log_err s; fail; } +fn my_err(s: str) -> ! { log_full(core::error, s); fail; } fn okay(i: uint) -> int { if i == 3u { my_err("I don't like three"); } else { ret 42; } diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index d6a63d5cfe4..5a6255038f6 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -14,12 +14,12 @@ fn make_generic_record(a: A, b: B) -> pair { fn test05_start(&&f: sendfn(&&float, &&str) -> pair) { let p = f(22.22f, "Hi"); - log p; + log_full(core::debug, p); assert p.a == 22.22f; assert p.b == "Hi"; let q = f(44.44f, "Ho"); - log q; + log_full(core::debug, q); assert q.a == 44.44f; assert q.b == "Ho"; } diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index d96345e9e41..2edc604deb8 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -13,7 +13,7 @@ fn test05_start(&&f: sendfn(int)) { fn test05() { let three = ~3; let fn_to_send = sendfn(n: int) { - log_err *three + n; // will copy x into the closure + log_full(core::error, *three + n); // will copy x into the closure assert(*three == 3); }; task::spawn(fn_to_send, test05_start); diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs index 3fc3a015915..1a693bc3b1a 100644 --- a/src/test/run-pass/shadow.rs +++ b/src/test/run-pass/shadow.rs @@ -5,7 +5,13 @@ fn foo(c: [int]) { alt none:: { - some::(_) { for i: int in c { log a; let a = 17; b += [a]; } } + some::(_) { + for i: int in c { + log_full(core::debug, a); + let a = 17; + b += [a]; + } + } _ { } } } diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs index 0d427dca45f..9132f650772 100644 --- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs +++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs @@ -26,6 +26,6 @@ fn main() { let p_: path_ = { global: true, idents: ["hi"], types: [t] }; let p: path = { data: p_, span: sp }; let x = { sp: sp, path: p }; - log_err x.path; - log_err x; + log_full(core::error, x.path); + log_full(core::error, x); } diff --git a/src/test/run-pass/simple-alt-generic-tag.rs b/src/test/run-pass/simple-alt-generic-tag.rs index ac0e5ed6994..3b0776fcd55 100644 --- a/src/test/run-pass/simple-alt-generic-tag.rs +++ b/src/test/run-pass/simple-alt-generic-tag.rs @@ -4,5 +4,5 @@ tag opt { none; } fn main() { let x = none::; - alt x { none::. { log "hello world"; } } + alt x { none::. { #debug("hello world"); } } } diff --git a/src/test/run-pass/simple-infer.rs b/src/test/run-pass/simple-infer.rs index 03656fc8c1b..887df2ef3f3 100644 --- a/src/test/run-pass/simple-infer.rs +++ b/src/test/run-pass/simple-infer.rs @@ -1,3 +1,3 @@ -fn main() { let n; n = 1; log n; } +fn main() { let n; n = 1; log_full(core::debug, n); } diff --git a/src/test/run-pass/simple-obj.rs b/src/test/run-pass/simple-obj.rs index 6cb4caafe16..fe85e2852ba 100644 --- a/src/test/run-pass/simple-obj.rs +++ b/src/test/run-pass/simple-obj.rs @@ -3,7 +3,7 @@ // -*- rust -*- obj x() { - fn hello() { log "hello, object world"; } + fn hello() { #debug("hello, object world"); } } fn main() { let mx = x(); mx.hello(); } diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs index 10c1e45017d..38e473f082c 100644 --- a/src/test/run-pass/size-and-align.rs +++ b/src/test/run-pass/size-and-align.rs @@ -6,8 +6,8 @@ tag clam { a(T, int); b; } fn uhoh(v: [clam]) { alt v[1] { - a::(t, u) { log "incorrect"; log u; fail; } - b::. { log "correct"; } + a::(t, u) { #debug("incorrect"); log_full(core::debug, u); fail; } + b::. { #debug("correct"); } } } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index df64e47bbf8..38600ba9f7e 100644 --- a/src/test/run-pass/spawn-fn.rs +++ b/src/test/run-pass/spawn-fn.rs @@ -6,7 +6,7 @@ import task; fn x(&&args: (str, int)) { let (s, n) = args; - log s; log n; + log_full(core::debug, s); log_full(core::debug, n); } fn main() { @@ -14,5 +14,5 @@ fn main() { task::spawn(("hello from second spawned fn", 66), x); task::spawn(("hello from third spawned fn", 67), x); let i: int = 30; - while i > 0 { i = i - 1; log "parent sleeping"; yield(); } + while i > 0 { i = i - 1; #debug("parent sleeping"); yield(); } } diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs index 66ca0363472..664f3e33b06 100644 --- a/src/test/run-pass/spawn-module-qualified.rs +++ b/src/test/run-pass/spawn-module-qualified.rs @@ -5,5 +5,5 @@ import task::spawn_joinable; fn main() { let x = spawn_joinable(10, m::child); join(x); } mod m { - fn child(&&i: int) { log i; } + fn child(&&i: int) { log_full(core::debug, i); } } diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs index cc540efa2af..431eee700d1 100644 --- a/src/test/run-pass/spawn.rs +++ b/src/test/run-pass/spawn.rs @@ -6,7 +6,7 @@ import task; fn main() { let t = task::spawn_joinable(10, child); task::join(t); } -fn child(&&i: int) { log_err i; assert (i == 10); } +fn child(&&i: int) { log_full(core::error, i); assert (i == 10); } // Local Variables: // mode: rust; diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs index fa07cfecf58..1ecc5e8b3b9 100644 --- a/src/test/run-pass/spawn2.rs +++ b/src/test/run-pass/spawn2.rs @@ -7,15 +7,15 @@ fn main() { spawn((10, 20, 30, 40, 50, 60, 70, 80, 90), child); } fn child(&&args: (int, int, int, int, int, int, int, int, int)) { let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args; - log_err i1; - log_err i2; - log_err i3; - log_err i4; - log_err i5; - log_err i6; - log_err i7; - log_err i8; - log_err i9; + log_full(core::error, i1); + log_full(core::error, i2); + log_full(core::error, i3); + log_full(core::error, i4); + log_full(core::error, i5); + log_full(core::error, i6); + log_full(core::error, i7); + log_full(core::error, i8); + log_full(core::error, i9); assert (i1 == 10); assert (i2 == 20); assert (i3 == 30); diff --git a/src/test/run-pass/stateful-obj.rs b/src/test/run-pass/stateful-obj.rs index 97160244d16..8176b30f9f2 100644 --- a/src/test/run-pass/stateful-obj.rs +++ b/src/test/run-pass/stateful-obj.rs @@ -11,9 +11,9 @@ obj counter(mutable x: int) { fn main() { let y = counter(0); assert (y.hello() == 12345); - log y.get(); + log_full(core::debug, y.get()); y.incr(); y.incr(); - log y.get(); + log_full(core::debug, y.get()); assert (y.get() == 2); } diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index 4e117c4baa2..5b6b36ba4d6 100644 --- a/src/test/run-pass/str-append.rs +++ b/src/test/run-pass/str-append.rs @@ -7,7 +7,7 @@ import str; fn test1() { let s: str = "hello"; s += "world"; - log s; + log_full(core::debug, s); assert (s[9] == 'd' as u8); } @@ -17,8 +17,8 @@ fn test2() { let ff: str = "abc"; let a: str = ff + "ABC" + ff; let b: str = "ABC" + ff + "ABC"; - log a; - log b; + log_full(core::debug, a); + log_full(core::debug, b); assert (str::eq(a, "abcABCabc")); assert (str::eq(b, "ABCabcABC")); } diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs index 8fc48725875..69ea90b126c 100644 --- a/src/test/run-pass/str-concat.rs +++ b/src/test/run-pass/str-concat.rs @@ -6,6 +6,6 @@ fn main() { let a: str = "hello"; let b: str = "world"; let s: str = a + b; - log s; + log_full(core::debug, s); assert (s[9] == 'd' as u8); } diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index 4b5ea5f7961..5911cb30e1b 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -3,6 +3,6 @@ fn main() { let s = "hello"; let c: u8 = s[4]; - log c; + log_full(core::debug, c); assert (c == 0x6f as u8); } diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index d65cfcbf4a9..34d867e30b6 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -7,7 +7,7 @@ fn main() { let i = 20; let expected_len = 1u; while i > 0 { - log_err str::byte_len(a); + log_full(core::error, str::byte_len(a)); assert (str::byte_len(a) == expected_len); a += a; i -= 1; diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs index a100386d1dc..9612a7749cb 100644 --- a/src/test/run-pass/supported-cast.rs +++ b/src/test/run-pass/supported-cast.rs @@ -3,251 +3,251 @@ import std::os; fn main() { let f = 1 as os::libc::FILE; - log f as int; - log f as uint; - log f as i8; - log f as i16; - log f as i32; - log f as i64; - log f as u8; - log f as u16; - log f as u32; - log f as u64; + log_full(core::debug, f as int); + log_full(core::debug, f as uint); + log_full(core::debug, f as i8); + log_full(core::debug, f as i16); + log_full(core::debug, f as i32); + log_full(core::debug, f as i64); + log_full(core::debug, f as u8); + log_full(core::debug, f as u16); + log_full(core::debug, f as u32); + log_full(core::debug, f as u64); - log 1 as int; - log 1 as uint; - log 1 as float; - log 1 as bool; - log 1 as os::libc::FILE; - log 1 as i8; - log 1 as i16; - log 1 as i32; - log 1 as i64; - log 1 as u8; - log 1 as u16; - log 1 as u32; - log 1 as u64; - log 1 as f32; - log 1 as f64; + log_full(core::debug, 1 as int); + log_full(core::debug, 1 as uint); + log_full(core::debug, 1 as float); + log_full(core::debug, 1 as bool); + log_full(core::debug, 1 as os::libc::FILE); + log_full(core::debug, 1 as i8); + log_full(core::debug, 1 as i16); + log_full(core::debug, 1 as i32); + log_full(core::debug, 1 as i64); + log_full(core::debug, 1 as u8); + log_full(core::debug, 1 as u16); + log_full(core::debug, 1 as u32); + log_full(core::debug, 1 as u64); + log_full(core::debug, 1 as f32); + log_full(core::debug, 1 as f64); - log 1u as int; - log 1u as uint; - log 1u as float; - log 1u as bool; - log 1u as os::libc::FILE; - log 1u as i8; - log 1u as i16; - log 1u as i32; - log 1u as i64; - log 1u as u8; - log 1u as u16; - log 1u as u32; - log 1u as u64; - log 1u as f32; - log 1u as f64; + log_full(core::debug, 1u as int); + log_full(core::debug, 1u as uint); + log_full(core::debug, 1u as float); + log_full(core::debug, 1u as bool); + log_full(core::debug, 1u as os::libc::FILE); + log_full(core::debug, 1u as i8); + log_full(core::debug, 1u as i16); + log_full(core::debug, 1u as i32); + log_full(core::debug, 1u as i64); + log_full(core::debug, 1u as u8); + log_full(core::debug, 1u as u16); + log_full(core::debug, 1u as u32); + log_full(core::debug, 1u as u64); + log_full(core::debug, 1u as f32); + log_full(core::debug, 1u as f64); - log 1i8 as int; - log 1i8 as uint; - log 1i8 as float; - log 1i8 as bool; - log 1i8 as os::libc::FILE; - log 1i8 as i8; - log 1i8 as i16; - log 1i8 as i32; - log 1i8 as i64; - log 1i8 as u8; - log 1i8 as u16; - log 1i8 as u32; - log 1i8 as u64; - log 1i8 as f32; - log 1i8 as f64; + log_full(core::debug, 1i8 as int); + log_full(core::debug, 1i8 as uint); + log_full(core::debug, 1i8 as float); + log_full(core::debug, 1i8 as bool); + log_full(core::debug, 1i8 as os::libc::FILE); + log_full(core::debug, 1i8 as i8); + log_full(core::debug, 1i8 as i16); + log_full(core::debug, 1i8 as i32); + log_full(core::debug, 1i8 as i64); + log_full(core::debug, 1i8 as u8); + log_full(core::debug, 1i8 as u16); + log_full(core::debug, 1i8 as u32); + log_full(core::debug, 1i8 as u64); + log_full(core::debug, 1i8 as f32); + log_full(core::debug, 1i8 as f64); - log 1u8 as int; - log 1u8 as uint; - log 1u8 as float; - log 1u8 as bool; - log 1u8 as os::libc::FILE; - log 1u8 as i8; - log 1u8 as i16; - log 1u8 as i32; - log 1u8 as i64; - log 1u8 as u8; - log 1u8 as u16; - log 1u8 as u32; - log 1u8 as u64; - log 1u8 as f32; - log 1u8 as f64; + log_full(core::debug, 1u8 as int); + log_full(core::debug, 1u8 as uint); + log_full(core::debug, 1u8 as float); + log_full(core::debug, 1u8 as bool); + log_full(core::debug, 1u8 as os::libc::FILE); + log_full(core::debug, 1u8 as i8); + log_full(core::debug, 1u8 as i16); + log_full(core::debug, 1u8 as i32); + log_full(core::debug, 1u8 as i64); + log_full(core::debug, 1u8 as u8); + log_full(core::debug, 1u8 as u16); + log_full(core::debug, 1u8 as u32); + log_full(core::debug, 1u8 as u64); + log_full(core::debug, 1u8 as f32); + log_full(core::debug, 1u8 as f64); - log 1i16 as int; - log 1i16 as uint; - log 1i16 as float; - log 1i16 as bool; - log 1i16 as os::libc::FILE; - log 1i16 as i8; - log 1i16 as i16; - log 1i16 as i32; - log 1i16 as i64; - log 1i16 as u8; - log 1i16 as u16; - log 1i16 as u32; - log 1i16 as u64; - log 1i16 as f32; - log 1i16 as f64; + log_full(core::debug, 1i16 as int); + log_full(core::debug, 1i16 as uint); + log_full(core::debug, 1i16 as float); + log_full(core::debug, 1i16 as bool); + log_full(core::debug, 1i16 as os::libc::FILE); + log_full(core::debug, 1i16 as i8); + log_full(core::debug, 1i16 as i16); + log_full(core::debug, 1i16 as i32); + log_full(core::debug, 1i16 as i64); + log_full(core::debug, 1i16 as u8); + log_full(core::debug, 1i16 as u16); + log_full(core::debug, 1i16 as u32); + log_full(core::debug, 1i16 as u64); + log_full(core::debug, 1i16 as f32); + log_full(core::debug, 1i16 as f64); - log 1u16 as int; - log 1u16 as uint; - log 1u16 as float; - log 1u16 as bool; - log 1u16 as os::libc::FILE; - log 1u16 as i8; - log 1u16 as i16; - log 1u16 as i32; - log 1u16 as i64; - log 1u16 as u8; - log 1u16 as u16; - log 1u16 as u32; - log 1u16 as u64; - log 1u16 as f32; - log 1u16 as f64; + log_full(core::debug, 1u16 as int); + log_full(core::debug, 1u16 as uint); + log_full(core::debug, 1u16 as float); + log_full(core::debug, 1u16 as bool); + log_full(core::debug, 1u16 as os::libc::FILE); + log_full(core::debug, 1u16 as i8); + log_full(core::debug, 1u16 as i16); + log_full(core::debug, 1u16 as i32); + log_full(core::debug, 1u16 as i64); + log_full(core::debug, 1u16 as u8); + log_full(core::debug, 1u16 as u16); + log_full(core::debug, 1u16 as u32); + log_full(core::debug, 1u16 as u64); + log_full(core::debug, 1u16 as f32); + log_full(core::debug, 1u16 as f64); - log 1i32 as int; - log 1i32 as uint; - log 1i32 as float; - log 1i32 as bool; - log 1i32 as os::libc::FILE; - log 1i32 as i8; - log 1i32 as i16; - log 1i32 as i32; - log 1i32 as i64; - log 1i32 as u8; - log 1i32 as u16; - log 1i32 as u32; - log 1i32 as u64; - log 1i32 as f32; - log 1i32 as f64; + log_full(core::debug, 1i32 as int); + log_full(core::debug, 1i32 as uint); + log_full(core::debug, 1i32 as float); + log_full(core::debug, 1i32 as bool); + log_full(core::debug, 1i32 as os::libc::FILE); + log_full(core::debug, 1i32 as i8); + log_full(core::debug, 1i32 as i16); + log_full(core::debug, 1i32 as i32); + log_full(core::debug, 1i32 as i64); + log_full(core::debug, 1i32 as u8); + log_full(core::debug, 1i32 as u16); + log_full(core::debug, 1i32 as u32); + log_full(core::debug, 1i32 as u64); + log_full(core::debug, 1i32 as f32); + log_full(core::debug, 1i32 as f64); - log 1u32 as int; - log 1u32 as uint; - log 1u32 as float; - log 1u32 as bool; - log 1u32 as os::libc::FILE; - log 1u32 as i8; - log 1u32 as i16; - log 1u32 as i32; - log 1u32 as i64; - log 1u32 as u8; - log 1u32 as u16; - log 1u32 as u32; - log 1u32 as u64; - log 1u32 as f32; - log 1u32 as f64; + log_full(core::debug, 1u32 as int); + log_full(core::debug, 1u32 as uint); + log_full(core::debug, 1u32 as float); + log_full(core::debug, 1u32 as bool); + log_full(core::debug, 1u32 as os::libc::FILE); + log_full(core::debug, 1u32 as i8); + log_full(core::debug, 1u32 as i16); + log_full(core::debug, 1u32 as i32); + log_full(core::debug, 1u32 as i64); + log_full(core::debug, 1u32 as u8); + log_full(core::debug, 1u32 as u16); + log_full(core::debug, 1u32 as u32); + log_full(core::debug, 1u32 as u64); + log_full(core::debug, 1u32 as f32); + log_full(core::debug, 1u32 as f64); - log 1i64 as int; - log 1i64 as uint; - log 1i64 as float; - log 1i64 as bool; - log 1i64 as os::libc::FILE; - log 1i64 as i8; - log 1i64 as i16; - log 1i64 as i32; - log 1i64 as i64; - log 1i64 as u8; - log 1i64 as u16; - log 1i64 as u32; - log 1i64 as u64; - log 1i64 as f32; - log 1i64 as f64; + log_full(core::debug, 1i64 as int); + log_full(core::debug, 1i64 as uint); + log_full(core::debug, 1i64 as float); + log_full(core::debug, 1i64 as bool); + log_full(core::debug, 1i64 as os::libc::FILE); + log_full(core::debug, 1i64 as i8); + log_full(core::debug, 1i64 as i16); + log_full(core::debug, 1i64 as i32); + log_full(core::debug, 1i64 as i64); + log_full(core::debug, 1i64 as u8); + log_full(core::debug, 1i64 as u16); + log_full(core::debug, 1i64 as u32); + log_full(core::debug, 1i64 as u64); + log_full(core::debug, 1i64 as f32); + log_full(core::debug, 1i64 as f64); - log 1u64 as int; - log 1u64 as uint; - log 1u64 as float; - log 1u64 as bool; - log 1u64 as os::libc::FILE; - log 1u64 as i8; - log 1u64 as i16; - log 1u64 as i32; - log 1u64 as i64; - log 1u64 as u8; - log 1u64 as u16; - log 1u64 as u32; - log 1u64 as u64; - log 1u64 as f32; - log 1u64 as f64; + log_full(core::debug, 1u64 as int); + log_full(core::debug, 1u64 as uint); + log_full(core::debug, 1u64 as float); + log_full(core::debug, 1u64 as bool); + log_full(core::debug, 1u64 as os::libc::FILE); + log_full(core::debug, 1u64 as i8); + log_full(core::debug, 1u64 as i16); + log_full(core::debug, 1u64 as i32); + log_full(core::debug, 1u64 as i64); + log_full(core::debug, 1u64 as u8); + log_full(core::debug, 1u64 as u16); + log_full(core::debug, 1u64 as u32); + log_full(core::debug, 1u64 as u64); + log_full(core::debug, 1u64 as f32); + log_full(core::debug, 1u64 as f64); - log 1u64 as int; - log 1u64 as uint; - log 1u64 as float; - log 1u64 as bool; - log 1u64 as os::libc::FILE; - log 1u64 as i8; - log 1u64 as i16; - log 1u64 as i32; - log 1u64 as i64; - log 1u64 as u8; - log 1u64 as u16; - log 1u64 as u32; - log 1u64 as u64; - log 1u64 as f32; - log 1u64 as f64; + log_full(core::debug, 1u64 as int); + log_full(core::debug, 1u64 as uint); + log_full(core::debug, 1u64 as float); + log_full(core::debug, 1u64 as bool); + log_full(core::debug, 1u64 as os::libc::FILE); + log_full(core::debug, 1u64 as i8); + log_full(core::debug, 1u64 as i16); + log_full(core::debug, 1u64 as i32); + log_full(core::debug, 1u64 as i64); + log_full(core::debug, 1u64 as u8); + log_full(core::debug, 1u64 as u16); + log_full(core::debug, 1u64 as u32); + log_full(core::debug, 1u64 as u64); + log_full(core::debug, 1u64 as f32); + log_full(core::debug, 1u64 as f64); - log true as int; - log true as uint; - log true as float; - log true as bool; - log true as os::libc::FILE; - log true as i8; - log true as i16; - log true as i32; - log true as i64; - log true as u8; - log true as u16; - log true as u32; - log true as u64; - log true as f32; - log true as f64; + log_full(core::debug, true as int); + log_full(core::debug, true as uint); + log_full(core::debug, true as float); + log_full(core::debug, true as bool); + log_full(core::debug, true as os::libc::FILE); + log_full(core::debug, true as i8); + log_full(core::debug, true as i16); + log_full(core::debug, true as i32); + log_full(core::debug, true as i64); + log_full(core::debug, true as u8); + log_full(core::debug, true as u16); + log_full(core::debug, true as u32); + log_full(core::debug, true as u64); + log_full(core::debug, true as f32); + log_full(core::debug, true as f64); - log 1. as int; - log 1. as uint; - log 1. as float; - log 1. as bool; - log 1. as i8; - log 1. as i16; - log 1. as i32; - log 1. as i64; - log 1. as u8; - log 1. as u16; - log 1. as u32; - log 1. as u64; - log 1. as f32; - log 1. as f64; + log_full(core::debug, 1. as int); + log_full(core::debug, 1. as uint); + log_full(core::debug, 1. as float); + log_full(core::debug, 1. as bool); + log_full(core::debug, 1. as i8); + log_full(core::debug, 1. as i16); + log_full(core::debug, 1. as i32); + log_full(core::debug, 1. as i64); + log_full(core::debug, 1. as u8); + log_full(core::debug, 1. as u16); + log_full(core::debug, 1. as u32); + log_full(core::debug, 1. as u64); + log_full(core::debug, 1. as f32); + log_full(core::debug, 1. as f64); - log 1f32 as int; - log 1f32 as uint; - log 1f32 as float; - log 1f32 as bool; - log 1f32 as i8; - log 1f32 as i16; - log 1f32 as i32; - log 1f32 as i64; - log 1f32 as u8; - log 1f32 as u16; - log 1f32 as u32; - log 1f32 as u64; - log 1f32 as f32; - log 1f32 as f64; + log_full(core::debug, 1f32 as int); + log_full(core::debug, 1f32 as uint); + log_full(core::debug, 1f32 as float); + log_full(core::debug, 1f32 as bool); + log_full(core::debug, 1f32 as i8); + log_full(core::debug, 1f32 as i16); + log_full(core::debug, 1f32 as i32); + log_full(core::debug, 1f32 as i64); + log_full(core::debug, 1f32 as u8); + log_full(core::debug, 1f32 as u16); + log_full(core::debug, 1f32 as u32); + log_full(core::debug, 1f32 as u64); + log_full(core::debug, 1f32 as f32); + log_full(core::debug, 1f32 as f64); - log 1f64 as int; - log 1f64 as uint; - log 1f64 as float; - log 1f64 as bool; - log 1f64 as i8; - log 1f64 as i16; - log 1f64 as i32; - log 1f64 as i64; - log 1f64 as u8; - log 1f64 as u16; - log 1f64 as u32; - log 1f64 as u64; - log 1f64 as f32; - log 1f64 as f64; + log_full(core::debug, 1f64 as int); + log_full(core::debug, 1f64 as uint); + log_full(core::debug, 1f64 as float); + log_full(core::debug, 1f64 as bool); + log_full(core::debug, 1f64 as i8); + log_full(core::debug, 1f64 as i16); + log_full(core::debug, 1f64 as i32); + log_full(core::debug, 1f64 as i64); + log_full(core::debug, 1f64 as u8); + log_full(core::debug, 1f64 as u16); + log_full(core::debug, 1f64 as u32); + log_full(core::debug, 1f64 as u64); + log_full(core::debug, 1f64 as f32); + log_full(core::debug, 1f64 as f64); } diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index 66192aac5aa..fdcdfac1ee9 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -2,8 +2,8 @@ use std; import str; fn test(actual: str, expected: str) { - log actual; - log expected; + log_full(core::debug, actual); + log_full(core::debug, expected); assert (str::eq(actual, expected)); } diff --git a/src/test/run-pass/syntax-extension-shell.rs b/src/test/run-pass/syntax-extension-shell.rs index a7189359121..3153f60d2f3 100644 --- a/src/test/run-pass/syntax-extension-shell.rs +++ b/src/test/run-pass/syntax-extension-shell.rs @@ -1,5 +1,5 @@ // xfail-test fn main() { auto s = #shell { uname -a }; - log s; + log_full(core::debug, s); } diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs index a8a4436a2be..901cc990864 100644 --- a/src/test/run-pass/tail-cps.rs +++ b/src/test/run-pass/tail-cps.rs @@ -7,13 +7,13 @@ fn checktrue(rs: bool) -> bool { assert (rs); ret true; } fn main() { let k = checktrue; evenk(42, k); oddk(45, k); } fn evenk(n: int, k: fn(bool) -> bool) -> bool { - log "evenk"; - log n; + #debug("evenk"); + log_full(core::debug, n); if n == 0 { be k(true); } else { be oddk(n - 1, k); } } fn oddk(n: int, k: fn(bool) -> bool) -> bool { - log "oddk"; - log n; + #debug("oddk"); + log_full(core::debug, n); if n == 0 { be k(false); } else { be evenk(n - 1, k); } } diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index abd4819b3bd..b512da1b204 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -8,13 +8,13 @@ import task; fn main() { test05(); } fn test05_start(ch : chan) { - log_err ch; + log_full(core::error, ch); send(ch, 10); - log_err "sent 10"; + #error("sent 10"); send(ch, 20); - log_err "sent 20"; + #error("sent 20"); send(ch, 30); - log_err "sent 30"; + #error("sent 30"); } fn test05() { @@ -22,10 +22,10 @@ fn test05() { let ch = comm::chan(po); task::spawn(ch, test05_start); let value = comm::recv(po); - log_err value; + log_full(core::error, value); value = comm::recv(po); - log_err value; + log_full(core::error, value); value = comm::recv(po); - log_err value; + log_full(core::error, value); assert (value == 30); } diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs index 970e885e673..478eb3292ea 100644 --- a/src/test/run-pass/task-comm-1.rs +++ b/src/test/run-pass/task-comm-1.rs @@ -5,10 +5,10 @@ import task::join; fn main() { test00(); } -fn start(&&_i: ()) { log "Started / Finished task."; } +fn start(&&_i: ()) { #debug("Started / Finished task."); } fn test00() { let t = spawn_joinable((), start); join(t); - log "Completing."; + #debug("Completing."); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index 61017a994fc..ee4a8338599 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -10,10 +10,10 @@ fn start(c: comm::chan>) { let b; a = comm::recv(p); assert a == "A"; - log_err a; + log_full(core::error, a); b = comm::recv(p); assert b == "B"; - log_err b; + log_full(core::error, b); } fn main() { diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs index bd4c8a64418..2f6adfea5dc 100644 --- a/src/test/run-pass/task-comm-12.rs +++ b/src/test/run-pass/task-comm-12.rs @@ -3,7 +3,7 @@ import task; fn main() { test00(); } -fn start(&&task_number: int) { log "Started / Finished task."; } +fn start(&&task_number: int) { #debug("Started / Finished task."); } fn test00() { let i: int = 0; @@ -15,5 +15,5 @@ fn test00() { // Try joining tasks that have already finished. task::join(t); - log "Joined task."; + #debug("Joined task."); } diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index a9d63c70237..c2a15229f88 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -10,9 +10,9 @@ fn start(&&args: (comm::chan, int, int)) { } fn main() { - log "Check that we don't deadlock."; + #debug("Check that we don't deadlock."); let p = comm::port::(); let a = task::spawn_joinable((comm::chan(p), 0, 10), start); task::join(a); - log "Joined task"; + #debug("Joined task"); } diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index 6bf0fe89abd..0381fabb2d3 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -8,7 +8,7 @@ fn main() { // Spawn 10 tasks each sending us back one int. let i = 10; while (i > 0) { - log i; + log_full(core::debug, i); task::spawn((i, comm::chan(po)), child); i = i - 1; } @@ -19,16 +19,16 @@ fn main() { i = 10; let value = 0; while (i > 0) { - log i; + log_full(core::debug, i); value = comm::recv(po); i = i - 1; } - log "main thread exiting"; + #debug("main thread exiting"); } fn child(&&args: (int, comm::chan)) { let (x, ch) = args; - log x; + log_full(core::debug, x); comm::send(ch, x); } diff --git a/src/test/run-pass/task-comm-2.rs b/src/test/run-pass/task-comm-2.rs index 84033d3c101..6ad262bc3ab 100644 --- a/src/test/run-pass/task-comm-2.rs +++ b/src/test/run-pass/task-comm-2.rs @@ -3,13 +3,16 @@ use std; import task; -fn main() { log "===== SPAWNING and JOINING THREAD TASKS ====="; test00(); } +fn main() { + #debug("===== SPAWNING and JOINING THREAD TASKS ====="); + test00(); +} fn start(&&task_number: int) { - log "Started task."; + #debug("Started task."); let i: int = 0; while i < 10000 { i = i + 1; } - log "Finished task."; + #debug("Finished task."); } fn test00() { @@ -24,5 +27,5 @@ fn test00() { for t in tasks { task::join(t); } - log "Joined all task."; + #debug("Joined all task."); } diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index 7a193819756..78b50e614fd 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -5,25 +5,25 @@ import comm::chan; import comm::send; import comm::recv; -fn main() { log "===== WITHOUT THREADS ====="; test00(); } +fn main() { #debug("===== WITHOUT THREADS ====="); test00(); } fn test00_start(&&args: (chan, int, int)) { let (ch, message, count) = args; - log "Starting test00_start"; + #debug("Starting test00_start"); let i: int = 0; while i < count { - log "Sending Message"; + #debug("Sending Message"); send(ch, message + 0); i = i + 1; } - log "Ending test00_start"; + #debug("Ending test00_start"); } fn test00() { let number_of_tasks: int = 16; let number_of_messages: int = 4; - log "Creating tasks"; + #debug("Creating tasks"); let po = comm::port(); let ch = chan(po); @@ -52,8 +52,8 @@ fn test00() { // Join spawned tasks... for t in tasks { task::join(t); } - log "Completed: Final number is: "; - log_err sum; + #debug("Completed: Final number is: "); + log_full(core::error, sum); // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * // number_of_messages)); assert (sum == 480); diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index bc30f2e4e7d..3409c8d4c54 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -15,31 +15,31 @@ fn test00() { send(c, 4); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); send(c, 5); send(c, 6); send(c, 7); send(c, 8); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); r = comm::recv(p); sum += r; - log r; + log_full(core::debug, r); assert (sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8); } diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index b020118ed8a..77d86081c06 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -20,7 +20,11 @@ fn test00() { test00_start); let i: int = 0; - while i < number_of_messages { sum += comm::recv(p); log r; i += 1; } + while i < number_of_messages { + sum += comm::recv(p); + log_full(core::debug, r); + i += 1; + } task::join(t0); diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs index aa2806bdfbc..7fbfe5e2916 100644 --- a/src/test/run-pass/task-comm.rs +++ b/src/test/run-pass/task-comm.rs @@ -20,20 +20,20 @@ fn main() { fn test00_start(&&args: (chan, int, int)) { let (ch, message, count) = args; - log "Starting test00_start"; + #debug("Starting test00_start"); let i: int = 0; while i < count { - log "Sending Message"; + #debug("Sending Message"); send(ch, message + 0); i = i + 1; } - log "Ending test00_start"; + #debug("Ending test00_start"); } fn test00() { let number_of_tasks: int = 1; let number_of_messages: int = 4; - log "Creating tasks"; + #debug("Creating tasks"); let po = port(); let ch = chan(po); @@ -54,7 +54,7 @@ fn test00() { for t in tasks { task::join(t); } - log "Completed: Final number is: "; + #debug("Completed: Final number is: "); assert (sum == number_of_messages * (number_of_tasks * number_of_tasks + number_of_tasks) / @@ -63,19 +63,19 @@ fn test00() { fn test01() { let p = port(); - log "Reading from a port that is never written to."; + #debug("Reading from a port that is never written to."); let value: int = recv(p); - log value; + log_full(core::debug, value); } fn test02() { let p = port(); let c = chan(p); - log "Writing to a local task channel."; + #debug("Writing to a local task channel."); send(c, 42); - log "Reading from a local task port."; + #debug("Reading from a local task port."); let value: int = recv(p); - log value; + log_full(core::debug, value); } obj vector(mutable x: int, y: int) { @@ -83,25 +83,25 @@ obj vector(mutable x: int, y: int) { } fn test03() { - log "Creating object ..."; + #debug("Creating object ..."); let v: vector = vector(1, 2); - log "created object ..."; + #debug("created object ..."); let t: vector = v; - log v.length(); + log_full(core::debug, v.length()); } fn test04_start(&&_args: ()) { - log "Started task"; + #debug("Started task"); let i: int = 1024 * 1024; while i > 0 { i = i - 1; } - log "Finished task"; + #debug("Finished task"); } fn test04() { - log "Spawning lots of tasks."; + #debug("Spawning lots of tasks."); let i: int = 4; while i > 0 { i = i - 1; task::spawn((), test04_start); } - log "Finishing up."; + #debug("Finishing up."); } fn test05_start(ch: chan) { @@ -120,19 +120,19 @@ fn test05() { value = recv(po); value = recv(po); value = recv(po); - log value; + log_full(core::debug, value); } fn test06_start(&&task_number: int) { - log "Started task."; + #debug("Started task."); let i: int = 0; while i < 1000000 { i = i + 1; } - log "Finished task."; + #debug("Finished task."); } fn test06() { let number_of_tasks: int = 4; - log "Creating tasks"; + #debug("Creating tasks"); let i: int = 0; diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index d5bbb90b044..417e537a905 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -6,8 +6,8 @@ import task; fn main() { let i = 10; while i > 0 { task::spawn(copy i, child); i = i - 1; } - log "main thread exiting"; + #debug("main thread exiting"); } -fn child(&&x: int) { log x; } +fn child(&&x: int) { log_full(core::debug, x); } diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs index 0961cb7df3b..cea3d49772e 100644 --- a/src/test/run-pass/trivial-message.rs +++ b/src/test/run-pass/trivial-message.rs @@ -10,5 +10,5 @@ fn main() { let ch = chan(po); send(ch, 42); let r = recv(po); - log_err r; + log_full(core::error, r); } diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs index afcc2f53406..a25155db3d7 100644 --- a/src/test/run-pass/unique-copy-box.rs +++ b/src/test/run-pass/unique-copy-box.rs @@ -7,6 +7,6 @@ fn main() unsafe { let rc1 = refcount(*i); let j = i; let rc2 = refcount(*i); - log_err #fmt("rc1: %u rc2: %u", rc1, rc2); + #error("rc1: %u rc2: %u", rc1, rc2); assert rc1 + 1u == rc2; } \ No newline at end of file diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs index 0b364ae13b5..21159a32e73 100644 --- a/src/test/run-pass/unique-in-tag.rs +++ b/src/test/run-pass/unique-in-tag.rs @@ -4,7 +4,7 @@ fn test1() { let x = u(~10); assert alt x { u(a) { - log_err a; + log_full(core::error, a); *a } _ { 66 } diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs index 91ce7e504d9..4b545eb9c79 100644 --- a/src/test/run-pass/unique-log.rs +++ b/src/test/run-pass/unique-log.rs @@ -1,4 +1,4 @@ fn main() { let i = ~100; - log_err i; + log_full(core::error, i); } \ No newline at end of file diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs index cd422fe9151..d6908607130 100644 --- a/src/test/run-pass/unique-pat-3.rs +++ b/src/test/run-pass/unique-pat-3.rs @@ -4,7 +4,7 @@ tag bar { u(~int); w(int); } fn main() { assert alt u(~10) { u(a) { - log_err a; + log_full(core::error, a); *a } _ { 66 } diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs index 4b93d54b133..52181a0cf5a 100644 --- a/src/test/run-pass/unreachable-code.rs +++ b/src/test/run-pass/unreachable-code.rs @@ -19,13 +19,13 @@ fn bind_id_2() { bind id(ret); } fn fail_fail() { fail fail; } -fn log_fail() { log_err fail; } +fn log_fail() { log_full(core::error, fail); } -fn log_ret() { log_err ret; } +fn log_ret() { log_full(core::error, ret); } -fn log_break() { while true { log_err break; } } +fn log_break() { while true { log_full(core::error, break); } } -fn log_cont() { do { log_err cont; } while false } +fn log_cont() { do { log_full(core::error, cont); } while false } fn ret_ret() -> int { ret (ret 2) + 3; } diff --git a/src/test/run-pass/use-uninit-alt.rs b/src/test/run-pass/use-uninit-alt.rs index e1656c8dda9..d30f7d65afb 100644 --- a/src/test/run-pass/use-uninit-alt.rs +++ b/src/test/run-pass/use-uninit-alt.rs @@ -8,4 +8,4 @@ fn foo(o: myoption) -> int { tag myoption { none; some(T); } -fn main() { log 5; } +fn main() { log_full(core::debug, 5); } diff --git a/src/test/run-pass/use-uninit-alt2.rs b/src/test/run-pass/use-uninit-alt2.rs index f702694d75a..4481d65e9f4 100644 --- a/src/test/run-pass/use-uninit-alt2.rs +++ b/src/test/run-pass/use-uninit-alt2.rs @@ -8,4 +8,4 @@ fn foo(o: myoption) -> int { tag myoption { none; some(T); } -fn main() { log 5; } +fn main() { log_full(core::debug, 5); } diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs index 6587b701518..ddca218ada2 100644 --- a/src/test/run-pass/user.rs +++ b/src/test/run-pass/user.rs @@ -8,8 +8,8 @@ use std (name = "std", fn main() { auto s = str.alloc(10 as uint); s += "hello "; - log s; + log_full(core::debug, s); s += "there"; - log s; + log_full(core::debug, s); auto z = vec.alloc::(10 as uint); } diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index c27d7a23c0a..778fa22c446 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -32,10 +32,10 @@ fn main() { fn check_str_eq(a: str, b: str) { let i: int = 0; for ab: u8 in a { - log i; - log ab; + log_full(core::debug, i); + log_full(core::debug, ab); let bb: u8 = b[i]; - log bb; + log_full(core::debug, bb); assert (ab == bb); i += 1; } diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs index e107d861a2a..7604f74f7b2 100644 --- a/src/test/run-pass/vec-concat.rs +++ b/src/test/run-pass/vec-concat.rs @@ -6,7 +6,7 @@ fn main() { let a: [int] = [1, 2, 3, 4, 5]; let b: [int] = [6, 7, 8, 9, 0]; let v: [int] = a + b; - log v[9]; + log_full(core::debug, v[9]); assert (v[0] == 1); assert (v[7] == 8); assert (v[9] == 0); diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs index 6a84317747c..c41293dadb6 100644 --- a/src/test/run-pass/vec-late-init.rs +++ b/src/test/run-pass/vec-late-init.rs @@ -3,5 +3,5 @@ fn main() { let later: [int]; if true { later = [1]; } else { later = [2]; } - log later[0]; + log_full(core::debug, later[0]); } diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs index 5065fad43d6..ad88a315ab2 100644 --- a/src/test/run-pass/vec-self-append.rs +++ b/src/test/run-pass/vec-self-append.rs @@ -38,7 +38,7 @@ fn test_loop() { let i = 20; let expected_len = 1u; while i > 0 { - log_err vec::len(a); + log_full(core::error, vec::len(a)); assert (vec::len(a) == expected_len); a += a; i -= 1; diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index 797ed1b0f39..3870ebdc63e 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -36,14 +36,14 @@ fn notsure() { } fn hammertime() -> int { - let _x = log true == (ret 0); + let _x = log_full(core::debug, true == (ret 0)); } fn canttouchthis() -> uint { pure fn p() -> bool { true } let _a = (assert (true)) == (check (p())); let _c = (check (p())) == (); - let _b = (log 0) == (ret 0u); + let _b = (log_full(core::debug, 0) == (ret 0u)); } fn angrydome() { @@ -52,7 +52,7 @@ fn angrydome() { do { i += 1; if i == 1 { alt cont { _ { } } } } while false } -fn evil_lincoln() { let evil <- log "lincoln"; } +fn evil_lincoln() { let evil <- #debug("lincoln"); } fn main() { strange(); diff --git a/src/test/run-pass/while-and-do-while.rs b/src/test/run-pass/while-and-do-while.rs index c5b09cb8149..da7101349a3 100644 --- a/src/test/run-pass/while-and-do-while.rs +++ b/src/test/run-pass/while-and-do-while.rs @@ -3,6 +3,10 @@ fn main() { let x: int = 10; let y: int = 0; - while y < x { log y; log "hello"; y = y + 1; } - do { log "goodbye"; x = x - 1; log x; } while x > 0 + while y < x { log_full(core::debug, y); #debug("hello"); y = y + 1; } + do { + #debug("goodbye"); + x = x - 1; + log_full(core::debug, x); + } while x > 0 } diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs index 6a2e9acfda3..06d7a1492f0 100644 --- a/src/test/run-pass/while-cont.rs +++ b/src/test/run-pass/while-cont.rs @@ -1,2 +1,10 @@ // Issue #825: Should recheck the loop contition after continuing -fn main() { let i = 1; while i > 0 { assert (i > 0); log i; i -= 1; cont; } } +fn main() { + let i = 1; + while i > 0 { + assert (i > 0); + log_full(core::debug, i); + i -= 1; + cont; + } +} diff --git a/src/test/run-pass/while-loop-constraints-2.rs b/src/test/run-pass/while-loop-constraints-2.rs index 29ab411b31b..65759d537a9 100644 --- a/src/test/run-pass/while-loop-constraints-2.rs +++ b/src/test/run-pass/while-loop-constraints-2.rs @@ -3,6 +3,10 @@ fn main() { let y: int = 42; let z: int = 42; let x: int; - while z < 50 { z += 1; while false { x <- y; y = z; } log y; } + while z < 50 { + z += 1; + while false { x <- y; y = z; } + log_full(core::debug, y); + } assert (y == 42 && z == 50); } diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs index f8050e3d3eb..6f73e9780f9 100644 --- a/src/test/run-pass/while-with-break.rs +++ b/src/test/run-pass/while-with-break.rs @@ -5,13 +5,13 @@ fn main() { let i: int = 90; while i < 100 { - log i; + log_full(core::debug, i); i = i + 1; if i == 95 { let v: [int] = [1, 2, 3, 4, 5]; // we check that it is freed by break - log "breaking"; + #debug("breaking"); break; } } diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs index d32042eaed1..fc4faf46008 100644 --- a/src/test/run-pass/x86stdcall.rs +++ b/src/test/run-pass/x86stdcall.rs @@ -13,7 +13,7 @@ fn main() { let expected = 1234u; kernel32::SetLastError(expected); let actual = kernel32::GetLastError(); - log_err actual; + log_full(core::error, actual); assert (expected == actual); } diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs index bddd8331347..43cfecf2045 100644 --- a/src/test/run-pass/yield.rs +++ b/src/test/run-pass/yield.rs @@ -5,14 +5,14 @@ import task::*; fn main() { let other = task::spawn_joinable((), child); - log_err "1"; + #error("1"); yield(); - log_err "2"; + #error("2"); yield(); - log_err "3"; + #error("3"); join(other); } fn child(&&_i: ()) { - log_err "4"; yield(); log_err "5"; yield(); log_err "6"; + #error("4"); yield(); #error("5"); yield(); #error("6"); } diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs index 0b207629159..3b4795a47a1 100644 --- a/src/test/run-pass/yield1.rs +++ b/src/test/run-pass/yield1.rs @@ -5,9 +5,9 @@ import task::*; fn main() { let other = task::spawn_joinable((), child); - log_err "1"; + #error("1"); yield(); join(other); } -fn child(&&_i: ()) { log_err "2"; } +fn child(&&_i: ()) { #error("2"); } diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs index 9b637c53cb5..ea7c3916662 100644 --- a/src/test/run-pass/yield2.rs +++ b/src/test/run-pass/yield2.rs @@ -3,5 +3,5 @@ use std; fn main() { let i: int = 0; - while i < 100 { i = i + 1; log_err i; task::yield(); } + while i < 100 { i = i + 1; log_full(core::error, i); task::yield(); } } diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs index 70b2c99f571..f48260f4cce 100644 --- a/src/test/stdtest/deque.rs +++ b/src/test/stdtest/deque.rs @@ -14,21 +14,21 @@ fn test_simple() { assert (d.size() == 3u); d.add_back(137); assert (d.size() == 4u); - log d.peek_front(); + log_full(core::debug, d.peek_front()); assert (d.peek_front() == 42); - log d.peek_back(); + log_full(core::debug, d.peek_back()); assert (d.peek_back() == 137); let i: int = d.pop_front(); - log i; + log_full(core::debug, i); assert (i == 42); i = d.pop_back(); - log i; + log_full(core::debug, i); assert (i == 137); i = d.pop_back(); - log i; + log_full(core::debug, i); assert (i == 137); i = d.pop_back(); - log i; + log_full(core::debug, i); assert (i == 17); assert (d.size() == 0u); d.add_back(3); @@ -39,10 +39,10 @@ fn test_simple() { assert (d.size() == 3u); d.add_front(1); assert (d.size() == 4u); - log d.get(0); - log d.get(1); - log d.get(2); - log d.get(3); + log_full(core::debug, d.get(0)); + log_full(core::debug, d.get(1)); + log_full(core::debug, d.get(2)); + log_full(core::debug, d.get(3)); assert (d.get(0) == 1); assert (d.get(1) == 2); assert (d.get(2) == 3); @@ -162,36 +162,36 @@ fn test() { fn reccyeq(a: reccy, b: reccy) -> bool { ret a.x == b.x && a.y == b.y && taggyeq(a.t, b.t); } - log "*** test boxes"; + #debug("*** test boxes"); test_boxes(@5, @72, @64, @175); - log "*** end test boxes"; - log "test parameterized: int"; + #debug("*** end test boxes"); + #debug("test parameterized: int"); let eq1: eqfn = inteq; test_parameterized::(eq1, 5, 72, 64, 175); - log "*** test parameterized: @int"; + #debug("*** test parameterized: @int"); let eq2: eqfn<@int> = intboxeq; test_parameterized::<@int>(eq2, @5, @72, @64, @175); - log "*** end test parameterized @int"; - log "test parameterized: taggy"; + #debug("*** end test parameterized @int"); + #debug("test parameterized: taggy"); let eq3: eqfn = taggyeq; test_parameterized::(eq3, one(1), two(1, 2), three(1, 2, 3), two(17, 42)); - log "*** test parameterized: taggypar"; + #debug("*** test parameterized: taggypar"); let eq4: eqfn> = bind taggypareq::(_, _); test_parameterized::>(eq4, onepar::(1), twopar::(1, 2), threepar::(1, 2, 3), twopar::(17, 42)); - log "*** end test parameterized: taggypar::"; + #debug("*** end test parameterized: taggypar::"); - log "*** test parameterized: reccy"; + #debug("*** test parameterized: reccy"); let reccy1: reccy = {x: 1, y: 2, t: one(1)}; let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)}; let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)}; let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)}; let eq5: eqfn = reccyeq; test_parameterized::(eq5, reccy1, reccy2, reccy3, reccy4); - log "*** end test parameterized: reccy"; - log "*** done"; + #debug("*** end test parameterized: reccy"); + #debug("*** done"); } diff --git a/src/test/stdtest/four.rs b/src/test/stdtest/four.rs index 25f1abc4cea..f28edd03e36 100644 --- a/src/test/stdtest/four.rs +++ b/src/test/stdtest/four.rs @@ -139,7 +139,7 @@ fn test_four_to_tri() { assert tri::eq( four::to_trit(four::true), tri::true ); assert tri::eq( four::to_trit(four::false), tri::false ); assert tri::eq( four::to_trit(four::none), tri::unknown ); - log four::to_trit(four::both); + log_full(core::debug, four::to_trit(four::both)); assert tri::eq( four::to_trit(four::both), tri::unknown ); } diff --git a/src/test/stdtest/fs.rs b/src/test/stdtest/fs.rs index a9b1f5ea259..fca25f70fa5 100644 --- a/src/test/stdtest/fs.rs +++ b/src/test/stdtest/fs.rs @@ -7,7 +7,7 @@ import vec; #[test] fn test_connect() { let slash = fs::path_sep(); - log_err fs::connect("a", "b"); + log_full(core::error, fs::connect("a", "b")); assert (fs::connect("a", "b") == "a" + slash + "b"); assert (fs::connect("a" + slash, "b") == "a" + slash + "b"); } @@ -22,7 +22,7 @@ fn list_dir() { // Just assuming that we've got some contents in the current directory assert (vec::len(dirs) > 0u); - for dir in dirs { log dir; } + for dir in dirs { log_full(core::debug, dir); } } #[test] @@ -140,7 +140,7 @@ fn normalize9() { fn normalize10() { let actual = fs::normalize("/a/b/c/../d/./../../e/"); let expected = "/a/e/"; - log_err actual; + log_full(core::error, actual); assert actual == expected; } @@ -156,7 +156,7 @@ fn normalize11() { fn normalize12() { let actual = fs::normalize("C:/whatever"); let expected = "C:/whatever"; - log_err actual; + log_full(core::error, actual); assert actual == expected; } diff --git a/src/test/stdtest/getopts.rs b/src/test/stdtest/getopts.rs index eafc5ba0b5d..5d397f6e702 100644 --- a/src/test/stdtest/getopts.rs +++ b/src/test/stdtest/getopts.rs @@ -246,7 +246,7 @@ fn test_optflag_long_arg() { let rs = opt::getopts(args, opts); alt rs { err(f) { - log_err opt::fail_str(f); + log_full(core::error, opt::fail_str(f)); check_fail_type(f, unexpected_argument); } _ { fail; } diff --git a/src/test/stdtest/io.rs b/src/test/stdtest/io.rs index 1c9774b7fe6..742ec39d828 100644 --- a/src/test/stdtest/io.rs +++ b/src/test/stdtest/io.rs @@ -9,9 +9,9 @@ import result; #[test] fn test_simple() { let tmpfile: str = "tmp/lib-io-test-simple.tmp"; - log tmpfile; + log_full(core::debug, tmpfile); let frood: str = "A hoopy frood who really knows where his towel is."; - log frood; + log_full(core::debug, frood); { let out: io::writer = result::get(io::file_writer(tmpfile, [io::create, io::truncate])); @@ -19,7 +19,7 @@ fn test_simple() { } let inp: io::reader = result::get(io::file_reader(tmpfile)); let frood2: str = inp.read_c_str(); - log frood2; + log_full(core::debug, frood2); assert (str::eq(frood, frood2)); } diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs index b7e62a6b0d2..787baa4a023 100644 --- a/src/test/stdtest/map.rs +++ b/src/test/stdtest/map.rs @@ -10,14 +10,14 @@ import option; #[test] fn test_simple() { - log "*** starting test_simple"; + #debug("*** starting test_simple"); fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; } fn uint_id(&&x: uint) -> uint { x } let hasher_uint: map::hashfn = uint_id; let eqer_uint: map::eqfn = eq_uint; let hasher_str: map::hashfn = str::hash; let eqer_str: map::eqfn = str::eq; - log "uint -> uint"; + #debug("uint -> uint"); let hm_uu: map::hashmap = map::mk_hashmap::(hasher_uint, eqer_uint); assert (hm_uu.insert(10u, 12u)); @@ -33,7 +33,7 @@ fn test_simple() { let ten: str = "ten"; let eleven: str = "eleven"; let twelve: str = "twelve"; - log "str -> uint"; + #debug("str -> uint"); let hm_su: map::hashmap = map::mk_hashmap::(hasher_str, eqer_str); assert (hm_su.insert("ten", 12u)); @@ -47,7 +47,7 @@ fn test_simple() { assert (hm_su.get("twelve") == 14u); assert (!hm_su.insert("twelve", 12u)); assert (hm_su.get("twelve") == 12u); - log "uint -> str"; + #debug("uint -> str"); let hm_us: map::hashmap = map::mk_hashmap::(hasher_uint, eqer_uint); assert (hm_us.insert(10u, "twelve")); @@ -60,7 +60,7 @@ fn test_simple() { assert (str::eq(hm_us.get(12u), "fourteen")); assert (!hm_us.insert(12u, "twelve")); assert (str::eq(hm_us.get(12u), "twelve")); - log "str -> str"; + #debug("str -> str"); let hm_ss: map::hashmap = map::mk_hashmap::(hasher_str, eqer_str); assert (hm_ss.insert(ten, "twelve")); @@ -73,7 +73,7 @@ fn test_simple() { assert (str::eq(hm_ss.get("twelve"), "fourteen")); assert (!hm_ss.insert("twelve", "twelve")); assert (str::eq(hm_ss.get("twelve"), "twelve")); - log "*** finished test_simple"; + #debug("*** finished test_simple"); } @@ -82,11 +82,11 @@ fn test_simple() { */ #[test] fn test_growth() { - log "*** starting test_growth"; + #debug("*** starting test_growth"); let num_to_insert: uint = 64u; fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; } fn uint_id(&&x: uint) -> uint { x } - log "uint -> uint"; + #debug("uint -> uint"); let hasher_uint: map::hashfn = uint_id; let eqer_uint: map::eqfn = eq_uint; let hm_uu: map::hashmap = @@ -98,7 +98,7 @@ fn test_growth() { uint::to_str(i * i, 10u); i += 1u; } - log "-----"; + #debug("-----"); i = 0u; while i < num_to_insert { log "get(" + uint::to_str(i, 10u) + ") = " + @@ -108,7 +108,7 @@ fn test_growth() { } assert (hm_uu.insert(num_to_insert, 17u)); assert (hm_uu.get(num_to_insert) == 17u); - log "-----"; + #debug("-----"); hm_uu.rehash(); i = 0u; while i < num_to_insert { @@ -117,7 +117,7 @@ fn test_growth() { assert (hm_uu.get(i) == i * i); i += 1u; } - log "str -> str"; + #debug("str -> str"); let hasher_str: map::hashfn = str::hash; let eqer_str: map::eqfn = str::eq; let hm_ss: map::hashmap = @@ -129,7 +129,7 @@ fn test_growth() { uint::to_str(i * i, 2u) + "\""; i += 1u; } - log "-----"; + #debug("-----"); i = 0u; while i < num_to_insert { log "get(\"" + uint::to_str(i, 2u) + "\") = \"" + @@ -142,7 +142,7 @@ fn test_growth() { uint::to_str(17u, 2u))); assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)), uint::to_str(17u, 2u))); - log "-----"; + #debug("-----"); hm_ss.rehash(); i = 0u; while i < num_to_insert { @@ -152,12 +152,12 @@ fn test_growth() { uint::to_str(i * i, 2u))); i += 1u; } - log "*** finished test_growth"; + #debug("*** finished test_growth"); } #[test] fn test_removal() { - log "*** starting test_removal"; + #debug("*** starting test_removal"); let num_to_insert: uint = 64u; fn eq(&&x: uint, &&y: uint) -> bool { ret x == y; } fn hash(&&u: uint) -> uint { @@ -181,8 +181,8 @@ fn test_removal() { i += 1u; } assert (hm.size() == num_to_insert); - log "-----"; - log "removing evens"; + #debug("-----"); + #debug("removing evens"); i = 0u; while i < num_to_insert { let v = hm.remove(i); @@ -193,7 +193,7 @@ fn test_removal() { i += 2u; } assert (hm.size() == num_to_insert / 2u); - log "-----"; + #debug("-----"); i = 1u; while i < num_to_insert { log "get(" + uint::to_str(i, 10u) + ") = " + @@ -201,10 +201,10 @@ fn test_removal() { assert (hm.get(i) == i * i); i += 2u; } - log "-----"; - log "rehashing"; + #debug("-----"); + #debug("rehashing"); hm.rehash(); - log "-----"; + #debug("-----"); i = 1u; while i < num_to_insert { log "get(" + uint::to_str(i, 10u) + ") = " + @@ -212,7 +212,7 @@ fn test_removal() { assert (hm.get(i) == i * i); i += 2u; } - log "-----"; + #debug("-----"); i = 0u; while i < num_to_insert { assert (hm.insert(i, i * i)); @@ -221,7 +221,7 @@ fn test_removal() { i += 2u; } assert (hm.size() == num_to_insert); - log "-----"; + #debug("-----"); i = 0u; while i < num_to_insert { log "get(" + uint::to_str(i, 10u) + ") = " + @@ -229,10 +229,10 @@ fn test_removal() { assert (hm.get(i) == i * i); i += 1u; } - log "-----"; - log "rehashing"; + #debug("-----"); + #debug("rehashing"); hm.rehash(); - log "-----"; + #debug("-----"); assert (hm.size() == num_to_insert); i = 0u; while i < num_to_insert { @@ -241,7 +241,7 @@ fn test_removal() { assert (hm.get(i) == i * i); i += 1u; } - log "*** finished test_removal"; + #debug("*** finished test_removal"); } #[test] diff --git a/src/test/stdtest/os.rs b/src/test/stdtest/os.rs index 1236a790925..2d1a64da753 100644 --- a/src/test/stdtest/os.rs +++ b/src/test/stdtest/os.rs @@ -36,7 +36,7 @@ fn get_exe_path() { let path = std::os::get_exe_path(); assert option::is_some(path); let path = option::get(path); - log path; + log_full(core::debug, path); // Hard to test this function if std::os::target_os() != "win32" { diff --git a/src/test/stdtest/path.rs b/src/test/stdtest/path.rs index 911b1fa6404..bb07fae6899 100644 --- a/src/test/stdtest/path.rs +++ b/src/test/stdtest/path.rs @@ -11,8 +11,8 @@ import std::os; fn test() { assert (!fs::path_is_absolute("test-path")); - log "Current working directory: " + os::getcwd(); + log_full(core::debug, "Current working directory: " + os::getcwd()); - log fs::make_absolute("test-path"); - log fs::make_absolute("/usr/bin"); + log_full(core::debug, fs::make_absolute("test-path")); + log_full(core::debug, fs::make_absolute("/usr/bin")); } diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs index 123fb39d25e..cac57233ea1 100644 --- a/src/test/stdtest/qsort.rs +++ b/src/test/stdtest/qsort.rs @@ -12,7 +12,11 @@ fn check_sort(v1: [mutable int], v2: [mutable int]) { let f = ltequal; std::sort::quick_sort::(f, v1); let i = 0u; - while i < len { log v2[i]; assert (v2[i] == v1[i]); i += 1u; } + while i < len { + log_full(core::debug, v2[i]); + assert (v2[i] == v1[i]); + i += 1u; + } } #[test] @@ -55,7 +59,7 @@ fn test_simple() { // Silly, but what else can we do? check (vec::same_length(expected, immut_names)); let pairs = vec::zip(expected, immut_names); - for (a, b) in pairs { log #fmt["%d %d", a, b]; assert (a == b); } + for (a, b) in pairs { #debug("%d %d", a, b); assert (a == b); } } // Local Variables: diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs index 0b178a00591..50f7bd27427 100644 --- a/src/test/stdtest/qsort3.rs +++ b/src/test/stdtest/qsort3.rs @@ -10,7 +10,11 @@ fn check_sort(v1: [mutable int], v2: [mutable int]) { let f2 = equal; std::sort::quick_sort3::(f1, f2, v1); let i = 0u; - while i < len { log v2[i]; assert (v2[i] == v1[i]); i += 1u; } + while i < len { + log_full(core::debug, v2[i]); + assert (v2[i] == v1[i]); + i += 1u; + } } #[test] diff --git a/src/test/stdtest/rand.rs b/src/test/stdtest/rand.rs index 2ee04719776..e59134830d2 100644 --- a/src/test/stdtest/rand.rs +++ b/src/test/stdtest/rand.rs @@ -8,33 +8,33 @@ import str; #[test] fn test() { let r1: rand::rng = rand::mk_rng(); - log r1.next(); - log r1.next(); + log_full(core::debug, r1.next()); + log_full(core::debug, r1.next()); { let r2 = rand::mk_rng(); - log r1.next(); - log r2.next(); - log r1.next(); - log r1.next(); - log r2.next(); - log r2.next(); - log r1.next(); - log r1.next(); - log r1.next(); - log r2.next(); - log r2.next(); - log r2.next(); + log_full(core::debug, r1.next()); + log_full(core::debug, r2.next()); + log_full(core::debug, r1.next()); + log_full(core::debug, r1.next()); + log_full(core::debug, r2.next()); + log_full(core::debug, r2.next()); + log_full(core::debug, r1.next()); + log_full(core::debug, r1.next()); + log_full(core::debug, r1.next()); + log_full(core::debug, r2.next()); + log_full(core::debug, r2.next()); + log_full(core::debug, r2.next()); } - log r1.next(); - log r1.next(); + log_full(core::debug, r1.next()); + log_full(core::debug, r1.next()); } #[test] fn genstr() { let r: rand::rng = rand::mk_rng(); - log r.gen_str(10u); - log r.gen_str(10u); - log r.gen_str(10u); + log_full(core::debug, r.gen_str(10u)); + log_full(core::debug, r.gen_str(10u)); + log_full(core::debug, r.gen_str(10u)); assert(str::char_len(r.gen_str(10u)) == 10u); assert(str::char_len(r.gen_str(16u)) == 16u); } diff --git a/src/test/stdtest/run.rs b/src/test/stdtest/run.rs index 9f6bc4c424d..e2d4f0e62b1 100644 --- a/src/test/stdtest/run.rs +++ b/src/test/stdtest/run.rs @@ -35,8 +35,8 @@ fn test_pipes() { readclose(pipe_err.in); os::waitpid(pid); - log expected; - log actual; + log_full(core::debug, expected); + log_full(core::debug, actual); assert (expected == actual); fn writeclose(fd: fd_t, s: str) { diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs index 717a1d829a6..9a8f4686920 100644 --- a/src/test/stdtest/sort.rs +++ b/src/test/stdtest/sort.rs @@ -8,7 +8,11 @@ fn check_sort(v1: [int], v2: [int]) { let f = lteq; let v3 = std::sort::merge_sort::(f, v1); let i = 0u; - while i < len { log v3[i]; assert (v3[i] == v2[i]); i += 1u; } + while i < len { + log_full(core::debug, v3[i]); + assert (v3[i] == v2[i]); + i += 1u; + } } #[test] diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs index b70cafe7392..0e819bac4c8 100644 --- a/src/test/stdtest/str.rs +++ b/src/test/stdtest/str.rs @@ -42,10 +42,10 @@ fn test_index_and_rindex() { #[test] fn test_split() { fn t(s: str, c: char, u: [str]) { - log "split: " + s; + log_full(core::debug, "split: " + s); let v = str::split(s, c as u8); - log "split to: "; - log v; + #debug("split to: "); + log_full(core::debug, v); assert (vec::all2(v, u, { |a,b| a == b })); } t("abc.hello.there", '.', ["abc", "hello", "there"]); @@ -56,12 +56,12 @@ fn test_split() { #[test] fn test_splitn() { fn t(s: str, c: char, n: uint, u: [str]) { - log "splitn: " + s; + log_full(core::debug, "splitn: " + s); let v = str::splitn(s, c as u8, n); - log "split to: "; - log v; - log "comparing vs. "; - log u; + #debug("split to: "); + log_full(core::debug, v); + #debug("comparing vs. "); + log_full(core::debug, u); assert (vec::all2(v, u, { |a,b| a == b })); } t("abc.hello.there", '.', 0u, ["abc.hello.there"]); @@ -92,8 +92,8 @@ fn test_split_str() { fn test_find() { fn t(haystack: str, needle: str, i: int) { let j: int = str::find(haystack, needle); - log "searched for " + needle; - log j; + log_full(core::debug, "searched for " + needle); + log_full(core::debug, j); assert (i == j); } t("this is a simple", "is a", 5); @@ -329,8 +329,8 @@ fn vec_str_conversions() { while i < n1 { let a: u8 = s1[i]; let b: u8 = s2[i]; - log a; - log b; + log_full(core::debug, a); + log_full(core::debug, b); assert (a == b); i += 1u; } diff --git a/src/test/stdtest/sys.rs b/src/test/stdtest/sys.rs index 35e14b5df1d..8a47d9c3039 100644 --- a/src/test/stdtest/sys.rs +++ b/src/test/stdtest/sys.rs @@ -4,7 +4,7 @@ import sys; #[test] fn last_os_error() { - log sys::last_os_error(); + log_full(core::debug, sys::last_os_error()); } #[test] diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs index 78e85c881b0..1059f9084e3 100644 --- a/src/test/stdtest/task.rs +++ b/src/test/stdtest/task.rs @@ -17,7 +17,7 @@ fn test_unsupervise() { #[test] fn test_lib_spawn() { - fn foo(&&_i: ()) { log_err "Hello, World!"; } + fn foo(&&_i: ()) { #error("Hello, World!"); } task::spawn((), foo); } @@ -34,8 +34,8 @@ fn test_join_chan() { let p = comm::port(); task::spawn_notify((), winner, comm::chan(p)); let s = comm::recv(p); - log_err "received task status message"; - log_err s; + #error("received task status message"); + log_full(core::error, s); alt s { task::exit(_, task::tr_success.) {/* yay! */ } _ { fail "invalid task status received" } @@ -51,8 +51,8 @@ fn test_join_chan_fail() { let p = comm::port(); task::spawn_notify((), failer, comm::chan(p)); let s = comm::recv(p); - log_err "received task status message"; - log_err s; + #error("received task status message"); + log_full(core::error, s); alt s { task::exit(_, task::tr_failure.) {/* yay! */ } _ { fail "invalid task status received" } @@ -70,7 +70,7 @@ fn test_join_convenient() { #[ignore] fn spawn_polymorphic() { // FIXME #1038: Can't spawn palymorphic functions - /*fn foo(x: T) { log_err x; } + /*fn foo(x: T) { log_full(core::error, x); } task::spawn(true, foo); task::spawn(42, foo);*/