// Type encoding
+import std::istr;
import std::io;
import std::map::hashmap;
import std::option::some;
// I.e. it's actually an abbreviation.
let s =
- "#" + uint::to_str(pos, 16u) + ":" +
- uint::to_str(len, 16u) + "#";
- let a = {pos: pos, len: len, s: s};
+ ~"#" + uint::to_str(pos, 16u) + ~":" +
+ uint::to_str(len, 16u) + ~"#";
+ let a = {pos: pos, len: len, s: istr::to_estr(s)};
abbrevs.insert(t, a);
}
ret;
kind_shared. { w.write_str("ps"); }
kind_pinned. { w.write_str("pp"); }
}
- w.write_str(uint::str(id));
+ w.write_str(istr::to_estr(uint::str(id)));
}
ty::ty_type. { w.write_char('Y'); }
ty::ty_constr(ty, cs) {
// int) and rec(x=int, y=int, z=int) will have the same TypeRef.
import std::int;
import std::str;
+import std::istr;
import std::uint;
import std::str::rustrt::sbuf;
import std::map;
} else {
bcx_tcx(cx).sess.span_bug(cx.sp,
"Unbound typaram in get_tydesc: " +
- "orig_t = " +
- ty_to_str(bcx_tcx(cx), orig_t) +
- " ty_param = " +
- std::uint::str(id));
+ "orig_t = " +
+ ty_to_str(bcx_tcx(cx), orig_t) +
+ " ty_param = " +
+ istr::to_estr(std::uint::str(id)));
}
}
none. {/* fall through */ }
for variant: ty::variant_info in variants {
let variant_cx =
new_sub_block_ctxt(bcx,
- "tag-iter-variant-" +
- uint::to_str(i, 10u));
+ istr::to_estr(~"tag-iter-variant-" +
+ uint::to_str(i, 10u)));
llvm::LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb);
variant_cx =
iter_variant(variant_cx, llunion_a_ptr, variant, tps, tid,
fn_args +=
[{mode: ast::alias(false),
ty: varg.ty,
- ident: "arg" + uint::to_str(i, 10u),
+ ident: istr::to_estr(~"arg" + uint::to_str(i, 10u)),
id: varg.id}];
}
assert (cx.ccx.item_ids.contains_key(variant.node.id));
import std::int;
import std::vec;
import std::str;
+import std::istr;
import std::uint;
import std::str::rustrt::sbuf;
import std::map;
}
fn T_tag(tn: &type_names, size: uint) -> TypeRef {
- let s = "tag_" + uint::to_str(size, 10u);
+ let s = "tag_" + istr::to_estr(uint::to_str(size, 10u));
if tn.name_has_type(s) { ret tn.get_type(s); }
let t = T_struct([T_int(), T_array(T_i8(), size)]);
tn.associate(s, t);
import std::option::none;
import std::int;
import std::uint;
+import std::istr;
import syntax::ast::*;
import syntax::ast_util::pat_binding_ids;
import syntax::visit;
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 int::str(i) + " |-> " + istr::to_estr(uint::str(len));
add_node(ccx, i, empty_ann(len));
}
}
import std::vec;
import std::int::str;
import std::str;
+import std::istr;
import std::option;
import std::option::*;
import std::int;
}
fn pred_args_to_str(p: &pred_args) -> str {
- "<" + uint::str(p.node.bit_num) + ", " +
+ "<" + istr::to_estr(uint::str(p.node.bit_num)) + ", " +
constr_args_to_str(fn (i: &inst) -> str { ret i.ident; }, p.node.args)
+ ">"
}
+import std::istr;
import std::uint;
import std::int;
import std::vec;
fn add_constraint(tcx: &ty::ctxt, c: sp_constr, next: uint, tbl: constr_map)
-> uint {
- log constraint_to_str(tcx, c) + " |-> " + std::uint::str(next);
+ log constraint_to_str(tcx, c) + " |-> "
+ + istr::to_estr(std::uint::str(next));
alt c.node {
ninit(id, i) { tbl.insert(local_def(id), cinit(next, c.span, i)); }
npred(p, d_id, args) {
i_diverge: ninit(diverges_id, diverges_name),
used_vars: v};
ccx.fm.insert(id, rslt);
- log name + " has " + std::uint::str(num_constraints(rslt)) +
- " constraints";
+ log name + istr::to_estr(~" has "
+ + std::uint::str(num_constraints(rslt))
+ + ~" constraints");
}
import std::int;
import std::vec;
import std::str;
+import std::istr;
import std::uint;
import std::box;
import std::ufind;
terr_box_mutability. { ret "boxed values differ in mutability"; }
terr_vec_mutability. { ret "vectors differ in mutability"; }
terr_tuple_size(e_sz, a_sz) {
- ret "expected a tuple with " + uint::to_str(e_sz, 10u) +
- " elements but found one with " + uint::to_str(a_sz, 10u) +
- " elements";
+ ret istr::to_estr(~"expected a tuple with " +
+ uint::to_str(e_sz, 10u) +
+ ~" elements but found one with " +
+ uint::to_str(a_sz, 10u) +
+ ~" elements");
}
terr_record_size(e_sz, a_sz) {
- ret "expected a record with " + uint::to_str(e_sz, 10u) +
- " fields but found one with " + uint::to_str(a_sz, 10u) +
- " fields";
+ ret istr::to_estr(~"expected a record with " +
+ uint::to_str(e_sz, 10u) +
+ ~" fields but found one with " +
+ uint::to_str(a_sz, 10u) +
+ ~" fields");
}
terr_record_mutability. { ret "record elements differ in mutability"; }
terr_record_fields(e_fld, a_fld) {
mode_str_1(a_mode);
}
terr_constr_len(e_len, a_len) {
- ret "Expected a type with " + uint::str(e_len) +
- " constraints, \
- but found one with " +
- uint::str(a_len) + " constraints";
+ ret istr::to_estr(~"Expected a type with " +
+ uint::str(e_len) +
+ ~" constraints, but found one with " +
+ uint::str(a_len) + ~" constraints");
}
terr_constr_mismatch(e_constr, a_constr) {
ret "Expected a type with constraint " + ty_constr_to_str(e_constr) +
import std::int;
import std::uint;
import std::str;
+import std::istr;
type str_num = uint;
LIT_INT(i) {
ret int::to_str(i, 10u);
}
- LIT_UINT(u) { ret uint::to_str(u, 10u); }
+ LIT_UINT(u) { ret istr::to_estr(uint::to_str(u, 10u)); }
LIT_MACH_INT(tm, i) {
ret int::to_str(i, 10u) + "_" + ty_mach_to_str(tm);
}
import std::int;
import std::io;
import std::str;
+import std::istr;
import std::uint;
import std::option;
import parse::lexer;
"'");
}
ast::lit_int(val) { word(s.s, int::str(val)); }
- ast::lit_uint(val) { word(s.s, uint::str(val) + "u"); }
+ ast::lit_uint(val) { word(s.s, istr::to_estr(uint::str(val)) + "u"); }
ast::lit_float(fstr) { word(s.s, fstr); }
ast::lit_mach_int(mach, val) {
word(s.s, int::str(val as int));
// needed b/c constr_args_to_str needs
// something that takes an alias
// (argh)
-fn uint_to_str(i: &uint) -> str { ret uint::str(i); }
+fn uint_to_str(i: &uint) -> str { ret istr::to_estr(uint::str(i)); }
fn ast_ty_fn_constr_to_str(c: &@ast::constr) -> str {
ret path_to_str(c.node.path) +
import std::str;
+import std::istr;
import std::map;
import std::map::hashmap;
import std::uint;
let accum = if num < 0.0 { num = -num; "-" } else { "" };
let trunc = num as uint;
let frac = num - (trunc as float);
- accum += uint::str(trunc);
+ accum += istr::to_estr(uint::str(trunc));
if frac == 0.0 || digits == 0u { ret accum; }
accum += ".";
while digits > 0u && frac > 0.0 {
frac *= 10.0;
let digit = frac as uint;
- accum += uint::str(digit);
+ accum += istr::to_estr(uint::str(digit));
frac -= digit as float;
digits -= 1u;
}
alt maybe_get_doc(d, tg) {
some(d) { ret d; }
none. {
- log_err "failed to find block with tag " + uint::to_str(tg, 10u);
+ log_err "failed to find block with tag "
+ + istr::to_estr(uint::to_str(tg, 10u));
fail;
}
}
ret if prec == 0u && num == 0u {
""
} else {
- let s = uint::to_str(num, radix);
+ let s = istr::to_estr(uint::to_str(num, radix));
let len = str::char_len(s);
if len < prec {
let diff = prec - len;
fn to_str(n: int, radix: uint) -> str {
assert (0u < radix && radix <= 16u);
ret if n < 0 {
- "-" + uint::to_str(-n as uint, radix)
- } else { uint::to_str(n as uint, radix) };
+ "-" + istr::to_estr(uint::to_str(-n as uint, radix))
+ } else { istr::to_estr(uint::to_str(n as uint, radix)) };
}
fn str(i: int) -> str { ret to_str(i, 10u); }
out.write(str::bytes(str::from_char(ch)));
}
fn write_int(n: int) { out.write(str::bytes(int::to_str(n, 10u))); }
- fn write_uint(n: uint) { out.write(str::bytes(uint::to_str(n, 10u))); }
+ fn write_uint(n: uint) { out.write(str::bytes(
+ istr::to_estr(uint::to_str(n, 10u)))); }
fn write_bytes(bytes: &[u8]) { out.write(bytes); }
fn write_le_uint(n: uint, size: uint) {
out.write(uint_to_le_bytes(n, size));
index, rindex, find, starts_with, ends_with, substr, slice, split,
concat, connect, to_upper, replace, char_slice, trim_left, trim_right, trim,
unshift_char, shift_char, pop_char, push_char, is_utf8, from_chars, to_chars,
-char_len, char_at, bytes, is_ascii, shift_byte, pop_byte, unsafe_from_bytes;
+char_len, char_at, bytes, is_ascii, shift_byte, pop_byte, unsafe_from_byte,
+unsafe_from_bytes;
export from_estr, to_estr;
}
fn parse_addr(ip: str) -> ip_addr {
- let parts = vec::map(uint::from_str, str::split(ip, "."[0]));
+ let parts = vec::map(
+ { |&s| uint::from_str(istr::from_estr(s)) },
+ str::split(ip, "."[0]));
if vec::len(parts) != 4u { fail "Too many dots in IP address"; }
for i in parts { if i > 255u { fail "Invalid IP Address part."; } }
ipv4(parts[0] as u8, parts[1] as u8, parts[2] as u8, parts[3] as u8)
fn result_str() -> str {
let r = mk_result(st);
let s = "";
- for b: u8 in r { s += uint::to_str(b as uint, 16u); }
+ for b: u8 in r {
+ s += istr::to_estr(uint::to_str(b as uint, 16u));
+ }
ret s;
}
}
fail;
}
-fn from_str(s: &str) -> uint { parse_buf(str::bytes(s), 10u) }
+fn from_str(s: &istr) -> uint { parse_buf(istr::bytes(s), 10u) }
-fn to_str(num: uint, radix: uint) -> str {
+fn to_str(num: uint, radix: uint) -> istr {
let n = num;
assert (0u < radix && radix <= 16u);
fn digit(n: uint) -> char {
_ { fail }
};
}
- if n == 0u { ret "0"; }
- let s: str = "";
+ if n == 0u { ret ~"0"; }
+ let s: istr = ~"";
while n != 0u {
- s += str::unsafe_from_byte(digit(n % radix) as u8);
+ s += istr::unsafe_from_byte(digit(n % radix) as u8);
n /= radix;
}
- let s1: str = "";
- let len: uint = str::byte_len(s);
- while len != 0u { len -= 1u; s1 += str::unsafe_from_byte(s[len]); }
+ let s1: istr = ~"";
+ let len: uint = istr::byte_len(s);
+ while len != 0u { len -= 1u; s1 += istr::unsafe_from_byte(s[len]); }
ret s1;
}
-fn str(i: uint) -> str { ret to_str(i, 10u); }
+fn str(i: uint) -> istr { ret to_str(i, 10u); }
// Local Variables:
// mode: rust;
use std;
import std::map;
import std::str;
+import std::istr;
import std::uint;
import std::util;
import std::option;
let i: uint = 0u;
while i < num_to_insert {
assert (hm_uu.insert(i, i * i));
- log "inserting " + uint::to_str(i, 10u) + " -> " +
+ log ~"inserting " + uint::to_str(i, 10u) + ~" -> " +
uint::to_str(i * i, 10u);
i += 1u;
}
log "-----";
i = 0u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i);
i += 1u;
hm_uu.rehash();
i = 0u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i);
i += 1u;
map::mk_hashmap::<str, str>(hasher_str, eqer_str);
i = 0u;
while i < num_to_insert {
- assert (hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)));
- log "inserting \"" + uint::to_str(i, 2u) + "\" -> \"" +
- uint::to_str(i * i, 2u) + "\"";
+ assert (hm_ss.insert(istr::to_estr(uint::to_str(i, 2u)),
+ istr::to_estr(uint::to_str(i * i, 2u))));
+ log ~"inserting \"" + uint::to_str(i, 2u) + ~"\" -> \"" +
+ uint::to_str(i * i, 2u) + ~"\"";
i += 1u;
}
log "-----";
i = 0u;
while i < num_to_insert {
- log "get(\"" + uint::to_str(i, 2u) + "\") = \"" +
- hm_ss.get(uint::to_str(i, 2u)) + "\"";
- assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
- uint::to_str(i * i, 2u)));
+ log "get(\"" + istr::to_estr(uint::to_str(i, 2u)) + "\") = \"" +
+ hm_ss.get(istr::to_estr(uint::to_str(i, 2u))) + "\"";
+ assert (str::eq(hm_ss.get(istr::to_estr(uint::to_str(i, 2u))),
+ istr::to_estr(uint::to_str(i * i, 2u))));
i += 1u;
}
- assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
- uint::to_str(17u, 2u)));
- assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)),
- uint::to_str(17u, 2u)));
+ assert (hm_ss.insert(istr::to_estr(uint::to_str(num_to_insert, 2u)),
+ istr::to_estr(uint::to_str(17u, 2u))));
+ assert (str::eq(hm_ss.get(
+ istr::to_estr(uint::to_str(num_to_insert, 2u))),
+ istr::to_estr(uint::to_str(17u, 2u))));
log "-----";
hm_ss.rehash();
i = 0u;
while i < num_to_insert {
- log "get(\"" + uint::to_str(i, 2u) + "\") = \"" +
- hm_ss.get(uint::to_str(i, 2u)) + "\"";
- assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
- uint::to_str(i * i, 2u)));
+ log "get(\"" + istr::to_estr(uint::to_str(i, 2u)) + "\") = \"" +
+ hm_ss.get(istr::to_estr(uint::to_str(i, 2u))) + "\"";
+ assert (str::eq(hm_ss.get(istr::to_estr(uint::to_str(i, 2u))),
+ istr::to_estr(uint::to_str(i * i, 2u))));
i += 1u;
}
log "*** finished test_growth";
let i: uint = 0u;
while i < num_to_insert {
assert (hm.insert(i, i * i));
- log "inserting " + uint::to_str(i, 10u) + " -> " +
+ log ~"inserting " + uint::to_str(i, 10u) + ~" -> " +
uint::to_str(i * i, 10u);
i += 1u;
}
log "-----";
i = 1u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 2u;
log "-----";
i = 1u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 2u;
i = 0u;
while i < num_to_insert {
assert (hm.insert(i, i * i));
- log "inserting " + uint::to_str(i, 10u) + " -> " +
+ log ~"inserting " + uint::to_str(i, 10u) + ~" -> " +
uint::to_str(i * i, 10u);
i += 2u;
}
log "-----";
i = 0u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 1u;
assert (hm.size() == num_to_insert);
i = 0u;
while i < num_to_insert {
- log "get(" + uint::to_str(i, 10u) + ") = " +
+ log ~"get(" + uint::to_str(i, 10u) + ~") = " +
uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i);
i += 1u;