user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

m1!{...} -> m1!(...)

Browse source
This commit is contained in:
Paul Stansifer 2012-08-22 17:24:52 -07:00
parent 226fd87199
commit 29f32b4a72
380 changed files with 5330 additions and 2706 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/libstd/deque.rs
View file

@ -274,37 +274,37 @@ mod tests {
fn reccyeq(a: reccy, b: reccy) -> bool {
return a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
}
debug!{"*** test boxes"};
debug!("*** test boxes");
test_boxes(@5, @72, @64, @175);
debug!{"*** end test boxes"};
debug!{"test parameterized: int"};
debug!("*** end test boxes");
debug!("test parameterized: int");
let eq1: eqfn<int> = inteq;
test_parameterized::<int>(eq1, 5, 72, 64, 175);
debug!{"*** test parameterized: @int"};
debug!("*** test parameterized: @int");
let eq2: eqfn<@int> = intboxeq;
test_parameterized::<@int>(eq2, @5, @72, @64, @175);
debug!{"*** end test parameterized @int"};
debug!{"test parameterized: taggy"};
debug!("*** end test parameterized @int");
debug!("test parameterized: taggy");
let eq3: eqfn<taggy> = taggyeq;
test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
two(17, 42));
debug!{"*** test parameterized: taggypar<int>"};
debug!("*** test parameterized: taggypar<int>");
let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y);
test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
twopar::<int>(1, 2),
threepar::<int>(1, 2, 3),
twopar::<int>(17, 42));
debug!{"*** end test parameterized: taggypar::<int>"};
debug!("*** end test parameterized: taggypar::<int>");
debug!{"*** 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<reccy> = reccyeq;
test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
debug!{"*** end test parameterized: reccy"};
debug!{"*** done"};
debug!("*** end test parameterized: reccy");
debug!("*** done");
}
}

68
src/libstd/ebml.rs
View file

