OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add mutability annotations to libcore

Browse Source
This commit is contained in:
Niko Matsakis 2012-03-06 20:48:40 -08:00
parent 674587cfe5
commit 713006c7b6
22 changed files with 204 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libcore/comm.rs
View File

@ -180,7 +180,7 @@ fn select2<A: send, B: send>(
rustrt::rust_port_select(dptr, ports, n_ports, yield)
}
let ports = [];
let mut ports = [];
ports += [***p_a, ***p_b];
let n_ports = 2 as ctypes::size_t;
let yield = 0u;

8
src/libcore/either.rs
View File

@ -40,7 +40,7 @@ Function: lefts
Extracts from a vector of either all the left values.
*/
fn lefts<T: copy, U>(eithers: [t<T, U>]) -> [T] {
let result: [T] = [];
let mut result: [T] = [];
for elt: t<T, U> in eithers {
alt elt { left(l) { result += [l]; } _ {/* fallthrough */ } }
}
@ -53,7 +53,7 @@ Function: rights
Extracts from a vector of either all the right values
*/
fn rights<T, U: copy>(eithers: [t<T, U>]) -> [U] {
let result: [U] = [];
let mut result: [U] = [];
for elt: t<T, U> in eithers {
alt elt { right(r) { result += [r]; } _ {/* fallthrough */ } }
}
@ -70,8 +70,8 @@ right values.
*/
fn partition<T: copy, U: copy>(eithers: [t<T, U>])
-> {lefts: [T], rights: [U]} {
let lefts: [T] = [];
let rights: [U] = [];
let mut lefts: [T] = [];
let mut rights: [U] = [];
for elt: t<T, U> in eithers {
alt elt { left(l) { lefts += [l]; } right(r) { rights += [r]; } }
}

50
src/libcore/extfmt.rs
View File

@ -81,9 +81,9 @@ mod ct {
type error_fn = fn@(str) -> ! ;
fn parse_fmt_string(s: str, error: error_fn) -> [piece] unsafe {
let pieces: [piece] = [];
let mut pieces: [piece] = [];
let lim = str::len(s);
let buf = "";
let mut buf = "";
fn flush_buf(buf: str, &pieces: [piece]) -> str {
if str::len(buf) > 0u {
let piece = piece_string(buf);
@ -91,7 +91,7 @@ mod ct {
}
ret "";
}
let i = 0u;
let mut i = 0u;
while i < lim {
let curr = str::slice(s, i, i+1u);
if str::eq(curr, "%") {
@ -285,7 +285,7 @@ mod rt {
fn conv_int(cv: conv, i: int) -> str {
let radix = 10u;
let prec = get_int_precision(cv);
let s = int_to_str_prec(i, radix, prec);
let mut s = int_to_str_prec(i, radix, prec);
if 0 <= i {
if have_flag(cv.flags, flag_sign_always) {
s = "+" + s;
@ -335,7 +335,7 @@ mod rt {
count_is(c) { (float::to_str_exact, c as uint) }
count_implied { (float::to_str, 6u) }
};
let s = to_str(f, digits);
let mut s = to_str(f, digits);
if 0.0 <= f {
if have_flag(cv.flags, flag_sign_always) {
s = "+" + s;
@ -389,42 +389,38 @@ mod rt {
}
enum pad_mode { pad_signed, pad_unsigned, pad_nozero, }
fn pad(cv: conv, s: str, mode: pad_mode) -> str unsafe {
let uwidth;
alt cv.width {
let uwidth = alt cv.width {
count_implied { ret s; }
count_is(width) {
// FIXME: Maybe width should be uint
uwidth = width as uint;
width as uint
}
}
};
let strlen = str::char_len(s);
if uwidth <= strlen { ret s; }
let padchar = ' ';
let mut padchar = ' ';
let diff = uwidth - strlen;
if have_flag(cv.flags, flag_left_justify) {
let padstr = str_init_elt(diff, padchar);
ret s + padstr;
}
let might_zero_pad = false;
let signed = false;
alt mode {
pad_nozero {
// fallthrough
}
pad_signed { might_zero_pad = true; signed = true; }
pad_unsigned { might_zero_pad = true; }
}
let {might_zero_pad, signed} = alt mode {
pad_nozero { {might_zero_pad:false, signed:false} }
pad_signed { {might_zero_pad:true, signed:true } }
pad_unsigned { {might_zero_pad:true, signed:false} }
};
fn have_precision(cv: conv) -> bool {
ret alt cv.precision { count_implied { false } _ { true } };
}
let zero_padding = false;
if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
!have_precision(cv) {
padchar = '0';
zero_padding = true;
}
let zero_padding = {
if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
!have_precision(cv) {
padchar = '0';
true
} else {
false
}
};
let padstr = str_init_elt(diff, padchar);
// This is completely heinous. If we have a signed value then
// potentially rip apart the intermediate result and insert some

32
src/libcore/float.rs
View File

@ -49,14 +49,14 @@ exact - Whether to enforce the exact number of significant digits
*/
fn to_str_common(num: float, digits: uint, exact: bool) -> str {
if is_NaN(num) { ret "NaN"; }
let (num, accum) = if num < 0.0 { (-num, "-") } else { (num, "") };
let mut (num, accum) = if num < 0.0 { (-num, "-") } else { (num, "") };
let trunc = num as uint;
let frac = num - (trunc as float);
let mut frac = num - (trunc as float);
accum += uint::str(trunc);
if (frac < epsilon && !exact) || digits == 0u { ret accum; }
accum += ".";
let i = digits;
let epsilon = 1. / pow_with_uint(10u, i);
let mut i = digits;
let mut epsilon = 1. / pow_with_uint(10u, i);
while i > 0u && (frac >= epsilon || exact) {
frac *= 10.0;
epsilon *= 10.0;
@ -132,13 +132,13 @@ Otherwise, some(n) where n is the floating-point
number represented by [num].
*/
fn from_str(num: str) -> option<float> {
let pos = 0u; //Current byte position in the string.
//Used to walk the string in O(n).
let len = str::len(num); //Length of the string, in bytes.
let mut pos = 0u; //Current byte position in the string.
//Used to walk the string in O(n).
let len = str::len(num); //Length of the string, in bytes.
if len == 0u { ret none; }
let total = 0f; //Accumulated result
let c = 'z'; //Latest char.
let mut total = 0f; //Accumulated result
let mut c = 'z'; //Latest char.
//The string must start with one of the following characters.
alt str::char_at(num, 0u) {
@ -147,7 +147,7 @@ fn from_str(num: str) -> option<float> {
}
//Determine if first char is '-'/'+'. Set [pos] and [neg] accordingly.
let neg = false; //Sign of the result
let mut neg = false; //Sign of the result
alt str::char_at(num, 0u) {
'-' {
neg = true;
@ -179,7 +179,7 @@ fn from_str(num: str) -> option<float> {
}
if c == '.' {//Examine decimal part
let decimal = 1f;
let mut decimal = 1f;
while(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
@ -200,8 +200,8 @@ fn from_str(num: str) -> option<float> {
}
if (c == 'e') | (c == 'E') {//Examine exponent
let exponent = 0u;
let neg_exponent = false;
let mut exponent = 0u;
let mut neg_exponent = false;
if(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
@ -275,9 +275,9 @@ fn pow_with_uint(base: uint, pow: uint) -> float {
}
ret 0.;
}
let my_pow = pow;
let total = 1f;
let multiplier = base as float;
let mut my_pow = pow;
let mut total = 1f;
let mut multiplier = base as float;
while (my_pow > 0u) {
if my_pow % 2u == 1u {
total = total * multiplier;

2
src/libcore/future.rs
View File

@ -93,7 +93,7 @@ fn spawn<A:send>(+blk: fn~() -> A) -> future<A> {
"];
let po = comm::port();
let mut po = comm::port();
let ch = comm::chan(po);
task::spawn {||
comm::send(ch, blk())

2
src/libcore/i16.rs
View File

@ -26,7 +26,7 @@ pure fn nonnegative(x: i16) -> bool { x >= 0i16 }
#[doc = "Iterate over the range [`lo`..`hi`)"]
fn range(lo: i16, hi: i16, it: fn(i16)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1i16; }
}

2
src/libcore/i32.rs
View File

@ -26,7 +26,7 @@ pure fn nonnegative(x: i32) -> bool { x >= 0i32 }
#[doc = "Iterate over the range [`lo`..`hi`)"]
fn range(lo: i32, hi: i32, it: fn(i32)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1i32; }
}

2
src/libcore/i64.rs
View File

@ -26,7 +26,7 @@ pure fn nonnegative(x: i64) -> bool { x >= 0i64 }
#[doc = "Iterate over the range [`lo`..`hi`)"]
fn range(lo: i64, hi: i64, it: fn(i64)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1i64; }
}

2
src/libcore/i8.rs
View File

@ -26,7 +26,7 @@ pure fn nonnegative(x: i8) -> bool { x >= 0i8 }
#[doc = "Iterate over the range [`lo`..`hi`)"]
fn range(lo: i8, hi: i8, it: fn(i8)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1i8; }
}

16
src/libcore/int.rs
View File

@ -90,7 +90,7 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: int, hi: int, it: fn(int)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1; }
}
@ -106,15 +106,15 @@ radix - The base of the number
*/
fn parse_buf(buf: [u8], radix: uint) -> option<int> {
if vec::len(buf) == 0u { ret none; }
let i = vec::len(buf) - 1u;
let start = 0u;
let power = 1;
let mut i = vec::len(buf) - 1u;
let mut start = 0u;
let mut power = 1;
if buf[0] == ('-' as u8) {
power = -1;
start = 1u;
}
let n = 0;
let mut n = 0;
while true {
alt char::to_digit(buf[i] as char, radix) {
some(d) { n += (d as int) * power; }
@ -161,9 +161,9 @@ Returns `base` raised to the power of `exponent`
fn pow(base: int, exponent: uint) -> int {
if exponent == 0u { ret 1; } //Not mathemtically true if [base == 0]
if base == 0 { ret 0; }
let my_pow = exponent;
let acc = 1;
let multiplier = base;
let mut my_pow = exponent;
let mut acc = 1;
let mut multiplier = base;
while(my_pow > 0u) {
if my_pow % 2u == 1u {
acc *= multiplier;

8
src/libcore/iter.rs
View File

@ -40,7 +40,7 @@ impl of iterable<char> for str {
}
fn enumerate<A,IA:iterable<A>>(self: IA, blk: fn(uint, A)) {
let i = 0u;
let mut i = 0u;
self.iter {|a|
blk(i, a);
i += 1u;
@ -82,7 +82,7 @@ fn flat_map<A,B,IA:iterable<A>,IB:iterable<B>>(
}
fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(-B, A) -> B) -> B {
let b <- b0;
let mut b <- b0;
self.iter {|a|
b = blk(b, a);
}
@ -92,7 +92,7 @@ fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(-B, A) -> B) -> B {
fn foldr<A:copy,B,IA:iterable<A>>(
self: IA, +b0: B, blk: fn(A, -B) -> B) -> B {
let b <- b0;
let mut b <- b0;
reversed(self) {|a|
b = blk(a, b);
}
@ -119,7 +119,7 @@ fn count<A,IA:iterable<A>>(self: IA, x: A) -> uint {
}
fn repeat(times: uint, blk: fn()) {
let i = 0u;
let mut i = 0u;
while i < times {
blk();
i += 1u;

8
src/libcore/os.rs
View File

@ -41,7 +41,7 @@ native mod rustrt {
fn env() -> [(str,str)] {
let pairs = [];
let mut pairs = [];
for p in rustrt::rust_env_pairs() {
let vs = str::splitn_char(p, '=', 1u);
assert vec::len(vs) == 2u;
@ -87,7 +87,7 @@ mod win32 {
}
fn as_utf16_p<T>(s: str, f: fn(*u16) -> T) -> T {
let t = str::to_utf16(s);
let mut t = str::to_utf16(s);
// Null terminate before passing on.
t += [0u16];
vec::as_buf(t, f)
@ -468,13 +468,13 @@ fn list_dir(p: path) -> [str] {
#[cfg(target_os = "win32")]
fn star() -> str { "*" }
let p = p;
let mut p = p;
let pl = str::len(p);
if pl == 0u || (p[pl - 1u] as char != path::consts::path_sep
&& p[pl - 1u] as char != path::consts::alt_path_sep) {
p += path::path_sep();
}
let full_paths: [str] = [];
let mut full_paths: [str] = [];
for filename: str in rustrt::rust_list_files(p + star()) {
if !str::eq(filename, ".") {
if !str::eq(filename, "..") {

12
src/libcore/path.rs
View File

@ -112,8 +112,8 @@ with a single path separator between them.
*/
fn connect(pre: path, post: path) -> path unsafe {
let pre_ = pre;
let post_ = post;
let mut pre_ = pre;
let mut post_ = post;
let sep = consts::path_sep as u8;
let pre_len = str::len(pre);
let post_len = str::len(post);
@ -246,9 +246,9 @@ fn normalize(p: path) -> path {
ret [];
}
let t = [];
let i = vec::len(s);
let skip = 0;
let mut t = [];
let mut i = vec::len(s);
let mut skip = 0;
do {
i -= 1u;
if s[i] == ".." {
@ -261,7 +261,7 @@ fn normalize(p: path) -> path {
}
}
} while i != 0u;
let t = vec::reversed(t);
let mut t = vec::reversed(t);
while skip > 0 {
t += [".."];
skip -= 1;

102
src/libcore/str.rs
View File

@ -127,7 +127,7 @@ Convert a byte to a UTF-8 string. Fails if invalid UTF-8.
*/
fn from_byte(b: u8) -> str unsafe {
assert b < 128u8;
let v = [b, 0u8];
let mut v = [b, 0u8];
let s: str = ::unsafe::reinterpret_cast(v);
::unsafe::leak(v);
s
@ -176,7 +176,7 @@ Function: from_char
Convert a char to a string
*/
fn from_char(ch: char) -> str {
let buf = "";
let mut buf = "";
push_char(buf, ch);
ret buf;
}
@ -187,7 +187,7 @@ Function: from_chars
Convert a vector of chars to a string
*/
fn from_chars(chs: [char]) -> str {
let buf = "";
let mut buf = "";
reserve(buf, chs.len());
for ch in chs { push_char(buf, ch); }
ret buf;
@ -199,7 +199,7 @@ Function: from_cstr
Create a Rust string from a null-terminated C string
*/
fn from_cstr(cstr: sbuf) -> str unsafe {
let curr = cstr, i = 0u;
let mut curr = cstr, i = 0u;
while *curr != 0u8 {
i += 1u;
curr = ptr::offset(cstr, i);
@ -213,7 +213,7 @@ Function: from_cstr_len
Create a Rust string from a C string of the given length
*/
fn from_cstr_len(cstr: sbuf, len: uint) -> str unsafe {
let buf: [u8] = [];
let mut buf: [u8] = [];
vec::reserve(buf, len + 1u);
vec::as_buf(buf) {|b| ptr::memcpy(b, cstr, len); }
vec::unsafe::set_len(buf, len);
@ -231,7 +231,7 @@ Function: concat
Concatenate a vector of strings
*/
fn concat(v: [str]) -> str {
let s: str = "";
let mut s: str = "";
for ss: str in v { s += ss; }
ret s;
}
@ -242,7 +242,7 @@ Function: connect
Concatenate a vector of strings, placing a given separator between each
*/
fn connect(v: [str], sep: str) -> str {
let s = "", first = true;
let mut s = "", first = true;
for ss: str in v {
if first { first = false; } else { s += sep; }
s += ss;
@ -350,7 +350,8 @@ Function: chars
Convert a string to a vector of characters
*/
fn chars(s: str) -> [char] {
let buf = [], i = 0u, len = len(s);
let mut buf = [], i = 0u;
let len = len(s);
while i < len {
let {ch, next} = char_range_at(s, i);
buf += [ch];
@ -408,8 +409,9 @@ fn split_char_nonempty(s: str, sep: char) -> [str] {
fn split_char_inner(s: str, sep: char, count: uint, allow_empty: bool)
-> [str] unsafe {
if sep < 128u as char {
let result = [], b = sep as u8, l = len(s), done = 0u;
let i = 0u, start = 0u;
let b = sep as u8, l = len(s);
let mut result = [], done = 0u;
let mut i = 0u, start = 0u;
while i < l && done < count {
if s[i] == b {
if allow_empty || start < i {
@ -458,7 +460,8 @@ fn split_nonempty(s: str, sepfn: fn(char) -> bool) -> [str] {
fn split_inner(s: str, sepfn: fn(cc: char) -> bool, count: uint,
allow_empty: bool) -> [str] unsafe {
let result = [], i = 0u, l = len(s), start = 0u, done = 0u;
let l = len(s);
let mut result = [], i = 0u, start = 0u, done = 0u;
while i < l && done < count {
let {ch, next} = char_range_at(s, i);
if sepfn(ch) {
@ -480,7 +483,7 @@ fn split_inner(s: str, sepfn: fn(cc: char) -> bool, count: uint,
fn iter_matches(s: str, sep: str, f: fn(uint, uint)) {
let sep_len = len(sep), l = len(s);
assert sep_len > 0u;
let i = 0u, match_start = 0u, match_i = 0u;
let mut i = 0u, match_start = 0u, match_i = 0u;
while i < l {
if s[i] == sep[match_i] {
@ -505,7 +508,7 @@ fn iter_matches(s: str, sep: str, f: fn(uint, uint)) {
}
fn iter_between_matches(s: str, sep: str, f: fn(uint, uint)) {
let last_end = 0u;
let mut last_end = 0u;
iter_matches(s, sep) {|from, to|
f(last_end, from);
last_end = to;
@ -522,7 +525,7 @@ Note that this has recently been changed. For example:
> assert ["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", ".")
*/
fn split_str(s: str, sep: str) -> [str] {
let result = [];
let mut result = [];
iter_between_matches(s, sep) {|from, to|
unsafe { result += [unsafe::slice_bytes(s, from, to)]; }
}
@ -530,7 +533,7 @@ fn split_str(s: str, sep: str) -> [str] {
}
fn split_str_nonempty(s: str, sep: str) -> [str] {
let result = [];
let mut result = [];
iter_between_matches(s, sep) {|from, to|
if to > from {
unsafe { result += [unsafe::slice_bytes(s, from, to)]; }
@ -555,7 +558,8 @@ separated by LF ('\n') and/or CR LF ('\r\n')
*/
fn lines_any(s: str) -> [str] {
vec::map(lines(s), {|s|
let l = len(s), cp = s;
let l = len(s);
let mut cp = s;
if l > 0u && s[l - 1u] == '\r' as u8 {
unsafe { unsafe::set_len(cp, l - 1u); }
}
@ -607,7 +611,7 @@ Returns:
The original string with all occurances of `from` replaced with `to`
*/
fn replace(s: str, from: str, to: str) -> str unsafe {
let result = "", first = true;
let mut result = "", first = true;
iter_between_matches(s, from) {|start, end|
if first { first = false; } else { result += to; }
unsafe { result += unsafe::slice_bytes(s, start, end); }
@ -641,7 +645,7 @@ String hash function
fn hash(&&s: str) -> uint {
// djb hash.
// FIXME: replace with murmur.
let u: uint = 5381u;
let mut u: uint = 5381u;
for c: u8 in s { u *= 33u; u += c as uint; }
ret u;
}
@ -676,7 +680,7 @@ Function: map
Apply a function to each character
*/
fn map(ss: str, ff: fn(char) -> char) -> str {
let result = "";
let mut result = "";
reserve(result, len(ss));
chars_iter(ss) {|cc| str::push_char(result, ff(cc));}
result
@ -688,7 +692,7 @@ Function: bytes_iter
Iterate over the bytes in a string
*/
fn bytes_iter(ss: str, it: fn(u8)) {
let pos = 0u;
let mut pos = 0u;
let len = len(ss);
while (pos < len) {
@ -703,7 +707,8 @@ Function: chars_iter
Iterate over the characters in a string
*/
fn chars_iter(s: str, it: fn(char)) {
let pos = 0u, len = len(s);
let mut pos = 0u;
let len = len(s);
while (pos < len) {
let {ch, next} = char_range_at(s, pos);
pos = next;
@ -778,7 +783,8 @@ fn find_char_between(s: str, c: char, start: uint, end: uint)
if c < 128u as char {
assert start <= end;
assert end <= len(s);
let i = start, b = c as u8;
let mut i = start;
let b = c as u8;
while i < end {
if s[i] == b { ret some(i); }
i += 1u;
@ -815,7 +821,8 @@ fn rfind_char_between(s: str, c: char, start: uint, end: uint)
if c < 128u as char {
assert start >= end;
assert start <= len(s);
let i = start, b = c as u8;
let mut i = start;
let b = c as u8;
while i > end {
i -= 1u;
if s[i] == b { ret some(i); }
@ -851,7 +858,7 @@ fn find_between(s: str, start: uint, end: uint, f: fn(char) -> bool)
assert start <= end;
assert end <= len(s);
assert is_char_boundary(s, start);
let i = start;
let mut i = start;
while i < end {
let {ch, next} = char_range_at(s, i);
if f(ch) { ret some(i); }
@ -886,7 +893,7 @@ fn rfind_between(s: str, start: uint, end: uint, f: fn(char) -> bool)
assert start >= end;
assert start <= len(s);
assert is_char_boundary(s, start);
let i = start;
let mut i = start;
while i > end {
let {ch, prev} = char_range_at_reverse(s, i);
if f(ch) { ret some(prev); }
@ -897,7 +904,7 @@ fn rfind_between(s: str, start: uint, end: uint, f: fn(char) -> bool)
// Utility used by various searching functions
fn match_at(haystack: str, needle: str, at: uint) -> bool {
let i = at;
let mut i = at;
for c in needle { if haystack[i] != c { ret false; } i += 1u; }
ret true;
}
@ -931,7 +938,8 @@ fn find_str_between(haystack: str, needle: str, start: uint, end:uint)
if needle_len == 0u { ret some(start); }
if needle_len > end { ret none; }
let i = start, e = end - needle_len;
let mut i = start;
let e = end - needle_len;
while i <= e {
if match_at(haystack, needle, i) { ret some(i); }
i += 1u;
@ -995,7 +1003,7 @@ Function: is_ascii
Determines if a string contains only ASCII characters
*/
fn is_ascii(s: str) -> bool {
let i: uint = len(s);
let mut i: uint = len(s);
while i > 0u { i -= 1u; if !u8::is_ascii(s[i]) { ret false; } }
ret true;
}
@ -1048,10 +1056,10 @@ Function: is_utf8
Determines if a vector of bytes contains valid UTF-8
*/
fn is_utf8(v: [const u8]) -> bool {
let i = 0u;
let mut i = 0u;
let total = vec::len::<u8>(v);
while i < total {
let chsize = utf8_char_width(v[i]);
let mut chsize = utf8_char_width(v[i]);
if chsize == 0u { ret false; }
if i + chsize > total { ret false; }
i += 1u;
@ -1067,7 +1075,7 @@ fn is_utf8(v: [const u8]) -> bool {
fn is_utf16(v: [const u16]) -> bool {
let len = v.len();
let i = 0u;
let mut i = 0u;
while (i < len) {
let u = v[i];
@ -1085,12 +1093,11 @@ fn is_utf16(v: [const u16]) -> bool {
ret true;
}
fn to_utf16(s: str) -> [u16] {
let u = [];
let mut u = [];
chars_iter(s) {|cch|
// Arithmetic with u32 literals is easier on the eyes than chars.
let ch = cch as u32;
let mut ch = cch as u32;
if (ch & 0xFFFF_u32) == ch {
// The BMP falls through (assuming non-surrogate, as it should)
@ -1110,9 +1117,9 @@ fn to_utf16(s: str) -> [u16] {
fn utf16_chars(v: [const u16], f: fn(char)) {
let len = v.len();
let i = 0u;
let mut i = 0u;
while (i < len && v[i] != 0u16) {
let u = v[i];
let mut u = v[i];
if u <= 0xD7FF_u16 || u >= 0xE000_u16 {
f(u as char);
@ -1122,7 +1129,7 @@ fn utf16_chars(v: [const u16], f: fn(char)) {
let u2 = v[i+1u];
assert u >= 0xD800_u16 && u <= 0xDBFF_u16;
assert u2 >= 0xDC00_u16 && u2 <= 0xDFFF_u16;
let c = (u - 0xD800_u16) as char;
let mut c = (u - 0xD800_u16) as char;
c = c << 10;
c |= (u2 - 0xDC00_u16) as char;
c |= 0x1_0000_u32 as char;
@ -1134,7 +1141,7 @@ fn utf16_chars(v: [const u16], f: fn(char)) {
fn from_utf16(v: [const u16]) -> str {
let buf = "";
let mut buf = "";
reserve(buf, v.len());
utf16_chars(v) {|ch| push_char(buf, ch); }
ret buf;
@ -1157,7 +1164,7 @@ Returns:
fn count_chars(s: str, start: uint, end: uint) -> uint {
assert is_char_boundary(s, start);
assert is_char_boundary(s, end);
let i = start, len = 0u;
let mut i = start, len = 0u;
while i < end {
let {next, _} = char_range_at(s, i);
len += 1u;
@ -1172,7 +1179,8 @@ fn count_chars(s: str, start: uint, end: uint) -> uint {
// `start`.
fn count_bytes(s: str, start: uint, n: uint) -> uint {
assert is_char_boundary(s, start);
let end = start, cnt = n, l = len(s);
let mut end = start, cnt = n;
let l = len(s);
while cnt > 0u {
assert end < l;
let {next, _} = char_range_at(s, end);
@ -1260,9 +1268,9 @@ fn char_range_at(s: str, i: uint) -> {ch: char, next: uint} {
let w = utf8_char_width(b0);
assert (w != 0u);
if w == 1u { ret {ch: b0 as char, next: i + 1u}; }
let val = 0u;
let mut val = 0u;
let end = i + w;
let i = i + 1u;
let mut i = i + 1u;
while i < end {
let byte = s[i];
assert (byte & 192u8 == tag_cont_u8);
@ -1289,7 +1297,7 @@ fn char_at(s: str, i: uint) -> char { ret char_range_at(s, i).ch; }
// Given a byte position and a str, return the previous char and its position
// This function can be used to iterate over a unicode string in reverse.
fn char_range_at_reverse(ss: str, start: uint) -> {ch: char, prev: uint} {
let prev = start;
let mut prev = start;
// while there is a previous byte == 10......
while prev > 0u && ss[prev - 1u] & 192u8 == tag_cont_u8 {
@ -1327,7 +1335,7 @@ Safety note:
*/
fn all_between(s: str, start: uint, end: uint, it: fn(char) -> bool) -> bool {
assert is_char_boundary(s, start);
let i = start;
let mut i = start;
while i < end {
let {ch, next} = char_range_at(s, i);
if !it(ch) { ret false; }
@ -1366,7 +1374,7 @@ Example:
*/
fn as_bytes<T>(s: str, f: fn([u8]) -> T) -> T unsafe {
let v: [u8] = ::unsafe::reinterpret_cast(s);
let mut v: [u8] = ::unsafe::reinterpret_cast(s);
let r = f(v);
::unsafe::leak(v);
r
@ -1421,7 +1429,7 @@ mod unsafe {
// Converts a vector of bytes to a string. Does not verify that the
// vector contains valid UTF-8.
unsafe fn from_bytes(v: [const u8]) -> str unsafe {
let vcopy: [u8] = v + [0u8];
let mut vcopy: [u8] = v + [0u8];
let scopy: str = ::unsafe::reinterpret_cast(vcopy);
::unsafe::leak(vcopy);
ret scopy;
@ -1448,7 +1456,7 @@ mod unsafe {
assert (begin <= end);
assert (end <= len(s));
let v = as_bytes(s) { |v| vec::slice(v, begin, end) };
let mut v = as_bytes(s) { |v| vec::slice(v, begin, end) };
v += [0u8];
let s: str = ::unsafe::reinterpret_cast(v);
::unsafe::leak(v);

14
src/libcore/task.rs
View File

@ -309,7 +309,7 @@ fn future_result(builder: task_builder) -> future::future<task_result> {
fn future_task(builder: task_builder) -> future::future<task> {
#[doc = "Get a future representing the handle to the new task"];
let po = comm::port();
let mut po = comm::port();
let ch = comm::chan(po);
add_wrapper(builder) {|body|
fn~() {
@ -349,7 +349,7 @@ fn run_listener<A:send>(-builder: task_builder,
run(builder) {||
let po = comm::port();
let ch = comm::chan(po);
let mut ch = comm::chan(po);
comm::send(setup_ch, ch);
f(po);
}
@ -421,7 +421,7 @@ fn spawn_sched(mode: sched_mode, +f: fn~()) {
")];
let builder = mk_task_builder();
let mut builder = mk_task_builder();
set_opts(builder, {
sched: some({
mode: mode,
@ -448,7 +448,7 @@ fn try<T:send>(+f: fn~() -> T) -> result::t<T,()> {
let po = comm::port();
let ch = comm::chan(po);
let builder = mk_task_builder();
let mut builder = mk_task_builder();
unsupervise(builder);
let result = future_result(builder);
run(builder) {||
@ -467,7 +467,7 @@ fn yield() {
#[doc = "Yield control to the task scheduler"];
let task_ = rustrt::rust_get_task();
let killed = false;
let mut killed = false;
rusti::task_yield(task_, killed);
if killed && !failing() {
fail "killed";
@ -499,7 +499,7 @@ type rust_closure = ctypes::void;
fn spawn_raw(opts: task_opts, +f: fn~()) unsafe {
let f = if opts.supervise {
let mut f = if opts.supervise {
f
} else {
// FIXME: The runtime supervision API is weird here because it
@ -924,4 +924,4 @@ fn test_avoid_copying_the_body_unsupervise() {
f();
}
}
}
}

2
src/libcore/to_str.rs
View File

@ -37,7 +37,7 @@ impl <A: to_str copy, B: to_str copy, C: to_str copy> of to_str for (A, B, C){
impl <A: to_str> of to_str for [A] {
fn to_str() -> str {
let acc = "[", first = true;
let mut acc = "[", first = true;
for elt in self {
if first { first = false; }
else { acc += ", "; }

2
src/libcore/u16.rs
View File

@ -26,7 +26,7 @@ pure fn nonnegative(x: u16) -> bool { x >= 0u16 }
#[doc = "Iterate over the range [`lo`..`hi`)"]
fn range(lo: u16, hi: u16, it: fn(u16)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1u16; }
}

2
src/libcore/u32.rs
View File

@ -60,7 +60,7 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: u32, hi: u32, it: fn(u32)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1u32; }
}

10
src/libcore/u64.rs
View File

@ -60,7 +60,7 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: u64, hi: u64, it: fn(u64)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1u64; }
}
@ -98,9 +98,9 @@ fn to_str(n: u64, radix: uint) -> str {
if n == 0u64 { ret "0"; }
let s = "";
let mut s = "";
let n = n;
let mut n = n;
while n > 0u64 { s = digit(n % r64) + s; n /= r64; }
ret s;
}
@ -119,8 +119,8 @@ Parse a string as an unsigned integer.
*/
fn from_str(buf: str, radix: u64) -> option<u64> {
if str::len(buf) == 0u { ret none; }
let i = str::len(buf) - 1u;
let power = 1u64, n = 0u64;
let mut i = str::len(buf) - 1u;
let mut power = 1u64, n = 0u64;
while true {
alt char::to_digit(buf[i] as char, radix as uint) {
some(d) { n += d as u64 * power; }

2
src/libcore/u8.rs
View File

@ -60,7 +60,7 @@ Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: u8, hi: u8, it: fn(u8)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1u8; }
}

22
src/libcore/uint.rs
View File

@ -133,7 +133,7 @@ Iterate over the range [`lo`..`hi`)
*/
#[inline(always)]
fn range(lo: uint, hi: uint, it: fn(uint)) {
let i = lo;
let mut i = lo;
while i < hi { it(i); i += 1u; }
}
@ -154,7 +154,7 @@ Returns:
that is if `it` returned `false` at any point.
*/
fn loop(lo: uint, hi: uint, it: fn(uint) -> bool) -> bool {
let i = lo;
let mut i = lo;
while i < hi {
if (!it(i)) { ret false; }
i += 1u;
@ -169,8 +169,8 @@ Returns the smallest power of 2 greater than or equal to `n`
*/
fn next_power_of_two(n: uint) -> uint {
let halfbits: uint = sys::size_of::<uint>() * 4u;
let tmp: uint = n - 1u;
let shift: uint = 1u;
let mut tmp: uint = n - 1u;
let mut shift: uint = 1u;
while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
ret tmp + 1u;
}
@ -191,9 +191,9 @@ buf must not be empty
*/
fn parse_buf(buf: [u8], radix: uint) -> option<uint> {
if vec::len(buf) == 0u { ret none; }
let i = vec::len(buf) - 1u;
let power = 1u;
let n = 0u;
let mut i = vec::len(buf) - 1u;
let mut power = 1u;
let mut n = 0u;
while true {
alt char::to_digit(buf[i] as char, radix) {
some(d) { n += d * power; }
@ -219,7 +219,7 @@ Function: to_str
Convert to a string in a given base
*/
fn to_str(num: uint, radix: uint) -> str {
let n = num;
let mut n = num;
assert (0u < radix && radix <= 16u);
fn digit(n: uint) -> char {
ret alt n {
@ -243,13 +243,13 @@ fn to_str(num: uint, radix: uint) -> str {
};
}
if n == 0u { ret "0"; }
let s: str = "";
let mut s: str = "";
while n != 0u {
s += str::from_byte(digit(n % radix) as u8);
n /= radix;
}
let s1: str = "";
let len: uint = str::len(s);
let mut s1: str = "";
let mut len: uint = str::len(s);
while len != 0u { len -= 1u; s1 += str::from_byte(s[len]); }
ret s1;
}

100
src/libcore/vec.rs
View File

@ -90,9 +90,9 @@ Creates an immutable vector of size `n_elts` and initializes the elements
to the value returned by the function `op`.
*/
fn init_fn<T>(n_elts: uint, op: init_op<T>) -> [T] {
let v = [];
let mut v = [];
reserve(v, n_elts);
let i: uint = 0u;
let mut i: uint = 0u;
while i < n_elts { v += [op(i)]; i += 1u; }
ret v;
}
@ -106,9 +106,9 @@ Creates an immutable vector of size `n_elts` and initializes the elements
to the value `t`.
*/
fn init_elt<T: copy>(n_elts: uint, t: T) -> [T] {
let v = [];
let mut v = [];
reserve(v, n_elts);
let i: uint = 0u;
let mut i: uint = 0u;
while i < n_elts { v += [t]; i += 1u; }
ret v;
}
@ -217,9 +217,9 @@ Returns a copy of the elements from [`start`..`end`) from `v`.
fn slice<T: copy>(v: [const T], start: uint, end: uint) -> [T] {
assert (start <= end);
assert (end <= len(v));
let result = [];
let mut result = [];
reserve(result, end - start);
let i = start;
let mut i = start;
while i < end { result += [v[i]]; i += 1u; }
ret result;
}
@ -233,8 +233,8 @@ fn split<T: copy>(v: [const T], f: fn(T) -> bool) -> [[T]] {
let ln = len(v);
if (ln == 0u) { ret [] }
let start = 0u;
let result = [];
let mut start = 0u;
let mut result = [];
while start < ln {
alt position_from(v, start, ln, f) {
none { break }
@ -258,9 +258,9 @@ fn splitn<T: copy>(v: [const T], n: uint, f: fn(T) -> bool) -> [[T]] {
let ln = len(v);
if (ln == 0u) { ret [] }
let start = 0u;
let count = n;
let result = [];
let mut start = 0u;
let mut count = n;
let mut result = [];
while start < ln && count > 0u {
alt position_from(v, start, ln, f) {
none { break }
@ -286,8 +286,8 @@ fn rsplit<T: copy>(v: [const T], f: fn(T) -> bool) -> [[T]] {
let ln = len(v);
if (ln == 0u) { ret [] }
let end = ln;
let result = [];
let mut end = ln;
let mut result = [];
while end > 0u {
alt rposition_from(v, 0u, end, f) {
none { break }
@ -311,9 +311,9 @@ fn rsplitn<T: copy>(v: [const T], n: uint, f: fn(T) -> bool) -> [[T]] {
let ln = len(v);
if (ln == 0u) { ret [] }
let end = ln;
let count = n;
let result = [];
let mut end = ln;
let mut count = n;
let mut result = [];
while end > 0u && count > 0u {
alt rposition_from(v, 0u, end, f) {
none { break }
@ -385,7 +385,7 @@ initval - The value for the new elements
*/
fn grow<T: copy>(&v: [const T], n: uint, initval: T) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
let mut i: uint = 0u;
while i < n { v += [initval]; i += 1u; }
}
@ -405,7 +405,7 @@ init_op - A function to call to retreive each appended element's value
*/
fn grow_fn<T>(&v: [const T], n: uint, op: init_op<T>) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
let mut i: uint = 0u;
while i < n { v += [op(i)]; i += 1u; }
}
@ -433,7 +433,7 @@ Function: map
Apply a function to each element of a vector and return the results
*/
fn map<T, U>(v: [T], f: fn(T) -> U) -> [U] {
let result = [];
let mut result = [];
reserve(result, len(v));
for elem: T in v { result += [f(elem)]; }
ret result;
@ -448,8 +448,8 @@ fn map2<T: copy, U: copy, V>(v0: [const T], v1: [const U],
f: fn(T, U) -> V) -> [V] {
let v0_len = len(v0);
if v0_len != len(v1) { fail; }
let u: [V] = [];
let i = 0u;
let mut u: [V] = [];
let mut i = 0u;
while i < v0_len { u += [f(copy v0[i], copy v1[i])]; i += 1u; }
ret u;
}
@ -464,7 +464,7 @@ the resulting vector.
*/
fn filter_map<T: copy, U: copy>(v: [const T], f: fn(T) -> option<U>)
-> [U] {
let result = [];
let mut result = [];
for elem: T in v {
alt f(copy elem) {
none {/* no-op */ }
@ -484,7 +484,7 @@ Apply function `f` to each element of `v` and return a vector containing
only those elements for which `f` returned true.
*/
fn filter<T: copy>(v: [T], f: fn(T) -> bool) -> [T] {
let result = [];
let mut result = [];
for elem: T in v {
if f(elem) { result += [elem]; }
}
@ -498,7 +498,7 @@ Concatenate a vector of vectors. Flattens a vector of vectors of T into
a single vector of T.
*/
fn concat<T: copy>(v: [const [const T]]) -> [T] {
let new: [T] = [];
let mut new: [T] = [];
for inner: [T] in v { new += inner; }
ret new;
}
@ -509,8 +509,8 @@ Function: connect
Concatenate a vector of vectors, placing a given separator between each
*/
fn connect<T: copy>(v: [const [const T]], sep: T) -> [T] {
let new: [T] = [];
let first = true;
let mut new: [T] = [];
let mut first = true;
for inner: [T] in v {
if first { first = false; } else { push(new, sep); }
new += inner;
@ -524,7 +524,7 @@ Function: foldl
Reduce a vector from left to right
*/
fn foldl<T: copy, U>(z: T, v: [const U], p: fn(T, U) -> T) -> T {
let accum = z;
let mut accum = z;
iter(v) { |elt|
accum = p(accum, elt);
}
@ -537,7 +537,7 @@ Function: foldr
Reduce a vector from right to left
*/
fn foldr<T, U: copy>(v: [const T], z: U, p: fn(T, U) -> U) -> U {
let accum = z;
let mut accum = z;
riter(v) { |elt|
accum = p(elt, accum);
}
@ -566,7 +566,7 @@ If the vectors contains no elements then false is returned.
fn any2<T, U>(v0: [const T], v1: [U], f: fn(T, U) -> bool) -> bool {
let v0_len = len(v0);
let v1_len = len(v1);
let i = 0u;
let mut i = 0u;
while i < v0_len && i < v1_len {
if f(v0[i], v1[i]) { ret true; };
i += 1u;
@ -596,7 +596,7 @@ If the vectors are not the same size then false is returned.
fn all2<T, U>(v0: [const T], v1: [const U], f: fn(T, U) -> bool) -> bool {
let v0_len = len(v0);
if v0_len != len(v1) { ret false; }
let i = 0u;
let mut i = 0u;
while i < v0_len { if !f(v0[i], v1[i]) { ret false; }; i += 1u; }
ret true;
}
@ -617,7 +617,7 @@ Function: count
Returns the number of elements that are equal to a given value
*/
fn count<T>(v: [const T], x: T) -> uint {
let cnt = 0u;
let mut cnt = 0u;
for elt: T in v { if x == elt { cnt += 1u; } }
ret cnt;
}
@ -716,7 +716,7 @@ fn position_from<T>(v: [const T], start: uint, end: uint,
f: fn(T) -> bool) -> option<uint> {
assert start <= end;
assert end <= len(v);
let i = start;
let mut i = start;
while i < end { if f(v[i]) { ret some::<uint>(i); } i += 1u; }
ret none;
}
@ -761,7 +761,7 @@ fn rposition_from<T>(v: [const T], start: uint, end: uint,
f: fn(T) -> bool) -> option<uint> {
assert start <= end;
assert end <= len(v);
let i = end;
let mut i = end;
while i > start {
if f(v[i - 1u]) { ret some::<uint>(i - 1u); }
i -= 1u;
@ -784,7 +784,7 @@ and the i-th element of the second vector contains the second element
of the i-th tuple of the input vector.
*/
fn unzip<T: copy, U: copy>(v: [const (T, U)]) -> ([T], [U]) {
let as = [], bs = [];
let mut as = [], bs = [];
for (a, b) in v { as += [a]; bs += [b]; }
ret (as, bs);
}
@ -802,8 +802,9 @@ Preconditions:
<same_length> (v, u)
*/
fn zip<T: copy, U: copy>(v: [const T], u: [const U]) -> [(T, U)] {
let zipped = [];
let sz = len(v), i = 0u;
let mut zipped = [];
let sz = len(v);
let mut i = 0u;
assert sz == len(u);
while i < sz { zipped += [(v[i], u[i])]; i += 1u; }
ret zipped;
@ -829,7 +830,7 @@ Function: reverse
Reverse the order of elements in a vector, in place
*/
fn reverse<T>(v: [mutable T]) {
let i: uint = 0u;
let mut i: uint = 0u;
let ln = len::<T>(v);
while i < ln / 2u { v[i] <-> v[ln - i - 1u]; i += 1u; }
}
@ -841,8 +842,8 @@ Function: reversed
Returns a vector with the order of elements reversed
*/
fn reversed<T: copy>(v: [const T]) -> [T] {
let rs: [T] = [];
let i = len::<T>(v);
let mut rs: [T] = [];
let mut i = len::<T>(v);
if i == 0u { ret rs; } else { i -= 1u; }
while i != 0u { rs += [v[i]]; i -= 1u; }
rs += [v[0]];
@ -857,8 +858,8 @@ Returns a vector containing a range of chars
*/
fn enum_chars(start: u8, end: u8) -> [char] {
assert start < end;
let i = start;
let r = [];
let mut i = start;
let mut r = [];
while i <= end { r += [i as char]; i += 1u as u8; }
ret r;
}
@ -871,8 +872,8 @@ Returns a vector containing a range of uints
*/
fn enum_uints(start: uint, end: uint) -> [uint] {
assert start < end;
let i = start;
let r = [];
let mut i = start;
let mut r = [];
while i <= end { r += [i]; i += 1u; }
ret r;
}
@ -907,7 +908,7 @@ Iterates over two vectors in parallel
*/
#[inline]
fn iter2<U, T>(v: [ U], v2: [const T], f: fn(U, T)) {
let i = 0;
let mut i = 0;
for elt in v { f(elt, v2[i]); i += 1; }
}
@ -921,7 +922,8 @@ element's value and index.
*/
#[inline(always)]
fn iteri<T>(v: [const T], f: fn(uint, T)) {
let i = 0u, l = len(v);
let mut i = 0u;
let l = len(v);
while i < l { f(i, v[i]); i += 1u; }
}
@ -947,7 +949,7 @@ Iterates over vector `v` and, for each element, calls function `f` with the
element's value and index.
*/
fn riteri<T>(v: [const T], f: fn(uint, T)) {
let i = len(v);
let mut i = len(v);
while 0u < i {
i -= 1u;
f(i, v[i]);
@ -969,7 +971,7 @@ fn permute<T: copy>(v: [T], put: fn([T])) {
if ln == 0u {
put([]);
} else {
let i = 0u;
let mut i = 0u;
while i < ln {
let elt = v[i];
let rest = slice(v, 0u, i) + slice(v, i+1u, ln);
@ -980,7 +982,7 @@ fn permute<T: copy>(v: [T], put: fn([T])) {
}
fn windowed <TT: copy> (nn: uint, xx: [const TT]) -> [[TT]] {
let ww = [];
let mut ww = [];
assert 1u <= nn;
@ -1153,7 +1155,7 @@ mod u8 {
// djb hash.
// FIXME: replace with murmur.
let u: uint = 5381u;
let mut u: uint = 5381u;
vec::iter(s, { |c| u *= 33u; u += c as uint; });
ret u;
}