@ -70,7 +70,7 @@ fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
(data[start + 2u] as uint) << 8u |
(data[start + 3u] as uint),
next: start + 4u};
} else { error!{"vint too big"}; fail; }
} else { error!("vint too big"); fail; }
}
fn doc(data: @~[u8]) -> doc {
@ -106,7 +106,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
match maybe_get_doc(d, tg) {
some(d) => return d,
none => {
error!{"failed to find block with tag %u", tg};
error!("failed to find block with tag %u", tg);
fail;
}
}
@ -186,7 +186,7 @@ fn write_sized_vuint(w: io::Writer, n: uint, size: uint) {
n as u8]),
4u => w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
(n >> 8_u) as u8, n as u8]),
_ => fail fmt!{"vint to write too big: %?", n}
_ => fail fmt!("vint to write too big: %?", n)
};
}
@ -195,7 +195,7 @@ fn write_vuint(w: io::Writer, n: uint) {
if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; }
if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; }
if n < 0x10000000_u { write_sized_vuint(w, n, 4u); return; }
fail fmt!{"vint to write too big: %?", n};
fail fmt!("vint to write too big: %?", n);
}
fn writer(w: io::Writer) -> writer {
@ -206,7 +206,7 @@ fn writer(w: io::Writer) -> writer {
// FIXME (#2741): Provide a function to write the standard ebml header.
impl writer {
fn start_tag(tag_id: uint) {
debug!{"Start tag %u", tag_id};
debug!("Start tag %u", tag_id);
// Write the enum ID:
write_vuint(self.writer, tag_id);
@ -225,7 +225,7 @@ impl writer {
write_sized_vuint(self.writer, size, 4u);
self.writer.seek(cur_pos as int, io::SeekSet);
debug!{"End tag (size = %u)", size};
debug!("End tag (size = %u)", size);
}
fn wr_tag(tag_id: uint, blk: fn()) {
@ -289,12 +289,12 @@ impl writer {
}
fn wr_bytes(b: &[u8]) {
debug!{"Write %u bytes", vec::len(b)};
debug!("Write %u bytes", vec::len(b));
self.writer.write(b);
}
fn wr_str(s: ~str) {
debug!{"Write str: %?", s};
debug!("Write str: %?", s);
self.writer.write(str::bytes(s));
}
}
@ -417,29 +417,29 @@ priv impl ebml_deserializer {
self.pos = r_doc.end;
let str = ebml::doc_as_str(r_doc);
if lbl != str {
fail fmt!{"Expected label %s but found %s", lbl, str};
fail fmt!("Expected label %s but found %s", lbl, str);
}
}
}
}
fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc {
debug!{". next_doc(exp_tag=%?)", exp_tag};
debug!(". next_doc(exp_tag=%?)", exp_tag);
if self.pos >= self.parent.end {
fail ~"no more documents in current node!";
}
let {tag: r_tag, doc: r_doc} =
ebml::doc_at(self.parent.data, self.pos);
debug!{"self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
debug!("self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
copy self.parent.start, copy self.parent.end,
copy self.pos, r_tag, r_doc.start, r_doc.end};
copy self.pos, r_tag, r_doc.start, r_doc.end);
if r_tag != (exp_tag as uint) {
fail fmt!{"expected EMBL doc with tag %? but found tag %?",
exp_tag, r_tag};
fail fmt!("expected EMBL doc with tag %? but found tag %?",
exp_tag, r_tag);
}
if r_doc.end > self.parent.end {
fail fmt!{"invalid EBML, child extends to 0x%x, parent to 0x%x",
r_doc.end, self.parent.end};
fail fmt!("invalid EBML, child extends to 0x%x, parent to 0x%x",
r_doc.end, self.parent.end);
}
self.pos = r_doc.end;
return r_doc;
@ -458,7 +458,7 @@ priv impl ebml_deserializer {
fn _next_uint(exp_tag: ebml_serializer_tag) -> uint {
let r = ebml::doc_as_u32(self.next_doc(exp_tag));
debug!{"_next_uint exp_tag=%? result=%?", exp_tag, r};
debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
return r as uint;
}
}
@ -473,7 +473,7 @@ impl ebml_deserializer: serialization::deserializer {
fn read_uint() -> uint {
let v = ebml::doc_as_u64(self.next_doc(es_uint));
if v > (core::uint::max_value as u64) {
fail fmt!{"uint %? too large for this architecture", v};
fail fmt!("uint %? too large for this architecture", v);
}
return v as uint;
}
@ -485,7 +485,7 @@ impl ebml_deserializer: serialization::deserializer {
fn read_int() -> int {
let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64;
if v > (int::max_value as i64) || v < (int::min_value as i64) {
fail fmt!{"int %? out of range for this architecture", v};
fail fmt!("int %? out of range for this architecture", v);
}
return v as int;
}
@ -500,67 +500,67 @@ impl ebml_deserializer: serialization::deserializer {
// Compound types:
fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
debug!{"read_enum(%s)", name};
debug!("read_enum(%s)", name);
self._check_label(name);
self.push_doc(self.next_doc(es_enum), f)
}
fn read_enum_variant<T>(f: fn(uint) -> T) -> T {
debug!{"read_enum_variant()"};
debug!("read_enum_variant()");
let idx = self._next_uint(es_enum_vid);
debug!{" idx=%u", idx};
debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(es_enum_body)) {
f(idx)
}
}
fn read_enum_variant_arg<T>(idx: uint, f: fn() -> T) -> T {
debug!{"read_enum_variant_arg(idx=%u)", idx};
debug!("read_enum_variant_arg(idx=%u)", idx);
f()
}
fn read_vec<T>(f: fn(uint) -> T) -> T {
debug!{"read_vec()"};
debug!("read_vec()");
do self.push_doc(self.next_doc(es_vec)) {
let len = self._next_uint(es_vec_len);
debug!{" len=%u", len};
debug!(" len=%u", len);
f(len)
}
}
fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T {
debug!{"read_vec_elt(idx=%u)", idx};
debug!("read_vec_elt(idx=%u)", idx);
self.push_doc(self.next_doc(es_vec_elt), f)
}
fn read_box<T>(f: fn() -> T) -> T {
debug!{"read_box()"};
debug!("read_box()");
f()
}
fn read_uniq<T>(f: fn() -> T) -> T {
debug!{"read_uniq()"};
debug!("read_uniq()");
f()
}
fn read_rec<T>(f: fn() -> T) -> T {
debug!{"read_rec()"};
debug!("read_rec()");
f()
}
fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
debug!{"read_rec_field(%s, idx=%u)", f_name, f_idx};
debug!("read_rec_field(%s, idx=%u)", f_name, f_idx);
self._check_label(f_name);
f()
}
fn read_tup<T>(sz: uint, f: fn() -> T) -> T {
debug!{"read_tup(sz=%u)", sz};
debug!("read_tup(sz=%u)", sz);
f()
}
fn read_tup_elt<T>(idx: uint, f: fn() -> T) -> T {
debug!{"read_tup_elt(idx=%u)", idx};
debug!("read_tup_elt(idx=%u)", idx);
f()
}
}
@ -613,14 +613,14 @@ fn test_option_int() {
}
fn test_v(v: option<int>) {
debug!{"v == %?", v};
debug!("v == %?", v);
let mbuf = io::mem_buffer();
let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
serialize_0(ebml_w, v);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let deser = ebml_deserializer(ebml_doc);
let v1 = deserialize_0(deser);
debug!{"v1 == %?", v1};
debug!("v1 == %?", v1);
assert v == v1;
}

2
src/libstd/getopts.rs
View file

@ -314,7 +314,7 @@ fn opt_vals(m: matches, nm: ~str) -> ~[optval] {
return match find_opt(m.opts, mkname(nm)) {
some(id) => m.vals[id],
none => {
error!{"No option '%s' defined", nm};
error!("No option '%s' defined", nm);
fail
}
};

2
src/libstd/json.rs
View file

@ -628,7 +628,7 @@ impl json: to_str::ToStr {
impl error: to_str::ToStr {
fn to_str() -> ~str {
fmt!{"%u:%u: %s", self.line, self.col, *self.msg}
fmt!("%u:%u: %s", self.line, self.col, *self.msg)
}
}

94
src/libstd/map.rs
View file

@ -137,16 +137,16 @@ mod chained {
loop {
match copy e0.next {
none => {
debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx};
debug!("search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx);
return not_found;
}
some(e1) => {
comp += 1u;
if e1.hash == h && self.eqer(&e1.key, k) {
debug!{"search_tbl: present, comp %u, \
debug!("search_tbl: present, comp %u, \
hash %u, idx %u",
comp, h, idx};
comp, h, idx);
return found_after(e0, e1);
} else {
e0 = e1;
@ -160,14 +160,14 @@ mod chained {
let idx = h % vec::len(self.chains);
match copy self.chains[idx] {
none => {
debug!{"search_tbl: none, comp %u, hash %u, idx %u",
0u, h, idx};
debug!("search_tbl: none, comp %u, hash %u, idx %u",
0u, h, idx);
return not_found;
}
some(e) => {
if e.hash == h && self.eqer(&e.key, k) {
debug!{"search_tbl: present, comp %u, hash %u, idx %u",
1u, h, idx};
debug!("search_tbl: present, comp %u, hash %u, idx %u",
1u, h, idx);
return found_first(idx, e);
} else {
return self.search_rem(k, h, idx, e);
@ -277,7 +277,7 @@ mod chained {
fn get(+k: K) -> V {
let opt_v = self.find(k);
if opt_v.is_none() {
fail fmt!{"Key not found in table: %?", k};
fail fmt!("Key not found in table: %?", k);
}
option::unwrap(opt_v)
}
@ -563,14 +563,14 @@ mod tests {
#[test]
fn test_simple() {
debug!{"*** starting test_simple"};
debug!("*** starting test_simple");
pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y }
pure fn uint_id(x: &uint) -> uint { *x }
let hasher_uint: map::hashfn<uint> = uint_id;
let eqer_uint: map::eqfn<uint> = eq_uint;
let hasher_str: map::hashfn<~str> = str::hash;
let eqer_str: map::eqfn<~str> = str::eq;
debug!{"uint -> uint"};
debug!("uint -> uint");
let hm_uu: map::hashmap<uint, uint> =
map::hashmap::<uint, uint>(copy hasher_uint, copy eqer_uint);
assert (hm_uu.insert(10u, 12u));
@ -586,7 +586,7 @@ mod tests {
let ten: ~str = ~"ten";
let eleven: ~str = ~"eleven";
let twelve: ~str = ~"twelve";
debug!{"str -> uint"};
debug!("str -> uint");
let hm_su: map::hashmap<~str, uint> =
map::hashmap::<~str, uint>(copy hasher_str, copy eqer_str);
assert (hm_su.insert(~"ten", 12u));
@ -600,7 +600,7 @@ mod tests {
assert (hm_su.get(~"twelve") == 14u);
assert (!hm_su.insert(~"twelve", 12u));
assert (hm_su.get(~"twelve") == 12u);
debug!{"uint -> str"};
debug!("uint -> str");
let hm_us: map::hashmap<uint, ~str> =
map::hashmap::<uint, ~str>(copy hasher_uint, copy eqer_uint);
assert (hm_us.insert(10u, ~"twelve"));
@ -613,7 +613,7 @@ mod tests {
assert hm_us.get(12u) == ~"fourteen";
assert (!hm_us.insert(12u, ~"twelve"));
assert hm_us.get(12u) == ~"twelve";
debug!{"str -> str"};
debug!("str -> str");
let hm_ss: map::hashmap<~str, ~str> =
map::hashmap::<~str, ~str>(copy hasher_str, copy eqer_str);
assert (hm_ss.insert(ten, ~"twelve"));
@ -626,7 +626,7 @@ mod tests {
assert hm_ss.get(~"twelve") == ~"fourteen";
assert (!hm_ss.insert(~"twelve", ~"twelve"));
assert hm_ss.get(~"twelve") == ~"twelve";
debug!{"*** finished test_simple"};
debug!("*** finished test_simple");
}
@ -635,11 +635,11 @@ mod tests {
*/
#[test]
fn test_growth() {
debug!{"*** starting test_growth"};
debug!("*** starting test_growth");
let num_to_insert: uint = 64u;
pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y }
pure fn uint_id(x: &uint) -> uint { *x }
debug!{"uint -> uint"};
debug!("uint -> uint");
let hasher_uint: map::hashfn<uint> = uint_id;
let eqer_uint: map::eqfn<uint> = eq_uint;
let hm_uu: map::hashmap<uint, uint> =
@ -647,26 +647,26 @@ mod tests {
let mut i: uint = 0u;
while i < num_to_insert {
assert (hm_uu.insert(i, i * i));
debug!{"inserting %u -> %u", i, i*i};
debug!("inserting %u -> %u", i, i*i);
i += 1u;
}
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm_uu.get(i)};
debug!("get(%u) = %u", i, hm_uu.get(i));
assert (hm_uu.get(i) == i * i);
i += 1u;
}
assert (hm_uu.insert(num_to_insert, 17u));
assert (hm_uu.get(num_to_insert) == 17u);
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm_uu.get(i)};
debug!("get(%u) = %u", i, hm_uu.get(i));
assert (hm_uu.get(i) == i * i);
i += 1u;
}
debug!{"str -> str"};
debug!("str -> str");
let hasher_str: map::hashfn<~str> = str::hash;
let eqer_str: map::eqfn<~str> = str::eq;
let hm_ss: map::hashmap<~str, ~str> =
@ -674,17 +674,17 @@ mod tests {
i = 0u;
while i < num_to_insert {
assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
debug!{"inserting \"%s\" -> \"%s\"",
debug!("inserting \"%s\" -> \"%s\"",
uint::to_str(i, 2u),
uint::to_str(i*i, 2u)};
uint::to_str(i*i, 2u));
i += 1u;
}
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
debug!{"get(\"%s\") = \"%s\"",
debug!("get(\"%s\") = \"%s\"",
uint::to_str(i, 2u),
hm_ss.get(uint::to_str(i, 2u))};
hm_ss.get(uint::to_str(i, 2u)));
assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
i += 1u;
}
@ -692,21 +692,21 @@ mod tests {
uint::to_str(17u, 2u)));
assert hm_ss.get(uint::to_str(num_to_insert, 2u)) ==
uint::to_str(17u, 2u);
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
debug!{"get(\"%s\") = \"%s\"",
debug!("get(\"%s\") = \"%s\"",
uint::to_str(i, 2u),
hm_ss.get(uint::to_str(i, 2u))};
hm_ss.get(uint::to_str(i, 2u)));
assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
i += 1u;
}
debug!{"*** finished test_growth"};
debug!("*** finished test_growth");
}
#[test]
fn test_removal() {
debug!{"*** starting test_removal"};
debug!("*** starting test_removal");
let num_to_insert: uint = 64u;
fn eq(x: &uint, y: &uint) -> bool { *x == *y }
fn hash(u: &uint) -> uint {
@ -724,12 +724,12 @@ mod tests {
let mut i: uint = 0u;
while i < num_to_insert {
assert (hm.insert(i, i * i));
debug!{"inserting %u -> %u", i, i*i};
debug!("inserting %u -> %u", i, i*i);
i += 1u;
}
assert (hm.size() == num_to_insert);
debug!{"-----"};
debug!{"removing evens"};
debug!("-----");
debug!("removing evens");
i = 0u;
while i < num_to_insert {
let v = hm.remove(i);
@ -737,44 +737,44 @@ mod tests {
i += 2u;
}
assert (hm.size() == num_to_insert / 2u);
debug!{"-----"};
debug!("-----");
i = 1u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm.get(i)};
debug!("get(%u) = %u", i, hm.get(i));
assert (hm.get(i) == i * i);
i += 2u;
}
debug!{"-----"};
debug!("-----");
i = 1u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm.get(i)};
debug!("get(%u) = %u", i, hm.get(i));
assert (hm.get(i) == i * i);
i += 2u;
}
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
assert (hm.insert(i, i * i));
debug!{"inserting %u -> %u", i, i*i};
debug!("inserting %u -> %u", i, i*i);
i += 2u;
}
assert (hm.size() == num_to_insert);
debug!{"-----"};
debug!("-----");
i = 0u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm.get(i)};
debug!("get(%u) = %u", i, hm.get(i));
assert (hm.get(i) == i * i);
i += 1u;
}
debug!{"-----"};
debug!("-----");
assert (hm.size() == num_to_insert);
i = 0u;
while i < num_to_insert {
debug!{"get(%u) = %u", i, hm.get(i)};
debug!("get(%u) = %u", i, hm.get(i));
assert (hm.get(i) == i * i);
i += 1u;
}
debug!{"*** finished test_removal"};
debug!("*** finished test_removal");
}
#[test]

46
src/libstd/net_ip.rs
View file

@ -88,7 +88,7 @@ fn get_addr(++node: ~str, iotask: iotask)
-> result::result<~[ip_addr], ip_get_addr_err> unsafe {
do core::comm::listen |output_ch| {
do str::as_buf(node) |node_ptr, len| {
log(debug, fmt!{"slice len %?", len});
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
let handle_ptr = ptr::addr_of(handle);
let handle_data: get_addr_data = {
@ -161,10 +161,10 @@ mod v4 {
}
});
if vec::len(parts) != 4u {
result::err(fmt!{"'%s' doesn't have 4 parts", ip})
result::err(fmt!("'%s' doesn't have 4 parts", ip))
}
else if vec::contains(parts, 256u) {
result::err(fmt!{"invalid octal in addr '%s'", ip})
result::err(fmt!("invalid octal in addr '%s'", ip))
}
else {
result::ok({a: parts[0] as u8, b: parts[1] as u8,
@ -185,8 +185,8 @@ mod v4 {
let new_addr = uv_ip4_addr(ip, 22);
let reformatted_name = uv_ip4_name(&new_addr);
log(debug, fmt!{"try_parse_addr: input ip: %s reparsed ip: %s",
ip, reformatted_name});
log(debug, fmt!("try_parse_addr: input ip: %s reparsed ip: %s",
ip, reformatted_name));
let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
if result::is_err(ref_ip_rep_result) {
let err_str = result::get_err(ref_ip_rep_result);
@ -230,13 +230,13 @@ mod v6 {
// need to figure out how to establish a parse failure..
let new_addr = uv_ip6_addr(ip, 22);
let reparsed_name = uv_ip6_name(&new_addr);
log(debug, fmt!{"v6::try_parse_addr ip: '%s' reparsed '%s'",
ip, reparsed_name});
log(debug, fmt!("v6::try_parse_addr ip: '%s' reparsed '%s'",
ip, reparsed_name));
// '::' appears to be uv_ip6_name() returns for bogus
// parses..
if ip != ~"::" && reparsed_name == ~"::" {
result::err({err_msg:fmt!{"failed to parse '%s'",
ip}})
result::err({err_msg:fmt!("failed to parse '%s'",
ip)})
}
else {
result::ok(ipv6(new_addr))
@ -257,7 +257,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
if status == 0i32 {
if res != (ptr::null::<addrinfo>()) {
let mut out_vec = ~[];
log(debug, fmt!{"initial addrinfo: %?", res});
log(debug, fmt!("initial addrinfo: %?", res));
let mut curr_addr = res;
loop {
let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
@ -284,11 +284,11 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
}
else {
curr_addr = next_addr;
log(debug, fmt!{"next_addr addrinfo: %?", curr_addr});
log(debug, fmt!("next_addr addrinfo: %?", curr_addr));
}
}
log(debug, fmt!{"successful process addrinfo result, len: %?",
vec::len(out_vec)});
log(debug, fmt!("successful process addrinfo result, len: %?",
vec::len(out_vec)));
(*handle_data).output_ch.send(result::ok(out_vec));
}
else {
@ -320,19 +320,19 @@ mod test {
fn test_ip_ipv6_parse_and_format_ip() {
let localhost_str = ~"::1";
let format_result = format_addr(v6::parse_addr(localhost_str));
log(debug, fmt!{"results: expected: '%s' actual: '%s'",
localhost_str, format_result});
log(debug, fmt!("results: expected: '%s' actual: '%s'",
localhost_str, format_result));
assert format_result == localhost_str;
}
#[test]
fn test_ip_ipv4_bad_parse() {
match v4::try_parse_addr(~"b4df00d") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
log(debug, fmt!("got error as expected %?", err_info));
assert true;
}
result::ok(addr) => {
fail fmt!{"Expected failure, but got addr %?", addr};
fail fmt!("Expected failure, but got addr %?", addr);
}
}
}
@ -341,11 +341,11 @@ mod test {
fn test_ip_ipv6_bad_parse() {
match v6::try_parse_addr(~"::,~2234k;") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
log(debug, fmt!("got error as expected %?", err_info));
assert true;
}
result::ok(addr) => {
fail fmt!{"Expected failure, but got addr %?", addr};
fail fmt!("Expected failure, but got addr %?", addr);
}
}
}
@ -361,15 +361,15 @@ mod test {
// note really sure how to realiably test/assert
// this.. mostly just wanting to see it work, atm.
let results = result::unwrap(ga_result);
log(debug, fmt!{"test_get_addr: Number of results for %s: %?",
localhost_name, vec::len(results)});
log(debug, fmt!("test_get_addr: Number of results for %s: %?",
localhost_name, vec::len(results)));
for vec::each(results) |r| {
let ipv_prefix = match r {
ipv4(_) => ~"IPv4",
ipv6(_) => ~"IPv6"
};
log(debug, fmt!{"test_get_addr: result %s: '%s'",
ipv_prefix, format_addr(r)});
log(debug, fmt!("test_get_addr: result %s: '%s'",
ipv_prefix, format_addr(r)));
}
// at least one result.. this is going to vary from system
// to system, based on stuff like the contents of /etc/hosts

138
src/libstd/net_tcp.rs
View file

@ -140,15 +140,15 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
iotask: iotask
};
let socket_data_ptr = ptr::addr_of(*socket_data);
log(debug, fmt!{"tcp_connect result_ch %?", conn_data.result_ch});
log(debug, fmt!("tcp_connect result_ch %?", conn_data.result_ch));
// get an unsafe representation of our stream_handle_ptr that
// we can send into the interact cb to be handled in libuv..
log(debug, fmt!{"stream_handle_ptr outside interact %?",
stream_handle_ptr});
log(debug, fmt!("stream_handle_ptr outside interact %?",
stream_handle_ptr));
do iotask::interact(iotask) |loop_ptr| {
log(debug, ~"in interact cb for tcp client connect..");
log(debug, fmt!{"stream_handle_ptr in interact %?",
stream_handle_ptr});
log(debug, fmt!("stream_handle_ptr in interact %?",
stream_handle_ptr));
match uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
0i32 => {
log(debug, ~"tcp_init successful");
@ -165,7 +165,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
// info.. should probably add an additional
// rust type that actually is closer to
// what the libuv API expects (ip str + port num)
log(debug, fmt!{"addr: %?", addr});
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip4_addr(addr_str, port as int);
uv::ll::tcp_connect(
connect_req_ptr,
@ -174,7 +174,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
tcp_connect_on_connect_cb)
}
ip::ipv6(addr) => {
log(debug, fmt!{"addr: %?", addr});
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip6_addr(addr_str, port as int);
uv::ll::tcp_connect6(
connect_req_ptr,
@ -333,7 +333,7 @@ fn read_start(sock: tcp_socket)
fn read_stop(sock: tcp_socket,
-read_port: comm::Port<result::result<~[u8], tcp_err_data>>) ->
result::result<(), tcp_err_data> unsafe {
log(debug, fmt!{"taking the read_port out of commission %?", read_port});
log(debug, fmt!("taking the read_port out of commission %?", read_port));
let socket_data = ptr::addr_of(*sock.socket_data);
read_stop_common_impl(socket_data)
}
@ -617,13 +617,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
let addr_str = ip::format_addr(loc_ip);
let bind_result = match loc_ip {
ip::ipv4(addr) => {
log(debug, fmt!{"addr: %?", addr});
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip4_addr(addr_str, port as int);
uv::ll::tcp_bind(server_stream_ptr,
ptr::addr_of(in_addr))
}
ip::ipv6(addr) => {
log(debug, fmt!{"addr: %?", addr});
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip6_addr(addr_str, port as int);
uv::ll::tcp_bind6(server_stream_ptr,
ptr::addr_of(in_addr))
@ -661,8 +661,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
match setup_result {
some(err_data) => {
do iotask::interact(iotask) |loop_ptr| {
log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
loop_ptr});
log(debug, fmt!("tcp::listen post-kill recv hl interact %?",
loop_ptr));
(*server_data_ptr).active = false;
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
@ -677,8 +677,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
result::err(address_in_use)
}
_ => {
log(debug, fmt!{"Got '%s' '%s' libuv error",
err_data.err_name, err_data.err_msg});
log(debug, fmt!("Got '%s' '%s' libuv error",
err_data.err_name, err_data.err_msg));
result::err(
generic_listen_err(err_data.err_name, err_data.err_msg))
}
@ -688,8 +688,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
on_establish_cb(kill_ch);
let kill_result = core::comm::recv(kill_po);
do iotask::interact(iotask) |loop_ptr| {
log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
loop_ptr});
log(debug, fmt!("tcp::listen post-kill recv hl interact %?",
loop_ptr));
(*server_data_ptr).active = false;
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
@ -765,8 +765,8 @@ impl @tcp_socket_buf: io::Reader {
if err_data.err_name == ~"EOF" {
break;
} else {
debug!{"ERROR sock_buf as io::reader.read err %? %?",
err_data.err_name, err_data.err_msg};
debug!("ERROR sock_buf as io::reader.read err %? %?",
err_data.err_name, err_data.err_msg);
return 0;
}
@ -798,7 +798,7 @@ impl @tcp_socket_buf: io::Reader {
false // noop
}
fn seek(dist: int, seek: io::SeekStyle) {
log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
// noop
}
fn tell() -> uint {
@ -815,12 +815,12 @@ impl @tcp_socket_buf: io::Writer {
vec::slice(data, 0, vec::len(data)));
if w_result.is_err() {
let err_data = w_result.get_err();
log(debug, fmt!{"ERROR sock_buf as io::writer.writer err: %? %?",
err_data.err_name, err_data.err_msg});
log(debug, fmt!("ERROR sock_buf as io::writer.writer err: %? %?",
err_data.err_name, err_data.err_msg));
}
}
fn seek(dist: int, seek: io::SeekStyle) {
log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
// noop
}
fn tell() -> uint {
@ -845,14 +845,14 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
let close_data_ptr = ptr::addr_of(close_data);
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, fmt!{"interact dtor for tcp_socket stream %? loop %?",
stream_handle_ptr, loop_ptr});
log(debug, fmt!("interact dtor for tcp_socket stream %? loop %?",
stream_handle_ptr, loop_ptr));
uv::ll::set_data_for_uv_handle(stream_handle_ptr,
close_data_ptr);
uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
};
core::comm::recv(closed_po);
log(debug, fmt!{"about to free socket_data at %?", socket_data});
log(debug, fmt!("about to free socket_data at %?", socket_data));
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
as *libc::c_void);
log(debug, ~"exiting dtor for tcp_socket");
@ -931,7 +931,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
let start_ch = core::comm::chan(start_po);
log(debug, ~"in tcp::read_start before interact loop");
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, fmt!{"in tcp::read_start interact cb %?", loop_ptr});
log(debug, fmt!("in tcp::read_start interact cb %?", loop_ptr));
match uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
on_alloc_cb,
on_tcp_read_cb) {
@ -971,7 +971,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
};
let write_data_ptr = ptr::addr_of(write_data);
do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| {
log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr});
log(debug, fmt!("in interact cb for tcp::write %?", loop_ptr));
match uv::ll::write(write_req_ptr,
stream_handle_ptr,
write_buf_vec_ptr,
@ -1075,8 +1075,8 @@ impl uv::ll::uv_err_data: to_tcp_err {
extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
nread: libc::ssize_t,
++buf: uv::ll::uv_buf_t) unsafe {
log(debug, fmt!{"entering on_tcp_read_cb stream: %? nread: %?",
stream, nread});
log(debug, fmt!("entering on_tcp_read_cb stream: %? nread: %?",
stream, nread));
let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
as *tcp_socket_data;
@ -1084,8 +1084,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
// incoming err.. probably eof
-1 => {
let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
log(debug, fmt!{"on_tcp_read_cb: incoming err.. name %? msg %?",
err_data.err_name, err_data.err_msg});
log(debug, fmt!("on_tcp_read_cb: incoming err.. name %? msg %?",
err_data.err_name, err_data.err_msg));
let reader_ch = (*socket_data_ptr).reader_ch;
core::comm::send(reader_ch, result::err(err_data));
}
@ -1094,7 +1094,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
// have data
_ => {
// we have data
log(debug, fmt!{"tcp on_read_cb nread: %d", nread as int});
log(debug, fmt!("tcp on_read_cb nread: %d", nread as int));
let reader_ch = (*socket_data_ptr).reader_ch;
let buf_base = uv::ll::get_base_from_buf(buf);
let new_bytes = vec::unsafe::from_buf(buf_base, nread as uint);
@ -1110,10 +1110,10 @@ extern fn on_alloc_cb(handle: *libc::c_void,
-> uv::ll::uv_buf_t unsafe {
log(debug, ~"tcp read on_alloc_cb!");
let char_ptr = uv::ll::malloc_buf_base_of(suggested_size);
log(debug, fmt!{"tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
log(debug, fmt!("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
handle,
char_ptr as uint,
suggested_size as uint});
suggested_size as uint));
uv::ll::buf_init(char_ptr, suggested_size as uint)
}
@ -1160,11 +1160,11 @@ extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let data = uv::ll::get_data_for_uv_handle(handle) as
*connect_req_data;
core::comm::send((*data).closed_signal_ch, ());
log(debug, fmt!{"exiting steam_error_close_cb for %?", handle});
log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
}
extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
log(debug, fmt!{"closed client tcp handle %?", handle});
log(debug, fmt!("closed client tcp handle %?", handle));
}
extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
@ -1172,7 +1172,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
as *connect_req_data);
let result_ch = (*conn_data_ptr).result_ch;
log(debug, fmt!{"tcp_connect result_ch %?", result_ch});
log(debug, fmt!("tcp_connect result_ch %?", result_ch));
let tcp_stream_ptr =
uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
match status {
@ -1184,8 +1184,8 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
log(debug, ~"error in tcp_connect_on_connect_cb");
let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr);
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, fmt!{"err_data %? %?", err_data.err_name,
err_data.err_msg});
log(debug, fmt!("err_data %? %?", err_data.err_name,
err_data.err_msg));
core::comm::send(result_ch, conn_failure(err_data));
uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
conn_data_ptr);
@ -1314,10 +1314,10 @@ mod test {
assert actual_resp_result.is_ok();
let actual_resp = actual_resp_result.get();
let actual_req = core::comm::recv(server_result_po);
log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
expected_req, actual_req});
log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
expected_resp, actual_resp});
log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
expected_req, actual_req));
log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
expected_resp, actual_resp));
assert str::contains(actual_req, expected_req);
assert str::contains(actual_resp, expected_resp);
}
@ -1453,27 +1453,27 @@ mod test {
};
let actual_req = core::comm::recv(server_result_po);
log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
expected_req, actual_req});
log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
expected_resp, actual_resp});
log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
expected_req, actual_req));
log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
expected_resp, actual_resp));
assert str::contains(actual_req, expected_req);
assert str::contains(actual_resp, expected_resp);
}
fn buf_write(+w: io::Writer, val: ~str) {
log(debug, fmt!{"BUF_WRITE: val len %?", str::len(val)});
log(debug, fmt!("BUF_WRITE: val len %?", str::len(val)));
do str::byte_slice(val) |b_slice| {
log(debug, fmt!{"BUF_WRITE: b_slice len %?",
vec::len(b_slice)});
log(debug, fmt!("BUF_WRITE: b_slice len %?",
vec::len(b_slice)));
w.write(b_slice)
}
}
fn buf_read(+r: io::Reader, len: uint) -> ~str {
let new_bytes = r.read_bytes(len);
log(debug, fmt!{"in buf_read.. new_bytes len: %?",
vec::len(new_bytes)});
log(debug, fmt!("in buf_read.. new_bytes len: %?",
vec::len(new_bytes)));
str::from_bytes(new_bytes)
}
@ -1485,8 +1485,8 @@ mod test {
let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
// on_establish_cb -- called when listener is set up
|kill_ch| {
log(debug, fmt!{"establish_cb %?",
kill_ch});
log(debug, fmt!("establish_cb %?",
kill_ch));
core::comm::send(cont_ch, ());
},
// risky to run this on the loop, but some users
@ -1518,8 +1518,8 @@ mod test {
match received_req_bytes {
result::ok(data) => {
log(debug, ~"SERVER: got REQ str::from_bytes..");
log(debug, fmt!{"SERVER: REQ data len: %?",
vec::len(data)});
log(debug, fmt!("SERVER: REQ data len: %?",
vec::len(data)));
server_ch.send(
str::from_bytes(data));
log(debug, ~"SERVER: before write");
@ -1528,8 +1528,8 @@ mod test {
core::comm::send(kill_ch, none);
}
result::err(err_data) => {
log(debug, fmt!{"SERVER: error recvd: %s %s",
err_data.err_name, err_data.err_msg});
log(debug, fmt!("SERVER: error recvd: %s %s",
err_data.err_name, err_data.err_msg));
core::comm::send(kill_ch, some(err_data));
server_ch.send(~"");
}
@ -1546,8 +1546,8 @@ mod test {
if result::is_err(listen_result) {
match result::get_err(listen_result) {
generic_listen_err(name, msg) => {
fail fmt!{"SERVER: exited abnormally name %s msg %s",
name, msg};
fail fmt!("SERVER: exited abnormally name %s msg %s",
name, msg);
}
access_denied => {
fail ~"SERVER: exited abnormally, got access denied..";
@ -1558,7 +1558,7 @@ mod test {
}
}
let ret_val = server_ch.recv();
log(debug, fmt!{"SERVER: exited and got return val: '%s'", ret_val});
log(debug, fmt!("SERVER: exited and got return val: '%s'", ret_val));
ret_val
}
@ -1568,12 +1568,12 @@ mod test {
let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
// on_establish_cb -- called when listener is set up
|kill_ch| {
log(debug, fmt!{"establish_cb %?",
kill_ch});
log(debug, fmt!("establish_cb %?",
kill_ch));
},
|new_conn, kill_ch| {
fail fmt!{"SERVER: shouldn't be called.. %? %?",
new_conn, kill_ch};
fail fmt!("SERVER: shouldn't be called.. %? %?",
new_conn, kill_ch);
});
// err check on listen_result
if result::is_err(listen_result) {
@ -1609,8 +1609,8 @@ mod test {
else {
client_ch.send(str::from_bytes(read_result.get()));
let ret_val = client_ch.recv();
log(debug, fmt!{"CLIENT: after client_ch recv ret: '%s'",
ret_val});
log(debug, fmt!("CLIENT: after client_ch recv ret: '%s'",
ret_val));
ok(ret_val)
}
}
@ -1622,8 +1622,8 @@ mod test {
if result::is_err(write_result) {
log(debug, ~"tcp_write_single: write failed!");
let err_data = result::get_err(write_result);
log(debug, fmt!{"tcp_write_single err name: %s msg: %s",
err_data.err_name, err_data.err_msg});
log(debug, fmt!("tcp_write_single err name: %s msg: %s",
err_data.err_name, err_data.err_msg));
// meh. torn on what to do here.
fail ~"tcp_write_single failed";
}

8
src/libstd/par.rs
View file

@ -47,11 +47,11 @@ fn map_slices<A: copy send, B: copy send>(
let len = end - base;
let slice = (ptr::offset(p, base),
len * sys::size_of::<A>());
log(info, fmt!{"pre-slice: %?", (base, slice)});
log(info, fmt!("pre-slice: %?", (base, slice)));
let slice : &[A] =
unsafe::reinterpret_cast(slice);
log(info, fmt!{"slice: %?",
(base, vec::len(slice), end - base)});
log(info, fmt!("slice: %?",
(base, vec::len(slice), end - base)));
assert(vec::len(slice) == end - base);
f(base, slice)
}
@ -62,7 +62,7 @@ fn map_slices<A: copy send, B: copy send>(
}
log(info, ~"tasks spawned");
log(info, fmt!{"num_tasks: %?", (num_tasks, futures.len())});
log(info, fmt!("num_tasks: %?", (num_tasks, futures.len())));
assert(num_tasks == futures.len());
let r = do futures.map() |ys| {

30
src/libstd/prettyprint.rs
View file

@ -8,63 +8,63 @@ impl Writer: serializer {
}
fn emit_uint(v: uint) {
self.write_str(fmt!{"%?u", v});
self.write_str(fmt!("%?u", v));
}
fn emit_u64(v: u64) {
self.write_str(fmt!{"%?_u64", v});
self.write_str(fmt!("%?_u64", v));
}
fn emit_u32(v: u32) {
self.write_str(fmt!{"%?_u32", v});
self.write_str(fmt!("%?_u32", v));
}
fn emit_u16(v: u16) {
self.write_str(fmt!{"%?_u16", v});
self.write_str(fmt!("%?_u16", v));
}
fn emit_u8(v: u8) {
self.write_str(fmt!{"%?_u8", v});
self.write_str(fmt!("%?_u8", v));
}
fn emit_int(v: int) {
self.write_str(fmt!{"%?", v});
self.write_str(fmt!("%?", v));
}
fn emit_i64(v: i64) {
self.write_str(fmt!{"%?_i64", v});
self.write_str(fmt!("%?_i64", v));
}
fn emit_i32(v: i32) {
self.write_str(fmt!{"%?_i32", v});
self.write_str(fmt!("%?_i32", v));
}
fn emit_i16(v: i16) {
self.write_str(fmt!{"%?_i16", v});
self.write_str(fmt!("%?_i16", v));
}
fn emit_i8(v: i8) {
self.write_str(fmt!{"%?_i8", v});
self.write_str(fmt!("%?_i8", v));
}
fn emit_bool(v: bool) {
self.write_str(fmt!{"%b", v});
self.write_str(fmt!("%b", v));
}
fn emit_float(v: float) {
self.write_str(fmt!{"%?_f", v});
self.write_str(fmt!("%?_f", v));
}
fn emit_f64(v: f64) {
self.write_str(fmt!{"%?_f64", v});
self.write_str(fmt!("%?_f64", v));
}
fn emit_f32(v: f32) {
self.write_str(fmt!{"%?_f32", v});
self.write_str(fmt!("%?_f32", v));
}
fn emit_str(v: &str) {
self.write_str(fmt!{"%?", v});
self.write_str(fmt!("%?", v));
}
fn emit_enum(_name: ~str, f: fn()) {

4
src/libstd/smallintmap.rs
View file

@ -27,7 +27,7 @@ fn mk<T: copy>() -> smallintmap<T> {
*/
#[inline(always)]
fn insert<T: copy>(self: smallintmap<T>, key: uint, val: T) {
//io::println(fmt!{"%?", key});
//io::println(fmt!("%?", key));
self.v.grow_set_elt(key, none, some(val));
}
@ -50,7 +50,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
match find(self, key) {
none => {
error!{"smallintmap::get(): key not present"};
error!("smallintmap::get(): key not present");
fail;
}
some(v) => return v

2
src/libstd/sort.rs
View file

@ -250,7 +250,7 @@ mod test_qsort {
let pairs = vec::zip(expected, immut_names);
for vec::each(pairs) |p| {
let (a, b) = p;
debug!{"%d %d", a, b};
debug!("%d %d", a, b);
assert (a == b);
}
}

20
src/libstd/test.rs
View file

@ -110,9 +110,9 @@ fn run_tests_console(opts: test_opts,
te_filtered(filtered_tests) => {
st.total = vec::len(filtered_tests);
let noun = if st.total != 1u { ~"tests" } else { ~"test" };
st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun});
st.out.write_line(fmt!("\nrunning %u %s", st.total, noun));
}
te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
te_wait(test) => st.out.write_str(fmt!("test %s ... ", test.name)),
te_result(test, result) => {
match st.log_out {
some(f) => write_log(f, result, test),
@ -145,7 +145,7 @@ fn run_tests_console(opts: test_opts,
~[io::Create, io::Truncate]) {
result::ok(w) => some(w),
result::err(s) => {
fail(fmt!{"can't open output file: %s", s})
fail(fmt!("can't open output file: %s", s))
}
},
none => none
@ -170,23 +170,23 @@ fn run_tests_console(opts: test_opts,
print_failures(st);
}
st.out.write_str(fmt!{"\nresult: "});
st.out.write_str(fmt!("\nresult: "));
if success {
// There's no parallelism at this point so it's safe to use color
write_ok(st.out, true);
} else { write_failed(st.out, true); }
st.out.write_str(fmt!{". %u passed; %u failed; %u ignored\n\n", st.passed,
st.failed, st.ignored});
st.out.write_str(fmt!(". %u passed; %u failed; %u ignored\n\n", st.passed,
st.failed, st.ignored));
return success;
fn write_log(out: io::Writer, result: test_result, test: test_desc) {
out.write_line(fmt!{"%s %s",
out.write_line(fmt!("%s %s",
match result {
tr_ok => ~"ok",
tr_failed => ~"failed",
tr_ignored => ~"ignored"
}, test.name});
}, test.name));
}
fn write_ok(out: io::Writer, use_color: bool) {
@ -218,7 +218,7 @@ fn print_failures(st: console_test_state) {
let failures = vec::map(failures, |test| test.name);
let failures = sort::merge_sort(str::le, failures);
for vec::each(failures) |name| {
st.out.write_line(fmt!{" %s", name});
st.out.write_line(fmt!(" %s", name));
}
}
@ -279,7 +279,7 @@ fn run_tests(opts: test_opts, tests: ~[test_desc],
// It's tempting to just spawn all the tests at once, but since we have
// many tests that run in other processes we would be making a big mess.
let concurrency = get_concurrency();
debug!{"using %u test tasks", concurrency};
debug!("using %u test tasks", concurrency);
let total = vec::len(filtered_tests);
let mut run_idx = 0u;

68
src/libstd/time.rs
View file

@ -200,9 +200,9 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
if c == ch {
ok(next)
} else {
err(fmt!{"Expected %?, found %?",
err(fmt!("Expected %?, found %?",
str::from_char(c),
str::from_char(ch)})
str::from_char(ch)))
}
}
@ -511,7 +511,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'%' => parse_char(s, pos, '%'),
ch => {
err(fmt!{"unknown formatting type: %?", str::from_char(ch)})
err(fmt!("unknown formatting type: %?", str::from_char(ch)))
}
}
}
@ -625,70 +625,70 @@ fn strftime(format: ~str, tm: tm) -> ~str {
11 => ~"Dec",
_ => die()
},
'C' => fmt!{"%02d", (tm.tm_year as int + 1900) / 100},
'C' => fmt!("%02d", (tm.tm_year as int + 1900) / 100),
'c' => {
fmt!{"%s %s %s %s %s",
fmt!("%s %s %s %s %s",
parse_type('a', tm),
parse_type('b', tm),
parse_type('e', tm),
parse_type('T', tm),
parse_type('Y', tm)}
parse_type('Y', tm))
}
'D' | 'x' => {
fmt!{"%s/%s/%s",
fmt!("%s/%s/%s",
parse_type('m', tm),
parse_type('d', tm),
parse_type('y', tm)}
parse_type('y', tm))
}
'd' => fmt!{"%02d", tm.tm_mday as int},
'e' => fmt!{"%2d", tm.tm_mday as int},
'd' => fmt!("%02d", tm.tm_mday as int),
'e' => fmt!("%2d", tm.tm_mday as int),
'F' => {
fmt!{"%s-%s-%s",
fmt!("%s-%s-%s",
parse_type('Y', tm),
parse_type('m', tm),
parse_type('d', tm)}
parse_type('d', tm))
}
//'G' {}
//'g' {}
'H' => fmt!{"%02d", tm.tm_hour as int},
'H' => fmt!("%02d", tm.tm_hour as int),
'I' => {
let mut h = tm.tm_hour as int;
if h == 0 { h = 12 }
if h > 12 { h -= 12 }
fmt!{"%02d", h}
fmt!("%02d", h)
}
'j' => fmt!{"%03d", tm.tm_yday as int + 1},
'k' => fmt!{"%2d", tm.tm_hour as int},
'j' => fmt!("%03d", tm.tm_yday as int + 1),
'k' => fmt!("%2d", tm.tm_hour as int),
'l' => {
let mut h = tm.tm_hour as int;
if h == 0 { h = 12 }
if h > 12 { h -= 12 }
fmt!{"%2d", h}
fmt!("%2d", h)
}
'M' => fmt!{"%02d", tm.tm_min as int},
'm' => fmt!{"%02d", tm.tm_mon as int + 1},
'M' => fmt!("%02d", tm.tm_min as int),
'm' => fmt!("%02d", tm.tm_mon as int + 1),
'n' => ~"\n",
'P' => if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" },
'p' => if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" },
'R' => {
fmt!{"%s:%s",
fmt!("%s:%s",
parse_type('H', tm),
parse_type('M', tm)}
parse_type('M', tm))
}
'r' => {
fmt!{"%s:%s:%s %s",
fmt!("%s:%s:%s %s",
parse_type('I', tm),
parse_type('M', tm),
parse_type('S', tm),
parse_type('p', tm)}
parse_type('p', tm))
}
'S' => fmt!{"%02d", tm.tm_sec as int},
's' => fmt!{"%d", tm.to_timespec().sec as int},
'S' => fmt!("%02d", tm.tm_sec as int),
's' => fmt!("%d", tm.to_timespec().sec as int),
'T' | 'X' => {
fmt!{"%s:%s:%s",
fmt!("%s:%s:%s",
parse_type('H', tm),
parse_type('M', tm),
parse_type('S', tm)}
parse_type('S', tm))
}
't' => ~"\t",
//'U' {}
@ -698,24 +698,24 @@ fn strftime(format: ~str, tm: tm) -> ~str {
}
//'V' {}
'v' => {
fmt!{"%s-%s-%s",
fmt!("%s-%s-%s",
parse_type('e', tm),
parse_type('b', tm),
parse_type('Y', tm)}
parse_type('Y', tm))
}
//'W' {}
'w' => int::str(tm.tm_wday as int),
//'X' {}
//'x' {}
'Y' => int::str(tm.tm_year as int + 1900),
'y' => fmt!{"%02d", (tm.tm_year as int + 1900) % 100},
'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
'Z' => tm.tm_zone,
'z' => {
let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
let h = m / 60_i32;
m -= h * 60_i32;
fmt!{"%c%02d%02d", sign, h as int, m as int}
fmt!("%c%02d%02d", sign, h as int, m as int)
}
//'+' {}
'%' => ~"%",
@ -807,7 +807,7 @@ impl tm {
let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
let h = m / 60_i32;
m -= h * 60_i32;
s + fmt!{"%c%02d:%02d", sign, h as int, m as int}
s + fmt!("%c%02d:%02d", sign, h as int, m as int)
}
}
}
@ -888,7 +888,7 @@ mod tests {
let time = { sec: 1234567890_i64, nsec: 54321_i32 };
let local = at(time);
error!{"time_at: %?", local};
error!("time_at: %?", local);
assert local.tm_sec == 30_i32;
assert local.tm_min == 31_i32;
@ -1094,7 +1094,7 @@ mod tests {
let utc = at_utc(time);
let local = at(time);
error!{"test_ctime: %? %?", utc.ctime(), local.ctime()};
error!("test_ctime: %? %?", utc.ctime(), local.ctime());
assert utc.ctime() == ~"Fri Feb 13 23:31:30 2009";
assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";

8
src/libstd/timer.rs
View file

@ -108,8 +108,8 @@ fn recv_timeout<T: copy send>(iotask: iotask,
// FIXME: This could be written clearer (#2618)
either::either(
|left_val| {
log(debug, fmt!{"recv_time .. left_val %?",
left_val});
log(debug, fmt!("recv_time .. left_val %?",
left_val));
none
}, |right_val| {
some(*right_val)
@ -120,7 +120,7 @@ fn recv_timeout<T: copy send>(iotask: iotask,
// INTERNAL API
extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
status: libc::c_int) unsafe {
log(debug, fmt!{"delayed_send_cb handle %? status %?", handle, status});
log(debug, fmt!("delayed_send_cb handle %? status %?", handle, status));
let timer_done_ch =
*(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
let stop_result = uv::ll::timer_stop(handle);
@ -136,7 +136,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
}
extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
log(debug, fmt!{"delayed_send_close_cb handle %?", handle});
log(debug, fmt!("delayed_send_close_cb handle %?", handle));
let timer_done_ch =
*(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
comm::send(timer_done_ch, ());

32
src/libstd/uv_global_loop.rs
View file

@ -37,10 +37,10 @@ fn get_monitor_task_gl() -> iotask unsafe {
let monitor_loop_chan_ptr = rustrt::rust_uv_get_kernel_global_chan_ptr();
debug!{"ENTERING global_loop::get() loop chan: %?",
monitor_loop_chan_ptr};
debug!("ENTERING global_loop::get() loop chan: %?",
monitor_loop_chan_ptr);
debug!{"before priv::chan_from_global_ptr"};
debug!("before priv::chan_from_global_ptr");
type monchan = Chan<iotask>;
let monitor_ch =
@ -50,31 +50,31 @@ fn get_monitor_task_gl() -> iotask unsafe {
(task::SingleThreaded)
.unlinked()
}) |msg_po| {
debug!{"global monitor task starting"};
debug!("global monitor task starting");
// As a weak task the runtime will notify us when to exit
do weaken_task() |weak_exit_po| {
debug!{"global monitor task is now weak"};
debug!("global monitor task is now weak");
let hl_loop = spawn_loop();
loop {
debug!{"in outer_loop..."};
debug!("in outer_loop...");
match select2(weak_exit_po, msg_po) {
Left(weak_exit) => {
// all normal tasks have ended, tell the
// libuv loop to tear_down, then exit
debug!{"weak_exit_po recv'd msg: %?", weak_exit};
debug!("weak_exit_po recv'd msg: %?", weak_exit);
iotask::exit(hl_loop);
break;
}
Right(fetch_ch) => {
debug!{"hl_loop req recv'd: %?", fetch_ch};
debug!("hl_loop req recv'd: %?", fetch_ch);
fetch_ch.send(hl_loop);
}
}
}
debug!{"global monitor task is leaving weakend state"};
debug!("global monitor task is leaving weakend state");
};
debug!{"global monitor task exiting"};
debug!("global monitor task exiting");
};
// once we have a chan to the monitor loop, we ask it for
@ -91,14 +91,14 @@ fn spawn_loop() -> iotask unsafe {
// The I/O loop task also needs to be weak so it doesn't keep
// the runtime alive
do weaken_task |weak_exit_po| {
debug!{"global libuv task is now weak %?", weak_exit_po};
debug!("global libuv task is now weak %?", weak_exit_po);
task_body();
// We don't wait for the exit message on weak_exit_po
// because the monitor task will tell the uv loop when to
// exit
debug!{"global libuv task is leaving weakened state"};
debug!("global libuv task is leaving weakened state");
}
}
};
@ -112,8 +112,8 @@ mod test {
timer_ptr as *libc::c_void) as *comm::Chan<bool>;
let exit_ch = *exit_ch_ptr;
core::comm::send(exit_ch, true);
log(debug, fmt!{"EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
exit_ch_ptr});
log(debug, fmt!("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
exit_ch_ptr));
}
extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t,
_status: libc::c_int) unsafe {
@ -133,8 +133,8 @@ mod test {
let exit_po = core::comm::port::<bool>();
let exit_ch = core::comm::chan(exit_po);
let exit_ch_ptr = ptr::addr_of(exit_ch);
log(debug, fmt!{"EXIT_CH_PTR newly created exit_ch_ptr: %?",
exit_ch_ptr});
log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
exit_ch_ptr));
let timer_handle = ll::timer_t();
let timer_ptr = ptr::addr_of(timer_handle);
do iotask::interact(iotask) |loop_ptr| {

22
src/libstd/uv_iotask.rs
View file

@ -30,9 +30,9 @@ fn spawn_iotask(-task: task::TaskBuilder) -> iotask {
do listen |iotask_ch| {
do task.sched_mode(task::SingleThreaded).spawn {
debug!{"entering libuv task"};
debug!("entering libuv task");
run_loop(iotask_ch);
debug!{"libuv task exiting"};
debug!("libuv task exiting");
};
iotask_ch.recv()
@ -137,8 +137,8 @@ fn send_msg(iotask: iotask,
extern fn wake_up_cb(async_handle: *ll::uv_async_t,
status: int) unsafe {
log(debug, fmt!{"wake_up_cb extern.. handle: %? status: %?",
async_handle, status});
log(debug, fmt!("wake_up_cb extern.. handle: %? status: %?",
async_handle, status));
let loop_ptr = ll::get_loop_for_uv_handle(async_handle);
let data = ll::get_data_for_uv_handle(async_handle) as *iotask_loop_data;
@ -161,22 +161,22 @@ fn begin_teardown(data: *iotask_loop_data) unsafe {
extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
let loop_ptr = ll::get_loop_for_uv_handle(handle);
let loop_refs = ll::loop_refcount(loop_ptr);
log(debug, fmt!{"tear_down_close_cb called, closing handle at %? refs %?",
handle, loop_refs});
log(debug, fmt!("tear_down_close_cb called, closing handle at %? refs %?",
handle, loop_refs));
assert loop_refs == 1i32;
}
#[cfg(test)]
mod test {
extern fn async_close_cb(handle: *ll::uv_async_t) unsafe {
log(debug, fmt!{"async_close_cb handle %?", handle});
log(debug, fmt!("async_close_cb handle %?", handle));
let exit_ch = (*(ll::get_data_for_uv_handle(handle)
as *ah_data)).exit_ch;
core::comm::send(exit_ch, ());
}
extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int)
unsafe {
log(debug, fmt!{"async_handle_cb handle %? status %?",handle,status});
log(debug, fmt!("async_handle_cb handle %? status %?",handle,status));
ll::close(handle, async_close_cb);
}
type ah_data = {
@ -214,13 +214,13 @@ mod test {
}
extern fn lifetime_handle_close(handle: *libc::c_void) unsafe {
log(debug, fmt!{"lifetime_handle_close ptr %?", handle});
log(debug, fmt!("lifetime_handle_close ptr %?", handle));
}
extern fn lifetime_async_callback(handle: *libc::c_void,
status: libc::c_int) {
log(debug, fmt!{"lifetime_handle_close ptr %? status %?",
handle, status});
log(debug, fmt!("lifetime_handle_close ptr %? status %?",
handle, status));
}
#[test]

168
src/libstd/uv_ll.rs
View file

@ -707,8 +707,8 @@ unsafe fn tcp_connect(connect_ptr: *uv_connect_t,
addr_ptr: *sockaddr_in,
++after_connect_cb: *u8)
-> libc::c_int {
log(debug, fmt!{"b4 foreign tcp_connect--addr port: %u cb: %u",
(*addr_ptr).sin_port as uint, after_connect_cb as uint});
log(debug, fmt!("b4 foreign tcp_connect--addr port: %u cb: %u",
(*addr_ptr).sin_port as uint, after_connect_cb as uint));
return rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr,
after_connect_cb, addr_ptr);
}
@ -788,10 +788,10 @@ unsafe fn async_send(async_handle: *uv_async_t) {
unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
let out_buf_ptr = ptr::addr_of(out_buf);
log(debug, fmt!{"buf_init - input %u len %u out_buf: %u",
log(debug, fmt!("buf_init - input %u len %u out_buf: %u",
input as uint,
len as uint,
out_buf_ptr as uint});
out_buf_ptr as uint));
// yuck :/
rustrt::rust_uv_buf_init(out_buf_ptr, input, len as size_t);
//let result = rustrt::rust_uv_buf_init_2(input, len as size_t);
@ -799,9 +799,9 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
let res_base = get_base_from_buf(out_buf);
let res_len = get_len_from_buf(out_buf);
//let res_base = get_base_from_buf(result);
log(debug, fmt!{"buf_init - result %u len %u",
log(debug, fmt!("buf_init - result %u len %u",
res_base as uint,
res_len as uint});
res_len as uint));
return out_buf;
//return result;
}
@ -845,8 +845,8 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
0u8,0u8,0u8,0u8,0u8,0u8];
do vec::as_buf(dst) |dst_buf, size| {
let src_unsafe_ptr = assimilate(src);
log(debug, fmt!{"val of src *sockaddr_in6: %? sockaddr_in6: %?",
src_unsafe_ptr, src});
log(debug, fmt!("val of src *sockaddr_in6: %? sockaddr_in6: %?",
src_unsafe_ptr, src));
let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
dst_buf, size as libc::size_t);
match result {
@ -962,8 +962,8 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
let err_ptr = ptr::addr_of(err);
let err_name = str::unsafe::from_c_str(err_name(err_ptr));
let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
return fmt!{"LIBUV ERROR: name: %s msg: %s",
err_name, err_msg};
return fmt!("LIBUV ERROR: name: %s msg: %s",
err_name, err_msg);
}
unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
@ -1013,8 +1013,8 @@ mod test {
};
extern fn after_close_cb(handle: *libc::c_void) {
log(debug, fmt!{"after uv_close! handle ptr: %?",
handle});
log(debug, fmt!("after uv_close! handle ptr: %?",
handle));
}
extern fn on_alloc_cb(handle: *libc::c_void,
@ -1022,10 +1022,10 @@ mod test {
-> uv_buf_t unsafe {
log(debug, ~"on_alloc_cb!");
let char_ptr = malloc_buf_base_of(suggested_size);
log(debug, fmt!{"on_alloc_cb h: %? char_ptr: %u sugsize: %u",
log(debug, fmt!("on_alloc_cb h: %? char_ptr: %u sugsize: %u",
handle,
char_ptr as uint,
suggested_size as uint});
suggested_size as uint));
return buf_init(char_ptr, suggested_size as uint);
}
@ -1033,11 +1033,11 @@ mod test {
nread: libc::ssize_t,
++buf: uv_buf_t) unsafe {
let nread = nread as int;
log(debug, fmt!{"CLIENT entering on_read_cb nred: %d",
nread});
log(debug, fmt!("CLIENT entering on_read_cb nred: %d",
nread));
if (nread > 0) {
// we have data
log(debug, fmt!{"CLIENT read: data! nread: %d", nread});
log(debug, fmt!("CLIENT read: data! nread: %d", nread));
read_stop(stream);
let client_data =
get_data_for_uv_handle(stream as *libc::c_void)
@ -1065,20 +1065,20 @@ mod test {
extern fn on_write_complete_cb(write_req: *uv_write_t,
status: libc::c_int) unsafe {
log(debug, fmt!{"CLIENT beginning on_write_complete_cb status: %d",
status as int});
log(debug, fmt!("CLIENT beginning on_write_complete_cb status: %d",
status as int));
let stream = get_stream_handle_from_write_req(write_req);
log(debug, fmt!{"CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
stream as int, write_req as int});
log(debug, fmt!("CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
stream as int, write_req as int));
let result = read_start(stream, on_alloc_cb, on_read_cb);
log(debug, fmt!{"CLIENT ending on_write_complete_cb .. status: %d",
result as int});
log(debug, fmt!("CLIENT ending on_write_complete_cb .. status: %d",
result as int));
}
extern fn on_connect_cb(connect_req_ptr: *uv_connect_t,
status: libc::c_int) unsafe {
log(debug, fmt!{"beginning on_connect_cb .. status: %d",
status as int});
log(debug, fmt!("beginning on_connect_cb .. status: %d",
status as int));
let stream =
get_stream_handle_from_connect_req(connect_req_ptr);
if (status == 0i32) {
@ -1087,14 +1087,14 @@ mod test {
connect_req_ptr as *libc::c_void)
as *request_wrapper;
let write_handle = (*client_data).write_req;
log(debug, fmt!{"on_connect_cb: tcp: %d write_hdl: %d",
stream as int, write_handle as int});
log(debug, fmt!("on_connect_cb: tcp: %d write_hdl: %d",
stream as int, write_handle as int));
let write_result = write(write_handle,
stream as *libc::c_void,
(*client_data).req_buf,
on_write_complete_cb);
log(debug, fmt!{"on_connect_cb: write() status: %d",
write_result as int});
log(debug, fmt!("on_connect_cb: write() status: %d",
write_result as int));
}
else {
let test_loop = get_loop_for_uv_handle(
@ -1121,7 +1121,7 @@ mod test {
// data field in our uv_connect_t struct
let req_str_bytes = str::bytes(req_str);
let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
log(debug, fmt!{"req_msg ptr: %u", req_msg_ptr as uint});
log(debug, fmt!("req_msg ptr: %u", req_msg_ptr as uint));
let req_msg = ~[
buf_init(req_msg_ptr, vec::len(req_str_bytes))
];
@ -1129,9 +1129,9 @@ mod test {
// this to C..
let write_handle = write_t();
let write_handle_ptr = ptr::addr_of(write_handle);
log(debug, fmt!{"tcp req: tcp stream: %d write_handle: %d",
log(debug, fmt!("tcp req: tcp stream: %d write_handle: %d",
tcp_handle_ptr as int,
write_handle_ptr as int});
write_handle_ptr as int));
let client_data = { writer_handle: write_handle_ptr,
req_buf: ptr::addr_of(req_msg),
read_chan: client_chan };
@ -1145,12 +1145,12 @@ mod test {
let addr = ip4_addr(ip, port);
// FIXME ref #2064
let addr_ptr = ptr::addr_of(addr);
log(debug, fmt!{"after build addr in rust. port: %u",
addr.sin_port as uint});
log(debug, fmt!("after build addr in rust. port: %u",
addr.sin_port as uint));
// this should set up the connection request..
log(debug, fmt!{"b4 call tcp_connect connect cb: %u ",
on_connect_cb as uint});
log(debug, fmt!("b4 call tcp_connect connect cb: %u ",
on_connect_cb as uint));
let tcp_connect_result = tcp_connect(
connect_req_ptr, tcp_handle_ptr,
addr_ptr, on_connect_cb);
@ -1181,8 +1181,8 @@ mod test {
}
extern fn server_after_close_cb(handle: *libc::c_void) unsafe {
log(debug, fmt!{"SERVER server stream closed, should exit.. h: %?",
handle});
log(debug, fmt!("SERVER server stream closed, should exit.. h: %?",
handle));
}
extern fn client_stream_after_close_cb(handle: *libc::c_void)
@ -1210,15 +1210,15 @@ mod test {
let nread = nread as int;
if (nread > 0) {
// we have data
log(debug, fmt!{"SERVER read: data! nread: %d", nread});
log(debug, fmt!("SERVER read: data! nread: %d", nread));
// pull out the contents of the write from the client
let buf_base = get_base_from_buf(buf);
let buf_len = get_len_from_buf(buf) as uint;
log(debug, fmt!{"SERVER buf base: %u, len: %u, nread: %d",
log(debug, fmt!("SERVER buf base: %u, len: %u, nread: %d",
buf_base as uint,
buf_len as uint,
nread});
nread));
let bytes = vec::unsafe::from_buf(buf_base, buf_len);
let request_str = str::from_bytes(bytes);
@ -1238,8 +1238,8 @@ mod test {
client_stream_ptr as *libc::c_void,
(*client_data).server_resp_buf,
after_server_resp_write);
log(debug, fmt!{"SERVER: resp write result: %d",
write_result as int});
log(debug, fmt!("SERVER: resp write result: %d",
write_result as int));
if (write_result != 0i32) {
log(debug, ~"bad result for server resp write()");
log(debug, get_last_err_info(
@ -1273,8 +1273,8 @@ mod test {
server_stream_ptr as *libc::c_void);
if status != 0i32 {
let err_msg = get_last_err_info(test_loop);
log(debug, fmt!{"server_connect_cb: non-zero status: %?",
err_msg});
log(debug, fmt!("server_connect_cb: non-zero status: %?",
err_msg));
return;
}
let server_data = get_data_for_uv_handle(
@ -1301,20 +1301,20 @@ mod test {
log(debug, ~"successful server read start");
}
else {
log(debug, fmt!{"server_connection_cb: bad read:%d",
read_result as int});
log(debug, fmt!("server_connection_cb: bad read:%d",
read_result as int));
assert false;
}
}
else {
log(debug, fmt!{"server_connection_cb: bad accept: %d",
accept_result as int});
log(debug, fmt!("server_connection_cb: bad accept: %d",
accept_result as int));
assert false;
}
}
else {
log(debug, fmt!{"server_connection_cb: bad client init: %d",
client_init_result as int});
log(debug, fmt!("server_connection_cb: bad client init: %d",
client_init_result as int));
assert false;
}
}
@ -1333,8 +1333,8 @@ mod test {
};
extern fn async_close_cb(handle: *libc::c_void) {
log(debug, fmt!{"SERVER: closing async cb... h: %?",
handle});
log(debug, fmt!("SERVER: closing async cb... h: %?",
handle));
}
extern fn continue_async_cb(async_handle: *uv_async_t,
@ -1369,7 +1369,7 @@ mod test {
let resp_str_bytes = str::bytes(server_resp_msg);
let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
log(debug, fmt!{"resp_msg ptr: %u", resp_msg_ptr as uint});
log(debug, fmt!("resp_msg ptr: %u", resp_msg_ptr as uint));
let resp_msg = ~[
buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
];
@ -1428,26 +1428,26 @@ mod test {
log(debug, ~"server uv::run() has returned");
}
else {
log(debug, fmt!{"uv_async_init failure: %d",
async_result as int});
log(debug, fmt!("uv_async_init failure: %d",
async_result as int));
assert false;
}
}
else {
log(debug, fmt!{"non-zero result on uv_listen: %d",
listen_result as int});
log(debug, fmt!("non-zero result on uv_listen: %d",
listen_result as int));
assert false;
}
}
else {
log(debug, fmt!{"non-zero result on uv_tcp_bind: %d",
bind_result as int});
log(debug, fmt!("non-zero result on uv_tcp_bind: %d",
bind_result as int));
assert false;
}
}
else {
log(debug, fmt!{"non-zero result on uv_tcp_init: %d",
tcp_init_result as int});
log(debug, fmt!("non-zero result on uv_tcp_init: %d",
tcp_init_result as int));
assert false;
}
loop_delete(test_loop);
@ -1524,8 +1524,8 @@ mod test {
fn test_uv_ll_struct_size_uv_tcp_t() {
let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
let rust_handle_size = sys::size_of::<uv_tcp_t>();
let output = fmt!{"uv_tcp_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_tcp_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1535,8 +1535,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_connect_t_size();
let rust_handle_size = sys::size_of::<uv_connect_t>();
let output = fmt!{"uv_connect_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_connect_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1546,8 +1546,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_buf_t_size();
let rust_handle_size = sys::size_of::<uv_buf_t>();
let output = fmt!{"uv_buf_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_buf_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1557,8 +1557,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_write_t_size();
let rust_handle_size = sys::size_of::<uv_write_t>();
let output = fmt!{"uv_write_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_write_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1569,8 +1569,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_sockaddr_in_size();
let rust_handle_size = sys::size_of::<sockaddr_in>();
let output = fmt!{"sockaddr_in -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("sockaddr_in -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1580,8 +1580,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_sockaddr_in6_size();
let rust_handle_size = sys::size_of::<sockaddr_in6>();
let output = fmt!{"sockaddr_in6 -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("sockaddr_in6 -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
// FIXME #1645 .. rust appears to pad structs to the nearest byte..?
// .. can't get the uv::ll::sockaddr_in6 to == 28 :/
@ -1595,8 +1595,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_addr_in_size();
let rust_handle_size = sys::size_of::<addr_in>();
let output = fmt!{"addr_in -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("addr_in -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
// FIXME #1645 .. see note above about struct padding
assert (4u+foreign_handle_size as uint) == rust_handle_size;
@ -1608,8 +1608,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_async_t_size();
let rust_handle_size = sys::size_of::<uv_async_t>();
let output = fmt!{"uv_async_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_async_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1620,8 +1620,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_timer_t_size();
let rust_handle_size = sys::size_of::<uv_timer_t>();
let output = fmt!{"uv_timer_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_timer_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1633,8 +1633,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_uv_getaddrinfo_t_size();
let rust_handle_size = sys::size_of::<uv_getaddrinfo_t>();
let output = fmt!{"uv_getaddrinfo_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("uv_getaddrinfo_t -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}
@ -1646,8 +1646,8 @@ mod test {
let foreign_handle_size =
rustrt::rust_uv_helper_addrinfo_size();
let rust_handle_size = sys::size_of::<addrinfo>();
let output = fmt!{"addrinfo -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size};
let output = fmt!("addrinfo -- foreign: %u rust: %u",
foreign_handle_size as uint, rust_handle_size);
log(debug, output);
assert foreign_handle_size as uint == rust_handle_size;
}