[submodule "src/llvm"]
path = src/llvm
- url = https://github.com/brson/llvm.git
+ url = https://github.com/alexcrichton/llvm.git
branch = master
[submodule "src/libuv"]
path = src/libuv
msgid ""
"~~~~ {.xfail-test}\n"
"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
-" foreach elt in seq.iter() { f(elt); }\n"
+" for elt in seq.iter() { f(elt); }\n"
"}\n"
"fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {\n"
" let mut acc = ~[];\n"
-" foreach elt in seq.iter() { acc.push(f(elt)); }\n"
+" for elt in seq.iter() { acc.push(f(elt)); }\n"
" acc\n"
"}\n"
"~~~~\n"
#: doc/rust.md:2405
#, no-wrap
msgid ""
-"foreach e in v.iter() {\n"
+"for e in v.iter() {\n"
" bar(*e);\n"
"}\n"
"~~~~\n"
#, no-wrap
msgid ""
"// print out all the elements in the vector\n"
-"foreach x in xs.iter() {\n"
+"for x in xs.iter() {\n"
" println(x.to_str())\n"
"}\n"
msgstr ""
#, no-wrap
msgid ""
"// print out all but the first 3 elements in the vector\n"
-"foreach x in xs.iter().skip(3) {\n"
+"for x in xs.iter().skip(3) {\n"
" println(x.to_str())\n"
"}\n"
"~~~\n"
#, no-wrap
msgid ""
"// print out the pairs of elements up to (&3, &\"baz\")\n"
-"foreach (x, y) in it {\n"
+"for (x, y) in it {\n"
" println(fmt!(\"%d %s\", *x, *y));\n"
msgstr ""
" pub fn from_iterator(iterator: &mut T) -> ~[A] {\n"
" let (lower, _) = iterator.size_hint();\n"
" let mut xs = with_capacity(lower);\n"
-" foreach x in iterator {\n"
+" for x in iterator {\n"
" xs.push(x);\n"
" }\n"
" xs\n"
#, no-wrap
msgid ""
"// prints `5`, `4` and `3`\n"
-"foreach &x in it.invert() {\n"
+"for &x in it.invert() {\n"
" println(fmt!(\"%?\", x))\n"
"}\n"
"~~~\n"
#, no-wrap
msgid ""
" let mut final_res = 0f64;\n"
-" foreach ft in futures.mut_iter() {\n"
+" for ft in futures.mut_iter() {\n"
" final_res += ft.get();\n"
" }\n"
" println(fmt!(\"^2/6 is not far from : %?\", final_res));\n"
msgid ""
"// Iterate over a vector, obtaining a pointer to each element\n"
"// (`for` is explained in the next section)\n"
-"foreach crayon in crayons.iter() {\n"
+"for crayon in crayons.iter() {\n"
" let delicious_crayon_wax = unwrap_crayon(*crayon);\n"
" eat_crayon_wax(delicious_crayon_wax);\n"
"}\n"
"~~~~\n"
"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
" let mut accumulator = ~[];\n"
-" foreach element in vector.iter() {\n"
+" for element in vector.iter() {\n"
" accumulator.push(function(element));\n"
" }\n"
" return accumulator;\n"
"~~~~\n"
"# trait Printable { fn print(&self); }\n"
"fn print_all<T: Printable>(printable_things: ~[T]) {\n"
-" foreach thing in printable_things.iter() {\n"
+" for thing in printable_things.iter() {\n"
" thing.print();\n"
" }\n"
"}\n"
#, no-wrap
msgid ""
"fn draw_all<T: Drawable>(shapes: ~[T]) {\n"
-" foreach shape in shapes.iter() { shape.draw(); }\n"
+" for shape in shapes.iter() { shape.draw(); }\n"
"}\n"
"# let c: Circle = new_circle();\n"
"# draw_all(~[c]);\n"
"~~~~\n"
"# trait Drawable { fn draw(&self); }\n"
"fn draw_all(shapes: &[@Drawable]) {\n"
-" foreach shape in shapes.iter() { shape.draw(); }\n"
+" for shape in shapes.iter() { shape.draw(); }\n"
"}\n"
"~~~~\n"
msgstr ""
~~~~ {.xfail-test}
fn iter<T>(seq: &[T], f: &fn(T)) {
- foreach elt in seq.iter() { f(elt); }
+ for elt in seq.iter() { f(elt); }
}
fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {
let mut acc = ~[];
- foreach elt in seq.iter() { acc.push(f(elt)); }
+ for elt in seq.iter() { acc.push(f(elt)); }
acc
}
~~~~
let v: &[foo] = &[a, b, c];
-foreach e in v.iter() {
+for e in v.iter() {
bar(*e);
}
~~~~
~~~~
# fn bar(b:uint) { }
-foreach i in range(0u, 256) {
+for i in range(0u, 256) {
bar(i);
}
~~~~
# use std::io::print;
# use std::task::spawn;
-foreach child_task_number in range(0, 20) {
+for child_task_number in range(0, 20) {
do spawn {
print(fmt!("I am child number %d\n", child_task_number));
}
let (port, chan) = stream();
let chan = SharedChan::new(chan);
-foreach init_val in range(0u, 3) {
+for init_val in range(0u, 3) {
// Create a new channel handle to distribute to the child task
let child_chan = chan.clone();
do spawn {
# use std::vec;
fn partial_sum(start: uint) -> f64 {
let mut local_sum = 0f64;
- foreach num in range(start*100000, (start+1)*100000) {
+ for num in range(start*100000, (start+1)*100000) {
local_sum += (num as f64 + 1.0).pow(&-2.0);
}
local_sum
let mut futures = vec::from_fn(1000, |ind| do extra::future::spawn { partial_sum(ind) });
let mut final_res = 0f64;
- foreach ft in futures.mut_iter() {
+ for ft in futures.mut_iter() {
final_res += ft.get();
}
println(fmt!("π^2/6 is not far from : %?", final_res));
let numbers_arc = Arc::new(numbers);
- foreach num in range(1u, 10) {
+ for num in range(1u, 10) {
let (port, chan) = stream();
chan.send(numbers_arc.clone());
else
# This is just a rough approximation of LLVM deps
-LLVM_DEPS=$(call rwildcard,$(CFG_LLVM_SRC_DIR),*cpp *hpp)
+LLVM_DEPS_SRC=$(call rwildcard,$(CFG_LLVM_SRC_DIR)/lib,*cpp *hpp)
+LLVM_DEPS_INC=$(call rwildcard,$(CFG_LLVM_SRC_DIR)/include,*cpp *hpp)
+LLVM_DEPS=$(LLVM_DEPS_SRC) $(LLVM_DEPS_INC)
endif
define DEF_LLVM_RULES
config.src_base.to_str());
let mut tests = ~[];
let dirs = os::list_dir_path(&config.src_base);
- foreach file in dirs.iter() {
+ for file in dirs.iter() {
let file = file.clone();
debug!("inspecting file %s", file.to_str());
if is_test(config, &file) {
let mut valid = false;
- foreach ext in valid_extensions.iter() {
+ for ext in valid_extensions.iter() {
if name.ends_with(*ext) { valid = true; }
}
- foreach pre in invalid_prefixes.iter() {
+ for pre in invalid_prefixes.iter() {
if name.starts_with(*pre) { valid = false; }
}
err_fd: None
});
- foreach input in input.iter() {
+ for input in input.iter() {
proc.input().write_str(*input);
}
let output = proc.finish_with_output();
// check if each line in props.check_lines appears in the
// output (in order)
let mut i = 0u;
- foreach line in ProcRes.stdout.line_iter() {
+ for line in ProcRes.stdout.line_iter() {
if check_lines[i].trim() == line.trim() {
i += 1u;
}
let mut next_err_idx = 0u;
let mut next_err_pat = &props.error_patterns[next_err_idx];
let mut done = false;
- foreach line in ProcRes.stderr.line_iter() {
+ for line in ProcRes.stderr.line_iter() {
if line.contains(*next_err_pat) {
debug!("found error pattern %s", *next_err_pat);
next_err_idx += 1u;
fatal_ProcRes(fmt!("error pattern '%s' not found!",
missing_patterns[0]), ProcRes);
} else {
- foreach pattern in missing_patterns.iter() {
+ for pattern in missing_patterns.iter() {
error(fmt!("error pattern '%s' not found!", *pattern));
}
fatal_ProcRes(~"multiple error patterns not found", ProcRes);
// filename:line1:col1: line2:col2: *warning:* msg
// where line1:col1: is the starting point, line2:col2:
// is the ending point, and * represents ANSI color codes.
- foreach line in ProcRes.stderr.line_iter() {
+ for line in ProcRes.stderr.line_iter() {
let mut was_expected = false;
- foreach (i, ee) in expected_errors.iter().enumerate() {
+ for (i, ee) in expected_errors.iter().enumerate() {
if !found_flags[i] {
debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
prefixes[i], ee.kind, ee.msg, line);
}
}
- foreach i in range(0u, found_flags.len()) {
+ for i in range(0u, found_flags.len()) {
if !found_flags[i] {
let ee = &expected_errors[i];
fatal_ProcRes(fmt!("expected %s on line %u not found: %s",
let extra_link_args = ~[~"-L",
aux_output_dir_name(config, testfile).to_str()];
- foreach rel_ab in props.aux_builds.iter() {
+ for rel_ab in props.aux_builds.iter() {
let abs_ab = config.aux_base.push_rel(&Path(*rel_ab));
let aux_args =
make_compile_args(config, props, ~[~"--lib"] + extra_link_args,
runargs.push(fmt!("%s", config.adb_test_dir));
runargs.push(fmt!("%s", prog_short));
- foreach tv in args.args.iter() {
+ for tv in args.args.iter() {
runargs.push(tv.to_owned());
}
Some(~""));
let mut exitcode : int = 0;
- foreach c in exitcode_out.iter() {
+ for c in exitcode_out.iter() {
if !c.is_digit() { break; }
exitcode = exitcode * 10 + match c {
'0' .. '9' => c as int - ('0' as int),
let tstr = aux_output_dir_name(config, testfile).to_str();
let dirs = os::list_dir_path(&Path(tstr));
- foreach file in dirs.iter() {
+ for file in dirs.iter() {
if (file.filetype() == Some(~".so")) {
my $anchors = {};
my $i = 0;
-foreach $line (@lines) {
+for $line (@lines) {
$i++;
if ($line =~ m/id="([^"]+)"/) {
$anchors->{$1} = $i;
}
$i = 0;
-foreach $line (@lines) {
+for $line (@lines) {
$i++;
while ($line =~ m/href="#([^"]+)"/g) {
if (! exists($anchors->{$1})) {
"do"
"else" "enum" "extern"
"false" "fn" "for"
- "if" "impl"
+ "if" "impl" "in"
"let" "loop"
"match" "mod" "mut"
"priv" "pub"
" Maintainer: Patrick Walton <pcwalton@mozilla.com>
" Maintainer: Ben Blum <bblum@cs.cmu.edu>
" Maintainer: Chris Morgan <me@chrismorgan.info>
-" Last Change: 2013 Jul 10
+" Last Change: 2013 Aug 1
if version < 600
syntax clear
syn match rustAssert "\<assert\(\w\)*!" contained
syn match rustFail "\<fail\(\w\)*!" contained
syn keyword rustKeyword break copy do extern
-syn keyword rustKeyword for if impl let log
+syn keyword rustKeyword in if impl let log
syn keyword rustKeyword copy do extern
syn keyword rustKeyword for impl let log
syn keyword rustKeyword loop mod once priv pub
syn match rustFuncCall "\w\(\w\)*("he=e-1,me=e-1
syn match rustFuncCall "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();
+" This is merely a convention; note also the use of [A-Z], restricting it to
+" latin identifiers rather than the full Unicode uppercase. I have not used
+" [:upper:] as it depends upon 'noignorecase'
+"syn match rustCapsIdent display "[A-Z]\w\(\w\)*"
+
+syn match rustOperator display "\%(+\|-\|/\|*\|=\|\^\|&\||\|!\|>\|<\|%\)=\?"
+" This one isn't *quite* right, as we could have binary-& with a reference
+syn match rustSigil display /&\s\+[&~@*][^)= \t\r\n]/he=e-1,me=e-1
+syn match rustSigil display /[&~@*][^)= \t\r\n]/he=e-1,me=e-1
+" This isn't actually correct; a closure with no arguments can be `|| { }`.
+" Last, because the & in && isn't a sigil
+syn match rustOperator display "&&\|||"
+
syn match rustMacro '\w\(\w\)*!' contains=rustAssert,rustFail
syn match rustMacro '#\w\(\w\)*' contains=rustAssert,rustFail
syn match rustFormat display "%\(\d\+\$\)\=[-+' #0*]*\(\d*\|\*\|\*\d\+\$\)\(\.\(\d*\|\*\|\*\d\+\$\)\)\=\([hlLjzt]\|ll\|hh\)\=\([aAbdiuoxXDOUfFeEgGcCsSpn?]\|\[\^\=.[^]]*\]\)" contained
syn match rustFormat display "%%" contained
-syn region rustString start=+L\="+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo,rustFormat
+syn match rustSpecial display contained /\\\([nrt\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
+syn region rustString start=+L\="+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo,rustFormat,rustSpecial
syn region rustAttribute start="#\[" end="\]" contains=rustString,rustDeriving
syn region rustDeriving start="deriving(" end=")" contained contains=rustTrait
syn match rustFloat display "\<[0-9][0-9_]*\.[0-9_]\+\%([eE][+-]\=[0-9_]\+\)\(f\|f32\|f64\)\>"
" For the benefit of delimitMate
-syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustLifetime
+syn region rustLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
syn region rustGenericRegion display start=/<\%('\|[^[cntrl:][:space:][:punct:]]\)\@=')\S\@=/ end=/>/ contains=rustGenericLifetimeCandidate
-syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustLifetime
+syn region rustGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=rustSigil,rustLifetime
"rustLifetime must appear before rustCharacter, or chars will get the lifetime highlighting
syn match rustLifetime display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
-syn match rustCharacter "'\([^'\\]\|\\\(['nrt\\\"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'"
+syn match rustCharacter /'\([^'\\]\|\\\([nrt\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial
syn region rustCommentML start="/\*" end="\*/" contains=rustTodo
syn region rustComment start="//" skip="\\$" end="$" contains=rustTodo keepend
hi def link rustIdentifierPrime rustIdentifier
hi def link rustTrait rustType
+hi def link rustSigil StorageClass
hi def link rustFormat Special
+hi def link rustSpecial Special
hi def link rustString String
hi def link rustCharacter Character
hi def link rustNumber Number
hi def link rustKeyword Keyword
hi def link rustConditional Conditional
hi def link rustIdentifier Identifier
+hi def link rustCapsIdent rustIdentifier
hi def link rustModPath Include
hi def link rustModPathSep Delimiter
hi def link rustFuncName Function
fun:*
...
}
+
+{
+ libuv-mac-no-thread-join
+ Memcheck:Leak
+ fun:malloc_zone_malloc
+ fun:_CFRuntimeCreateInstance
+ fun:CFRunLoopSourceCreate
+ fun:uv__platform_loop_init
+ fun:uv__loop_init
+ fun:uv_loop_new
+ fun:rust_uv_loop_new__c_stack_shim
+ ...
+}
\ No newline at end of file
}
// Wait for children to pass their asserts
- foreach r in children.iter() {
+ for r in children.iter() {
r.recv();
}
*state = 31337;
// FIXME: #7372: hits type inference bug with iterators
// send to other readers
- foreach i in range(0u, reader_convos.len()) {
+ for i in range(0u, reader_convos.len()) {
match reader_convos[i] {
(ref rc, _) => rc.send(()),
}
do (&read_mode).read |state| {
// FIXME: #7372: hits type inference bug with iterators
// complete handshake with other readers
- foreach i in range(0u, reader_convos.len()) {
+ for i in range(0u, reader_convos.len()) {
match reader_convos[i] {
(_, ref rp) => rp.recv(),
}
#[test]
fn test_arena_destructors() {
let arena = Arena();
- foreach i in range(0u, 10) {
+ for i in range(0u, 10) {
// Arena allocate something with drop glue to make sure it
// doesn't leak.
do arena.alloc { @i };
fn test_arena_destructors_fail() {
let arena = Arena();
// Put some stuff in the arena.
- foreach i in range(0u, 10) {
+ for i in range(0u, 10) {
// Arena allocate something with drop glue to make sure it
// doesn't leak.
do arena.alloc { @i };
let mut modulus = 0;
let mut it = self.iter();
- foreach &byte in it {
+ for &byte in it {
let ch = byte as char;
let val = byte as u32;
let len = b.storage.len();
assert_eq!(self.storage.len(), len);
let mut changed = false;
- foreach i in range(0, len) {
+ for i in range(0, len) {
let mask = big_mask(nbits, i);
let w0 = self.storage[i] & mask;
let w1 = b.storage[i] & mask;
match self.rep {
Small(ref b) => b.is_true(self.nbits),
_ => {
- foreach i in self.iter() { if !i { return false; } }
+ for i in self.iter() { if !i { return false; } }
true
}
}
match self.rep {
Small(ref b) => b.is_false(self.nbits),
Big(_) => {
- foreach i in self.iter() { if i { return false; } }
+ for i in self.iter() { if i { return false; } }
true
}
}
*/
pub fn to_str(&self) -> ~str {
let mut rs = ~"";
- foreach i in self.iter() {
+ for i in self.iter() {
if i {
rs.push_char('1');
} else {
*/
pub fn from_fn(len: uint, f: &fn(index: uint) -> bool) -> Bitv {
let mut bitv = Bitv::new(len, false);
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
bitv.set(i, f(i));
}
bitv
if bits == 0 {
return true;
}
- foreach i in range(0u, uint::bits) {
+ for i in range(0u, uint::bits) {
if bits & (1 << i) != 0 {
if !f(base + i) {
return false;
fn other_op(&mut self, other: &BitvSet, f: &fn(uint, uint) -> uint) {
fn nbits(mut w: uint) -> uint {
let mut bits = 0;
- foreach _ in range(0u, uint::bits) {
+ for _ in range(0u, uint::bits) {
if w == 0 {
break;
}
if self.capacity() < other.capacity() {
self.bitv.storage.grow(other.capacity() / uint::bits, &0);
}
- foreach (i, &w) in other.bitv.storage.iter().enumerate() {
+ for (i, &w) in other.bitv.storage.iter().enumerate() {
let old = self.bitv.storage[i];
let new = f(old, w);
self.bitv.storage[i] = new;
}
pub fn difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) -> bool {
- foreach (i, w1, w2) in self.common_iter(other) {
+ for (i, w1, w2) in self.common_iter(other) {
if !iterate_bits(i, w1 & !w2, |b| f(&b)) {
return false
}
pub fn symmetric_difference(&self, other: &BitvSet,
f: &fn(&uint) -> bool) -> bool {
- foreach (i, w1, w2) in self.common_iter(other) {
+ for (i, w1, w2) in self.common_iter(other) {
if !iterate_bits(i, w1 ^ w2, |b| f(&b)) {
return false
}
}
pub fn union(&self, other: &BitvSet, f: &fn(&uint) -> bool) -> bool {
- foreach (i, w1, w2) in self.common_iter(other) {
+ for (i, w1, w2) in self.common_iter(other) {
if !iterate_bits(i, w1 | w2, |b| f(&b)) {
return false
}
if self.size != other.size {
return false;
}
- foreach (_, w1, w2) in self.common_iter(other) {
+ for (_, w1, w2) in self.common_iter(other) {
if w1 != w2 {
return false;
}
}
- foreach (_, _, w) in self.outlier_iter(other) {
+ for (_, _, w) in self.outlier_iter(other) {
if w != 0 {
return false;
}
}
fn is_subset(&self, other: &BitvSet) -> bool {
- foreach (_, w1, w2) in self.common_iter(other) {
+ for (_, w1, w2) in self.common_iter(other) {
if w1 & w2 != w1 {
return false;
}
/* If anything is not ours, then everything is not ours so we're
definitely a subset in that case. Otherwise if there's any stray
ones that 'other' doesn't have, we're not a subset. */
- foreach (mine, _, w) in self.outlier_iter(other) {
+ for (mine, _, w) in self.outlier_iter(other) {
if !mine {
return true;
} else if w != 0 {
#[test]
fn test_equal_sneaky_big() {
let mut a = bitv::Bitv::new(100, false);
- foreach i in range(0u, 100) {
+ for i in range(0u, 100) {
a.set(i, true);
}
let mut b = bitv::Bitv::new(100, true);
- foreach i in range(0u, 100) {
+ for i in range(0u, 100) {
b.set(i, true);
}
let bools = [true, false, true, true];
let bitv = from_bools(bools);
- foreach (act, &ex) in bitv.iter().zip(bools.iter()) {
+ for (act, &ex) in bitv.iter().zip(bools.iter()) {
assert_eq!(ex, act);
}
}
let bitv = Bitv::new(uint::bits, false);
do b.iter {
let mut _sum = 0;
- foreach pres in bitv.iter() {
+ for pres in bitv.iter() {
_sum += pres as uint;
}
}
let bitv = Bitv::new(BENCH_BITS, false);
do b.iter {
let mut _sum = 0;
- foreach pres in bitv.iter() {
+ for pres in bitv.iter() {
_sum += pres as uint;
}
}
|idx| {idx % 3 == 0}));
do b.iter {
let mut _sum = 0;
- foreach idx in bitv.iter() {
+ for idx in bitv.iter() {
_sum += idx;
}
}
let mut rng = rand::XorShiftRng::new();
map.clear();
- foreach _ in range(0, n) {
+ for _ in range(0, n) {
map.insert(rng.gen::<uint>() % n, 1);
}
bh: &mut BenchHarness) {
// setup
map.clear();
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
map.insert(i*2, 1);
}
let mut rng = rand::XorShiftRng::new();
let mut keys = vec::from_fn(n, |_| rng.gen::<uint>() % n);
- foreach k in keys.iter() {
+ for k in keys.iter() {
map.insert(*k, 1);
}
map: &mut M,
bh: &mut BenchHarness) {
// setup
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
map.insert(i, 1);
}
fn to_hex(rr: &[u8]) -> ~str {
let mut s = ~"";
- foreach b in rr.iter() {
+ for b in rr.iter() {
let hex = uint::to_str_radix(*b as uint, 16u);
if hex.len() == 1 {
s.push_char('0');
let mut out = [0u8, ..20];
let mut sh = ~Sha1::new();
- foreach t in tests.iter() {
+ for t in tests.iter() {
(*sh).input_str(t.input);
sh.result(out);
assert!(t.output.as_slice() == out);
// Test that it works when accepting the message in pieces
- foreach t in tests.iter() {
+ for t in tests.iter() {
let len = t.input.len();
let mut left = len;
while left > 0u {
fn test_hash<D: Digest>(sh: &mut D, tests: &[Test]) {
// Test that it works when accepting the message all at once
- foreach t in tests.iter() {
+ for t in tests.iter() {
sh.input_str(t.input);
let out_str = sh.result_str();
}
// Test that it works when accepting the message in pieces
- foreach t in tests.iter() {
+ for t in tests.iter() {
let len = t.input.len();
let mut left = len;
while left > 0u {
impl<A, T: Iterator<A>> Extendable<A, T> for DList<A> {
fn extend(&mut self, iterator: &mut T) {
- foreach elt in *iterator { self.push_back(elt); }
+ for elt in *iterator { self.push_back(elt); }
}
}
check_links(&m);
let sum = v + u;
assert_eq!(sum.len(), m.len());
- foreach elt in sum.consume_iter() {
+ for elt in sum.consume_iter() {
assert_eq!(m.pop_front(), Some(elt))
}
}
check_links(&m);
let sum = u + v;
assert_eq!(sum.len(), m.len());
- foreach elt in sum.consume_iter() {
+ for elt in sum.consume_iter() {
assert_eq!(m.pop_front(), Some(elt))
}
}
#[test]
fn test_iterator() {
let m = generate_test();
- foreach (i, elt) in m.iter().enumerate() {
+ for (i, elt) in m.iter().enumerate() {
assert_eq!(i as int, *elt);
}
let mut n = DList::new();
#[test]
fn test_rev_iter() {
let m = generate_test();
- foreach (i, elt) in m.rev_iter().enumerate() {
+ for (i, elt) in m.rev_iter().enumerate() {
assert_eq!((6 - i) as int, *elt);
}
let mut n = DList::new();
fn test_mut_iter() {
let mut m = generate_test();
let mut len = m.len();
- foreach (i, elt) in m.mut_iter().enumerate() {
+ for (i, elt) in m.mut_iter().enumerate() {
assert_eq!(i as int, *elt);
len -= 1;
}
#[test]
fn test_mut_rev_iter() {
let mut m = generate_test();
- foreach (i, elt) in m.mut_rev_iter().enumerate() {
+ for (i, elt) in m.mut_rev_iter().enumerate() {
assert_eq!((6-i) as int, *elt);
}
let mut n = DList::new();
fn fuzz_test(sz: int) {
let mut m = DList::new::<int>();
let mut v = ~[];
- foreach i in range(0, sz) {
+ for i in range(0, sz) {
check_links(&m);
let r: u8 = rand::random();
match r % 6 {
check_links(&m);
let mut i = 0u;
- foreach (a, &b) in m.consume_iter().zip(v.iter()) {
+ for (a, &b) in m.consume_iter().zip(v.iter()) {
i += 1;
assert_eq!(a, b);
}
fn make_file(path : &Path, contents: &[~str]) {
let file = io::file_writer(path, [io::Create, io::Truncate]).unwrap();
- foreach str in contents.iter() {
+ for str in contents.iter() {
file.write_str(*str);
file.write_char('\n');
}
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-byte-%u.tmp", i)), true);
// 3 files containing 0\n, 1\n, and 2\n respectively
- foreach (i, filename) in filenames.iter().enumerate() {
+ for (i, filename) in filenames.iter().enumerate() {
make_file(filename.get_ref(), [fmt!("%u", i)]);
}
let fi = FileInput::from_vec(filenames.clone());
- foreach (line, c) in "012".iter().enumerate() {
+ for (line, c) in "012".iter().enumerate() {
assert_eq!(fi.read_byte(), c as int);
assert_eq!(fi.state().line_num, line);
assert_eq!(fi.state().line_num_file, 0);
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-%u.tmp", i)), true);
// 3 files containing 1\n, 2\n, and 3\n respectively
- foreach (i, filename) in filenames.iter().enumerate() {
+ for (i, filename) in filenames.iter().enumerate() {
make_file(filename.get_ref(), [fmt!("%u", i)]);
}
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-%u.tmp", i)), true);
- foreach (i, filename) in filenames.iter().enumerate() {
+ for (i, filename) in filenames.iter().enumerate() {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j));
make_file(filename.get_ref(), contents);
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-state-%u.tmp", i)),true);
- foreach (i, filename) in filenames.iter().enumerate() {
+ for (i, filename) in filenames.iter().enumerate() {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
make_file(filename.get_ref(), contents);
3,
|i| fmt!("tmp/lib-fileinput-test-next-file-%u.tmp", i)),true);
- foreach (i, filename) in filenames.iter().enumerate() {
+ for (i, filename) in filenames.iter().enumerate() {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
make_file(filename.get_ref(), contents);
input.next_file(); // skip the rest of 1
// read all lines from 1 (but don't read any from 2),
- foreach i in range(1u, 4) {
+ for i in range(1u, 4) {
assert_eq!(input.read_line(), fmt!("1 %u", i));
}
// 1 is finished, but 2 hasn't been started yet, so this will
let (port, chan) = serial::pipe_stream();
do task::spawn || {
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
chan.send(@i)
}
}
-foreach i in range(0, 10) {
+for i in range(0, 10) {
assert @i == port.recv()
}
~~~
let (port, chan) = serial::pipe_stream();
do task::spawn || {
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
chan.send(i)
}
}
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
assert!(i == port.recv())
}
}
let (port, chan) = serial::pipe_stream();
do task::spawn || {
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
chan.send(@i)
}
}
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
assert!(@i == port.recv())
}
}
let (port, chan) = pod::pipe_stream();
do task::spawn || {
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
chan.send(i)
}
}
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
assert!(i == port.recv())
}
}
// TcpSocketBuf is a Writer!
let chan = writer_chan(socket_buf);
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
debug!("sending %?", i);
chan.send(i)
}
// TcpSocketBuf is a Reader!
let port = reader_port(socket_buf);
- foreach i in range(0, 10) {
+ for i in range(0, 10) {
let j = port.recv();
debug!("received %?", j);
assert_eq!(i, j);
}
}
let mut name_pos = 0;
- foreach nm in names.iter() {
+ for nm in names.iter() {
name_pos += 1;
let optid = match find_opt(opts, (*nm).clone()) {
Some(id) => id,
/// Returns true if any of several options were matched
pub fn opts_present(mm: &Matches, names: &[~str]) -> bool {
- foreach nm in names.iter() {
+ for nm in names.iter() {
match find_opt(mm.opts, mkname(*nm)) {
Some(id) if !mm.vals[id].is_empty() => return true,
_ => (),
* option took an argument
*/
pub fn opts_str(mm: &Matches, names: &[~str]) -> ~str {
- foreach nm in names.iter() {
+ for nm in names.iter() {
match opt_val(mm, *nm) {
Some(Val(ref s)) => return (*s).clone(),
_ => ()
pub fn opt_strs(mm: &Matches, nm: &str) -> ~[~str] {
let mut acc: ~[~str] = ~[];
let r = opt_vals(mm, nm);
- foreach v in r.iter() {
+ for v in r.iter() {
match *v { Val(ref s) => acc.push((*s).clone()), _ => () }
}
acc
// Normalize desc to contain words separated by one space character
let mut desc_normalized_whitespace = ~"";
- foreach word in desc.word_iter() {
+ for word in desc.word_iter() {
desc_normalized_whitespace.push_str(word);
desc_normalized_whitespace.push_char(' ');
}
let xs = [0u, 1, 2, 3, 4, 5];
let ys = [30, 40, 50, 60];
let mut it = xs.iter().chain(ys.iter());
-foreach &x: &uint in it {
+for &x: &uint in it {
println(x.to_str());
}
~~~
fn escape_str(s: &str) -> ~str {
let mut escaped = ~"\"";
- foreach c in s.iter() {
+ for c in s.iter() {
match c {
'"' => escaped.push_str("\\\""),
'\\' => escaped.push_str("\\\\"),
fn read_char(&mut self) -> char {
let mut v = ~[];
let s = self.read_str();
- foreach c in s.iter() { v.push(c) }
+ for c in s.iter() { v.push(c) }
if v.len() != 1 { fail!("string must have one character") }
v[0]
}
let name = match self.stack.pop() {
String(s) => s,
List(list) => {
- foreach v in list.consume_rev_iter() {
+ for v in list.consume_rev_iter() {
self.stack.push(v);
}
match self.stack.pop() {
let len = match self.stack.pop() {
List(list) => {
let len = list.len();
- foreach v in list.consume_rev_iter() {
+ for v in list.consume_rev_iter() {
self.stack.push(v);
}
len
let len = match self.stack.pop() {
Object(obj) => {
let len = obj.len();
- foreach (key, value) in obj.consume_iter() {
+ for (key, value) in obj.consume_iter() {
self.stack.push(value);
self.stack.push(String(key));
}
let mut d1_flat = ~[];
// FIXME #4430: this is horribly inefficient...
- foreach (k, v) in d0.iter() {
+ for (k, v) in d0.iter() {
d0_flat.push((@(*k).clone(), @(*v).clone()));
}
d0_flat.qsort();
- foreach (k, v) in d1.iter() {
+ for (k, v) in d1.iter() {
d1_flat.push((@(*k).clone(), @(*v).clone()));
}
d1_flat.qsort();
impl<A:ToJson> ToJson for TreeMap<~str, A> {
fn to_json(&self) -> Json {
let mut d = TreeMap::new();
- foreach (key, value) in self.iter() {
+ for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Object(~d)
impl<A:ToJson> ToJson for HashMap<~str, A> {
fn to_json(&self) -> Json {
let mut d = TreeMap::new();
- foreach (key, value) in self.iter() {
+ for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Object(~d)
fn mk_object(items: &[(~str, Json)]) -> Json {
let mut d = ~TreeMap::new();
- foreach item in items.iter() {
+ for item in items.iter() {
match *item {
(ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
}
if s_len < o_len { return Less; }
if s_len > o_len { return Greater; }
- foreach (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
+ for (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
cond!((self_i < other_i) { return Less; }
(self_i > other_i) { return Greater; })
}
let bn = *b.data.last();
let mut d = ~[];
let mut carry = 0;
- foreach elt in an.rev_iter() {
+ for elt in an.rev_iter() {
let ai = BigDigit::to_uint(carry, *elt);
let di = ai / (bn as uint);
assert!(di < BigDigit::base);
fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str {
if v.is_empty() { return ~"0" }
let mut s = str::with_capacity(v.len() * l);
- foreach n in v.rev_iter() {
+ for n in v.rev_iter() {
let ss = uint::to_str_radix(*n as uint, radix);
s.push_str("0".repeat(l - ss.len()));
s.push_str(ss);
let mut borrow = 0;
let mut shifted = ~[];
- foreach elem in self.data.rev_iter() {
+ for elem in self.data.rev_iter() {
shifted = ~[(*elem >> n_bits) | borrow] + shifted;
borrow = *elem << (BigDigit::bits - n_bits);
}
fn test_cmp() {
let data: ~[BigUint] = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ]
.map(|v| BigUint::from_slice(*v));
- foreach (i, ni) in data.iter().enumerate() {
- foreach (j0, nj) in data.slice(i, data.len()).iter().enumerate() {
+ for (i, ni) in data.iter().enumerate() {
+ for (j0, nj) in data.slice(i, data.len()).iter().enumerate() {
let j = j0 + i;
if i == j {
assert_eq!(ni.cmp(nj), Equal);
#[test]
fn test_add() {
- foreach elm in sum_triples.iter() {
+ for elm in sum_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
#[test]
fn test_sub() {
- foreach elm in sum_triples.iter() {
+ for elm in sum_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
#[test]
fn test_mul() {
- foreach elm in mul_triples.iter() {
+ for elm in mul_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
assert!(b * a == c);
}
- foreach elm in div_rem_quadruples.iter() {
+ for elm in div_rem_quadruples.iter() {
let (aVec, bVec, cVec, dVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
#[test]
fn test_div_rem() {
- foreach elm in mul_triples.iter() {
+ for elm in mul_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
}
}
- foreach elm in div_rem_quadruples.iter() {
+ for elm in div_rem_quadruples.iter() {
let (aVec, bVec, cVec, dVec) = *elm;
let a = BigUint::from_slice(aVec);
let b = BigUint::from_slice(bVec);
#[test]
fn test_to_str_radix() {
let r = to_str_pairs();
- foreach num_pair in r.iter() {
+ for num_pair in r.iter() {
let &(ref n, ref rs) = num_pair;
- foreach str_pair in rs.iter() {
+ for str_pair in rs.iter() {
let &(ref radix, ref str) = str_pair;
assert_eq!(&n.to_str_radix(*radix), str);
}
#[test]
fn test_from_str_radix() {
let r = to_str_pairs();
- foreach num_pair in r.iter() {
+ for num_pair in r.iter() {
let &(ref n, ref rs) = num_pair;
- foreach str_pair in rs.iter() {
+ for str_pair in rs.iter() {
let &(ref radix, ref str) = str_pair;
assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).get());
}
fn test_factor() {
fn factor(n: uint) -> BigUint {
let mut f= One::one::<BigUint>();
- foreach i in range(2, n + 1) {
+ for i in range(2, n + 1) {
// FIXME(#6102): Assignment operator for BigInt causes ICE
// f *= BigUint::from_uint(i);
f = f * BigUint::from_uint(i);
fn test_cmp() {
let vs = [ &[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1] ];
let mut nums = ~[];
- foreach s in vs.rev_iter() {
+ for s in vs.rev_iter() {
nums.push(BigInt::from_slice(Minus, *s));
}
nums.push(Zero::zero());
nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
- foreach (i, ni) in nums.iter().enumerate() {
- foreach (j0, nj) in nums.slice(i, nums.len()).iter().enumerate() {
+ for (i, ni) in nums.iter().enumerate() {
+ for (j0, nj) in nums.slice(i, nums.len()).iter().enumerate() {
let j = i + j0;
if i == j {
assert_eq!(ni.cmp(nj), Equal);
#[test]
fn test_add() {
- foreach elm in sum_triples.iter() {
+ for elm in sum_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
#[test]
fn test_sub() {
- foreach elm in sum_triples.iter() {
+ for elm in sum_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
#[test]
fn test_mul() {
- foreach elm in mul_triples.iter() {
+ for elm in mul_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
assert!((-b) * a == -c);
}
- foreach elm in div_rem_quadruples.iter() {
+ for elm in div_rem_quadruples.iter() {
let (aVec, bVec, cVec, dVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
}
}
- foreach elm in mul_triples.iter() {
+ for elm in mul_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
- foreach elm in div_rem_quadruples.iter() {
+ for elm in div_rem_quadruples.iter() {
let (aVec, bVec, cVec, dVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
check_sub(&a.neg(), b, &q.neg(), &r.neg());
check_sub(&a.neg(), &b.neg(), q, &r.neg());
}
- foreach elm in mul_triples.iter() {
+ for elm in mul_triples.iter() {
let (aVec, bVec, cVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
}
- foreach elm in div_rem_quadruples.iter() {
+ for elm in div_rem_quadruples.iter() {
let (aVec, bVec, cVec, dVec) = *elm;
let a = BigInt::from_slice(Plus, aVec);
let b = BigInt::from_slice(Plus, bVec);
fn test_scale_unscale() {
assert_eq!(_05_05i.scale(2f), _1_1i);
assert_eq!(_1_1i.unscale(2f), _05_05i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(c.scale(2f).unscale(2f), c);
}
}
#[test]
fn test_conj() {
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(c.conj(), Cmplx::new(c.re, -c.im));
assert_eq!(c.conj().conj(), c);
}
let (r, theta) = c.to_polar();
assert!((c - Cmplx::from_polar(&r, &theta)).norm() < 1e-6);
}
- foreach &c in all_consts.iter() { test(c); }
+ for &c in all_consts.iter() { test(c); }
}
mod arith {
assert_eq!(_0_1i + _1_0i, _1_1i);
assert_eq!(_1_0i + _neg1_1i, _0_1i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(_0_0i + c, c);
assert_eq!(c + _0_0i, c);
}
assert_eq!(_0_1i - _1_0i, _neg1_1i);
assert_eq!(_0_1i - _neg1_1i, _1_0i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(c - _0_0i, c);
assert_eq!(c - c, _0_0i);
}
assert_eq!(_0_1i * _0_1i, -_1_0i);
assert_eq!(_0_1i * _0_1i * _0_1i * _0_1i, _1_0i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(c * _1_0i, c);
assert_eq!(_1_0i * c, c);
}
#[test]
fn test_div() {
assert_eq!(_neg1_1i / _0_1i, _1_1i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
if c != Zero::zero() {
assert_eq!(c / c, _1_0i);
}
fn test_neg() {
assert_eq!(-_1_0i + _0_1i, _neg1_1i);
assert_eq!((-_0_1i) * _0_1i, _1_0i);
- foreach &c in all_consts.iter() {
+ for &c in all_consts.iter() {
assert_eq!(-(-c), c);
}
}
}
let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1"];
- foreach &s in xs.iter() {
+ for &s in xs.iter() {
test(s);
}
}
}
let xs = ["0 /1", "abc", "", "1/", "--1/2","3/2/1", "3/2"];
- foreach &s in xs.iter() {
+ for &s in xs.iter() {
test(s);
}
}
let len = self.capacity();
self.reserve_at_least(len + lower);
- foreach elem in *iter {
+ for elem in *iter {
self.push(elem);
}
}
let iterout = ~[9, 5, 3];
let pq = PriorityQueue::from_vec(data);
let mut i = 0;
- foreach el in pq.iter() {
+ for el in pq.iter() {
assert_eq!(*el, iterout[i]);
i += 1;
}
let mut q: PriorityQueue<uint> = xs.rev_iter().transform(|&x| x).collect();
- foreach &x in xs.iter() {
+ for &x in xs.iter() {
assert_eq!(q.pop(), x);
}
}
impl<T> Mutable for RingBuf<T> {
/// Clear the RingBuf, removing all values.
fn clear(&mut self) {
- foreach x in self.elts.mut_iter() { *x = None }
+ for x in self.elts.mut_iter() { *x = None }
self.nelts = 0;
self.lo = 0;
}
elts.reserve(newlen);
/* fill with None */
- foreach _ in range(elts.len(), elts.capacity()) {
+ for _ in range(elts.len(), elts.capacity()) {
elts.push(None);
}
assert!(newlen - nelts/2 >= nelts);
if lo <= (nelts - lo) { // A
- foreach i in range(0u, lo) {
+ for i in range(0u, lo) {
elts.swap(i, nelts + i);
}
} else { // B
- foreach i in range(lo, nelts) {
+ for i in range(lo, nelts) {
elts.swap(i, newlen - nelts + i);
}
*loptr += newlen - nelts;
impl<A, T: Iterator<A>> Extendable<A, T> for RingBuf<A> {
fn extend(&mut self, iterator: &mut T) {
- foreach elt in *iterator {
+ for elt in *iterator {
self.push_back(elt);
}
}
#[test]
fn test_push_front_grow() {
let mut deq = RingBuf::new();
- foreach i in range(0u, 66) {
+ for i in range(0u, 66) {
deq.push_front(i);
}
assert_eq!(deq.len(), 66);
- foreach i in range(0u, 66) {
+ for i in range(0u, 66) {
assert_eq!(*deq.get(i), 65 - i);
}
let mut deq = RingBuf::new();
- foreach i in range(0u, 66) {
+ for i in range(0u, 66) {
deq.push_back(i);
}
- foreach i in range(0u, 66) {
+ for i in range(0u, 66) {
assert_eq!(*deq.get(i), i);
}
}
assert_eq!(d.iter().next(), None);
assert_eq!(d.iter().size_hint(), (0, Some(0)));
- foreach i in range(0, 5) {
+ for i in range(0, 5) {
d.push_back(i);
}
assert_eq!(d.iter().collect::<~[&int]>(), ~[&0,&1,&2,&3,&4]);
- foreach i in range(6, 9) {
+ for i in range(6, 9) {
d.push_front(i);
}
assert_eq!(d.iter().collect::<~[&int]>(), ~[&8,&7,&6,&0,&1,&2,&3,&4]);
let mut d = RingBuf::new();
assert_eq!(d.rev_iter().next(), None);
- foreach i in range(0, 5) {
+ for i in range(0, 5) {
d.push_back(i);
}
assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0]);
- foreach i in range(6, 9) {
+ for i in range(6, 9) {
d.push_front(i);
}
assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0,&6,&7,&8]);
let mut d = RingBuf::new();
assert!(d.mut_iter().next().is_none());
- foreach i in range(0u, 3) {
+ for i in range(0u, 3) {
d.push_front(i);
}
- foreach (i, elt) in d.mut_iter().enumerate() {
+ for (i, elt) in d.mut_iter().enumerate() {
assert_eq!(*elt, 2 - i);
*elt = i;
}
let mut d = RingBuf::new();
assert!(d.mut_rev_iter().next().is_none());
- foreach i in range(0u, 3) {
+ for i in range(0u, 3) {
d.push_front(i);
}
- foreach (i, elt) in d.mut_rev_iter().enumerate() {
+ for (i, elt) in d.mut_rev_iter().enumerate() {
assert_eq!(*elt, i);
*elt = i;
}
let mut seq = iterator::Counter::new(0u, 2).take_(256);
let deq: RingBuf<uint> = seq.collect();
- foreach (i, &x) in deq.iter().enumerate() {
+ for (i, &x) in deq.iter().enumerate() {
assert_eq!(2*i, x);
}
assert_eq!(deq.len(), 256);
impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- foreach (i, e) in self.iter().enumerate() {
+ for (i, e) in self.iter().enumerate() {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- foreach (i, e) in self.iter().enumerate() {
+ for (i, e) in self.iter().enumerate() {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- foreach (i, e) in self.iter().enumerate() {
+ for (i, e) in self.iter().enumerate() {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
> Encodable<S> for DList<T> {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- foreach (i, e) in self.iter().enumerate() {
+ for (i, e) in self.iter().enumerate() {
s.emit_seq_elt(i, |s| e.encode(s));
}
}
fn decode(d: &mut D) -> DList<T> {
let mut list = DList::new();
do d.read_seq |d, len| {
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
}
}
> Encodable<S> for RingBuf<T> {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- foreach (i, e) in self.iter().enumerate() {
+ for (i, e) in self.iter().enumerate() {
s.emit_seq_elt(i, |s| e.encode(s));
}
}
fn decode(d: &mut D) -> RingBuf<T> {
let mut deque = RingBuf::new();
do d.read_seq |d, len| {
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
}
}
fn encode(&self, e: &mut E) {
do e.emit_map(self.len()) |e| {
let mut i = 0;
- foreach (key, val) in self.iter() {
+ for (key, val) in self.iter() {
e.emit_map_elt_key(i, |e| key.encode(e));
e.emit_map_elt_val(i, |e| val.encode(e));
i += 1;
fn decode(d: &mut D) -> HashMap<K, V> {
do d.read_map |d, len| {
let mut map = HashMap::with_capacity(len);
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
let key = d.read_map_elt_key(i, |d| Decodable::decode(d));
let val = d.read_map_elt_val(i, |d| Decodable::decode(d));
map.insert(key, val);
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
let mut i = 0;
- foreach e in self.iter() {
+ for e in self.iter() {
s.emit_seq_elt(i, |s| e.encode(s));
i += 1;
}
fn decode(d: &mut D) -> HashSet<T> {
do d.read_seq |d, len| {
let mut set = HashSet::with_capacity(len);
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
set.insert(d.read_seq_elt(i, |d| Decodable::decode(d)));
}
set
fn decode(d: &mut D) -> TrieMap<V> {
do d.read_map |d, len| {
let mut map = TrieMap::new();
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
let key = d.read_map_elt_key(i, |d| Decodable::decode(d));
let val = d.read_map_elt_val(i, |d| Decodable::decode(d));
map.insert(key, val);
fn decode(d: &mut D) -> TrieSet {
do d.read_seq |d, len| {
let mut set = TrieSet::new();
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
set.insert(d.read_seq_elt(i, |d| Decodable::decode(d)));
}
set
fn encode(&self, e: &mut E) {
do e.emit_map(self.len()) |e| {
let mut i = 0;
- foreach (key, val) in self.iter() {
+ for (key, val) in self.iter() {
e.emit_map_elt_key(i, |e| key.encode(e));
e.emit_map_elt_val(i, |e| val.encode(e));
i += 1;
fn decode(d: &mut D) -> TreeMap<K, V> {
do d.read_map |d, len| {
let mut map = TreeMap::new();
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
let key = d.read_map_elt_key(i, |d| Decodable::decode(d));
let val = d.read_map_elt_val(i, |d| Decodable::decode(d));
map.insert(key, val);
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
let mut i = 0;
- foreach e in self.iter() {
+ for e in self.iter() {
s.emit_seq_elt(i, |s| e.encode(s));
i += 1;
}
fn decode(d: &mut D) -> TreeSet<T> {
do d.read_seq |d, len| {
let mut set = TreeSet::new();
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
set.insert(d.read_seq_elt(i, |d| Decodable::decode(d)));
}
set
impl<S:Encoder> EncoderHelpers for S {
fn emit_from_vec<T>(&mut self, v: &[T], f: &fn(&mut S, &T)) {
do self.emit_seq(v.len()) |this| {
- foreach (i, e) in v.iter().enumerate() {
+ for (i, e) in v.iter().enumerate() {
do this.emit_seq_elt(i) |this| {
f(this, e)
}
/// Return the number of elements in the map
fn len(&self) -> uint {
let mut sz = 0;
- foreach i in range(0u, self.v.len()) {
+ for i in range(0u, self.v.len()) {
match self.v[i] {
Some(_) => sz += 1,
None => {}
}
impl<V> Map<uint, V> for SmallIntMap<V> {
- /// Return true if the map contains a value for the specified key
- fn contains_key(&self, key: &uint) -> bool {
- self.find(key).is_some()
- }
-
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
if *key < self.v.len() {
/// Visit all key-value pairs in order
pub fn each<'a>(&'a self, it: &fn(&uint, &'a V) -> bool) -> bool {
- foreach i in range(0u, self.v.len()) {
+ for i in range(0u, self.v.len()) {
match self.v[i] {
Some(ref elt) => if !it(&i, elt) { return false; },
None => ()
/// Iterate over the map and mutate the contained values
pub fn mutate_values(&mut self, it: &fn(&uint, &mut V) -> bool) -> bool {
- foreach i in range(0, self.v.len()) {
+ for i in range(0, self.v.len()) {
match self.v[i] {
Some(ref mut elt) => if !it(&i, elt) { return false; },
None => ()
assert!(m.insert(6, 10));
assert!(m.insert(10, 11));
- foreach (k, v) in m.mut_iter() {
+ for (k, v) in m.mut_iter() {
*v += k as int;
}
assert!(m.insert(6, 10));
assert!(m.insert(10, 11));
- foreach (k, v) in m.mut_rev_iter() {
+ for (k, v) in m.mut_rev_iter() {
*v += k as int;
}
let mut m = SmallIntMap::new();
m.insert(1, ~2);
let mut called = false;
- foreach (k, v) in m.consume() {
+ for (k, v) in m.consume() {
assert!(!called);
called = true;
assert_eq!(k, 1);
assert!(len1 != 0 && len2 != 0 && base1+len1 == base2);
let mut tmp = ~[];
- foreach i in range(base1, base1+len1) {
+ for i in range(base1, base1+len1) {
tmp.push(array[i].clone());
}
assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
let mut tmp = ~[];
- foreach i in range(base2, base2+len2) {
+ for i in range(base2, base2+len2) {
tmp.push(array[i].clone());
}
from: &[T]) {
assert!(s1+from.len() <= dest.len());
- foreach (i, v) in from.iter().enumerate() {
+ for (i, v) in from.iter().enumerate() {
dest[s1+i] = (*v).clone();
}
}
let immut_names = names;
let pairs = vec::zip_slice(expected, immut_names);
- foreach p in pairs.iter() {
+ for p in pairs.iter() {
let (a, b) = *p;
debug!("%d %d", a, b);
assert_eq!(a, b);
fn tabulate_unique(lo: uint, hi: uint) {
fn isSorted<T:Ord>(arr: &[T]) {
- foreach i in range(0u, arr.len() - 1) {
+ for i in range(0u, arr.len() - 1) {
if arr[i] > arr[i+1] {
fail!("Array not sorted");
}
let mut rng = rand::rng();
- foreach i in range(lo, hi) {
+ for i in range(lo, hi) {
let n = 1 << i;
let mut arr: ~[float] = do vec::from_fn(n) |_i| {
rng.gen()
fn tabulate_managed(lo: uint, hi: uint) {
fn isSorted<T:Ord>(arr: &[@T]) {
- foreach i in range(0u, arr.len() - 1) {
+ for i in range(0u, arr.len() - 1) {
if arr[i] > arr[i+1] {
fail!("Array not sorted");
}
let mut rng = rand::rng();
- foreach i in range(lo, hi) {
+ for i in range(lo, hi) {
let n = 1 << i;
let arr: ~[@float] = do vec::from_fn(n) |_i| {
@rng.gen()
} else {
let mean = self.mean();
let mut v = 0.0;
- foreach s in self.iter() {
+ for s in self.iter() {
let x = *s - mean;
v += x*x;
}
sort::tim_sort(tmp);
let lo = percentile_of_sorted(tmp, pct);
let hi = percentile_of_sorted(tmp, 100.0-pct);
- foreach samp in samples.mut_iter() {
+ for samp in samples.mut_iter() {
if *samp > hi {
*samp = hi
} else if *samp < lo {
}
// wait until all children get in the mutex
- foreach port in ports.iter() { let _ = port.recv(); }
+ for port in ports.iter() { let _ = port.recv(); }
do m.lock_cond |cond| {
let num_woken = cond.broadcast();
assert_eq!(num_woken, num_waiters);
}
// wait until all children wake up
- foreach port in ports.iter() { let _ = port.recv(); }
+ for port in ports.iter() { let _ = port.recv(); }
}
#[test]
fn test_mutex_cond_broadcast() {
}
}
}
- foreach p in sibling_convos.iter() {
+ for p in sibling_convos.iter() {
let _ = p.recv(); // wait for sibling to get in the mutex
}
do m2.lock { }
assert!(result.is_err());
// child task must have finished by the time try returns
let r = p.recv();
- foreach p in r.iter() { p.recv(); } // wait on all its siblings
+ for p in r.iter() { p.recv(); } // wait on all its siblings
do m.lock_cond |cond| {
let woken = cond.broadcast();
assert_eq!(woken, 0);
}
// wait until all children get in the mutex
- foreach port in ports.iter() { let _ = port.recv(); }
+ for port in ports.iter() { let _ = port.recv(); }
do lock_cond(x, dg2) |cond| {
let num_woken = cond.broadcast();
assert_eq!(num_woken, num_waiters);
}
// wait until all children wake up
- foreach port in ports.iter() { let _ = port.recv(); }
+ for port in ports.iter() { let _ = port.recv(); }
}
#[test]
fn test_rwlock_cond_broadcast() {
#[unsafe_destructor]
impl<T> Drop for TaskPool<T> {
fn drop(&self) {
- foreach channel in self.channels.iter() {
+ for channel in self.channels.iter() {
channel.send(Quit);
}
}
/// have the suffix `suffix`. If no directory can be created, None is returned.
pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
let mut r = rand::rng();
- foreach _ in range(0u, 1000) {
+ for _ in range(0u, 1000) {
let p = tmpdir.push(r.gen_str(16) + suffix);
if os::make_dir(&p, 0x1c0) { // 700
return Some(p);
Number(0), Number(0), Number(0), Number(0), Number(0),
Number(0), Number(0), Number(0), Number(0),
];
- foreach (dst, src) in mparams.mut_iter().zip(params.iter()) {
+ for (dst, src) in mparams.mut_iter().zip(params.iter()) {
*dst = (*src).clone();
}
- foreach c in cap.iter().transform(|&x| x) {
+ for c in cap.iter().transform(|&x| x) {
let cur = c as char;
let mut old_state = state;
match state {
let mut varstruct = Variables::new();
let vars = &mut varstruct;
let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
- foreach cap in caps.iter() {
+ for cap in caps.iter() {
let res = expand(cap.as_bytes(), [], vars);
assert!(res.is_err(),
"Op %s succeeded incorrectly with 0 stack entries", *cap);
"Op %s failed with 1 stack entry: %s", *cap, res.unwrap_err());
}
let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
- foreach cap in caps.iter() {
+ for cap in caps.iter() {
let res = expand(cap.as_bytes(), [], vars);
assert!(res.is_err(),
"Binop %s succeeded incorrectly with 0 stack entries", *cap);
#[test]
fn test_comparison_ops() {
let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
- foreach &(op, bs) in v.iter() {
+ for &(op, bs) in v.iter() {
let s = fmt!("%%{1}%%{2}%%%c%%d", op);
let res = expand(s.as_bytes(), [], &mut Variables::new());
assert!(res.is_ok(), res.unwrap_err());
let mut bools_map = HashMap::new();
if bools_bytes != 0 {
- foreach i in range(0, bools_bytes) {
+ for i in range(0, bools_bytes) {
let b = file.read_byte();
if b < 0 {
error!("EOF reading bools after %? entries", i);
let mut numbers_map = HashMap::new();
if numbers_count != 0 {
- foreach i in range(0, numbers_count) {
+ for i in range(0, numbers_count) {
let n = file.read_le_u16();
if n != 0xFFFF {
debug!("%s#%?", nnames[i], n);
if string_offsets_count != 0 {
let mut string_offsets = vec::with_capacity(10);
- foreach _ in range(0, string_offsets_count) {
+ for _ in range(0, string_offsets_count) {
string_offsets.push(file.read_le_u16());
}
return Err(~"error: hit EOF before end of string table");
}
- foreach (i, v) in string_offsets.iter().enumerate() {
+ for (i, v) in string_offsets.iter().enumerate() {
let offset = *v;
if offset == 0xFFFF { // non-entry
loop;
dirs_to_search.push(homedir.unwrap().push(".terminfo")); // ncurses compatability
}
match getenv("TERMINFO_DIRS") {
- Some(dirs) => foreach i in dirs.split_iter(':') {
+ Some(dirs) => for i in dirs.split_iter(':') {
if i == "" {
dirs_to_search.push(path("/usr/share/terminfo"));
} else {
};
// Look for the terminal in all of the search directories
- foreach p in dirs_to_search.iter() {
+ for p in dirs_to_search.iter() {
let newp = ~p.push_many(&[str::from_char(first_char), term.to_owned()]);
if os::path_exists(p) && os::path_exists(newp) {
return Some(newp);
pub fn write_failures(&self) {
self.out.write_line("\nfailures:");
let mut failures = ~[];
- foreach f in self.failures.iter() {
+ for f in self.failures.iter() {
failures.push(f.name.to_str());
}
sort::tim_sort(failures);
- foreach name in failures.iter() {
+ for name in failures.iter() {
self.out.write_line(fmt!(" %s", name.to_str()));
}
}
let mut added = 0;
let mut removed = 0;
- foreach (k, v) in diff.iter() {
+ for (k, v) in diff.iter() {
match *v {
LikelyNoise => noise += 1,
MetricAdded => {
TrIgnored => st.ignored += 1,
TrMetrics(mm) => {
let tname = test.name.to_str();
- foreach (k,v) in mm.iter() {
+ for (k,v) in mm.iter() {
st.metrics.insert_metric(tname + "." + *k,
v.value, v.noise);
}
// All benchmarks run at the end, in serial.
// (this includes metric fns)
- foreach b in filtered_benchs_and_metrics.consume_iter() {
+ for b in filtered_benchs_and_metrics.consume_iter() {
callback(TeWait(b.desc.clone()));
run_test(!opts.run_benchmarks, b, ch.clone());
let (test, result) = p.recv();
pub fn compare_to_old(&self, old: &MetricMap,
noise_pct: Option<f64>) -> MetricDiff {
let mut diff : MetricDiff = TreeMap::new();
- foreach (k, vold) in old.iter() {
+ for (k, vold) in old.iter() {
let r = match self.find(k) {
None => MetricRemoved,
Some(v) => {
};
diff.insert((*k).clone(), r);
}
- foreach (k, _) in self.iter() {
+ for (k, _) in self.iter() {
if !diff.contains_key(k) {
diff.insert((*k).clone(), MetricAdded);
}
pub fn iter(&mut self, inner:&fn()) {
self.ns_start = precise_time_ns();
let k = self.iterations;
- foreach _ in range(0u64, k) {
+ for _ in range(0u64, k) {
inner();
}
self.ns_end = precise_time_ns();
loop {
let loop_start = precise_time_ns();
- foreach p in samples.mut_iter() {
+ for p in samples.mut_iter() {
self.bench_n(n as u64, |x| f(x));
*p = self.ns_per_iter() as f64;
};
stats::winsorize(samples, 5.0);
let summ = stats::Summary::new(samples);
- foreach p in samples.mut_iter() {
+ for p in samples.mut_iter() {
self.bench_n(5 * n as u64, |x| f(x));
*p = self.ns_per_iter() as f64;
};
{
fn testfn() { }
let mut tests = ~[];
- foreach name in names.iter() {
+ for name in names.iter() {
let test = TestDescAndFn {
desc: TestDesc {
name: DynTestName((*name).clone()),
let pairs = vec::zip(expected, filtered);
- foreach p in pairs.iter() {
+ for p in pairs.iter() {
match *p {
(ref a, ref b) => {
assert!(*a == b.desc.name.to_str());
priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
fn match_str(s: &str, pos: uint, needle: &str) -> bool {
let mut i = pos;
- foreach ch in needle.byte_iter() {
+ for ch in needle.byte_iter() {
if s[i] != ch {
return false;
}
~"Friday",
~"Saturday"
];
- foreach day in days.iter() {
+ for day in days.iter() {
assert!(test(*day, "%A"));
}
~"Fri",
~"Sat"
];
- foreach day in days.iter() {
+ for day in days.iter() {
assert!(test(*day, "%a"));
}
~"November",
~"December"
];
- foreach day in months.iter() {
+ for day in months.iter() {
assert!(test(*day, "%B"));
}
~"Nov",
~"Dec"
];
- foreach day in months.iter() {
+ for day in months.iter() {
assert!(test(*day, "%b"));
}
} else {
let mut x = self.iter();
let mut y = other.iter();
- foreach _ in range(0u, self.len()) {
+ for _ in range(0u, self.len()) {
if x.next().unwrap() != y.next().unwrap() {
return false
}
let mut y = b.iter();
let (a_len, b_len) = (a.len(), b.len());
- foreach _ in range(0u, num::min(a_len, b_len)) {
+ for _ in range(0u, num::min(a_len, b_len)) {
let (key_a, value_a) = x.next().unwrap();
let (key_b, value_b) = y.next().unwrap();
if *key_a < *key_b { return true; }
}
impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
- /// Return true if the map contains a value for the specified key
- fn contains_key(&self, key: &K) -> bool {
- self.find(key).is_some()
- }
-
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
let mut current: &'a Option<~TreeNode<K, V>> = &self.root;
fn heir_swap<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>,
child: &mut Option<~TreeNode<K, V>>) {
// *could* be done without recursion, but it won't borrow check
- foreach x in child.mut_iter() {
+ for x in child.mut_iter() {
if x.right.is_some() {
heir_swap(node, &mut x.right);
} else {
save.level -= 1;
if right_level > save.level {
- foreach x in save.right.mut_iter() { x.level = save.level }
+ for x in save.right.mut_iter() { x.level = save.level }
}
skew(save);
- foreach right in save.right.mut_iter() {
+ for right in save.right.mut_iter() {
skew(right);
- foreach x in right.right.mut_iter() { skew(x) }
+ for x in right.right.mut_iter() { skew(x) }
}
split(save);
- foreach x in save.right.mut_iter() { split(x) }
+ for x in save.right.mut_iter() { split(x) }
}
return ret;
impl<K: TotalOrd, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for TreeMap<K, V> {
#[inline]
fn extend(&mut self, iter: &mut T) {
- foreach (k, v) in *iter {
+ for (k, v) in *iter {
self.insert(k, v);
}
}
impl<T: TotalOrd, Iter: Iterator<T>> Extendable<T, Iter> for TreeSet<T> {
#[inline]
fn extend(&mut self, iter: &mut Iter) {
- foreach elem in *iter {
+ for elem in *iter {
self.insert(elem);
}
}
fn check_equal<K: Eq + TotalOrd, V: Eq>(ctrl: &[(K, V)],
map: &TreeMap<K, V>) {
assert_eq!(ctrl.is_empty(), map.is_empty());
- foreach x in ctrl.iter() {
+ for x in ctrl.iter() {
let &(ref k, ref v) = x;
assert!(map.find(k).unwrap() == v)
}
- foreach (map_k, map_v) in map.iter() {
+ for (map_k, map_v) in map.iter() {
let mut found = false;
- foreach x in ctrl.iter() {
+ for x in ctrl.iter() {
let &(ref ctrl_k, ref ctrl_v) = x;
if *map_k == *ctrl_k {
assert!(*map_v == *ctrl_v);
assert!(m.insert(1, 2));
let mut n = 0;
- foreach (k, v) in m.iter() {
+ for (k, v) in m.iter() {
assert_eq!(*k, n);
assert_eq!(*v, n * 2);
n += 1;
(&x5, &y5)];
let mut i = 0;
- foreach x in b {
+ for x in b {
assert_eq!(expected[i], x);
i += 1;
}
}
- foreach x in b {
+ for x in b {
assert_eq!(expected[i], x);
i += 1;
}
let map: TreeMap<int, int> = xs.iter().transform(|&x| x).collect();
- foreach &(k, v) in xs.iter() {
+ for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
}
}
assert!(m.insert(1));
let mut n = 0;
- foreach x in m.iter() {
+ for x in m.iter() {
printfln!(x);
assert_eq!(*x, n);
n += 1
let mut set_a = TreeSet::new();
let mut set_b = TreeSet::new();
- foreach x in a.iter() { assert!(set_a.insert(*x)) }
- foreach y in b.iter() { assert!(set_b.insert(*y)) }
+ for x in a.iter() { assert!(set_a.insert(*x)) }
+ for y in b.iter() { assert!(set_b.insert(*y)) }
let mut i = 0;
do f(&set_a, &set_b) |x| {
let set: TreeSet<int> = xs.iter().transform(|&x| x).collect();
- foreach x in xs.iter() {
+ for x in xs.iter() {
assert!(set.contains(x));
}
}
let mut out = ~"";
let mut first = true;
- foreach (key, values) in m.iter() {
+ for (key, values) in m.iter() {
let key = encode_plus(*key);
- foreach value in values.iter() {
+ for value in values.iter() {
if first {
first = false;
} else {
fn query_from_str(rawquery: &str) -> Query {
let mut query: Query = ~[];
if !rawquery.is_empty() {
- foreach p in rawquery.split_iter('&') {
+ for p in rawquery.split_iter('&') {
let (k, v) = split_char_first(p, '=');
query.push((decode_component(k), decode_component(v)));
};
pub fn query_to_str(query: &Query) -> ~str {
let mut strvec = ~[];
- foreach kv in query.iter() {
+ for kv in query.iter() {
match kv {
&(ref k, ref v) => {
strvec.push(fmt!("%s=%s",
// returns the scheme and the rest of the url, or a parsing error
pub fn get_scheme(rawurl: &str) -> Result<(~str, ~str), ~str> {
- foreach (i,c) in rawurl.iter().enumerate() {
+ for (i,c) in rawurl.iter().enumerate() {
match c {
'A' .. 'Z' | 'a' .. 'z' => loop,
'0' .. '9' | '+' | '-' | '.' => {
let mut begin = 2;
let mut end = len;
- foreach (i,c) in rawurl.iter().enumerate() {
+ for (i,c) in rawurl.iter().enumerate() {
if i < 2 { loop; } // ignore the leading //
// deal with input class first
Result<(~str, ~str), ~str> {
let len = rawurl.len();
let mut end = len;
- foreach (i,c) in rawurl.iter().enumerate() {
+ for (i,c) in rawurl.iter().enumerate() {
match c {
'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '&' |'\'' | '(' | ')' | '.'
| '@' | ':' | '%' | '/' | '+' | '!' | '*' | ',' | ';' | '='
}
fn all_fresh(&self, cat: &str, map: &WorkMap) -> bool {
- foreach (k, v) in map.iter() {
+ for (k, v) in map.iter() {
if ! self.is_fresh(cat, k.kind, k.name, *v) {
return false;
}
\n"
);
- foreach command in COMMANDS.iter() {
+ for command in COMMANDS.iter() {
let padding = " ".repeat(INDENT - command.cmd.len());
printfln!(" %s%s%s", command.cmd, padding, command.usage_line);
}
if !args.is_empty() {
let r = find_cmd(*args.head());
- foreach command in r.iter() {
+ for command in r.iter() {
let result = do_command(command, args.tail());
match result {
Valid(exit_code) => unsafe { exit(exit_code.to_i32()) },
let cstore = sess.cstore;
let r = cstore::get_used_crate_files(cstore);
- foreach cratepath in r.iter() {
+ for cratepath in r.iter() {
let path = cratepath.to_str();
debug!("linking: %s", path);
let mut cmh_items = ~[];
let linkage_metas = attr::find_linkage_metas(c.attrs);
attr::require_unique_names(sess.diagnostic(), linkage_metas);
- foreach meta in linkage_metas.iter() {
+ for meta in linkage_metas.iter() {
match meta.name_str_pair() {
Some((n, value)) if "name" == n => name = Some(value),
Some((n, value)) if "vers" == n => vers = Some(value),
}
ast::MetaList(name, ref mis) => {
write_string(symbol_hasher, len_and_str(name));
- foreach m_ in mis.iter() {
+ for m_ in mis.iter() {
hash(symbol_hasher, m_);
}
}
}
symbol_hasher.reset();
- foreach m in cmh_items.iter() {
+ for m in cmh_items.iter() {
hash(symbol_hasher, m);
}
- foreach dh in dep_hashes.iter() {
+ for dh in dep_hashes.iter() {
write_string(symbol_hasher, len_and_str(*dh));
}
// gas accepts the following characters in symbols: a-z, A-Z, 0-9, ., _, $
pub fn sanitize(s: &str) -> ~str {
let mut result = ~"";
- foreach c in s.iter() {
+ for c in s.iter() {
match c {
// Escape these with $ sequences
'@' => result.push_str("$SP$"),
let mut n = ~"_ZN"; // Begin name-sequence.
- foreach s in ss.iter() {
+ for s in ss.iter() {
match *s {
path_name(s) | path_mod(s) => {
let sani = sanitize(sess.str_of(s));
let cstore = sess.cstore;
let r = cstore::get_used_crate_files(cstore);
- foreach cratepath in r.iter() {
+ for cratepath in r.iter() {
if cratepath.filetype() == Some(~".rlib") {
args.push(cratepath.to_str());
loop;
}
let ula = cstore::get_used_link_args(cstore);
- foreach arg in ula.iter() { args.push(arg.to_owned()); }
+ for arg in ula.iter() { args.push(arg.to_owned()); }
// Add all the link args for external crates.
do cstore::iter_crate_data(cstore) |crate_num, _| {
let link_args = csearch::get_link_args_for_crate(cstore, crate_num);
- foreach link_arg in link_args.consume_iter() {
+ for link_arg in link_args.consume_iter() {
args.push(link_arg);
}
}
// to be found at compile time so it is still entirely up to outside
// forces to make sure that library can be found at runtime.
- foreach path in sess.opts.addl_lib_search_paths.iter() {
+ for path in sess.opts.addl_lib_search_paths.iter() {
args.push(~"-L" + path.to_str());
}
// The names of the extern libraries
let used_libs = cstore::get_used_libraries(cstore);
- foreach l in used_libs.iter() { args.push(~"-l" + *l); }
+ for l in used_libs.iter() { args.push(~"-l" + *l); }
if *sess.building_library {
args.push(lib_cmd);
passes.push(~"sroa");
passes.push(~"domtree");
passes.push(~"early-cse");
- passes.push(~"simplify-libcalls");
passes.push(~"lazy-value-info");
passes.push(~"jump-threading");
passes.push(~"correlated-propagation");
}
pub fn populate_pass_manager(sess: Session, pm: &mut PassManager, pass_list:&[~str]) {
- foreach nm in pass_list.iter() {
+ for nm in pass_list.iter() {
match create_pass(*nm) {
Some(p) => pm.add_pass(p),
None => sess.warn(fmt!("Unknown pass %s", *nm))
io::println("\nAvailable Passes:");
io::println("\nAnalysis Passes:");
- foreach &(name, desc) in analysis_passes.iter() {
+ for &(name, desc) in analysis_passes.iter() {
printfln!(" %-30s -- %s", name, desc);
}
io::println("\nTransformation Passes:");
- foreach &(name, desc) in transform_passes.iter() {
+ for &(name, desc) in transform_passes.iter() {
printfln!(" %-30s -- %s", name, desc);
}
io::println("\nUtility Passes:");
- foreach &(name, desc) in utility_passes.iter() {
+ for &(name, desc) in utility_passes.iter() {
printfln!(" %-30s -- %s", name, desc);
}
}
fn passes_exist() {
let mut failed = ~[];
unsafe { llvm::LLVMInitializePasses(); }
- foreach &(name,_) in analysis_passes.iter() {
+ for &(name,_) in analysis_passes.iter() {
let pass = create_pass(name);
if !pass.is_some() {
failed.push(name);
unsafe { llvm::LLVMDestroyPass(pass.get()) }
}
}
- foreach &(name,_) in transform_passes.iter() {
+ for &(name,_) in transform_passes.iter() {
let pass = create_pass(name);
if !pass.is_some() {
failed.push(name);
unsafe { llvm::LLVMDestroyPass(pass.get()) }
}
}
- foreach &(name,_) in utility_passes.iter() {
+ for &(name,_) in utility_passes.iter() {
let pass = create_pass(name);
if !pass.is_some() {
failed.push(name);
if failed.len() > 0 {
io::println("Some passes don't exist:");
- foreach &n in failed.iter() {
+ for &n in failed.iter() {
printfln!(" %s", n);
}
fail!();
debug!("sysroot: %s", sysroot.to_str());
debug!("output: %s", output.to_str());
debug!("libs:");
- foreach libpath in libs.iter() {
+ for libpath in libs.iter() {
debug!(" %s", libpath.to_str());
}
debug!("target_triple: %s", target_triple);
fn log_rpaths(desc: &str, rpaths: &[Path]) {
debug!("%s rpaths:", desc);
- foreach rpath in rpaths.iter() {
+ for rpath in rpaths.iter() {
debug!(" %s", rpath.to_str());
}
}
}
let mut path = ~[];
- foreach _ in range(start_idx, len1 - 1) { path.push(~".."); };
+ for _ in range(start_idx, len1 - 1) { path.push(~".."); };
path.push_all(split2.slice(start_idx, len2 - 1));
pub fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
let mut set = HashSet::new();
let mut minimized = ~[];
- foreach rpath in rpaths.iter() {
+ for rpath in rpaths.iter() {
if set.insert(rpath.to_str()) {
minimized.push(rpath.clone());
}
}
pub fn get_os(triple: &str) -> Option<session::os> {
- foreach &(name, os) in os_names.iter() {
+ for &(name, os) in os_names.iter() {
if triple.contains(name) { return Some(os) }
}
None
("freebsd", session::os_freebsd)];
pub fn get_arch(triple: &str) -> Option<abi::Architecture> {
- foreach &(arch, abi) in architecture_abis.iter() {
+ for &(arch, abi) in architecture_abis.iter() {
if triple.contains(arch) { return Some(abi) }
}
None
lint::deny, lint::forbid];
let mut lint_opts = ~[];
let lint_dict = lint::get_lint_dict();
- foreach level in lint_levels.iter() {
+ for level in lint_levels.iter() {
let level_name = lint::level_to_str(*level);
// FIXME: #4318 Instead of to_ascii and to_str_ascii, could use
let level_short = level_short.to_ascii().to_upper().to_str_ascii();
let flags = vec::append(getopts::opt_strs(matches, level_short),
getopts::opt_strs(matches, level_name));
- foreach lint_name in flags.iter() {
+ for lint_name in flags.iter() {
let lint_name = lint_name.replace("-", "_");
match lint_dict.find_equiv(&lint_name) {
None => {
let mut debugging_opts = 0u;
let debug_flags = getopts::opt_strs(matches, "Z");
let debug_map = session::debugging_opts_map();
- foreach debug_flag in debug_flags.iter() {
+ for debug_flag in debug_flags.iter() {
let mut this_bit = 0u;
- foreach tuple in debug_map.iter() {
+ for tuple in debug_map.iter() {
let (name, bit) = match *tuple { (ref a, _, b) => (a, b) };
if name == debug_flag { this_bit = bit; break; }
}
fn mk_test_descs(cx: &TestCtxt) -> @ast::expr {
debug!("building test vector from %u tests", cx.testfns.len());
let mut descs = ~[];
- foreach test in cx.testfns.iter() {
+ for test in cx.testfns.iter() {
descs.push(mk_test_desc_and_fn_rec(cx, test));
}
#[deriving(Clone)]
pub enum Attribute {
- ZExtAttribute = 1,
- SExtAttribute = 2,
- NoReturnAttribute = 4,
- InRegAttribute = 8,
- StructRetAttribute = 16,
- NoUnwindAttribute = 32,
- NoAliasAttribute = 64,
- ByValAttribute = 128,
- NestAttribute = 256,
- ReadNoneAttribute = 512,
- ReadOnlyAttribute = 1024,
- NoInlineAttribute = 2048,
- AlwaysInlineAttribute = 4096,
- OptimizeForSizeAttribute = 8192,
- StackProtectAttribute = 16384,
- StackProtectReqAttribute = 32768,
- // 31 << 16
- AlignmentAttribute = 2031616,
- NoCaptureAttribute = 2097152,
- NoRedZoneAttribute = 4194304,
- NoImplicitFloatAttribute = 8388608,
- NakedAttribute = 16777216,
- InlineHintAttribute = 33554432,
- // 7 << 26
- StackAttribute = 469762048,
- ReturnsTwiceAttribute = 536870912,
- // 1 << 30
- UWTableAttribute = 1073741824,
- NonLazyBindAttribute = 2147483648,
+ ZExtAttribute = 1 << 0,
+ SExtAttribute = 1 << 1,
+ NoReturnAttribute = 1 << 2,
+ InRegAttribute = 1 << 3,
+ StructRetAttribute = 1 << 4,
+ NoUnwindAttribute = 1 << 5,
+ NoAliasAttribute = 1 << 6,
+ ByValAttribute = 1 << 7,
+ NestAttribute = 1 << 8,
+ ReadNoneAttribute = 1 << 9,
+ ReadOnlyAttribute = 1 << 10,
+ NoInlineAttribute = 1 << 11,
+ AlwaysInlineAttribute = 1 << 12,
+ OptimizeForSizeAttribute = 1 << 13,
+ StackProtectAttribute = 1 << 14,
+ StackProtectReqAttribute = 1 << 15,
+ AlignmentAttribute = 31 << 16,
+ NoCaptureAttribute = 1 << 21,
+ NoRedZoneAttribute = 1 << 22,
+ NoImplicitFloatAttribute = 1 << 23,
+ NakedAttribute = 1 << 24,
+ InlineHintAttribute = 1 << 25,
+ StackAttribute = 7 << 26,
+ ReturnsTwiceAttribute = 1 << 29,
+ UWTableAttribute = 1 << 30,
+ NonLazyBindAttribute = 1 << 31,
+
+ // Not added to LLVM yet, so may need to stay updated if LLVM changes.
+ // FIXME(#8199): if this changes, be sure to change the relevant constant
+ // down below
+ // FixedStackSegment = 1 << 41,
}
// enum for the LLVM IntPredicate type
Op: AtomicBinOp,
LHS: ValueRef,
RHS: ValueRef,
- Order: AtomicOrdering)
+ Order: AtomicOrdering,
+ SingleThreaded: Bool)
-> ValueRef;
pub fn LLVMBuildAtomicFence(B: BuilderRef, Order: AtomicOrdering);
llvm::LLVMConstFCmp(Pred as c_ushort, V1, V2)
}
}
+
+pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
+ unsafe {
+ let attr = attr as u64;
+ let lower = attr & 0xffffffff;
+ let upper = (attr >> 32) & 0xffffffff;
+ llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
+ }
+}
+
+// FIXME(#8199): this shouldn't require this hackery. On i686
+// (FixedStackSegment as u64) will return 0 instead of 1 << 41.
+// Furthermore, if we use a match of any sort then an LLVM
+// assertion is generated!
+pub fn SetFixedStackSegmentAttribute(Fn: ValueRef) {
+ unsafe {
+ let attr = 1u64 << 41;
+ let lower = attr & 0xffffffff;
+ let upper = (attr >> 32) & 0xffffffff;
+ llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
+ }
+}
/* Memory-managed object interface to type handles. */
pub struct TypeNames {
fn dump_crates(crate_cache: &[cache_entry]) {
debug!("resolved crates:");
- foreach entry in crate_cache.iter() {
+ for entry in crate_cache.iter() {
debug!("cnum: %?", entry.cnum);
debug!("span: %?", entry.span);
debug!("hash: %?", entry.hash);
if matches.len() != 1u {
diag.handler().warn(
fmt!("using multiple versions of crate `%s`", name));
- foreach match_ in matches.iter() {
+ for match_ in matches.iter() {
diag.span_note(match_.span, "used here");
let attrs = ~[
attr::mk_attr(attr::mk_list_item(@"link",
fn visit_crate(e: &Env, c: &ast::Crate) {
let cstore = e.cstore;
- foreach a in c.attrs.iter().filter(|m| "link_args" == m.name()) {
+ for a in c.attrs.iter().filter(|m| "link_args" == m.name()) {
match a.value_str() {
Some(ref linkarg) => {
cstore::add_used_link_args(cstore, *linkarg);
ast::anonymous => { /* do nothing */ }
}
- foreach m in link_args.iter() {
+ for m in link_args.iter() {
match m.value_str() {
Some(linkarg) => {
cstore::add_used_link_args(cstore, linkarg);
fn existing_match(e: &Env, metas: &[@ast::MetaItem], hash: &str)
-> Option<int> {
- foreach c in e.crate_cache.iter() {
+ for c in e.crate_cache.iter() {
if loader::metadata_matches(*c.metas, metas)
&& (hash.is_empty() || c.hash.as_slice() == hash) {
return Some(c.cnum);
// numbers
let mut cnum_map = HashMap::new();
let r = decoder::get_crate_deps(cdata);
- foreach dep in r.iter() {
+ for dep in r.iter() {
let extrn_cnum = dep.cnum;
let cname = dep.name;
let cname_str = token::ident_to_str(&dep.name);
pub fn iter_crate_data(cstore: &CStore,
i: &fn(ast::CrateNum, @crate_metadata)) {
- foreach (&k, &v) in cstore.metas.iter() {
+ for (&k, &v) in cstore.metas.iter() {
i(k, v);
}
}
}
pub fn add_used_link_args(cstore: &mut CStore, args: &str) {
- foreach s in args.split_iter(' ') {
+ for s in args.split_iter(' ') {
cstore.used_link_args.push(s.to_managed());
}
}
pub fn get_dep_hashes(cstore: &CStore) -> ~[@str] {
let mut result = ~[];
- foreach (_, &cnum) in cstore.extern_mod_crate_map.iter() {
+ for (_, &cnum) in cstore.extern_mod_crate_map.iter() {
let cdata = cstore::get_crate_data(cstore, cnum);
let hash = decoder::get_crate_hash(cdata.data);
let vers = decoder::get_crate_vers(cdata.data);
};
debug!("sorted:");
- foreach x in sorted.iter() {
+ for x in sorted.iter() {
debug!(" hash[%s]: %s", x.name, x.hash);
}
let mut infos: ~[@ty::VariantInfo] = ~[];
let variant_ids = enum_variant_ids(item, cdata);
let mut disr_val = 0;
- foreach did in variant_ids.iter() {
+ for did in variant_ids.iter() {
let item = find_item(did.node, items);
let ctor_ty = item_type(ast::def_id { crate: cdata.cnum, node: id},
item, tcx, cdata);
};
let mut static_impl_methods = ~[];
- foreach impl_method_id in impl_method_ids.iter() {
+ for impl_method_id in impl_method_ids.iter() {
let impl_method_doc = lookup_item(impl_method_id.node, cdata.data);
let family = item_family(impl_method_doc);
match family {
meta_items: ebml::Doc,
out: @io::Writer) {
let r = get_meta_items(meta_items);
- foreach mi in r.iter() {
+ for mi in r.iter() {
out.write_str(fmt!("%s\n", pprust::meta_item_to_str(*mi, intr)));
}
}
out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
let r = get_attributes(md);
- foreach attr in r.iter() {
+ for attr in r.iter() {
out.write_str(fmt!("%s\n", pprust::attribute_to_str(attr, intr)));
}
out.write_str("=External Dependencies=\n");
let r = get_crate_deps(data);
- foreach dep in r.iter() {
+ for dep in r.iter() {
out.write_str(
fmt!("%d %s-%s-%s\n",
dep.cnum, token::ident_to_str(&dep.name), dep.hash, dep.vers));
ebml_w: &mut writer::Encoder,
it: @ast::item) {
let opt_rp = ecx.tcx.region_paramd_items.find(&it.id);
- foreach rp in opt_rp.iter() {
+ for rp in opt_rp.iter() {
ebml_w.start_tag(tag_region_param);
rp.encode(ebml_w);
ebml_w.end_tag();
tcx: ecx.tcx,
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)
};
- foreach param in params.iter() {
+ for param in params.iter() {
ebml_w.start_tag(tag);
tyencode::enc_type_param_def(ebml_w.writer, ty_str_ctxt, param);
ebml_w.end_tag();
fn encode_transformed_self_ty(ecx: &EncodeContext,
ebml_w: &mut writer::Encoder,
opt_typ: Option<ty::t>) {
- foreach &typ in opt_typ.iter() {
+ for &typ in opt_typ.iter() {
ebml_w.start_tag(tag_item_method_transformed_self_ty);
write_type(ecx, ebml_w, typ);
ebml_w.end_tag();
let mut i = 0;
let vi = ty::enum_variants(ecx.tcx,
ast::def_id { crate: LOCAL_CRATE, node: id });
- foreach variant in variants.iter() {
+ for variant in variants.iter() {
let def_id = local_def(variant.node.id);
index.push(entry {val: variant.node.id, pos: ebml_w.writer.tell()});
ebml_w.start_tag(tag_items_data_item);
ebml_w.start_tag(tag_path);
ebml_w.wr_tagged_u32(tag_path_len, (path.len() + 1) as u32);
- foreach pe in path.iter() {
+ for pe in path.iter() {
encode_path_elt(ecx, ebml_w, *pe);
}
encode_path_elt(ecx, ebml_w, name);
-> bool {
match ecx.tcx.inherent_impls.find(&exp.def_id) {
Some(implementations) => {
- foreach &base_impl in implementations.iter() {
- foreach &m in base_impl.methods.iter() {
+ for &base_impl in implementations.iter() {
+ for &m in base_impl.methods.iter() {
if m.explicit_self == ast::sty_static {
encode_reexported_static_method(ecx, ebml_w, exp,
m.def_id, m.ident);
-> bool {
match ecx.tcx.trait_methods_cache.find(&exp.def_id) {
Some(methods) => {
- foreach &m in methods.iter() {
+ for &m in methods.iter() {
if m.explicit_self == ast::sty_static {
encode_reexported_static_method(ecx, ebml_w, exp,
m.def_id, m.ident);
let mut continue = true;
match item.node {
item_enum(ref enum_def, _) => {
- foreach variant in enum_def.variants.iter() {
+ for variant in enum_def.variants.iter() {
continue = callback(variant.node.id);
if !continue {
break
match ecx.reexports2.find(&id) {
Some(ref exports) => {
debug!("(encoding info for module) found reexports for %d", id);
- foreach exp in exports.iter() {
+ for exp in exports.iter() {
debug!("(encoding info for module) reexport '%s' for %d",
exp.name, id);
ebml_w.start_tag(tag_items_data_item_reexport);
debug!("(encoding info for module) encoding info for module ID %d", id);
// Encode info about all the module children.
- foreach item in md.items.iter() {
+ for item in md.items.iter() {
ebml_w.start_tag(tag_mod_child);
ebml_w.wr_str(def_to_str(local_def(item.id)));
ebml_w.end_tag();
fn encode_provided_source(ebml_w: &mut writer::Encoder,
source_opt: Option<def_id>) {
- foreach source in source_opt.iter() {
+ for source in source_opt.iter() {
ebml_w.start_tag(tag_item_method_provided_source);
let s = def_to_str(*source);
ebml_w.writer.write(s.as_bytes());
let tcx = ecx.tcx;
/* We encode both private and public fields -- need to include
private fields to get the offsets right */
- foreach field in fields.iter() {
+ for field in fields.iter() {
let (nm, vis) = match field.node.kind {
named_field(nm, vis) => (nm, vis),
unnamed_field => (special_idents::unnamed_field, inherited)
encode_path(ecx, ebml_w, impl_path, ast_map::path_name(m.ident));
- foreach ast_method in ast_method_opt.iter() {
+ for ast_method in ast_method_opt.iter() {
let num_params = tpt.generics.type_param_defs.len();
if num_params > 0u || is_default_impl
|| should_inline(ast_method.attrs) {
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
// Encode all the items in this module.
- foreach foreign_item in fm.items.iter() {
+ for foreign_item in fm.items.iter() {
ebml_w.start_tag(tag_mod_child);
ebml_w.wr_str(def_to_str(local_def(foreign_item.id)));
ebml_w.end_tag();
encode_family(ebml_w, 't');
encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(ecx, ebml_w, item.ident);
- foreach v in (*enum_definition).variants.iter() {
+ for v in (*enum_definition).variants.iter() {
encode_variant_id(ebml_w, local_def(v.node.id));
}
(ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
/* Encode def_ids for each field and method
for methods, write all the stuff get_trait_method
needs to know*/
- foreach f in struct_def.fields.iter() {
+ for f in struct_def.fields.iter() {
match f.node.kind {
named_field(ident, vis) => {
ebml_w.start_tag(tag_item_field);
}
_ => {}
}
- foreach method in imp.methods.iter() {
+ for method in imp.methods.iter() {
ebml_w.start_tag(tag_item_impl_method);
let s = def_to_str(method.def_id);
ebml_w.writer.write(s.as_bytes());
ebml_w.end_tag();
}
- foreach ast_trait_ref in opt_trait.iter() {
+ for ast_trait_ref in opt_trait.iter() {
let trait_ref = ty::node_id_to_trait_ref(
tcx, ast_trait_ref.ref_id);
encode_trait_ref(ebml_w, ecx, trait_ref, tag_item_trait_ref);
// appear first in the impl structure, in the same order they do
// in the ast. This is a little sketchy.
let num_implemented_methods = ast_methods.len();
- foreach (i, m) in imp.methods.iter().enumerate() {
+ for (i, m) in imp.methods.iter().enumerate() {
let ast_method = if i < num_implemented_methods {
Some(ast_methods[i])
} else { None };
encode_trait_ref(ebml_w, ecx, trait_def.trait_ref, tag_item_trait_ref);
encode_name(ecx, ebml_w, item.ident);
encode_attributes(ebml_w, item.attrs);
- foreach &method_def_id in ty::trait_method_def_ids(tcx, def_id).iter() {
+ for &method_def_id in ty::trait_method_def_ids(tcx, def_id).iter() {
ebml_w.start_tag(tag_item_trait_method);
encode_def_id(ebml_w, method_def_id);
ebml_w.end_tag();
ebml_w.end_tag();
}
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
- foreach ast_trait_ref in super_traits.iter() {
+ for ast_trait_ref in super_traits.iter() {
let trait_ref = ty::node_id_to_trait_ref(ecx.tcx, ast_trait_ref.ref_id);
encode_trait_ref(ebml_w, ecx, trait_ref, tag_item_super_trait_ref);
}
// Now output the method info for each method.
let r = ty::trait_method_def_ids(tcx, def_id);
- foreach (i, &method_def_id) in r.iter().enumerate() {
+ for (i, &method_def_id) in r.iter().enumerate() {
assert_eq!(method_def_id.crate, ast::LOCAL_CRATE);
let method_ty = ty::method(tcx, method_def_id);
index: ~[entry<T>])
-> ~[@~[entry<T>]] {
let mut buckets: ~[@mut ~[entry<T>]] = ~[];
- foreach _ in range(0u, 256u) { buckets.push(@mut ~[]); };
- foreach elt in index.iter() {
+ for _ in range(0u, 256u) { buckets.push(@mut ~[]); };
+ for elt in index.iter() {
let h = elt.val.hash() as uint;
buckets[h % 256].push((*elt).clone());
}
let mut buckets_frozen = ~[];
- foreach bucket in buckets.iter() {
+ for bucket in buckets.iter() {
buckets_frozen.push(@/*bad*/(**bucket).clone());
}
return buckets_frozen;
ebml_w.start_tag(tag_index);
let mut bucket_locs: ~[uint] = ~[];
ebml_w.start_tag(tag_index_buckets);
- foreach bucket in buckets.iter() {
+ for bucket in buckets.iter() {
bucket_locs.push(ebml_w.writer.tell());
ebml_w.start_tag(tag_index_buckets_bucket);
- foreach elt in (**bucket).iter() {
+ for elt in (**bucket).iter() {
ebml_w.start_tag(tag_index_buckets_bucket_elt);
assert!(elt.pos < 0xffff_ffff);
writer.write_be_u32(elt.pos as u32);
}
ebml_w.end_tag();
ebml_w.start_tag(tag_index_table);
- foreach pos in bucket_locs.iter() {
+ for pos in bucket_locs.iter() {
assert!(*pos < 0xffff_ffff);
writer.write_be_u32(*pos as u32);
}
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(name.as_bytes());
ebml_w.end_tag();
- foreach inner_item in items.iter() {
+ for inner_item in items.iter() {
encode_meta_item(ebml_w, *inner_item);
}
ebml_w.end_tag();
fn encode_attributes(ebml_w: &mut writer::Encoder, attrs: &[Attribute]) {
ebml_w.start_tag(tag_attributes);
- foreach attr in attrs.iter() {
+ for attr in attrs.iter() {
ebml_w.start_tag(tag_attribute);
encode_meta_item(ebml_w, attr.node.value);
ebml_w.end_tag();
let mut meta_items = ~[name_item, vers_item];
- foreach &mi in items.iter().filter(|mi| "name" != mi.name() && "vers" != mi.name()) {
+ for &mi in items.iter().filter(|mi| "name" != mi.name() && "vers" != mi.name()) {
meta_items.push(mi);
}
let link_item = attr::mk_list_item(@"link", meta_items);
let mut attrs = ~[];
let mut found_link_attr = false;
- foreach attr in crate.attrs.iter() {
+ for attr in crate.attrs.iter() {
attrs.push(
if "link" != attr.name() {
*attr
// Sanity-check the crate numbers
let mut expected_cnum = 1;
- foreach n in deps.iter() {
+ for n in deps.iter() {
assert_eq!(n.cnum, expected_cnum);
expected_cnum += 1;
}
// but is enough to get transitive crate dependencies working.
ebml_w.start_tag(tag_crate_deps);
let r = get_ordered_deps(ecx, cstore);
- foreach dep in r.iter() {
+ for dep in r.iter() {
encode_crate_dep(ecx, ebml_w, *dep);
}
ebml_w.end_tag();
ebml_w.start_tag(tag_lang_items);
do ecx.tcx.lang_items.each_item |def_id, i| {
- foreach id in def_id.iter() {
+ for id in def_id.iter() {
if id.crate == LOCAL_CRATE {
ebml_w.start_tag(tag_lang_items_item);
ebml_w.start_tag(tag_link_args);
let link_args = cstore::get_used_link_args(ecx.cstore);
- foreach link_arg in link_args.iter() {
+ for link_arg in link_args.iter() {
ebml_w.start_tag(tag_link_args_arg);
ebml_w.writer.write_str(link_arg.to_str());
ebml_w.end_tag();
ebml_w: &mut writer::Encoder) {
ebml_w.start_tag(tag_misc_info);
ebml_w.start_tag(tag_misc_info_crate_items);
- foreach &item in crate.module.items.iter() {
+ for &item in crate.module.items.iter() {
ebml_w.start_tag(tag_mod_child);
ebml_w.wr_str(def_to_str(local_def(item.id)));
ebml_w.end_tag();
ecx.stats.total_bytes = *wr.pos;
if (tcx.sess.meta_stats()) {
- foreach e in wr.bytes.iter() {
+ for e in wr.bytes.iter() {
if *e == 0 {
ecx.stats.zero_bytes += 1;
}
do filesearch.for_each_lib_search_path() |lib_search_path| {
debug!("searching %s", lib_search_path.to_str());
let r = os::list_dir_path(lib_search_path);
- foreach path in r.iter() {
+ for path in r.iter() {
debug!("testing %s", path.to_str());
let maybe_picked = pick(path);
if maybe_picked.is_some() {
cx.diag.span_err(
cx.span, fmt!("multiple matching crates for `%s`", crate_name));
cx.diag.handler().note("candidates:");
- foreach pair in matches.iter() {
+ for pair in matches.iter() {
let ident = pair.first();
let data = pair.second();
cx.diag.handler().note(fmt!("path: %s", ident));
}
pub fn crate_name_from_metas(metas: &[@ast::MetaItem]) -> @str {
- foreach m in metas.iter() {
+ for m in metas.iter() {
match m.name_str_pair() {
Some((name, s)) if "name" == name => { return s; }
_ => {}
diag: @span_handler,
attrs: ~[ast::Attribute]) {
let r = attr::find_linkage_metas(attrs);
- foreach mi in r.iter() {
+ for mi in r.iter() {
diag.handler().note(fmt!("meta: %s", pprust::meta_item_to_str(*mi,intr)));
}
}
enc_region_substs(w, cx, &substs.regions);
do enc_opt(w, substs.self_ty) |t| { enc_ty(w, cx, t) }
w.write_char('[');
- foreach t in substs.tps.iter() { enc_ty(w, cx, *t); }
+ for t in substs.tps.iter() { enc_ty(w, cx, *t); }
w.write_char(']');
}
}
ty::NonerasedRegions(ref regions) => {
w.write_char('n');
- foreach &r in regions.iter() {
+ for &r in regions.iter() {
enc_region(w, cx, r);
}
w.write_char('.');
}
ty::ty_tup(ref ts) => {
w.write_str(&"T[");
- foreach t in ts.iter() { enc_ty(w, cx, *t); }
+ for t in ts.iter() { enc_ty(w, cx, *t); }
w.write_char(']');
}
ty::ty_box(mt) => { w.write_char('@'); enc_mt(w, cx, mt); }
fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
w.write_char('[');
- foreach ty in fsig.inputs.iter() {
+ for ty in fsig.inputs.iter() {
enc_ty(w, cx, *ty);
}
w.write_char(']');
true
};
- foreach &tp in bs.trait_bounds.iter() {
+ for &tp in bs.trait_bounds.iter() {
w.write_char('I');
enc_trait_ref(w, cx, tp);
}
{
let r = tcx.def_map.find(&id);
- foreach def in r.iter() {
+ for def in r.iter() {
do ebml_w.tag(c::tag_table_def) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = tcx.node_types.find(&(id as uint));
- foreach &ty in r.iter() {
+ for &ty in r.iter() {
do ebml_w.tag(c::tag_table_node_type) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = tcx.node_type_substs.find(&id);
- foreach tys in r.iter() {
+ for tys in r.iter() {
do ebml_w.tag(c::tag_table_node_type_subst) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = tcx.freevars.find(&id);
- foreach &fv in r.iter() {
+ for &fv in r.iter() {
do ebml_w.tag(c::tag_table_freevars) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
let lid = ast::def_id { crate: ast::LOCAL_CRATE, node: id };
{
let r = tcx.tcache.find(&lid);
- foreach &tpbt in r.iter() {
+ for &tpbt in r.iter() {
do ebml_w.tag(c::tag_table_tcache) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = tcx.ty_param_defs.find(&id);
- foreach &type_param_def in r.iter() {
+ for &type_param_def in r.iter() {
do ebml_w.tag(c::tag_table_param_defs) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = maps.method_map.find(&id);
- foreach &mme in r.iter() {
+ for &mme in r.iter() {
do ebml_w.tag(c::tag_table_method_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = maps.vtable_map.find(&id);
- foreach &dr in r.iter() {
+ for &dr in r.iter() {
do ebml_w.tag(c::tag_table_vtable_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = tcx.adjustments.find(&id);
- foreach adj in r.iter() {
+ for adj in r.iter() {
do ebml_w.tag(c::tag_table_adjustments) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
{
let r = maps.capture_map.find(&id);
- foreach &cap_vars in r.iter() {
+ for &cap_vars in r.iter() {
do ebml_w.tag(c::tag_table_capture_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
fn type_string(doc: ebml::Doc) -> ~str {
let mut str = ~"";
- foreach i in range(doc.start, doc.end) {
+ for i in range(doc.start, doc.end) {
str.push_char(doc.data[i] as char);
}
str
do self.each_in_scope_loan(scope_id) |loan| {
let mut ret = true;
- foreach restr in loan.restrictions.iter() {
+ for restr in loan.restrictions.iter() {
if restr.loan_path == loan_path {
if !op(loan, restr) {
ret = false;
debug!("new_loan_indices = %?", new_loan_indices);
do self.each_issued_loan(scope_id) |issued_loan| {
- foreach &new_loan_index in new_loan_indices.iter() {
+ for &new_loan_index in new_loan_indices.iter() {
let new_loan = &self.all_loans[new_loan_index];
self.report_error_if_loans_conflict(issued_loan, new_loan);
}
true
};
- foreach i in range(0u, new_loan_indices.len()) {
+ for i in range(0u, new_loan_indices.len()) {
let old_loan = &self.all_loans[new_loan_indices[i]];
- foreach j in range(i+1, new_loan_indices.len()) {
+ for j in range(i+1, new_loan_indices.len()) {
let new_loan = &self.all_loans[new_loan_indices[j]];
self.report_error_if_loans_conflict(old_loan, new_loan);
}
};
debug!("illegal_if=%?", illegal_if);
- foreach restr in loan1.restrictions.iter() {
+ for restr in loan1.restrictions.iter() {
if !restr.set.intersects(illegal_if) { loop; }
if restr.loan_path != loan2.loan_path { loop; }
closure_id: ast::NodeId,
span: span) {
let cap_vars = this.bccx.capture_map.get(&closure_id);
- foreach cap_var in cap_vars.iter() {
+ for cap_var in cap_vars.iter() {
let var_id = ast_util::def_id_of_def(cap_var.def).node;
let var_path = @LpVar(var_id);
this.check_if_path_is_moved(closure_id, span,
let cmt = this.bccx.cat_expr_unadjusted(expr);
debug!("path cmt=%s", cmt.repr(this.tcx()));
let r = opt_loan_path(cmt);
- foreach &lp in r.iter() {
+ for &lp in r.iter() {
this.check_if_path_is_moved(expr.id, expr.span, MovedInUse, lp);
}
}
move_data: &mut MoveData,
closure_expr: @ast::expr) {
let captured_vars = bccx.capture_map.get(&closure_expr.id);
- foreach captured_var in captured_vars.iter() {
+ for captured_var in captured_vars.iter() {
match captured_var.mode {
moves::CapMove => {
let fvar_id = ast_util::def_id_of_def(captured_var.def).node;
{
let r = ex.get_callee_id();
- foreach callee_id in r.iter() {
+ for callee_id in r.iter() {
this.id_range.add(*callee_id);
}
}
// If this expression is borrowed, have to ensure it remains valid:
{
let r = tcx.adjustments.find(&ex.id);
- foreach &adjustments in r.iter() {
+ for &adjustments in r.iter() {
this.guarantee_adjustments(ex, *adjustments);
}
}
ast::expr_match(ex_v, ref arms) => {
let cmt = this.bccx.cat_expr(ex_v);
- foreach arm in arms.iter() {
- foreach pat in arm.pats.iter() {
+ for arm in arms.iter() {
+ for pat in arm.pats.iter() {
this.gather_pat(cmt, *pat, Some((arm.body.id, ex.id)));
}
}
*/
let mc_ctxt = self.bccx.mc_ctxt();
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
let arg_ty = ty::node_id_to_type(self.tcx(), arg.pat.id);
let arg_cmt = mc_ctxt.cat_rvalue(
// static errors. For example, if there is code like
//
// let v = @mut ~[1, 2, 3];
- // foreach e in v.iter() {
+ // for e in v.iter() {
// v.push(e + 1);
// }
//
//
// let v = @mut ~[1, 2, 3];
// let w = v;
- // foreach e in v.iter() {
+ // for e in v.iter() {
// w.push(e + 1);
// }
//
// }
// ...
// let v: &V = ...;
- // foreach e in v.get_list().iter() {
+ // for e in v.get_list().iter() {
// v.get_list().push(e + 1);
// }
match opt_loan_path(cmt_base) {
LoanDataFlowOperator,
id_range,
all_loans.len());
- foreach (loan_idx, loan) in all_loans.iter().enumerate() {
+ for (loan_idx, loan) in all_loans.iter().enumerate() {
loan_dfcx.add_gen(loan.gen_scope, loan_idx);
loan_dfcx.add_kill(loan.kill_scope, loan_idx);
}
* killed by scoping. See `doc.rs` for more details.
*/
- foreach (i, move) in self.moves.iter().enumerate() {
+ for (i, move) in self.moves.iter().enumerate() {
dfcx_moves.add_gen(move.id, i);
}
- foreach (i, assignment) in self.var_assignments.iter().enumerate() {
+ for (i, assignment) in self.var_assignments.iter().enumerate() {
dfcx_assign.add_gen(assignment.id, i);
self.kill_moves(assignment.path, assignment.id, dfcx_moves);
}
- foreach assignment in self.path_assignments.iter() {
+ for assignment in self.path_assignments.iter() {
self.kill_moves(assignment.path, assignment.id, dfcx_moves);
}
// Kill all moves related to a variable `x` when it goes out
// of scope:
- foreach path in self.paths.iter() {
+ for path in self.paths.iter() {
match *path.loan_path {
LpVar(id) => {
let kill_id = tcx.region_maps.encl_scope(id);
}
// Kill all assignments when the variable goes out of scope:
- foreach (assignment_index, assignment) in self.var_assignments.iter().enumerate() {
+ for (assignment_index, assignment) in self.var_assignments.iter().enumerate() {
match *self.path(assignment.path).loan_path {
LpVar(id) => {
let kill_id = tcx.region_maps.encl_scope(id);
ret = false;
}
} else {
- foreach &loan_path_index in opt_loan_path_index.iter() {
+ for &loan_path_index in opt_loan_path_index.iter() {
let cont = do self.move_data.each_base_path(moved_path) |p| {
if p == loan_path_index {
// Scenario 3: some extension of `loan_path`
impl CFGBuilder {
fn block(&mut self, blk: &ast::Block, pred: CFGIndex) -> CFGIndex {
let mut stmts_exit = pred;
- foreach &stmt in blk.stmts.iter() {
+ for &stmt in blk.stmts.iter() {
stmts_exit = self.stmt(stmt, stmts_exit);
}
self.pat(pats[0], pred)
} else {
let collect = self.add_dummy_node([]);
- foreach &pat in pats.iter() {
+ for &pat in pats.iter() {
let pat_exit = self.pat(pat, pred);
self.add_contained_edge(pat_exit, collect);
}
let expr_exit = self.add_node(expr.id, []);
let mut guard_exit = discr_exit;
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
guard_exit = self.opt_expr(arm.guard, guard_exit); // 2
let pats_exit = self.pats_any(arm.pats, guard_exit); // 3
let body_exit = self.block(&arm.body, pats_exit); // 4
}
ast::expr_addr_of(_, e) |
- ast::expr_loop_body(e) |
ast::expr_do_body(e) |
ast::expr_cast(e, _) |
ast::expr_unary(_, _, e) |
assert!(!self.exit_map.contains_key(&id));
let node = self.graph.add_node(CFGNodeData {id: id});
self.exit_map.insert(id, node);
- foreach &pred in preds.iter() {
+ for &pred in preds.iter() {
self.add_contained_edge(pred, node);
}
node
Some(_) => {
match self.tcx.def_map.find(&expr.id) {
Some(&ast::def_label(loop_id)) => {
- foreach l in self.loop_scopes.iter() {
+ for l in self.loop_scopes.iter() {
if l.loop_id == loop_id {
return *l;
}
check_item_recursion(sess, ast_map, def_map, it);
}
item_enum(ref enum_definition, _) => {
- foreach var in (*enum_definition).variants.iter() {
- foreach ex in var.node.disr_expr.iter() {
+ for var in (*enum_definition).variants.iter() {
+ for ex in var.node.disr_expr.iter() {
(v.visit_expr)(*ex, (true, v));
}
}
can_ret: false
}, v));
}
- expr_loop_body(@expr {node: expr_fn_block(_, ref b), _}) => {
- let sigil = ty::ty_closure_sigil(ty::expr_ty(tcx, e));
- let blk = (sigil == BorrowedSigil);
- (v.visit_block)(b, (Context {
- in_loop: true,
- can_ret: blk
- }, v));
- }
expr_break(_) => {
if !cx.in_loop {
tcx.sess.span_err(e.span, "`break` outside of loop");
match ex.node {
expr_match(scrut, ref arms) => {
// First, check legality of move bindings.
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
check_legality_of_move_bindings(cx,
arm.guard.is_some(),
arm.pats);
// Check for unreachable patterns
pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) {
let mut seen = ~[];
- foreach arm in arms.iter() {
- foreach pat in arm.pats.iter() {
+ for arm in arms.iter() {
+ for pat in arm.pats.iter() {
// Check that we do not match against a static NaN (#6804)
let pat_matches_nan: &fn(@pat) -> bool = |p| {
}
}
ty::ty_enum(eid, _) => {
- foreach va in (*ty::enum_variants(cx.tcx, eid)).iter() {
+ for va in (*ty::enum_variants(cx.tcx, eid)).iter() {
match is_useful_specialized(cx, m, v, variant(va.id),
va.args.len(), left_ty) {
not_useful => (),
_ => max_len
}
};
- foreach n in iterator::range(0u, max_len + 1) {
+ for n in iterator::range(0u, max_len + 1) {
match is_useful_specialized(cx, m, v, vec(n), n, left_ty) {
not_useful => (),
ref u => return *u,
match ty::get(left_ty).sty {
ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) | ty::ty_tup(_) |
ty::ty_struct(*) => {
- foreach r in m.iter() {
+ for r in m.iter() {
if !is_wild(cx, r[0]) { return None; }
}
return Some(single);
}
ty::ty_enum(eid, _) => {
let mut found = ~[];
- foreach r in m.iter() {
+ for r in m.iter() {
let r = pat_ctor_id(cx, r[0]);
- foreach id in r.iter() {
+ for id in r.iter() {
if !found.contains(id) {
found.push(*id);
}
}
let variants = ty::enum_variants(cx.tcx, eid);
if found.len() != (*variants).len() {
- foreach v in (*variants).iter() {
+ for v in (*variants).iter() {
if !found.iter().any(|x| x == &(variant(v.id))) {
return Some(variant(v.id));
}
ty::ty_bool => {
let mut true_found = false;
let mut false_found = false;
- foreach r in m.iter() {
+ for r in m.iter() {
match pat_ctor_id(cx, r[0]) {
None => (),
Some(val(const_bool(true))) => true_found = true,
let mut found_slice = false;
let mut next = 0;
let mut missing = None;
- foreach &(length, slice) in sorted_vec_lens.iter() {
+ for &(length, slice) in sorted_vec_lens.iter() {
if length != next {
missing = Some(next);
break;
(s, v): ((),
oldvisit::vt<()>)) {
oldvisit::visit_fn(kind, decl, body, sp, id, (s, v));
- foreach input in decl.inputs.iter() {
+ for input in decl.inputs.iter() {
if is_refutable(cx, input.pat) {
cx.tcx.sess.span_err(input.pat.span,
"refutable pattern in function argument");
let def_map = tcx.def_map;
let mut by_ref_span = None;
let mut any_by_move = false;
- foreach pat in pats.iter() {
+ for pat in pats.iter() {
do pat_bindings(def_map, *pat) |bm, id, span, _path| {
match bm {
bind_by_ref(_) => {
};
if !any_by_move { return; } // pointless micro-optimization
- foreach pat in pats.iter() {
+ for pat in pats.iter() {
do walk_pat(*pat) |p| {
if pat_is_binding(def_map, p) {
match p.node {
variant_def: ast::def_id)
-> Option<@expr> {
fn variant_expr(variants: &[ast::variant], id: ast::NodeId) -> Option<@expr> {
- foreach variant in variants.iter() {
+ for variant in variants.iter() {
if variant.node.id == id {
return variant.node.disr_expr;
}
changed: bool
}
-#[deriving(Eq)]
-enum LoopKind {
- /// A `while` or `loop` loop
- TrueLoop,
-
- /// A `for` "loop" (i.e., really a func call where `break`, `return`,
- /// and `loop` all essentially perform an early return from the closure)
- ForLoop
-}
-
struct LoopScope<'self> {
loop_id: ast::NodeId,
- loop_kind: LoopKind,
break_bits: ~[uint]
}
f: &fn(uint) -> bool) -> bool {
//! Helper for iterating over the bits in a bit set.
- foreach (word_index, &word) in words.iter().enumerate() {
+ for (word_index, &word) in words.iter().enumerate() {
if word != 0 {
let base_index = word_index * uint::bits;
- foreach offset in range(0u, uint::bits) {
+ for offset in range(0u, uint::bits) {
let bit = 1 << offset;
if (word & bit) != 0 {
// NB: we round up the total number of bits
self.merge_with_entry_set(blk.id, in_out);
- foreach &stmt in blk.stmts.iter() {
+ for &stmt in blk.stmts.iter() {
self.walk_stmt(stmt, in_out, loop_scopes);
}
loop_scopes.push(LoopScope {
loop_id: expr.id,
- loop_kind: ForLoop,
break_bits: reslice(in_out).to_owned()
});
- foreach input in decl.inputs.iter() {
+ for input in decl.inputs.iter() {
self.walk_pat(input.pat, func_bits, loop_scopes);
}
self.walk_block(body, func_bits, loop_scopes);
let mut body_bits = reslice(in_out).to_owned();
loop_scopes.push(LoopScope {
loop_id: expr.id,
- loop_kind: TrueLoop,
break_bits: reslice(in_out).to_owned()
});
self.walk_block(blk, body_bits, loop_scopes);
self.reset(in_out);
loop_scopes.push(LoopScope {
loop_id: expr.id,
- loop_kind: TrueLoop,
break_bits: reslice(in_out).to_owned()
});
self.walk_block(blk, body_bits, loop_scopes);
// together the bits from each arm:
self.reset(in_out);
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
// in_out reflects the discr and all guards to date
self.walk_opt_expr(arm.guard, guards, loop_scopes);
ast::expr_ret(o_e) => {
self.walk_opt_expr(o_e, in_out, loop_scopes);
-
- // is this a return from a `for`-loop closure?
- match loop_scopes.iter().position(|s| s.loop_kind == ForLoop) {
- Some(i) => {
- // if so, add the in_out bits to the state
- // upon exit. Remember that we cannot count
- // upon the `for` loop function not to invoke
- // the closure again etc.
- self.break_from_to(expr, &mut loop_scopes[i], in_out);
- }
-
- None => {}
- }
-
self.reset(in_out);
}
ast::expr_again(label) => {
let scope = self.find_scope(expr, label, loop_scopes);
-
- match scope.loop_kind {
- TrueLoop => {
- self.pop_scopes(expr, scope, in_out);
- self.add_to_entry_set(scope.loop_id, reslice(in_out));
- }
-
- ForLoop => {
- // If this `loop` construct is looping back to a `for`
- // loop, then `loop` is really just a return from the
- // closure. Therefore, we treat it the same as `break`.
- // See case for `expr_fn_block` for more details.
- self.break_from_to(expr, scope, in_out);
- }
- }
-
+ self.pop_scopes(expr, scope, in_out);
+ self.add_to_entry_set(scope.loop_id, reslice(in_out));
self.reset(in_out);
}
}
ast::expr_struct(_, ref fields, with_expr) => {
- foreach field in fields.iter() {
+ for field in fields.iter() {
self.walk_expr(field.expr, in_out, loop_scopes);
}
self.walk_opt_expr(with_expr, in_out, loop_scopes);
}
ast::expr_addr_of(_, e) |
- ast::expr_loop_body(e) |
ast::expr_do_body(e) |
ast::expr_cast(e, _) |
ast::expr_unary(_, _, e) |
}
ast::expr_inline_asm(ref inline_asm) => {
- foreach &(_, expr) in inline_asm.inputs.iter() {
+ for &(_, expr) in inline_asm.inputs.iter() {
self.walk_expr(expr, in_out, loop_scopes);
}
- foreach &(_, expr) in inline_asm.outputs.iter() {
+ for &(_, expr) in inline_asm.outputs.iter() {
self.walk_expr(expr, in_out, loop_scopes);
}
}
exprs: &[@ast::expr],
in_out: &mut [uint],
loop_scopes: &mut ~[LoopScope]) {
- foreach &expr in exprs.iter() {
+ for &expr in exprs.iter() {
self.walk_expr(expr, in_out, loop_scopes);
}
}
opt_expr: Option<@ast::expr>,
in_out: &mut [uint],
loop_scopes: &mut ~[LoopScope]) {
- foreach &expr in opt_expr.iter() {
+ for &expr in opt_expr.iter() {
self.walk_expr(expr, in_out, loop_scopes);
}
}
// alternatives, so we must treat this like an N-way select
// statement.
let initial_state = reslice(in_out).to_owned();
- foreach &pat in pats.iter() {
+ for &pat in pats.iter() {
let mut temp = initial_state.clone();
self.walk_pat(pat, temp, loop_scopes);
join_bits(&self.dfcx.oper, temp, in_out);
fn reset(&mut self, bits: &mut [uint]) {
let e = if self.dfcx.oper.initial_value() {uint::max_value} else {0};
- foreach b in bits.mut_iter() { *b = e; }
+ for b in bits.mut_iter() { *b = e; }
}
fn add_to_entry_set(&mut self, id: ast::NodeId, pred_bits: &[uint]) {
// Note: this is a little endian printout of bytes.
- foreach &word in words.iter() {
+ for &word in words.iter() {
let mut v = word;
- foreach _ in range(0u, uint::bytes) {
+ for _ in range(0u, uint::bytes) {
result.push_char(sep);
result.push_str(fmt!("%02x", v & 0xFF));
v >>= 8;
op: &fn(uint, uint) -> uint) -> bool {
assert_eq!(out_vec.len(), in_vec.len());
let mut changed = false;
- foreach i in range(0u, out_vec.len()) {
+ for i in range(0u, out_vec.len()) {
let old_val = out_vec[i];
let new_val = op(old_val, in_vec[i]);
out_vec[i] = new_val;
but you have one or more functions named 'main' that are not \
defined at the crate level. Either move the definition or \
attach the `#[main]` attribute to override this behavior.");
- foreach &(_, span) in this.non_main_fns.iter() {
+ for &(_, span) in this.non_main_fns.iter() {
this.session.span_note(span, "here is a function named 'main'");
}
}
while changed {
changed = false;
iteration += 1;
- foreach (i, edge) in self.edges.iter().enumerate() {
+ for (i, edge) in self.edges.iter().enumerate() {
changed |= op(iteration, EdgeIndex(i), edge);
}
}
// Check kinds on free variables:
do with_appropriate_checker(cx, fn_id) |chk| {
let r = freevars::get_freevars(cx.tcx, fn_id);
- foreach fv in r.iter() {
+ for fv in r.iter() {
chk(cx, *fv);
}
}
};
{
let r = cx.tcx.node_type_substs.find(&type_parameter_id);
- foreach ts in r.iter() {
+ for ts in r.iter() {
let type_param_defs = match e.node {
expr_path(_) => {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&e.id));
ts.repr(cx.tcx),
type_param_defs.repr(cx.tcx));
}
- foreach (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
+ for (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
check_typaram_bounds(cx, type_parameter_id, e.span, ty, type_param_def)
}
}
match aty.node {
ty_path(_, _, id) => {
let r = cx.tcx.node_type_substs.find(&id);
- foreach ts in r.iter() {
+ for ts in r.iter() {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&id));
let type_param_defs =
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
- foreach (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
+ for (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
check_typaram_bounds(cx, aty.id, aty.span, ty, type_param_def)
}
}
let this: *mut LanguageItemCollector = &mut *self;
visit_crate(self.crate, ((), mk_simple_visitor(@SimpleVisitor {
visit_item: |item| {
- foreach attribute in item.attrs.iter() {
+ for attribute in item.attrs.iter() {
unsafe {
(*this).match_and_collect_meta_item(
local_def(item.id),
*/
pub fn get_lint_dict() -> LintDict {
let mut map = HashMap::new();
- foreach &(k, v) in lint_table.iter() {
+ for &(k, v) in lint_table.iter() {
map.insert(k, v);
}
return map;
}
fn lint_to_str(&self, lint: lint) -> &'static str {
- foreach (k, v) in self.dict.iter() {
+ for (k, v) in self.dict.iter() {
if v.lint == lint {
return *k;
}
allow => fail!(),
}
- foreach &span in note.iter() {
+ for &span in note.iter() {
self.tcx.sess.span_note(span, "lint level defined here");
}
}
// pair instead of just one visitor.
match n {
Item(it) => {
- foreach visitor in self.visitors.iter() {
+ for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(orig, stopping) => {
(orig.visit_item)(it, (self, stopping));
}
}
Crate(c) => {
- foreach visitor in self.visitors.iter() {
+ for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(_, stopping) => {
oldvisit::visit_crate(c, (self, stopping))
// item_stopping_visitor has overridden visit_fn(&fk_method(... ))
// to be a no-op, so manually invoke visit_fn.
Method(m) => {
- foreach visitor in self.visitors.iter() {
+ for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(orig, stopping) => {
let fk = oldvisit::fk_method(m.ident,
attrs: &[ast::Attribute],
f: &fn(@ast::MetaItem, level, @str) -> bool) -> bool {
let xs = [allow, warn, deny, forbid];
- foreach &level in xs.iter() {
+ for &level in xs.iter() {
let level_name = level_to_str(level);
- foreach attr in attrs.iter().filter(|m| level_name == m.name()) {
+ for attr in attrs.iter().filter(|m| level_name == m.name()) {
let meta = attr.node.value;
let metas = match meta.node {
ast::MetaList(_, ref metas) => metas,
loop;
}
};
- foreach meta in metas.iter() {
+ for meta in metas.iter() {
match meta.node {
ast::MetaWord(lintname) => {
if !f(*meta, level, lintname) {
}
fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) {
- foreach input in decl.inputs.iter() {
+ for input in decl.inputs.iter() {
check_ty(cx, &input.ty);
}
check_ty(cx, &decl.output)
match it.node {
ast::item_foreign_mod(ref nmod) if !nmod.abis.is_intrinsic() => {
- foreach ni in nmod.items.iter() {
+ for ni in nmod.items.iter() {
match ni.node {
ast::foreign_item_fn(ref decl, _) => {
check_foreign_fn(cx, decl);
fn check_type(cx: &Context, span: span, ty: ty::t) {
let xs = [managed_heap_memory, owned_heap_memory, heap_memory];
- foreach lint in xs.iter() {
+ for lint in xs.iter() {
check_type_for_lint(cx, *lint, span, ty);
}
}
// If it's a struct, we also have to check the fields' types
match it.node {
ast::item_struct(struct_def, _) => {
- foreach struct_field in struct_def.fields.iter() {
+ for struct_field in struct_def.fields.iter() {
check_type(cx, struct_field.span,
ty::node_id_to_type(cx.tcx,
struct_field.node.id));
}
ast::item_enum(ref enum_definition, _) => {
check_case(cx, "type", it.ident, it.span);
- foreach variant in enum_definition.variants.iter() {
+ for variant in enum_definition.variants.iter() {
check_case(cx, "variant", variant.node.name, variant.span);
}
}
}
fn visit_fn_decl(cx: &Context, fd: &ast::fn_decl) {
- foreach arg in fd.inputs.iter() {
+ for arg in fd.inputs.iter() {
if arg.is_mutbl {
check_pat(cx, arg.pat);
}
match cx.tcx.sess.lints.pop(&id) {
None => {},
Some(l) => {
- foreach (lint, span, msg) in l.consume_iter() {
+ for (lint, span, msg) in l.consume_iter() {
cx.span_lint(lint, span, msg)
}
}
ast::item_struct(sdef, _) if it.vis == ast::public => {
check_attrs(cx, it.attrs, it.span,
"missing documentation for a struct");
- foreach field in sdef.fields.iter() {
+ for field in sdef.fields.iter() {
match field.node.kind {
ast::named_field(_, vis) if vis != ast::private => {
check_attrs(cx, field.node.attrs, field.span,
};
// Install defaults.
- foreach (_, spec) in cx.dict.iter() {
+ for (_, spec) in cx.dict.iter() {
cx.set_level(spec.lint, spec.default, Default);
}
// Install command-line options, overriding defaults.
- foreach &(lint, level) in tcx.sess.opts.lint_opts.iter() {
+ for &(lint, level) in tcx.sess.opts.lint_opts.iter() {
cx.set_level(lint, level, CommandLine);
}
// If we missed any lints added to the session, then there's a bug somewhere
// in the iteration code.
- foreach (id, v) in tcx.sess.lints.iter() {
- foreach t in v.iter() {
+ for (id, v) in tcx.sess.lints.iter() {
+ for t in v.iter() {
match *t {
(lint, span, ref msg) =>
tcx.sess.span_bug(span, fmt!("unprocessed lint %? at %s: \
debug!("creating fn_maps: %x", transmute(&*fn_maps));
}
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
do pat_util::pat_bindings(this.tcx.def_map, arg.pat)
|_bm, arg_id, _x, path| {
debug!("adding argument %d", arg_id);
fn visit_arm(arm: &arm, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
let def_map = this.tcx.def_map;
- foreach pat in arm.pats.iter() {
+ for pat in arm.pats.iter() {
do pat_util::pat_bindings(def_map, *pat) |bm, p_id, sp, path| {
debug!("adding local variable %d from match with bm %?",
p_id, bm);
// construction site.
let cvs = this.capture_map.get(&expr.id);
let mut call_caps = ~[];
- foreach cv in cvs.iter() {
+ for cv in cvs.iter() {
match moves::moved_variable_node_id_from_def(cv.def) {
Some(rv) => {
let cv_ln = this.add_live_node(FreeVarNode(cv.span));
// otherwise, live nodes are not required:
expr_index(*) | expr_field(*) | expr_vstore(*) | expr_vec(*) |
expr_call(*) | expr_method_call(*) | expr_tup(*) | expr_log(*) |
- expr_binary(*) | expr_addr_of(*) | expr_loop_body(*) |
+ expr_binary(*) | expr_addr_of(*) |
expr_do_body(*) | expr_cast(*) | expr_unary(*) | expr_break(_) |
expr_again(_) | expr_lit(_) | expr_ret(*) | expr_block(*) |
expr_assign(*) | expr_assign_op(*) | expr_mac(*) |
pub fn indices(&self, ln: LiveNode, op: &fn(uint)) {
let node_base_idx = self.idx(ln, Variable(0));
- foreach var_idx in range(0u, self.ir.num_vars) {
+ for var_idx in range(0u, self.ir.num_vars) {
op(node_base_idx + var_idx)
}
}
op: &fn(uint, uint)) {
let node_base_idx = self.idx(ln, Variable(0u));
let succ_base_idx = self.idx(succ_ln, Variable(0u));
- foreach var_idx in range(0u, self.ir.num_vars) {
+ for var_idx in range(0u, self.ir.num_vars) {
op(node_base_idx + var_idx, succ_base_idx + var_idx);
}
}
ln: LiveNode,
test: &fn(uint) -> LiveNode) {
let node_base_idx = self.idx(ln, Variable(0));
- foreach var_idx in range(0u, self.ir.num_vars) {
+ for var_idx in range(0u, self.ir.num_vars) {
let idx = node_base_idx + var_idx;
if test(idx).is_valid() {
wr.write_str(" ");
// hack to skip the loop unless debug! is enabled:
debug!("^^ liveness computation results for body %d (entry=%s)",
{
- foreach ln_idx in range(0u, self.ir.num_live_nodes) {
+ for ln_idx in range(0u, self.ir.num_live_nodes) {
debug!("%s", self.ln_str(LiveNode(ln_idx)));
}
body.id
let ln = self.live_node(expr.id, expr.span);
self.init_empty(ln, succ);
let mut first_merge = true;
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
let body_succ =
self.propagate_through_block(&arm.body, succ);
let guard_succ =
}
expr_addr_of(_, e) |
- expr_loop_body(e) |
expr_do_body(e) |
expr_cast(e, _) |
expr_unary(_, _, e) |
}
expr_inline_asm(ref ia) => {
- foreach &(_, input) in ia.inputs.iter() {
+ for &(_, input) in ia.inputs.iter() {
(vt.visit_expr)(input, (this, vt));
}
// Output operands must be lvalues
- foreach &(_, out) in ia.outputs.iter() {
+ for &(_, out) in ia.outputs.iter() {
match out.node {
expr_addr_of(_, inner) => {
this.check_lvalue(inner, vt);
expr_call(*) | expr_method_call(*) | expr_if(*) | expr_match(*) |
expr_while(*) | expr_loop(*) | expr_index(*) | expr_field(*) |
expr_vstore(*) | expr_vec(*) | expr_tup(*) | expr_log(*) |
- expr_binary(*) | expr_loop_body(*) | expr_do_body(*) |
+ expr_binary(*) | expr_do_body(*) |
expr_cast(*) | expr_unary(*) | expr_ret(*) | expr_break(*) |
expr_again(*) | expr_lit(_) | expr_block(*) |
expr_mac(*) | expr_addr_of(*) | expr_struct(*) | expr_repeat(*) |
}
pub fn warn_about_unused_args(&self, decl: &fn_decl, entry_ln: LiveNode) {
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
do pat_util::pat_bindings(self.tcx.def_map, arg.pat)
|_bm, p_id, sp, _n| {
let var = self.variable(p_id, sp);
-> bool {
if !self.used_on_entry(ln, var) {
let r = self.should_warn(var);
- foreach name in r.iter() {
+ for name in r.iter() {
// annoying: for parameters in funcs like `fn(x: int)
// {ret}`, there is only one node, so asking about
var: Variable) {
if self.live_on_exit(ln, var).is_none() {
let r = self.should_warn(var);
- foreach name in r.iter() {
+ for name in r.iter() {
self.tcx.sess.add_lint(dead_assignment, id, sp,
fmt!("value assigned to `%s` is never read", *name));
}
pub fn cat_expr_autoderefd(&self, expr: @ast::expr, autoderefs: uint)
-> cmt {
let mut cmt = self.cat_expr_unadjusted(expr);
- foreach deref in range(1u, autoderefs + 1) {
+ for deref in range(1u, autoderefs + 1) {
cmt = self.cat_deref(expr, cmt, deref);
}
return cmt;
ast::expr_addr_of(*) | ast::expr_call(*) |
ast::expr_assign(*) | ast::expr_assign_op(*) |
- ast::expr_fn_block(*) | ast::expr_ret(*) | ast::expr_loop_body(*) |
+ ast::expr_fn_block(*) | ast::expr_ret(*) |
ast::expr_do_body(*) | ast::expr_unary(*) |
ast::expr_method_call(*) | ast::expr_cast(*) | ast::expr_vstore(*) |
ast::expr_vec(*) | ast::expr_tup(*) | ast::expr_if(*) |
}
};
- foreach (i, &subpat) in subpats.iter().enumerate() {
+ for (i, &subpat) in subpats.iter().enumerate() {
let subpat_ty = self.pat_ty(subpat); // see (*)
let subcmt =
}
Some(&ast::def_fn(*)) |
Some(&ast::def_struct(*)) => {
- foreach (i, &subpat) in subpats.iter().enumerate() {
+ for (i, &subpat) in subpats.iter().enumerate() {
let subpat_ty = self.pat_ty(subpat); // see (*)
let cmt_field =
self.cat_imm_interior(
}
}
Some(&ast::def_static(*)) => {
- foreach &subpat in subpats.iter() {
+ for &subpat in subpats.iter() {
self.cat_pattern(cmt, subpat, |x,y| op(x,y));
}
}
ast::pat_struct(_, ref field_pats, _) => {
// {f1: p1, ..., fN: pN}
- foreach fp in field_pats.iter() {
+ for fp in field_pats.iter() {
let field_ty = self.pat_ty(fp.pat); // see (*)
let cmt_field = self.cat_field(pat, cmt, fp.ident, field_ty);
self.cat_pattern(cmt_field, fp.pat, |x,y| op(x,y));
ast::pat_tup(ref subpats) => {
// (p1, ..., pN)
- foreach (i, &subpat) in subpats.iter().enumerate() {
+ for (i, &subpat) in subpats.iter().enumerate() {
let subpat_ty = self.pat_ty(subpat); // see (*)
let subcmt =
self.cat_imm_interior(
ast::pat_vec(ref before, slice, ref after) => {
let elt_cmt = self.cat_index(pat, cmt, 0);
- foreach &before_pat in before.iter() {
+ for &before_pat in before.iter() {
self.cat_pattern(elt_cmt, before_pat, |x,y| op(x,y));
}
- foreach &slice_pat in slice.iter() {
+ for &slice_pat in slice.iter() {
let slice_ty = self.pat_ty(slice_pat);
let slice_cmt = self.cat_rvalue_node(pat, slice_ty);
self.cat_pattern(slice_cmt, slice_pat, |x,y| op(x,y));
}
- foreach &after_pat in after.iter() {
+ for &after_pat in after.iter() {
self.cat_pattern(elt_cmt, after_pat, |x,y| op(x,y));
}
}
match ty::get(base_ty).sty {
ty::ty_struct(did, _) => {
let r = ty::lookup_struct_fields(tcx, did);
- foreach fld in r.iter() {
+ for fld in r.iter() {
if fld.ident == f_name {
return Some(ast::m_imm);
}
match tcx.def_map.get_copy(&node_id) {
ast::def_variant(_, variant_id) => {
let r = ty::lookup_struct_fields(tcx, variant_id);
- foreach fld in r.iter() {
+ for fld in r.iter() {
if fld.ident == f_name {
return Some(ast::m_imm);
}
(cx, v): (VisitContext,
vt<VisitContext>)) {
cx.use_pat(local.pat);
- foreach &init in local.init.iter() {
+ for &init in local.init.iter() {
cx.use_expr(init, Read, v);
}
}
id: NodeId,
(cx, v): (VisitContext,
vt<VisitContext>)) {
- foreach a in decl.inputs.iter() {
+ for a in decl.inputs.iter() {
cx.use_pat(a.pat);
}
oldvisit::visit_fn(fk, decl, body, span, id, (cx, v));
impl VisitContext {
pub fn consume_exprs(&self, exprs: &[@expr], visitor: vt<VisitContext>) {
- foreach expr in exprs.iter() {
+ for expr in exprs.iter() {
self.consume_expr(*expr, visitor);
}
}
debug!("consume_block(blk.id=%?)", blk.id);
- foreach stmt in blk.stmts.iter() {
+ for stmt in blk.stmts.iter() {
(visitor.visit_stmt)(*stmt, (*self, visitor));
}
- foreach tail_expr in blk.expr.iter() {
+ for tail_expr in blk.expr.iter() {
self.consume_expr(*tail_expr, visitor);
}
}
Move => {
let def = self.tcx.def_map.get_copy(&expr.id);
let r = moved_variable_node_id_from_def(def);
- foreach &id in r.iter() {
+ for &id in r.iter() {
self.move_maps.moved_variables_set.insert(id);
}
}
}
expr_struct(_, ref fields, opt_with) => {
- foreach field in fields.iter() {
+ for field in fields.iter() {
self.consume_expr(field.expr, visitor);
}
- foreach with_expr in opt_with.iter() {
+ for with_expr in opt_with.iter() {
// If there are any fields whose type is move-by-default,
// then `with` is consumed, otherwise it is only read
let with_ty = ty::expr_ty(self.tcx, *with_expr);
expr_if(cond_expr, ref then_blk, opt_else_expr) => {
self.consume_expr(cond_expr, visitor);
self.consume_block(then_blk, visitor);
- foreach else_expr in opt_else_expr.iter() {
+ for else_expr in opt_else_expr.iter() {
self.consume_expr(*else_expr, visitor);
}
}
expr_match(discr, ref arms) => {
// We must do this first so that `arms_have_by_move_bindings`
// below knows which bindings are moves.
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
self.consume_arm(arm, visitor);
}
}
expr_ret(ref opt_expr) => {
- foreach expr in opt_expr.iter() {
+ for expr in opt_expr.iter() {
self.consume_expr(*expr, visitor);
}
}
self.consume_expr(count, visitor);
}
- expr_loop_body(base) |
expr_do_body(base) => {
self.use_expr(base, comp_mode, visitor);
}
expr_fn_block(ref decl, ref body) => {
- foreach a in decl.inputs.iter() {
+ for a in decl.inputs.iter() {
self.use_pat(a.pat);
}
let cap_vars = self.compute_captures(expr.id);
// for overloaded operatrs, we are always passing in a
// borrowed pointer, so it's always read mode:
- foreach arg_expr in arg_exprs.iter() {
+ for arg_expr in arg_exprs.iter() {
self.use_expr(*arg_expr, Read, visitor);
}
}
pub fn consume_arm(&self, arm: &arm, visitor: vt<VisitContext>) {
- foreach pat in arm.pats.iter() {
+ for pat in arm.pats.iter() {
self.use_pat(*pat);
}
- foreach guard in arm.guard.iter() {
+ for guard in arm.guard.iter() {
self.consume_expr(*guard, visitor);
}
arg_exprs: &[@expr],
visitor: vt<VisitContext>) {
//! Uses the argument expressions.
- foreach arg_expr in arg_exprs.iter() {
+ for arg_expr in arg_exprs.iter() {
self.use_fn_arg(*arg_expr, visitor);
}
}
arms: &[arm])
-> Option<@pat> {
let mut ret = None;
- foreach arm in arms.iter() {
- foreach &pat in arm.pats.iter() {
+ for arm in arms.iter() {
+ for &pat in arm.pats.iter() {
let cont = do ast_util::walk_pat(pat) |p| {
if moves_map.contains(&p.id) {
ret = Some(p);
*count += 1;
}
item_impl(_, _, _, ref methods) => {
- foreach method in methods.iter() {
+ for method in methods.iter() {
privileged_items.push(method.id);
*count += 1;
}
*count += 1;
}
item_foreign_mod(ref foreign_mod) => {
- foreach foreign_item in foreign_mod.items.iter() {
+ for foreign_item in foreign_mod.items.iter() {
privileged_items.push(foreign_item.id);
*count += 1;
}
// Adds items that are privileged to this scope.
let add_privileged_items: @fn(&[@ast::item]) -> uint = |items| {
let mut count = 0;
- foreach &item in items.iter() {
+ for &item in items.iter() {
add_privileged_item(item, &mut count);
}
count
let check_field: @fn(span: span, id: ast::def_id, ident: ast::ident) =
|span, id, ident| {
let fields = ty::lookup_struct_fields(tcx, id);
- foreach field in fields.iter() {
+ for field in fields.iter() {
if field.ident != ident { loop; }
if field.vis == private {
tcx.sess.span_err(span, fmt!("field `%s` is private",
visit_block: |block, (method_map, visitor)| {
// Gather up all the privileged items.
let mut n_added = 0;
- foreach stmt in block.stmts.iter() {
+ for stmt in block.stmts.iter() {
match stmt.node {
stmt_decl(decl, _) => {
match decl.node {
ty_struct(id, _) => {
if id.crate != LOCAL_CRATE ||
!privileged_items.iter().any(|x| x == &(id.node)) {
- foreach field in (*fields).iter() {
+ for field in (*fields).iter() {
debug!("(privacy checking) checking \
field in struct literal");
check_field(expr.span, id, field.ident);
!privileged_items.iter().any(|x| x == &(id.node)) {
match tcx.def_map.get_copy(&expr.id) {
def_variant(_, variant_id) => {
- foreach field in (*fields).iter() {
+ for field in (*fields).iter() {
debug!("(privacy checking) \
checking field in \
struct variant \
ty_struct(id, _) => {
if id.crate != LOCAL_CRATE ||
!privileged_items.iter().any(|x| x == &(id.node)) {
- foreach field in fields.iter() {
+ for field in fields.iter() {
debug!("(privacy checking) checking \
struct pattern");
check_field(pattern.span, id, field.ident);
!privileged_items.iter().any(|x| x == &enum_id.node) {
match tcx.def_map.find(&pattern.id) {
Some(&def_variant(_, variant_id)) => {
- foreach field in fields.iter() {
+ for field in fields.iter() {
debug!("(privacy checking) \
checking field in \
struct variant pattern");
}
item_enum(ref enum_def, _) => {
if privacy_context == PublicContext {
- foreach variant in enum_def.variants.iter() {
+ for variant in enum_def.variants.iter() {
reachable_symbols.insert(variant.node.id);
}
}
};
// Mark all public methods as reachable.
- foreach &method in methods.iter() {
+ for &method in methods.iter() {
if should_be_considered_public(method) {
reachable_symbols.insert(method.id);
}
if generics_require_inlining(generics) {
// If the impl itself has generics, add all public
// symbols to the worklist.
- foreach &method in methods.iter() {
+ for &method in methods.iter() {
if should_be_considered_public(method) {
worklist.push(method.id)
}
} else {
// Otherwise, add only public methods that have
// generics to the worklist.
- foreach method in methods.iter() {
+ for method in methods.iter() {
let generics = &method.generics;
let attrs = &method.attrs;
if generics_require_inlining(generics) ||
item_trait(_, _, ref trait_methods) => {
// Mark all provided methods as reachable.
if privacy_context == PublicContext {
- foreach trait_method in trait_methods.iter() {
+ for trait_method in trait_methods.iter() {
match *trait_method {
provided(method) => {
reachable_symbols.insert(method.id);
// this properly would result in the necessity of computing *type*
// reachability, which might result in a compile time loss.
fn mark_destructors_reachable(&self) {
- foreach (_, destructor_def_id) in self.tcx.destructor_for_type.iter() {
+ for (_, destructor_def_id) in self.tcx.destructor_for_type.iter() {
if destructor_def_id.crate == LOCAL_CRATE {
self.reachable_symbols.insert(destructor_def_id.node);
}
while i < queue.len() {
match self.free_region_map.find(&queue[i]) {
Some(parents) => {
- foreach parent in parents.iter() {
+ for parent in parents.iter() {
if *parent == sup {
return true;
}
fn parent_to_expr(cx: Context, child_id: ast::NodeId, sp: span) {
debug!("region::parent_to_expr(span=%?)",
cx.sess.codemap.span_to_str(sp));
- foreach parent_id in cx.parent.iter() {
+ for parent_id in cx.parent.iter() {
cx.region_maps.record_parent(child_id, *parent_id);
}
}
oldvisit::vt<@mut DetermineRpCtxt>)) {
do cx.with(cx.item_id, false) {
do cx.with_ambient_variance(rv_contravariant) {
- foreach a in decl.inputs.iter() {
+ for a in decl.inputs.iter() {
(visitor.visit_ty)(&a.ty, (cx, visitor));
}
}
ast::ty_path(ref path, _, _) => {
// type parameters are---for now, anyway---always invariant
do cx.with_ambient_variance(rv_invariant) {
- foreach tp in path.types.iter() {
+ for tp in path.types.iter() {
(visitor.visit_ty)(tp, (cx, visitor));
}
}
do cx.with(cx.item_id, false) {
// parameters are contravariant
do cx.with_ambient_variance(rv_contravariant) {
- foreach a in decl.inputs.iter() {
+ for a in decl.inputs.iter() {
(visitor.visit_ty)(&a.ty, (cx, visitor));
}
}
match cx.dep_map.find(&c_id) {
None => {}
Some(deps) => {
- foreach dep in deps.iter() {
+ for dep in deps.iter() {
let v = add_variance(dep.ambient_variance, c_variance);
cx.add_rp(dep.id, v);
}
debug!("%s", {
debug!("Region variance results:");
let region_paramd_items = cx.region_paramd_items;
- foreach (&key, &value) in region_paramd_items.iter() {
+ for (&key, &value) in region_paramd_items.iter() {
debug!("item %? (%s) is parameterized with variance %?",
key,
ast_map::node_id_to_str(ast_map, key,
self.session.str_of(name)));
{
let r = child.span_for_namespace(ns);
- foreach sp in r.iter() {
+ for sp in r.iter() {
self.session.span_note(*sp,
fmt!("first definition of %s `%s` here",
namespace_error_to_str(duplicate_type),
}
// Check each statement.
- foreach statement in block.stmts.iter() {
+ for statement in block.stmts.iter() {
match statement.node {
stmt_decl(declaration, _) => {
match declaration.node {
name_bindings.define_type
(privacy, def_ty(local_def(item.id)), sp);
- foreach variant in (*enum_definition).variants.iter() {
+ for variant in (*enum_definition).variants.iter() {
self.build_reduced_graph_for_variant(
variant,
local_def(item.id),
};
// For each method...
- foreach method in methods.iter() {
+ for method in methods.iter() {
// Add the method to the module.
let ident = method.ident;
let (method_name_bindings, _) =
// Add the names of all the methods to the trait info.
let mut method_names = HashMap::new();
- foreach method in methods.iter() {
+ for method in methods.iter() {
let ty_m = trait_method_to_ty_method(method);
let ident = ty_m.ident;
}
let def_id = local_def(item.id);
- foreach (name, _) in method_names.iter() {
+ for (name, _) in method_names.iter() {
if !self.method_map.contains_key(name) {
self.method_map.insert(*name, HashSet::new());
}
let privacy = visibility_to_privacy(view_item.vis);
match view_item.node {
view_item_use(ref view_paths) => {
- foreach view_path in view_paths.iter() {
+ for view_path in view_paths.iter() {
// Extract and intern the module part of the path. For
// globs and lists, the path is found directly in the AST;
// for simple paths we have to munge the path a little.
let path_len = full_path.idents.len();
assert!(path_len != 0);
- foreach (i, ident) in full_path.idents.iter().enumerate() {
+ for (i, ident) in full_path.idents.iter().enumerate() {
if i != path_len - 1 {
module_path.push(*ident);
}
view_path_glob(ref module_ident_path, _) |
view_path_list(ref module_ident_path, _, _) => {
- foreach ident in module_ident_path.idents.iter() {
+ for ident in module_ident_path.idents.iter() {
module_path.push(*ident);
}
}
id);
}
view_path_list(_, ref source_idents, _) => {
- foreach source_ident in source_idents.iter() {
+ for source_ident in source_idents.iter() {
let name = source_ident.node.name;
let subclass = @SingleImport(name, name);
self.build_import_directive(
let method_def_ids =
get_trait_method_def_ids(self.session.cstore, def_id);
let mut interned_method_names = HashSet::new();
- foreach &method_def_id in method_def_ids.iter() {
+ for &method_def_id in method_def_ids.iter() {
let (method_name, explicit_self) =
get_method_name_and_explicit_self(self.session.cstore,
method_def_id);
interned_method_names.insert(method_name);
}
}
- foreach name in interned_method_names.iter() {
+ for name in interned_method_names.iter() {
if !self.method_map.contains_key(name) {
self.method_map.insert(*name, HashSet::new());
}
// need to.
let mut current_module = root;
- foreach ident_str in pieces.iter() {
+ for ident_str in pieces.iter() {
let ident = self.session.ident_of(*ident_str);
// Create or reuse a graph node for the child.
let (child_name_bindings, new_parent) =
// Add each static method to the module.
let new_parent = ModuleReducedGraphParent(
type_module);
- foreach static_method_info in static_methods.iter() {
+ for static_method_info in static_methods.iter() {
let ident = static_method_info.ident;
debug!("(building reduced graph for \
external crate) creating \
self.module_to_str(module_));
self.resolve_imports_for_module(module_);
- foreach (_, &child_node) in module_.children.iter() {
+ for (_, &child_node) in module_.children.iter() {
match child_node.get_module_if_available() {
None => {
// Nothing to do.
}
}
- foreach (_, &child_module) in module_.anonymous_children.iter() {
+ for (_, &child_module) in module_.anonymous_children.iter() {
self.resolve_imports_for_module_subtree(child_module);
}
}
pub fn idents_to_str(@mut self, idents: &[ident]) -> ~str {
let mut first = true;
let mut result = ~"";
- foreach ident in idents.iter() {
+ for ident in idents.iter() {
if first {
first = false
} else {
assert_eq!(containing_module.glob_count, 0);
// Add all resolved imports from the containing module.
- foreach (ident, target_import_resolution) in containing_module.import_resolutions.iter() {
+ for (ident, target_import_resolution) in containing_module.import_resolutions.iter() {
debug!("(resolving glob import) writing module resolution \
%? into `%s`",
};
// Add all children from the containing module.
- foreach (&ident, name_bindings) in containing_module.children.iter() {
+ for (&ident, name_bindings) in containing_module.children.iter() {
merge_import_resolution(ident, *name_bindings);
}
// Add external module children from the containing module.
- foreach (&ident, module) in containing_module.external_module_children.iter() {
+ for (&ident, module) in containing_module.external_module_children.iter() {
let name_bindings =
@mut Resolver::create_name_bindings_from_module(*module);
merge_import_resolution(ident, name_bindings);
}
// Descend into children and anonymous children.
- foreach (_, &child_node) in module_.children.iter() {
+ for (_, &child_node) in module_.children.iter() {
match child_node.get_module_if_available() {
None => {
// Continue.
}
}
- foreach (_, &module_) in module_.anonymous_children.iter() {
+ for (_, &module_) in module_.anonymous_children.iter() {
self.report_unresolved_imports(module_);
}
}
self.record_exports_for_module(module_);
- foreach (_, &child_name_bindings) in module_.children.iter() {
+ for (_, &child_name_bindings) in module_.children.iter() {
match child_name_bindings.get_module_if_available() {
None => {
// Nothing to do.
}
}
- foreach (_, &child_module) in module_.anonymous_children.iter() {
+ for (_, &child_module) in module_.anonymous_children.iter() {
self.record_exports_for_module_subtree(child_module);
}
}
pub fn add_exports_for_module(@mut self,
exports2: &mut ~[Export2],
module_: @mut Module) {
- foreach (ident, importresolution) in module_.import_resolutions.iter() {
+ for (ident, importresolution) in module_.import_resolutions.iter() {
if importresolution.privacy != Public {
debug!("(computing exports) not reexporting private `%s`",
self.session.str_of(*ident));
loop;
}
let xs = [TypeNS, ValueNS];
- foreach ns in xs.iter() {
+ for ns in xs.iter() {
match importresolution.target_for_namespace(*ns) {
Some(target) => {
debug!("(computing exports) maybe reexport '%s'",
// enum item: resolve all the variants' discrs,
// then resolve the ty params
item_enum(ref enum_def, ref generics) => {
- foreach variant in (*enum_def).variants.iter() {
- foreach dis_expr in variant.node.disr_expr.iter() {
+ for variant in (*enum_def).variants.iter() {
+ for dis_expr in variant.node.disr_expr.iter() {
// resolve the discriminator expr
// as a constant
self.with_constant_rib(|| {
visitor);
// Resolve derived traits.
- foreach trt in traits.iter() {
+ for trt in traits.iter() {
self.resolve_trait_reference(item.id, trt, visitor, TraitDerivation);
}
- foreach method in (*methods).iter() {
+ for method in (*methods).iter() {
// Create a new rib for the method-specific type
// parameters.
//
&ty_m.generics.ty_params,
visitor);
- foreach argument in ty_m.decl.inputs.iter() {
+ for argument in ty_m.decl.inputs.iter() {
self.resolve_type(&argument.ty, visitor);
}
item_foreign_mod(ref foreign_module) => {
do self.with_scope(Some(item.ident)) {
- foreach foreign_item in foreign_module.items.iter() {
+ for foreign_item in foreign_module.items.iter() {
match foreign_item.node {
foreign_item_fn(_, ref generics) => {
self.with_type_parameter_rib(
let function_type_rib = @Rib(rib_kind);
self.type_ribs.push(function_type_rib);
- foreach (index, type_parameter) in generics.ty_params.iter().enumerate() {
+ for (index, type_parameter) in generics.ty_params.iter().enumerate() {
let name = type_parameter.ident;
debug!("with_type_parameter_rib: %d %d", node_id,
type_parameter.id);
// Nothing to do.
}
Some(declaration) => {
- foreach argument in declaration.inputs.iter() {
+ for argument in declaration.inputs.iter() {
let binding_mode = ArgumentIrrefutableMode;
let mutability =
if argument.is_mutbl {Mutable} else {Immutable};
pub fn resolve_type_parameters(@mut self,
type_parameters: &OptVec<TyParam>,
visitor: ResolveVisitor) {
- foreach type_parameter in type_parameters.iter() {
- foreach bound in type_parameter.bounds.iter() {
+ for type_parameter in type_parameters.iter() {
+ for bound in type_parameter.bounds.iter() {
self.resolve_type_parameter_bound(type_parameter.id, bound, visitor);
}
}
fields: &[@struct_field],
visitor: ResolveVisitor) {
let mut ident_map = HashMap::new::<ast::ident, @struct_field>();
- foreach &field in fields.iter() {
+ for &field in fields.iter() {
match field.node.kind {
named_field(ident, _) => {
match ident_map.find(&ident) {
self.resolve_type_parameters(&generics.ty_params, visitor);
// Resolve fields.
- foreach field in fields.iter() {
+ for field in fields.iter() {
self.resolve_type(&field.node.ty, visitor);
}
}
let mut new_trait_refs = ~[];
{
let r = self.def_map.find(&trait_reference.ref_id);
- foreach &def in r.iter() {
+ for &def in r.iter() {
new_trait_refs.push(def_id_of_def(*def));
}
}
// Resolve the self type.
self.resolve_type(self_type, visitor);
- foreach method in methods.iter() {
+ for method in methods.iter() {
// We also need a new scope for the method-specific
// type parameters.
self.resolve_method(MethodRibKind(
pub fn check_consistent_bindings(@mut self, arm: &arm) {
if arm.pats.len() == 0 { return; }
let map_0 = self.binding_mode_map(arm.pats[0]);
- foreach (i, p) in arm.pats.iter().enumerate() {
+ for (i, p) in arm.pats.iter().enumerate() {
let map_i = self.binding_mode_map(*p);
- foreach (&key, &binding_0) in map_0.iter() {
+ for (&key, &binding_0) in map_0.iter() {
match map_i.find(&key) {
None => {
self.session.span_err(
}
}
- foreach (&key, &binding) in map_i.iter() {
+ for (&key, &binding) in map_i.iter() {
if !map_0.contains_key(&key) {
self.session.span_err(
binding.span,
self.value_ribs.push(@Rib(NormalRibKind));
let bindings_list = @mut HashMap::new();
- foreach pattern in arm.pats.iter() {
+ for pattern in arm.pats.iter() {
self.resolve_pattern(*pattern, RefutableMode, Immutable,
Some(bindings_list), visitor);
}
}
do bounds.map |bound_vec| {
- foreach bound in bound_vec.iter() {
+ for bound in bound_vec.iter() {
self.resolve_type_parameter_bound(ty.id, bound, visitor);
}
};
ty_closure(c) => {
do c.bounds.map |bounds| {
- foreach bound in bounds.iter() {
+ for bound in bounds.iter() {
self.resolve_type_parameter_bound(ty.id, bound, visitor);
}
};
}
// Check the types in the path pattern.
- foreach ty in path.types.iter() {
+ for ty in path.types.iter() {
self.resolve_type(ty, visitor);
}
}
}
// Check the types in the path pattern.
- foreach ty in path.types.iter() {
+ for ty in path.types.iter() {
self.resolve_type(ty, visitor);
}
}
}
// Check the types in the path pattern.
- foreach ty in path.types.iter() {
+ for ty in path.types.iter() {
self.resolve_type(ty, visitor);
}
}
visitor: ResolveVisitor)
-> Option<def> {
// First, resolve the types.
- foreach ty in path.types.iter() {
+ for ty in path.types.iter() {
self.resolve_type(ty, visitor);
}
pub fn intern_module_part_of_path(@mut self, path: &Path) -> ~[ident] {
let mut module_path_idents = ~[];
- foreach (index, ident) in path.idents.iter().enumerate() {
+ for (index, ident) in path.idents.iter().enumerate() {
if index == path.idents.len() - 1 {
break;
}
let mut j = this.value_ribs.len();
while j != 0 {
j -= 1;
- foreach (&k, _) in this.value_ribs[j].bindings.iter() {
+ for (&k, _) in this.value_ribs[j].bindings.iter() {
maybes.push(this.session.str_of(k));
values.push(uint::max_value);
}
}
let mut smallest = 0;
- foreach (i, &other) in maybes.iter().enumerate() {
+ for (i, &other) in maybes.iter().enumerate() {
values[i] = name.lev_distance(other);
if values[i] <= values[smallest] {
i -= 1;
match this.type_ribs[i].kind {
MethodRibKind(node_id, _) =>
- foreach item in this.crate.module.items.iter() {
+ for item in this.crate.module.items.iter() {
if item.id == node_id {
match item.node {
item_struct(class_def, _) => {
- foreach field in class_def.fields.iter() {
+ for field in class_def.fields.iter() {
match field.node.kind {
unnamed_field => {},
named_field(ident, _) => {
// Look for the current trait.
match self.current_trait_refs {
Some(ref trait_def_ids) => {
- foreach trait_def_id in trait_def_ids.iter() {
+ for trait_def_id in trait_def_ids.iter() {
if candidate_traits.contains(trait_def_id) {
self.add_trait_info(&mut found_traits,
*trait_def_id,
}
// Look for trait children.
- foreach (_, &child_name_bindings) in search_module.children.iter() {
+ for (_, &child_name_bindings) in search_module.children.iter() {
match child_name_bindings.def_for_namespace(TypeNS) {
Some(def) => {
match def {
}
// Look for imports.
- foreach (_, &import_resolution) in search_module.import_resolutions.iter() {
+ for (_, &import_resolution) in search_module.import_resolutions.iter() {
match import_resolution.target_for_namespace(TypeNS) {
None => {
// Continue.
match vi.node {
view_item_extern_mod(*) => {} // ignore
view_item_use(ref path) => {
- foreach p in path.iter() {
+ for p in path.iter() {
match p.node {
view_path_simple(_, _, id) | view_path_glob(_, id) => {
if !self.used_imports.contains(&id) {
}
view_path_list(_, ref list, _) => {
- foreach i in list.iter() {
+ for i in list.iter() {
if !self.used_imports.contains(&i.node.id) {
self.session.add_lint(unused_imports,
i.node.id, i.span,
debug!("Dump of module `%s`:", self.module_to_str(module_));
debug!("Children:");
- foreach (&name, _) in module_.children.iter() {
+ for (&name, _) in module_.children.iter() {
debug!("* %s", self.session.str_of(name));
}
debug!("Import resolutions:");
- foreach (name, import_resolution) in module_.import_resolutions.iter() {
+ for (name, import_resolution) in module_.import_resolutions.iter() {
let value_repr;
match import_resolution.target_for_namespace(ValueNS) {
None => { value_repr = ~""; }
match ccx.tcx.def_map.get_copy(&pat_id) {
ast::def_variant(enum_id, var_id) => {
let variants = ty::enum_variants(ccx.tcx, enum_id);
- foreach v in (*variants).iter() {
+ for v in (*variants).iter() {
if var_id == v.id {
return var(v.disr_val,
adt::represent_node(bcx, pat_id))
}
pub fn has_nested_bindings(m: &[Match], col: uint) -> bool {
- foreach br in m.iter() {
+ for br in m.iter() {
match br.pats[col].node {
ast::pat_ident(_, _, Some(_)) => return true,
_ => ()
let _indenter = indenter();
let mut result = ~[];
- foreach br in m.iter() {
+ for br in m.iter() {
match e(br.pats[col]) {
Some(sub) => {
let pats =
// unspecified fields with dummy.
let mut reordered_patterns = ~[];
let r = ty::lookup_struct_fields(tcx, struct_id);
- foreach field in r.iter() {
+ for field in r.iter() {
match field_pats.iter().find_(|p| p.ident == field.ident) {
None => reordered_patterns.push(dummy),
Some(fp) => reordered_patterns.push(fp.pat)
match p.node {
ast::pat_struct(_, ref fpats, _) => {
let mut pats = ~[];
- foreach fname in fields.iter() {
+ for fname in fields.iter() {
match fpats.iter().find_(|p| p.ident == *fname) {
None => pats.push(dummy),
Some(pat) => pats.push(pat.pat)
}
let mut found = ~[];
- foreach br in m.iter() {
+ for br in m.iter() {
let cur = br.pats[col];
match cur.node {
ast::pat_lit(l) => {
col: uint)
-> ~[ast::ident] {
let mut fields: ~[ast::ident] = ~[];
- foreach br in m.iter() {
+ for br in m.iter() {
match br.pats[col].node {
ast::pat_struct(_, ref fs, _) => {
match ty::get(node_id_type(bcx, br.pats[col].id)).sty {
return fields;
fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) {
- foreach field_pat in field_pats.iter() {
+ for field_pat in field_pats.iter() {
let field_ident = field_pat.ident;
if !idents.iter().any(|x| *x == field_ident) {
idents.push(field_ident);
col: uint,
val: ValueRef)
-> @mut Block {
- foreach br in m.iter() {
+ for br in m.iter() {
let pat_id = br.pats[col].id;
if pat_id != 0 {
let datum = Datum {val: val, ty: node_id_type(bcx, pat_id),
}
}
let mut scores = vec::from_elem(m[0].pats.len(), 0u);
- foreach br in m.iter() {
+ for br in m.iter() {
let mut i = 0u;
- foreach p in br.pats.iter() { scores[i] += score(*p); i += 1u; }
+ for p in br.pats.iter() { scores[i] += score(*p); i += 1u; }
}
let mut max_score = 0u;
let mut best_col = 0u;
let mut i = 0u;
- foreach score in scores.iter() {
+ for score in scores.iter() {
let score = *score;
// Irrefutable columns always go first, they'd only be duplicated in
*/
let mut bcx = bcx;
- foreach (_, &binding_info) in bindings_map.iter() {
+ for (_, &binding_info) in bindings_map.iter() {
match binding_info.trmode {
TrByValue(lldest) => {
let llval = Load(bcx, binding_info.llmatch); // get a T*
BindArgument => bcx.fcx.llargs
};
- foreach (_, &binding_info) in bindings_map.iter() {
+ for (_, &binding_info) in bindings_map.iter() {
let llval = match binding_info.trmode {
// By value bindings: use the stack slot that we
// copied/moved the value into
let val = bool_to_i1(bcx, val);
// Revoke the temp cleanups now that the guard successfully executed.
- foreach llval in temp_cleanups.iter() {
+ for llval in temp_cleanups.iter() {
revoke_clean(bcx, *llval);
}
fn drop_bindings(bcx: @mut Block, data: &ArmData) -> @mut Block {
let mut bcx = bcx;
- foreach (_, &binding_info) in data.bindings_map.iter() {
+ for (_, &binding_info) in data.bindings_map.iter() {
match binding_info.trmode {
TrByValue(llval) => {
bcx = glue::drop_ty(bcx, llval, binding_info.ty);
let ccx = bcx.fcx.ccx;
let mut pat_id = 0;
let mut pat_span = dummy_sp();
- foreach br in m.iter() {
+ for br in m.iter() {
// Find a real id (we're adding placeholder wildcard patterns, but
// each column is guaranteed to have at least one real pattern)
if pat_id == 0 {
var(_, repr) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val);
kind = the_kind;
- foreach &tval in val_opt.iter() { test_val = tval; }
+ for &tval in val_opt.iter() { test_val = tval; }
}
lit(_) => {
let pty = node_id_type(bcx, pat_id);
}
}
}
- foreach o in opts.iter() {
+ for o in opts.iter() {
match *o {
range(_, _) => { kind = compare; break }
_ => ()
let mut i = 0u;
// Compile subtrees for each option
- foreach opt in opts.iter() {
+ for opt in opts.iter() {
i += 1u;
let mut opt_cx = else_cx;
if !exhaustive || i < len {
let mut arm_datas = ~[];
let mut matches = ~[];
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
let body = scope_block(bcx, arm.body.info(), "case_body");
let bindings_map = create_bindings_map(bcx, arm.pats[0]);
let arm_data = ArmData {
bindings_map: @bindings_map
};
arm_datas.push(arm_data.clone());
- foreach p in arm.pats.iter() {
+ for p in arm.pats.iter() {
matches.push(Match {
pats: ~[*p],
data: arm_data.clone(),
compile_submatch(bcx, matches, [lldiscr], chk);
let mut arm_cxs = ~[];
- foreach arm_data in arm_datas.iter() {
+ for arm_data in arm_datas.iter() {
let mut bcx = arm_data.bodycx;
// If this arm has a guard, then the various by-value bindings have
});
}
- foreach &inner_pat in inner.iter() {
+ for &inner_pat in inner.iter() {
bcx = bind_irrefutable_pat(bcx, inner_pat, val, binding_mode);
}
}
repr,
vinfo.disr_val,
val);
- foreach sub_pat in sub_pats.iter() {
- foreach (i, argval) in args.vals.iter().enumerate() {
+ for sub_pat in sub_pats.iter() {
+ for (i, argval) in args.vals.iter().enumerate() {
bcx = bind_irrefutable_pat(bcx, sub_pat[i],
*argval, binding_mode);
}
Some(ref elems) => {
// This is the tuple struct case.
let repr = adt::represent_node(bcx, pat.id);
- foreach (i, elem) in elems.iter().enumerate() {
+ for (i, elem) in elems.iter().enumerate() {
let fldptr = adt::trans_field_ptr(bcx, repr,
val, 0, i);
bcx = bind_irrefutable_pat(bcx, *elem,
let pat_ty = node_id_type(bcx, pat.id);
let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
- foreach f in fields.iter() {
+ for f in fields.iter() {
let ix = ty::field_idx_strict(tcx, f.ident, field_tys);
let fldptr = adt::trans_field_ptr(bcx, pat_repr, val,
discr, ix);
}
ast::pat_tup(ref elems) => {
let repr = adt::represent_node(bcx, pat.id);
- foreach (i, elem) in elems.iter().enumerate() {
+ for (i, elem) in elems.iter().enumerate() {
let fldptr = adt::trans_field_ptr(bcx, repr, val, 0, i);
bcx = bind_irrefutable_pat(bcx, *elem, fldptr, binding_mode);
}
let mut most_aligned = None;
let mut largest_align = 0;
let mut largest_size = 0;
- foreach st in sts.iter() {
+ for st in sts.iter() {
if largest_size < st.size {
largest_size = st.size;
}
let mut offset = 0;
let mut cfields = ~[];
- foreach (i, &ty) in st.fields.iter().enumerate() {
+ for (i, &ty) in st.fields.iter().enumerate() {
let llty = type_of::sizing_type_of(ccx, ty);
let type_align = machine::llalign_of_min(ccx, llty)
/*bad*/as u64;
ty::ByCopy,
out,
&mut cleanups,
- None,
callee::DontAutorefArg)
}));
ty::ByCopy,
e,
&mut cleanups,
- None,
callee::DontAutorefArg)
})
};
- foreach c in cleanups.iter() {
+ for c in cleanups.iter() {
revoke_clean(bcx, *c);
}
cleanups.clear();
ty::ByCopy,
input,
&mut cleanups,
- None,
callee::DontAutorefArg)
})
};
- foreach c in cleanups.iter() {
+ for c in cleanups.iter() {
revoke_clean(bcx, *c);
}
let op = PointerCast(bcx, aoutputs[0], val_ty(outputs[0]).ptr_to());
Store(bcx, r, op);
} else {
- foreach (i, o) in aoutputs.iter().enumerate() {
+ for (i, o) in aoutputs.iter().enumerate() {
let v = ExtractValue(bcx, r, i);
let op = PointerCast(bcx, *o, val_ty(outputs[i]).ptr_to());
Store(bcx, v, op);
}
pub fn set_optimize_for_size(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::OptimizeForSizeAttribute
- as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::OptimizeForSizeAttribute)
}
pub fn set_no_inline(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::NoInlineAttribute as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::NoInlineAttribute)
}
pub fn set_no_unwind(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::NoUnwindAttribute as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::NoUnwindAttribute)
}
// Tell LLVM to emit the information necessary to unwind the stack for the
// function f.
pub fn set_uwtable(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::UWTableAttribute as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::UWTableAttribute)
}
pub fn set_inline_hint(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::InlineHintAttribute as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::InlineHintAttribute)
}
pub fn set_inline_hint_if_appr(attrs: &[ast::Attribute],
}
pub fn set_always_inline(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f,
- lib::llvm::AlwaysInlineAttribute as c_uint,
- 0);
- }
+ lib::llvm::SetFunctionAttribute(f, lib::llvm::AlwaysInlineAttribute)
}
pub fn set_fixed_stack_segment(f: ValueRef) {
- unsafe {
- llvm::LLVMAddFunctionAttr(f, 0, 1 << (39 - 32));
- }
+ lib::llvm::SetFixedStackSegmentAttribute(f);
}
pub fn set_glue_inlining(f: ValueRef, t: ty::t) {
let tcx = cx.tcx();
let mut cx = cx;
- foreach (i, &arg) in variant.args.iter().enumerate() {
+ for (i, &arg) in variant.args.iter().enumerate() {
cx = f(cx,
adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
ty::subst_tps(tcx, tps, None, arg));
ty::ty_struct(*) => {
let repr = adt::represent_type(cx.ccx(), t);
do expr::with_field_tys(cx.tcx(), t, None) |discr, field_tys| {
- foreach (i, field_ty) in field_tys.iter().enumerate() {
+ for (i, field_ty) in field_tys.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(cx, repr, av, discr, i);
cx = f(cx, llfld_a, field_ty.mt.ty);
}
}
ty::ty_tup(ref args) => {
let repr = adt::represent_type(cx.ccx(), t);
- foreach (i, arg) in args.iter().enumerate() {
+ for (i, arg) in args.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(cx, repr, av, 0, i);
cx = f(cx, llfld_a, *arg);
}
n_variants);
let next_cx = sub_block(cx, "enum-iter-next");
- foreach variant in (*variants).iter() {
+ for variant in (*variants).iter() {
let variant_cx =
sub_block(cx, ~"enum-iter-variant-" +
uint::to_str(variant.disr_val));
debug!("invoking %x at %x",
::std::cast::transmute(llfn),
::std::cast::transmute(bcx.llbb));
- foreach &llarg in llargs.iter() {
+ for &llarg in llargs.iter() {
debug!("arg: %x", ::std::cast::transmute(llarg));
}
}
debug!("calling %x at %x",
::std::cast::transmute(llfn),
::std::cast::transmute(bcx.llbb));
- foreach &llarg in llargs.iter() {
+ for &llarg in llargs.iter() {
debug!("arg: %x", ::std::cast::transmute(llarg));
}
}
loop {
cur_scope = match cur_scope {
Some(inf) => {
- foreach cleanup in inf.cleanups.iter() {
+ for cleanup in inf.cleanups.iter() {
match *cleanup {
clean(_, cleanup_type) | clean_temp(_, _, cleanup_type) => {
if cleanup_type == normal_exit_and_unwind {
opt_node_info,
cx);
bcx.scope = scope;
- foreach cx in parent.iter() {
+ for cx in parent.iter() {
if cx.unreachable {
Unreachable(bcx);
break;
bcx.ccx().sess.opts.debugging_opts & session::no_landing_pads != 0;
if bcx.unreachable && !no_lpads { return bcx; }
let mut bcx = bcx;
- foreach cu in cleanups.rev_iter() {
+ for cu in cleanups.rev_iter() {
match *cu {
clean(cfn, cleanup_type) | clean_temp(_, cfn, cleanup_type) => {
// Some types don't need to be cleaned up during
let mut dest = None;
{
let r = (*inf).cleanup_paths.rev_iter().find_(|cp| cp.target == leave);
- foreach cp in r.iter() {
+ for cp in r.iter() {
if cp.size == inf.cleanups.len() {
Br(bcx, cp.dest);
return;
bcx = trans_block_cleanups_(sub_cx,
inf_cleanups,
is_lpad);
- foreach &dest in dest.iter() {
+ for &dest in dest.iter() {
Br(bcx, dest);
return;
}
}
pub fn block_locals(b: &ast::Block, it: &fn(@ast::Local)) {
- foreach s in b.stmts.iter() {
+ for s in b.stmts.iter() {
match s.node {
ast::stmt_decl(d, _) => {
match d.node {
opt_node_info: Option<NodeInfo>,
sp: Option<span>)
-> @mut FunctionContext {
- foreach p in param_substs.iter() { p.validate(); }
+ for p in param_substs.iter() { p.validate(); }
debug!("new_fn_ctxt_w_id(path=%s, id=%?, \
param_substs=%s)",
_ => {}
}
- foreach arg_n in range(0u, arg_tys.len()) {
+ for arg_n in range(0u, arg_tys.len()) {
let arg_ty = arg_tys[arg_n];
let raw_llarg = raw_llargs[arg_n];
// Put return block after all other blocks.
// This somewhat improves single-stepping experience in debugger.
unsafe {
- foreach &llreturn in fcx.llreturn.iter() {
+ for &llreturn in fcx.llreturn.iter() {
llvm::LLVMMoveBasicBlockAfter(llreturn, bcx.llbb);
}
}
*/
let tcx = bcx.tcx();
- foreach i in range(0u, fn_args.len()) {
+ for i in range(0u, fn_args.len()) {
debug!("setting type of argument %u (pat node %d) to %s",
i, fn_args[i].pat.id, bcx.ty_to_str(arg_tys[i]));
let repr = adt::represent_type(ccx, result_ty);
adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr);
- foreach (i, fn_arg) in fn_args.iter().enumerate() {
+ for (i, fn_arg) in fn_args.iter().enumerate() {
let lldestptr = adt::trans_field_ptr(bcx,
repr,
fcx.llretptr.get(),
pub fn trans_enum_def(ccx: @mut CrateContext, enum_definition: &ast::enum_def,
id: ast::NodeId, vi: @~[@ty::VariantInfo],
i: &mut uint) {
- foreach variant in enum_definition.variants.iter() {
+ for variant in enum_definition.variants.iter() {
let disr_val = vi[*i].disr_val;
*i += 1;
item.id,
item.attrs);
} else {
- foreach stmt in body.stmts.iter() {
+ for stmt in body.stmts.iter() {
match stmt.node {
ast::stmt_decl(@codemap::spanned { node: ast::decl_item(i),
_ }, _) => {
consts::trans_const(ccx, m, item.id);
// Do static_assert checking. It can't really be done much earlier because we need to get
// the value of the bool out of LLVM
- foreach attr in item.attrs.iter() {
+ for attr in item.attrs.iter() {
if "static_assert" == attr.name() {
if m == ast::m_mutbl {
ccx.sess.span_fatal(expr.span,
// and control visibility.
pub fn trans_mod(ccx: @mut CrateContext, m: &ast::_mod) {
let _icx = push_ctxt("trans_mod");
- foreach item in m.items.iter() {
+ for item in m.items.iter() {
trans_item(ccx, *item);
}
}
node: it.id });
let mut i = 0;
let path = item_path(ccx, &it.id);
- foreach variant in (*enum_definition).variants.iter() {
+ for variant in (*enum_definition).variants.iter() {
let p = vec::append(path.clone(), [
path_name(variant.node.name),
path_name(special_idents::descrim)
// like the multiple borrows. At least, it doesn't
// like them on the current snapshot. (2013-06-14)
let mut keys = ~[];
- foreach (k, _) in ccx.module_data.iter() {
+ for (k, _) in ccx.module_data.iter() {
keys.push(k.to_managed());
}
- foreach key in keys.iter() {
+ for key in keys.iter() {
let val = *ccx.module_data.find_equiv(key).get();
let s_const = C_cstr(ccx, *key);
let s_ptr = p2i(ccx, s_const);
do sort::quick_sort(ccx.stats.fn_stats) |&(_, _, insns_a), &(_, _, insns_b)| {
insns_a > insns_b
}
- foreach tuple in ccx.stats.fn_stats.iter() {
+ for tuple in ccx.stats.fn_stats.iter() {
match *tuple {
(ref name, ms, insns) => {
printfln!("%u insns, %u ms, %s", insns, ms, *name);
}
}
if ccx.sess.count_llvm_insns() {
- foreach (k, v) in ccx.stats.llvm_insns.iter() {
+ for (k, v) in ccx.stats.llvm_insns.iter() {
printfln!("%-7u %s", *v, *k);
}
}
// we care about.
if ixs.len() < 16 {
let mut small_vec = [ C_i32(0), ..16 ];
- foreach (small_vec_e, &ix) in small_vec.mut_iter().zip(ixs.iter()) {
+ for (small_vec_e, &ix) in small_vec.mut_iter().zip(ixs.iter()) {
*small_vec_e = C_i32(ix as i32);
}
self.inbounds_gep(base, small_vec.slice(0, ixs.len()))
dst: ValueRef, src: ValueRef,
order: AtomicOrdering) -> ValueRef {
unsafe {
- llvm::LLVMBuildAtomicRMW(self.llbuilder, op, dst, src, order)
+ llvm::LLVMBuildAtomicRMW(self.llbuilder, op, dst, src, order, False)
}
}
let fnty = Type::func(atys, &rty);
let llfn = decl(fnty);
- foreach (i, a) in self.attrs.iter().enumerate() {
+ for (i, a) in self.attrs.iter().enumerate() {
match *a {
option::Some(attr) => {
unsafe {
pub fn build_shim_ret(&self, bcx: @mut Block, arg_tys: &[Type], ret_def: bool,
llargbundle: ValueRef, llretval: ValueRef) {
- foreach (i, a) in self.attrs.iter().enumerate() {
+ for (i, a) in self.attrs.iter().enumerate() {
match *a {
option::Some(attr) => {
unsafe {
ret_def: bool) -> FnType {
let mut arg_tys = ~[];
let mut attrs = ~[];
- foreach &aty in atys.iter() {
+ for &aty in atys.iter() {
let (ty, attr) = classify_arg_ty(aty);
arg_tys.push(ty);
attrs.push(attr);
let mut attrs = ~[];
let mut offset = if sret { 4 } else { 0 };
- foreach aty in atys.iter() {
+ for aty in atys.iter() {
let (ty, attr) = classify_arg_ty(*aty, &mut offset);
arg_tys.push(ty);
attrs.push(attr);
}
fn all_mem(cls: &mut [RegClass]) {
- foreach i in range(0u, cls.len()) {
+ for i in range(0u, cls.len()) {
cls[i] = Memory;
}
}
cls: &mut [RegClass], i: uint,
off: uint) {
let mut field_off = off;
- foreach ty in tys.iter() {
+ for ty in tys.iter() {
field_off = align(field_off, *ty);
classify(*ty, cls, i, field_off);
field_off += ty_size(*ty);
fn llreg_ty(cls: &[RegClass]) -> Type {
fn llvec_len(cls: &[RegClass]) -> uint {
let mut len = 1u;
- foreach c in cls.iter() {
+ for c in cls.iter() {
if *c != SSEUp {
break;
}
let mut arg_tys = ~[];
let mut attrs = ~[];
- foreach t in atys.iter() {
+ for t in atys.iter() {
let (ty, attr) = x86_64_ty(*t, |cls| cls.is_pass_byval(), ByValAttribute);
arg_tys.push(ty);
attrs.push(attr);
use middle::trans::base::*;
use middle::trans::build::*;
use middle::trans::callee;
-use middle::trans::closure;
use middle::trans::common;
use middle::trans::common::*;
use middle::trans::datum::*;
autoref_arg: AutorefArg)
-> Result {
do base::with_scope_result(in_cx, call_info, "call") |cx| {
- let ret_in_loop = match args {
- ArgExprs(args) => {
- args.len() > 0u && match args.last().node {
- ast::expr_loop_body(@ast::expr {
- node: ast::expr_fn_block(_, ref body),
- _
- }) => body_contains_ret(body),
- _ => false
- }
- }
- _ => false
- };
-
let callee = get_callee(cx);
let mut bcx = callee.bcx;
let ccx = cx.ccx();
- let ret_flag = if ret_in_loop {
- let flag = alloca(bcx, Type::bool(), "__ret_flag");
- Store(bcx, C_bool(false), flag);
- Some(flag)
- } else {
- None
- };
let (llfn, llenv) = unsafe {
match callee.data {
}
llargs.push(llenv);
- bcx = trans_args(bcx, args, fn_expr_ty,
- ret_flag, autoref_arg, &mut llargs);
-
+ bcx = trans_args(bcx, args, fn_expr_ty, autoref_arg, &mut llargs);
// Now that the arguments have finished evaluating, we need to revoke
// the cleanup for the self argument
match callee.data {
Method(d) => {
- foreach &v in d.temp_cleanup.iter() {
+ for &v in d.temp_cleanup.iter() {
revoke_clean(bcx, v);
}
}
// Uncomment this to debug calls.
/*
printfln!("calling: %s", bcx.val_to_str(llfn));
- foreach llarg in llargs.iter() {
+ for llarg in llargs.iter() {
printfln!("arg: %s", bcx.val_to_str(*llarg));
}
io::println("---");
if ty::type_is_bot(ret_ty) {
Unreachable(bcx);
- } else if ret_in_loop {
- let ret_flag_result = bool_to_i1(bcx, Load(bcx, ret_flag.get()));
- bcx = do with_cond(bcx, ret_flag_result) |bcx| {
- {
- let r = bcx.fcx.loop_ret;
- foreach &(flagptr, _) in r.iter() {
- Store(bcx, C_bool(true), flagptr);
- Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
- }
- }
- base::cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
- Unreachable(bcx);
- bcx
- }
}
rslt(bcx, llresult)
}
pub fn trans_args(cx: @mut Block,
args: CallArgs,
fn_ty: ty::t,
- ret_flag: Option<ValueRef>,
autoref_arg: AutorefArg,
llargs: &mut ~[ValueRef]) -> @mut Block
{
// to cast her view of the arguments to the caller's view.
match args {
ArgExprs(arg_exprs) => {
- let last = arg_exprs.len() - 1u;
- foreach (i, arg_expr) in arg_exprs.iter().enumerate() {
+ for (i, arg_expr) in arg_exprs.iter().enumerate() {
let arg_val = unpack_result!(bcx, {
trans_arg_expr(bcx,
arg_tys[i],
ty::ByCopy,
*arg_expr,
&mut temp_cleanups,
- if i == last { ret_flag } else { None },
autoref_arg)
});
llargs.push(arg_val);
// now that all arguments have been successfully built, we can revoke any
// temporary cleanups, as they are only needed if argument construction
// should fail (for example, cleanup of copy mode args).
- foreach c in temp_cleanups.iter() {
+ for c in temp_cleanups.iter() {
revoke_clean(bcx, *c)
}
self_mode: ty::SelfMode,
arg_expr: @ast::expr,
temp_cleanups: &mut ~[ValueRef],
- ret_flag: Option<ValueRef>,
autoref_arg: AutorefArg) -> Result {
let _icx = push_ctxt("trans_arg_expr");
let ccx = bcx.ccx();
- debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s, \
- ret_flag=%?)",
+ debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s)",
formal_arg_ty.repr(bcx.tcx()),
self_mode,
- arg_expr.repr(bcx.tcx()),
- ret_flag.map(|v| bcx.val_to_str(*v)));
+ arg_expr.repr(bcx.tcx()));
// translate the arg expr to a datum
- let arg_datumblock = match ret_flag {
- None => expr::trans_to_datum(bcx, arg_expr),
-
- // If there is a ret_flag, this *must* be a loop body
- Some(_) => {
- match arg_expr.node {
- ast::expr_loop_body(
- blk @ @ast::expr {
- node: ast::expr_fn_block(ref decl, ref body),
- _
- }) => {
- let scratch_ty = expr_ty(bcx, arg_expr);
- let scratch = alloc_ty(bcx, scratch_ty, "__ret_flag");
- let arg_ty = expr_ty(bcx, arg_expr);
- let sigil = ty::ty_closure_sigil(arg_ty);
- let bcx = closure::trans_expr_fn(
- bcx, sigil, decl, body, arg_expr.id,
- blk.id, Some(ret_flag), expr::SaveIn(scratch));
- DatumBlock {bcx: bcx,
- datum: Datum {val: scratch,
- ty: scratch_ty,
- mode: ByRef(RevokeClean)}}
- }
- _ => {
- bcx.sess().impossible_case(
- arg_expr.span, "ret_flag with non-loop-body expr");
- }
- }
- }
- };
+ let arg_datumblock = expr::trans_to_datum(bcx, arg_expr);
let arg_datum = arg_datumblock.datum;
let bcx = arg_datumblock.bcx;
val = arg_datum.to_ref_llval(bcx);
}
DontAutorefArg => {
- match self_mode {
+ let need_scratch = ty::type_needs_drop(bcx.tcx(), arg_datum.ty) ||
+ (bcx.expr_is_lval(arg_expr) &&
+ arg_datum.appropriate_mode(bcx.tcx()).is_by_ref());
+
+ let arg_datum = if need_scratch {
+ let scratch = scratch_datum(bcx, arg_datum.ty, "__self", false);
+ arg_datum.store_to_datum(bcx, INIT, scratch);
+
+ // Technically, ownership of val passes to the callee.
+ // However, we must cleanup should we fail before the
+ // callee is actually invoked.
+ scratch.add_clean(bcx);
+ temp_cleanups.push(scratch.val);
+
+ scratch
+ } else {
+ arg_datum
+ };
+
+ val = match self_mode {
ty::ByRef => {
- // This assertion should really be valid, but because
- // the explicit self code currently passes by-ref, it
- // does not hold.
- //
- //assert !bcx.ccx().maps.moves_map.contains_key(
- // &arg_expr.id);
- debug!("by ref arg with type %s, storing to scratch",
- bcx.ty_to_str(arg_datum.ty));
- let scratch = scratch_datum(bcx, arg_datum.ty,
- "__self", false);
-
- arg_datum.store_to_datum(bcx,
- INIT,
- scratch);
-
- // Technically, ownership of val passes to the callee.
- // However, we must cleanup should we fail before the
- // callee is actually invoked.
- scratch.add_clean(bcx);
- temp_cleanups.push(scratch.val);
-
- val = scratch.to_ref_llval(bcx);
+ debug!("by ref arg with type %s", bcx.ty_to_str(arg_datum.ty));
+ arg_datum.to_ref_llval(bcx)
}
ty::ByCopy => {
- if ty::type_needs_drop(bcx.tcx(), arg_datum.ty) ||
- arg_datum.appropriate_mode(bcx.tcx()).is_by_ref() {
- debug!("by copy arg with type %s, storing to scratch",
- bcx.ty_to_str(arg_datum.ty));
- let scratch = scratch_datum(bcx, arg_datum.ty,
- "__arg", false);
-
- arg_datum.store_to_datum(bcx,
- INIT,
- scratch);
-
- // Technically, ownership of val passes to the callee.
- // However, we must cleanup should we fail before the
- // callee is actually invoked.
- scratch.add_clean(bcx);
- temp_cleanups.push(scratch.val);
-
- match scratch.appropriate_mode(bcx.tcx()) {
- ByValue => val = Load(bcx, scratch.val),
- ByRef(_) => val = scratch.val,
- }
- } else {
- debug!("by copy arg with type %s", bcx.ty_to_str(arg_datum.ty));
- match arg_datum.mode {
- ByRef(_) => val = Load(bcx, arg_datum.val),
- ByValue => val = arg_datum.val,
- }
- }
+ debug!("by copy arg with type %s", bcx.ty_to_str(arg_datum.ty));
+ arg_datum.to_appropriate_llval(bcx)
}
}
}
// Copy expr values into boxed bindings.
let mut bcx = bcx;
- foreach (i, bv) in bound_values.iter().enumerate() {
+ for (i, bv) in bound_values.iter().enumerate() {
debug!("Copy %s into closure", bv.to_str(ccx));
if ccx.sess.asm_comments() {
// Package up the captured upvars
let mut env_vals = ~[];
- foreach cap_var in cap_vars.iter() {
+ for cap_var in cap_vars.iter() {
debug!("Building closure: captured variable %?", *cap_var);
let datum = expr::trans_local_var(bcx, cap_var.def);
match cap_var.mode {
// If this is a `for` loop body, add two special environment
// variables:
- foreach flagptr in include_ret_handle.iter() {
+ for flagptr in include_ret_handle.iter() {
// Flag indicating we have returned (a by-ref bool):
let flag_datum = Datum {val: *flagptr, ty: ty::mk_bool(),
mode: ByRef(ZeroMem)};
// Populate the upvars from the environment.
let mut i = 0u;
- foreach cap_var in cap_vars.iter() {
+ for cap_var in cap_vars.iter() {
let mut upvarptr = GEPi(bcx, llcdata, [0u, i]);
match sigil {
ast::BorrowedSigil => { upvarptr = Load(bcx, upvarptr); }
impl param_substs {
pub fn validate(&self) {
- foreach t in self.tys.iter() { assert!(!ty::type_needs_infer(*t)); }
- foreach t in self.self_ty.iter() { assert!(!ty::type_needs_infer(*t)); }
+ for t in self.tys.iter() { assert!(!ty::type_needs_infer(*t)); }
+ for t in self.self_ty.iter() { assert!(!ty::type_needs_infer(*t)); }
}
}
clean_temp(v, _, _) if v == val => true,
_ => false
});
- foreach i in cleanup_pos.iter() {
+ for i in cleanup_pos.iter() {
scope_info.cleanups =
vec::append(scope_info.cleanups.slice(0u, *i).to_owned(),
scope_info.cleanups.slice(*i + 1u,
pub fn path_str(sess: session::Session, p: &[path_elt]) -> ~str {
let mut r = ~"";
let mut first = true;
- foreach e in p.iter() {
+ for e in p.iter() {
match *e {
ast_map::path_name(s) | ast_map::path_mod(s) => {
if first {
pub fn trans_block(bcx: @mut Block, b: &ast::Block, dest: expr::Dest) -> @mut Block {
let _icx = push_ctxt("trans_block");
let mut bcx = bcx;
- foreach s in b.stmts.iter() {
+ for s in b.stmts.iter() {
debuginfo::update_source_pos(bcx, b.span);
bcx = trans_stmt(bcx, *s);
}
pub fn join_blocks(parent_bcx: @mut Block, in_cxs: &[@mut Block]) -> @mut Block {
let out = sub_block(parent_bcx, "join");
let mut reachable = false;
- foreach bcx in in_cxs.iter() {
+ for bcx in in_cxs.iter() {
if !bcx.unreachable {
Br(*bcx, out.llbb);
reachable = true;
let (modpath, modname) = {
let path = &mut bcx.fcx.path;
let mut modpath = ~[path_mod(ccx.sess.ident_of(ccx.link_meta.name))];
- foreach e in path.iter() {
+ for e in path.iter() {
match *e {
path_mod(_) => { modpath.push(*e) }
_ => {}
expr.id, expr.id,
None, dest);
}
- ast::expr_loop_body(blk) => {
- let expr_ty = expr_ty(bcx, expr);
- let sigil = ty::ty_closure_sigil(expr_ty);
- match blk.node {
- ast::expr_fn_block(ref decl, ref body) => {
- return closure::trans_expr_fn(bcx,
- sigil,
- decl,
- body,
- expr.id,
- blk.id,
- Some(None),
- dest);
- }
- _ => {
- bcx.sess().impossible_case(
- expr.span,
- "loop_body has the wrong kind of contents")
- }
- }
- }
ast::expr_do_body(blk) => {
return trans_into(bcx, blk, dest);
}
let optbase = match base {
Some(base_expr) => {
let mut leftovers = ~[];
- foreach (i, b) in need_base.iter().enumerate() {
+ for (i, b) in need_base.iter().enumerate() {
if *b {
leftovers.push((i, field_tys[i].mt.ty))
}
let mut bcx = bcx;
let addr = match dest {
Ignore => {
- foreach &(_i, e) in fields.iter() {
+ for &(_i, e) in fields.iter() {
bcx = trans_into(bcx, e, Ignore);
}
- foreach sbi in optbase.iter() {
+ for sbi in optbase.iter() {
// FIXME #7261: this moves entire base, not just certain fields
bcx = trans_into(bcx, sbi.expr, Ignore);
}
};
let mut temp_cleanups = ~[];
adt::trans_start_init(bcx, repr, addr, discr);
- foreach &(i, e) in fields.iter() {
+ for &(i, e) in fields.iter() {
let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
let e_ty = expr_ty(bcx, e);
bcx = trans_into(bcx, e, SaveIn(dest));
add_clean_temp_mem(bcx, dest, e_ty);
temp_cleanups.push(dest);
}
- foreach base in optbase.iter() {
+ for base in optbase.iter() {
// FIXME #6573: is it sound to use the destination's repr on the base?
// And, would it ever be reasonable to be here with discr != 0?
let base_datum = unpack_datum!(bcx, trans_to_datum(bcx, base.expr));
- foreach &(i, t) in base.fields.iter() {
+ for &(i, t) in base.fields.iter() {
let datum = do base_datum.get_element(bcx, t, ZeroMem) |srcval| {
adt::trans_field_ptr(bcx, repr, srcval, discr, i)
};
}
}
- foreach cleanup in temp_cleanups.iter() {
+ for cleanup in temp_cleanups.iter() {
revoke_clean(bcx, *cleanup);
}
return bcx;
Some(abi) => abi,
};
- foreach &foreign_item in foreign_mod.items.iter() {
+ for &foreign_item in foreign_mod.items.iter() {
match foreign_item.node {
ast::foreign_item_fn(*) => {
let id = foreign_item.id;
let _icx = push_ctxt("foreign::wrap::build_args");
let ccx = bcx.ccx();
let n = tys.llsig.llarg_tys.len();
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
let arg_i = bcx.fcx.arg_pos(i);
let mut llargval = get_param(llwrapfn, arg_i);
store_inbounds(bcx, llargval, llargbundle, [0u, i]);
}
- foreach &retptr in bcx.fcx.llretptr.iter() {
+ for &retptr in bcx.fcx.llretptr.iter() {
store_inbounds(bcx, retptr, llargbundle, [0u, n]);
}
}
llargbundle: ValueRef) {
let _icx = push_ctxt("foreign::wrap::build_ret");
let arg_count = shim_types.fn_sig.inputs.len();
- foreach &retptr in bcx.fcx.llretptr.iter() {
+ for &retptr in bcx.fcx.llretptr.iter() {
let llretptr = load_inbounds(bcx, llargbundle, [0, arg_count]);
Store(bcx, Load(bcx, llretptr), retptr);
}
assert!(num_args <= 4);
let mut args = [0 as ValueRef, ..4];
let first_real_arg = bcx.fcx.arg_pos(0u);
- foreach i in range(0u, num_args) {
+ for i in range(0u, num_args) {
args[i] = get_param(bcx.fcx.llfn, first_real_arg + i);
}
let llfn = bcx.ccx().intrinsics.get_copy(&name);
// Drop the fields
let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
- foreach (i, fld) in field_tys.iter().enumerate() {
+ for (i, fld) in field_tys.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
}
// Drop the fields
let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
- foreach (i, fld) in field_tys.iter().enumerate() {
+ for (i, fld) in field_tys.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
}
ccx.finished_tydescs = true;
let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to();
let tyds = &mut ccx.tydescs;
- foreach (_, &val) in tyds.iter() {
+ for (_, &val) in tyds.iter() {
let ti = val;
// Each of the glue functions needs to be cast to a generic type
ast::item_enum(_, _) => {
let vs_here = ty::enum_variants(ccx.tcx, local_def(item.id));
let vs_there = ty::enum_variants(ccx.tcx, parent_id);
- foreach (here, there) in vs_here.iter().zip(vs_there.iter()) {
+ for (here, there) in vs_here.iter().zip(vs_there.iter()) {
if there.id == fn_id { my_id = here.id.node; }
ccx.external.insert(there.id, Some(here.id.node));
}
if !generics.ty_params.is_empty() { return; }
let sub_path = vec::append_one(path, path_name(name));
- foreach method in methods.iter() {
+ for method in methods.iter() {
if method.generics.ty_params.len() == 0u {
let llfn = get_item_val(ccx, method.id);
let path = vec::append_one(sub_path.clone(),
mentry.self_mode,
base,
temp_cleanups,
- None,
DontAutorefArg)
}
let _icx = push_ctxt("impl::make_vtable");
let mut components = ~[ tydesc.tydesc ];
- foreach &ptr in ptrs.iter() {
+ for &ptr in ptrs.iter() {
components.push(ptr)
}
self_vtables: self_vtables
};
- foreach s in real_substs.tps.iter() { assert!(!ty::type_has_params(*s)); }
- foreach s in psubsts.tys.iter() { assert!(!ty::type_has_params(*s)); }
+ for s in real_substs.tps.iter() { assert!(!ty::type_has_params(*s)); }
+ for s in psubsts.tys.iter() { assert!(!ty::type_has_params(*s)); }
let param_uses = type_use::type_uses_for(ccx, fn_id, psubsts.tys.len());
let v = self.visitor_val;
debug!("passing %u args:", args.len());
let mut bcx = self.bcx;
- foreach (i, a) in args.iter().enumerate() {
+ for (i, a) in args.iter().enumerate() {
debug!("arg %u: %s", i, bcx.val_to_str(*a));
}
let bool_ty = ty::mk_bool();
let extra = ~[self.c_uint(tys.len())]
+ self.c_size_and_align(t);
do self.bracketed("tup", extra) |this| {
- foreach (i, t) in tys.iter().enumerate() {
+ for (i, t) in tys.iter().enumerate() {
let extra = ~[this.c_uint(i), this.c_tydesc(*t)];
this.visit("tup_field", extra);
}
let extra = ~[self.c_uint(fields.len())]
+ self.c_size_and_align(t);
do self.bracketed("class", extra) |this| {
- foreach (i, field) in fields.iter().enumerate() {
+ for (i, field) in fields.iter().enumerate() {
let extra = ~[this.c_uint(i),
this.c_slice(
bcx.ccx().sess.str_of(field.ident))]
let enum_args = ~[self.c_uint(variants.len()), make_get_disr()]
+ self.c_size_and_align(t);
do self.bracketed("enum", enum_args) |this| {
- foreach (i, v) in variants.iter().enumerate() {
+ for (i, v) in variants.iter().enumerate() {
let name = ccx.sess.str_of(v.name);
let variant_args = ~[this.c_uint(i),
this.c_uint(v.disr_val),
this.c_uint(v.args.len()),
this.c_slice(name)];
do this.bracketed("enum_variant", variant_args) |this| {
- foreach (j, a) in v.args.iter().enumerate() {
+ for (j, a) in v.args.iter().enumerate() {
let bcx = this.bcx;
let null = C_null(llptrty);
let ptr = adt::trans_field_ptr(bcx, repr, null, v.disr_val, j);
}
pub fn visit_sig(&mut self, retval: uint, sig: &ty::FnSig) {
- foreach (i, arg) in sig.inputs.iter().enumerate() {
+ for (i, arg) in sig.inputs.iter().enumerate() {
let modeval = 5u; // "by copy"
let extra = ~[self.c_uint(i),
self.c_uint(modeval),
ast::expr_vec(ref elements, _) => {
match dest {
Ignore => {
- foreach element in elements.iter() {
+ for element in elements.iter() {
bcx = expr::trans_into(bcx, *element, Ignore);
}
}
SaveIn(lldest) => {
let mut temp_cleanups = ~[];
- foreach (i, element) in elements.iter().enumerate() {
+ for (i, element) in elements.iter().enumerate() {
let lleltptr = GEPi(bcx, lldest, [i]);
debug!("writing index %? with lleltptr=%?",
i, bcx.val_to_str(lleltptr));
add_clean_temp_mem(bcx, lleltptr, vt.unit_ty);
temp_cleanups.push(lleltptr);
}
- foreach cleanup in temp_cleanups.iter() {
+ for cleanup in temp_cleanups.iter() {
revoke_clean(bcx, *cleanup);
}
}
// We also mark all of the params as used if it is an extern thing
// that we haven't been able to inline yet.
if is_default || fn_id_loc.crate != LOCAL_CRATE {
- foreach n in range(0u, n_tps) { cx.uses[n] |= use_all; }
+ for n in range(0u, n_tps) { cx.uses[n] |= use_all; }
return store_type_uses(cx, fn_id);
}
// This will be a static trait method. For now, we just assume
// it fully depends on all of the type information. (Doing
// otherwise would require finding the actual implementation).
- foreach n in range(0u, n_tps) { cx.uses[n] |= use_all;}
+ for n in range(0u, n_tps) { cx.uses[n] |= use_all;}
// We need to return early, before the arguments are processed,
// because of difficulties in the handling of Self.
return store_type_uses(cx, fn_id);
}
ast_map::node_variant(_, _, _) => {
- foreach n in range(0u, n_tps) { cx.uses[n] |= use_repr;}
+ for n in range(0u, n_tps) { cx.uses[n] |= use_repr;}
}
ast_map::node_foreign_item(i@@foreign_item {
node: foreign_item_fn(*),
_ => fail!("unknown intrinsic in type_use")
}
};
- foreach n in range(0u, n_tps) { cx.uses[n] |= flags;}
+ for n in range(0u, n_tps) { cx.uses[n] |= flags;}
}
}
ast_map::node_struct_ctor(*) => {
// Similarly to node_variant, this monomorphized function just
// uses the representations of all of its type parameters.
- foreach n in range(0u, n_tps) { cx.uses[n] |= use_repr; }
+ for n in range(0u, n_tps) { cx.uses[n] |= use_repr; }
}
_ => {
ccx.tcx.sess.bug(fmt!("unknown node type in type_use: %s",
match ty::get(ty::lookup_item_type(cx.ccx.tcx, fn_id).ty).sty {
ty::ty_bare_fn(ty::BareFnTy {sig: ref sig, _}) |
ty::ty_closure(ty::ClosureTy {sig: ref sig, _}) => {
- foreach arg in sig.inputs.iter() {
+ for arg in sig.inputs.iter() {
type_needs(&cx, use_repr, *arg);
}
}
let uses = &*cx.uses;
uses.len()
};
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
if cx.uses[i] & use_ != use_ {
type_needs_inner(cx, use_, ty, @Nil);
return;
if list::find(enums_seen, |id| *id == did).is_none() {
let seen = @Cons(did, enums_seen);
let r = ty::enum_variants(cx.ccx.tcx, did);
- foreach v in r.iter() {
- foreach aty in v.args.iter() {
+ for v in r.iter() {
+ for aty in v.args.iter() {
let t = ty::subst(cx.ccx.tcx, &(*substs), *aty);
type_needs_inner(cx, use_, t, seen);
}
let mut opt_static_did = None;
{
let r = cx.ccx.maps.method_map.find(&e_id);
- foreach mth in r.iter() {
+ for mth in r.iter() {
match mth.origin {
typeck::method_static(did) => {
opt_static_did = Some(did);
// above because the recursive call to `type_needs` can trigger
// inlining and hence can cause `method_map` and
// `node_type_substs` to be modified.
- foreach &did in opt_static_did.iter() {
+ for &did in opt_static_did.iter() {
{
let r = cx.ccx.tcx.node_type_substs.find_copy(&callee_id);
- foreach ts in r.iter() {
+ for ts in r.iter() {
let type_uses = type_uses_for(cx.ccx, did, ts.len());
- foreach (uses, subst) in type_uses.iter().zip(ts.iter()) {
+ for (uses, subst) in type_uses.iter().zip(ts.iter()) {
type_needs(cx, *uses, *subst)
}
}
}
expr_path(_) | expr_self => {
let opt_ts = cx.ccx.tcx.node_type_substs.find_copy(&e.id);
- foreach ts in opt_ts.iter() {
+ for ts in opt_ts.iter() {
let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get_copy(&e.id));
let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
- foreach (uses, subst) in uses_for_ts.iter().zip(ts.iter()) {
+ for (uses, subst) in uses_for_ts.iter().zip(ts.iter()) {
type_needs(cx, *uses, *subst)
}
}
match ty::ty_closure_sigil(ty::expr_ty(cx.ccx.tcx, e)) {
ast::OwnedSigil => {}
ast::BorrowedSigil | ast::ManagedSigil => {
- foreach fv in freevars::get_freevars(cx.ccx.tcx, e.id).iter() {
+ for fv in freevars::get_freevars(cx.ccx.tcx, e.id).iter() {
let node_id = ast_util::def_id_of_def(fv.def).node;
node_type_needs(cx, use_repr, node_id);
}
}
expr_call(f, _, _) => {
let r = ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, f.id));
- foreach a in r.iter() {
+ for a in r.iter() {
type_needs(cx, use_repr, *a);
}
}
type_needs(cx, use_repr, ty::type_autoderef(cx.ccx.tcx, base_ty));
let r = ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, callee_id));
- foreach a in r.iter() {
+ for a in r.iter() {
type_needs(cx, use_repr, *a);
}
mark_for_method_call(cx, e.id, callee_id);
}
expr_inline_asm(ref ia) => {
- foreach &(_, input) in ia.inputs.iter() {
+ for &(_, input) in ia.inputs.iter() {
node_type_needs(cx, use_repr, input.id);
}
- foreach &(_, out) in ia.outputs.iter() {
+ for &(_, out) in ia.outputs.iter() {
node_type_needs(cx, use_repr, out.id);
}
}
expr_match(*) | expr_block(_) | expr_if(*) | expr_while(*) |
expr_break(_) | expr_again(_) | expr_unary(*) | expr_lit(_) |
expr_mac(_) | expr_addr_of(*) | expr_ret(_) | expr_loop(*) |
- expr_loop_body(_) | expr_do_body(_) => (),
+ expr_do_body(_) => (),
expr_for_loop(*) => fail!("non-desugared expr_for_loop")
}
},
visit_block: |b, (cx, v)| {
oldvisit::visit_block(b, (cx, v));
- foreach e in b.expr.iter() {
+ for e in b.expr.iter() {
node_type_needs(cx, use_repr, e.id);
}
},
}
fn sflags(substs: &substs) -> uint {
let mut f = 0u;
- foreach tt in substs.tps.iter() { f |= get(*tt).flags; }
+ for tt in substs.tps.iter() { f |= get(*tt).flags; }
match substs.regions {
ErasedRegions => {}
NonerasedRegions(ref regions) => {
- foreach r in regions.iter() {
+ for r in regions.iter() {
f |= rflags(*r)
}
}
flags |= rflags(r);
flags |= get(m.ty).flags;
}
- &ty_tup(ref ts) => foreach tt in ts.iter() { flags |= get(*tt).flags; },
+ &ty_tup(ref ts) => for tt in ts.iter() { flags |= get(*tt).flags; },
&ty_bare_fn(ref f) => {
- foreach a in f.sig.inputs.iter() { flags |= get(*a).flags; }
+ for a in f.sig.inputs.iter() { flags |= get(*a).flags; }
flags |= get(f.sig.output).flags;
// T -> _|_ is *not* _|_ !
flags &= !(has_ty_bot as uint);
}
&ty_closure(ref f) => {
flags |= rflags(f.region);
- foreach a in f.sig.inputs.iter() { flags |= get(*a).flags; }
+ for a in f.sig.inputs.iter() { flags |= get(*a).flags; }
flags |= get(f.sig.output).flags;
// T -> _|_ is *not* _|_ !
flags &= !(has_ty_bot as uint);
}
ty_enum(_, ref substs) | ty_struct(_, ref substs) |
ty_trait(_, ref substs, _, _, _) => {
- foreach subty in (*substs).tps.iter() { maybe_walk_ty(*subty, |x| f(x)); }
+ for subty in (*substs).tps.iter() { maybe_walk_ty(*subty, |x| f(x)); }
}
- ty_tup(ref ts) => { foreach tt in ts.iter() { maybe_walk_ty(*tt, |x| f(x)); } }
+ ty_tup(ref ts) => { for tt in ts.iter() { maybe_walk_ty(*tt, |x| f(x)); } }
ty_bare_fn(ref ft) => {
- foreach a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
+ for a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
maybe_walk_ty(ft.sig.output, f);
}
ty_closure(ref ft) => {
- foreach a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
+ for a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
maybe_walk_ty(ft.sig.output, f);
}
}
true
}
ty_enum(did, ref substs) => {
- foreach v in (*enum_variants(cx, did)).iter() {
- foreach aty in v.args.iter() {
+ for v in (*enum_variants(cx, did)).iter() {
+ for aty in v.args.iter() {
let t = subst(cx, substs, *aty);
needs_unwind_cleanup |=
type_needs_unwind_cleanup_(cx, t, tycache,
if test(sty) { return true; }
match *sty {
ty_enum(did, ref substs) => {
- foreach variant in (*enum_variants(cx, did)).iter() {
- foreach aty in variant.args.iter() {
+ for variant in (*enum_variants(cx, did)).iter() {
+ for aty in variant.args.iter() {
let sty = subst(cx, substs, *aty);
if type_structurally_contains(cx, sty, |x| test(x)) { return true; }
}
}
ty_struct(did, ref substs) => {
let r = lookup_struct_fields(cx, did);
- foreach field in r.iter() {
+ for field in r.iter() {
let ft = lookup_field_type(cx, did, field.id, substs);
if type_structurally_contains(cx, ft, |x| test(x)) { return true; }
}
}
ty_tup(ref ts) => {
- foreach tt in ts.iter() {
+ for tt in ts.iter() {
if type_structurally_contains(cx, *tt, |x| test(x)) { return true; }
}
return false;
// Structural types
ty_enum(did, ref substs) => {
let variants = enum_variants(cx, did);
- foreach variant in (*variants).iter() {
+ for variant in (*variants).iter() {
// XXX(pcwalton): This is an inefficient way to do this. Don't
// synthesize a tuple!
//
}
}
ty_tup(ref elts) => {
- foreach elt in elts.iter() { if !type_is_pod(cx, *elt) { result = false; } }
+ for elt in elts.iter() { if !type_is_pod(cx, *elt) { result = false; } }
}
ty_estr(vstore_fixed(_)) => result = true,
ty_evec(ref mt, vstore_fixed(_)) | ty_unboxed_vec(ref mt) => {
let mut adjusted_ty = unadjusted_ty;
if (!ty::type_is_error(adjusted_ty)) {
- foreach i in range(0, adj.autoderefs) {
+ for i in range(0, adj.autoderefs) {
match ty::deref(cx, adjusted_ty, true) {
Some(mt) => { adjusted_ty = mt.ty; }
None => {
ast::expr_if(*) |
ast::expr_match(*) |
ast::expr_fn_block(*) |
- ast::expr_loop_body(*) |
ast::expr_do_body(*) |
ast::expr_block(*) |
ast::expr_repeat(*) |
pub fn field_idx(id: ast::ident, fields: &[field]) -> Option<uint> {
let mut i = 0u;
- foreach f in fields.iter() { if f.ident == id { return Some(i); } i += 1u; }
+ for f in fields.iter() { if f.ident == id { return Some(i); } i += 1u; }
return None;
}
pub fn field_idx_strict(tcx: ty::ctxt, id: ast::ident, fields: &[field])
-> uint {
let mut i = 0u;
- foreach f in fields.iter() { if f.ident == id { return i; } i += 1u; }
+ for f in fields.iter() { if f.ident == id { return i; } i += 1u; }
tcx.sess.bug(fmt!(
"No field named `%s` found in the list of fields `%?`",
tcx.sess.str_of(id),
pub fn each_bound_trait_and_supertraits(tcx: ctxt,
bounds: &[@TraitRef],
f: &fn(@TraitRef) -> bool) -> bool {
- foreach &bound_trait_ref in bounds.iter() {
+ for &bound_trait_ref in bounds.iter() {
let mut supertrait_set = HashMap::new();
let mut trait_refs = ~[];
let mut i = 0;
// Add supertraits to supertrait_set
let supertrait_refs = trait_ref_supertraits(tcx, trait_refs[i]);
- foreach &supertrait_ref in supertrait_refs.iter() {
+ for &supertrait_ref in supertrait_refs.iter() {
debug!("each_bound_trait_and_supertraits(supertrait_ref=%s)",
supertrait_ref.repr(tcx));
pub fn count_traits_and_supertraits(tcx: ctxt,
type_param_defs: &[TypeParameterDef]) -> uint {
let mut total = 0;
- foreach type_param_def in type_param_defs.iter() {
+ for type_param_def in type_param_defs.iter() {
do each_bound_trait_and_supertraits(
tcx, type_param_def.bounds.trait_bounds) |_| {
total += 1;
match (ast_bounds, store) {
(&Some(ref bound_vec), _) => {
let mut builtin_bounds = ty::EmptyBuiltinBounds();
- foreach ast_bound in bound_vec.iter() {
+ for ast_bound in bound_vec.iter() {
match *ast_bound {
ast::TraitTyParamBound(ref b) => {
match lookup_def_tcx(tcx, b.path.span, b.ref_id) {
// Typecheck the patterns first, so that we get types for all the
// bindings.
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
let pcx = pat_ctxt {
fcx: fcx,
map: pat_id_map(tcx.def_map, arm.pats[0]),
};
- foreach p in arm.pats.iter() { check_pat(&pcx, *p, discrim_ty);}
+ for p in arm.pats.iter() { check_pat(&pcx, *p, discrim_ty);}
}
// The result of the match is the common supertype of all the
// Now typecheck the blocks.
let mut saw_err = ty::type_is_error(discrim_ty);
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
let mut guard_err = false;
let mut guard_bot = false;
match arm.guard {
}
if !error_happened {
- foreach pats in subpats.iter() {
- foreach (subpat, arg_ty) in pats.iter().zip(arg_types.iter()) {
+ for pats in subpats.iter() {
+ for (subpat, arg_ty) in pats.iter().zip(arg_types.iter()) {
check_pat(pcx, *subpat, *arg_ty);
}
}
}
if error_happened {
- foreach pats in subpats.iter() {
- foreach pat in pats.iter() {
+ for pats in subpats.iter() {
+ for pat in pats.iter() {
check_pat(pcx, *pat, ty::mk_err());
}
}
// Index the class fields.
let mut field_map = HashMap::new();
- foreach (i, class_field) in class_fields.iter().enumerate() {
+ for (i, class_field) in class_fields.iter().enumerate() {
field_map.insert(class_field.ident, i);
}
// Typecheck each field.
let mut found_fields = HashSet::new();
- foreach field in fields.iter() {
+ for field in fields.iter() {
match field_map.find(&field.ident) {
Some(&index) => {
let class_field = class_fields[index];
// Report an error if not all the fields were specified.
if !etc {
- foreach (i, field) in class_fields.iter().enumerate() {
+ for (i, field) in class_fields.iter().enumerate() {
if found_fields.contains(&i) {
loop;
}
let e_count = elts.len();
match *s {
ty::ty_tup(ref ex_elts) if e_count == ex_elts.len() => {
- foreach (i, elt) in elts.iter().enumerate() {
+ for (i, elt) in elts.iter().enumerate() {
check_pat(pcx, *elt, ex_elts[i]);
}
fcx.write_ty(pat.id, expected);
}
_ => {
- foreach elt in elts.iter() {
+ for elt in elts.iter() {
check_pat(pcx, *elt, ty::mk_err());
}
// use terr_tuple_size if both types are tuples
(mt, default_region_var)
},
_ => {
- foreach &elt in before.iter() {
+ for &elt in before.iter() {
check_pat(pcx, elt, ty::mk_err());
}
- foreach &elt in slice.iter() {
+ for &elt in slice.iter() {
check_pat(pcx, elt, ty::mk_err());
}
- foreach &elt in after.iter() {
+ for &elt in after.iter() {
check_pat(pcx, elt, ty::mk_err());
}
fcx.infcx().type_error_message_str_with_expected(
return;
}
};
- foreach elt in before.iter() {
+ for elt in before.iter() {
check_pat(pcx, *elt, elt_type.ty);
}
match slice {
}
None => ()
}
- foreach elt in after.iter() {
+ for elt in after.iter() {
check_pat(pcx, *elt, elt_type.ty);
}
fcx.write_ty(pat.id, expected);
// candidates.
let trait_map: &mut resolve::TraitMap = &mut self.fcx.ccx.trait_map;
let opt_applicable_traits = trait_map.find(&self.expr.id);
- foreach applicable_traits in opt_applicable_traits.iter() {
- foreach trait_did in applicable_traits.iter() {
+ for applicable_traits in opt_applicable_traits.iter() {
+ for trait_did in applicable_traits.iter() {
// Look for explicit implementations.
let opt_impl_infos = self.tcx().trait_impls.find(trait_did);
- foreach impl_infos in opt_impl_infos.iter() {
- foreach impl_info in impl_infos.iter() {
+ for impl_infos in opt_impl_infos.iter() {
+ for impl_info in impl_infos.iter() {
self.push_candidates_from_impl(
self.extension_candidates, *impl_info);
pub fn push_inherent_impl_candidates_for_type(&self, did: def_id) {
let opt_impl_infos = self.tcx().inherent_impls.find(&did);
- foreach impl_infos in opt_impl_infos.iter() {
- foreach impl_info in impl_infos.iter() {
+ for impl_infos in opt_impl_infos.iter() {
+ for impl_info in impl_infos.iter() {
self.push_candidates_from_impl(
self.inherent_candidates, *impl_info);
}
let region =
self.infcx().next_region_var(
infer::Autoref(self.expr.span));
- foreach mutbl in mutbls.iter() {
+ for mutbl in mutbls.iter() {
let autoref_ty = mk_autoref_ty(*mutbl, region);
match self.search_for_method(autoref_ty) {
None => {}
self.tcx().sess.span_err(
self.expr.span,
"multiple applicable methods in scope");
- foreach idx in range(0u, relevant_candidates.len()) {
+ for idx in range(0u, relevant_candidates.len()) {
self.report_candidate(idx, &relevant_candidates[idx].origin);
}
}
#[deriving(Clone)]
pub enum FnKind {
- // This is a for-closure. The ty::t is the return type of the
- // enclosing function.
- ForLoop(ty::t),
-
// A do-closure.
DoBlock,
err_count_on_creation: uint,
ret_ty: ty::t,
- // Used by loop bodies that return from the outer function
- indirect_ret_ty: Option<ty::t>,
ps: PurityState,
// Sometimes we generate region pointers where the precise region
@mut FnCtxt {
err_count_on_creation: ccx.tcx.sess.err_count(),
ret_ty: rty,
- indirect_ret_ty: None,
ps: PurityState::function(ast::impure_fn, 0),
region_lb: region_bnd,
in_scope_regions: @Nil,
// Create the function context. This is either derived from scratch or,
// in the case of function expressions, based on the outer context.
let fcx: @mut FnCtxt = {
- // In a for-loop, you have an 'indirect return' because return
- // does not return out of the directly enclosing fn
- let indirect_ret_ty = match fn_kind {
- ForLoop(t) => Some(t),
- DoBlock | Vanilla => None
- };
-
@mut FnCtxt {
err_count_on_creation: err_count_on_creation,
ret_ty: ret_ty,
- indirect_ret_ty: indirect_ret_ty,
ps: PurityState::function(purity, id),
region_lb: body.id,
in_scope_regions: isr,
None => ()
}
- foreach self_info in opt_self_info.iter() {
+ for self_info in opt_self_info.iter() {
fcx.write_ty(self_info.self_id, self_info.self_ty);
}
- foreach (input, arg) in decl.inputs.iter().zip(arg_tys.iter()) {
+ for (input, arg) in decl.inputs.iter().zip(arg_tys.iter()) {
fcx.write_ty(input.id, *arg);
}
};
// Add the self parameter
- foreach self_info in opt_self_info.iter() {
+ for self_info in opt_self_info.iter() {
assign(self_info.self_id, Some(self_info.self_ty));
debug!("self is assigned to %s",
fcx.infcx().ty_to_str(
}
// Add formal parameters.
- foreach (arg_ty, input) in arg_tys.iter().zip(decl.inputs.iter()) {
+ for (arg_ty, input) in arg_tys.iter().zip(decl.inputs.iter()) {
// Create type variables for each argument.
do pat_util::pat_bindings(tcx.def_map, input.pat)
|_bm, pat_id, _sp, _path| {
fields: ~[(ast::ident, span)]) {
let mut field_names = HashMap::new();
- foreach p in fields.iter() {
+ for p in fields.iter() {
let (id, sp) = *p;
let orig_sp = field_names.find(&id).map_consume(|x| *x);
match orig_sp {
let rp = ccx.tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
debug!("item_impl %s with id %d rp %?",
ccx.tcx.sess.str_of(it.ident), it.id, rp);
- foreach m in ms.iter() {
+ for m in ms.iter() {
check_method(ccx, *m);
}
vtable::resolve_impl(ccx, it);
}
ast::item_trait(_, _, ref trait_methods) => {
- foreach trait_method in (*trait_methods).iter() {
+ for trait_method in (*trait_methods).iter() {
match *trait_method {
required(*) => {
// Nothing to do, since required methods don't have
}
ast::item_foreign_mod(ref m) => {
if m.abis.is_intrinsic() {
- foreach item in m.items.iter() {
+ for item in m.items.iter() {
check_intrinsic_type(ccx, *item);
}
} else {
- foreach item in m.items.iter() {
+ for item in m.items.iter() {
let tpt = ty::lookup_item_type(ccx.tcx, local_def(item.id));
if tpt.generics.has_type_params() {
ccx.tcx.sess.span_err(
return;
}
match self.fn_kind {
- ForLoop(_) if !ty::type_is_bool(e) && !ty::type_is_nil(a) =>
- self.tcx().sess.span_err(sp, fmt!("A for-loop body must \
- return (), but it returns %s here. \
- Perhaps you meant to write a `do`-block?",
- ppaux::ty_to_str(self.tcx(), a))),
DoBlock if ty::type_is_bool(e) && ty::type_is_nil(a) =>
// If we expected bool and got ()...
self.tcx().sess.span_err(sp, fmt!("Do-block body must \
// of arguments when we typecheck the functions. This isn't really the
// right way to do this.
let xs = [false, true];
- foreach check_blocks in xs.iter() {
+ for check_blocks in xs.iter() {
let check_blocks = *check_blocks;
debug!("check_blocks=%b", check_blocks);
vtable::early_resolve_expr(callee_expr, fcx, true);
}
- foreach (i, arg) in args.iter().enumerate() {
+ for (i, arg) in args.iter().enumerate() {
let is_block = match arg.node {
- ast::expr_fn_block(*) | ast::expr_loop_body(*) |
+ ast::expr_fn_block(*) |
ast::expr_do_body(*) => true,
_ => false
};
let mut class_field_map = HashMap::new();
let mut fields_found = 0;
- foreach field in field_types.iter() {
+ for field in field_types.iter() {
class_field_map.insert(field.ident, (field.id, false));
}
let mut error_happened = false;
// Typecheck each field.
- foreach field in ast_fields.iter() {
+ for field in ast_fields.iter() {
let mut expected_field_type = ty::mk_err();
let pair = class_field_map.find(&field.ident).
assert!(fields_found <= field_types.len());
if fields_found < field_types.len() {
let mut missing_fields = ~[];
- foreach class_field in field_types.iter() {
+ for class_field in field_types.iter() {
let name = class_field.ident;
let (_, seen) = *class_field_map.get(&name);
if !seen {
fcx.write_ty(id, enum_type);
}
- fn check_loop_body(fcx: @mut FnCtxt,
- expr: @ast::expr,
- expected: Option<ty::t>,
- loop_body: @ast::expr) {
- // a loop body is the special argument to a `for` loop. We know that
- // there will be an expected type in this context because it can only
- // appear in the context of a call, so we get the expected type of the
- // parameter. The catch here is that we need to validate two things:
- // 1. a closure that returns a bool is expected
- // 2. the closure that was given returns unit
- let tcx = fcx.tcx();
- let mut err_happened = false;
- let expected_sty = unpack_expected(fcx,
- expected,
- |x| Some((*x).clone()));
- let inner_ty = match expected_sty {
- Some(ty::ty_closure(ref fty)) => {
- match fcx.mk_subty(false, infer::Misc(expr.span),
- fty.sig.output, ty::mk_bool()) {
- result::Ok(_) => {
- ty::mk_closure(tcx, ty::ClosureTy {
- sig: FnSig {
- output: ty::mk_nil(),
- ..fty.sig.clone()
- },
- ..(*fty).clone()
- })
- }
- result::Err(_) => {
- fcx.type_error_message(
- expr.span,
- |actual| {
- let did_you_mean = {
- if ty::type_is_nil(fty.sig.output) {
- "\nDid you mean to use \
- `do` instead of `for`?"
- } else {
- ""
- }
- };
- fmt!("A `for` loop iterator should expect a \
- closure that returns `bool`. This \
- iterator expects a closure that \
- returns `%s`.%s",
- actual, did_you_mean)
- },
- fty.sig.output,
- None);
- err_happened = true;
- fcx.write_error(expr.id);
- ty::mk_err()
- }
- }
- }
- _ => {
- match expected {
- Some(expected_t) => {
- fcx.type_error_message(
- expr.span,
- |actual| {
- fmt!("last argument in `for` call \
- has non-closure type: %s",
- actual)
- },
- expected_t, None);
- let err_ty = ty::mk_err();
- fcx.write_error(expr.id);
- err_happened = true;
- err_ty
- }
- None => fcx.tcx().sess.impossible_case(
- expr.span,
- "loop body must have an expected type")
- }
- }
- };
-
- match loop_body.node {
- ast::expr_fn_block(ref decl, ref body) => {
- // If an error occurred, we pretend this isn't a for
- // loop, so as to assign types to all nodes while also
- // propagating ty_err throughout so as to suppress
- // derived errors. If we passed in ForLoop in the
- // error case, we'd potentially emit a spurious error
- // message because of the indirect_ret_ty.
- let fn_kind = if err_happened {
- Vanilla
- } else {
- let indirect_ret_ty =
- fcx.indirect_ret_ty.get_or_default(fcx.ret_ty);
- ForLoop(indirect_ret_ty)
- };
- check_expr_fn(fcx, loop_body, None,
- decl, body, fn_kind, Some(inner_ty));
- demand::suptype(fcx, loop_body.span,
- inner_ty, fcx.expr_ty(loop_body));
- }
- ref n => {
- fail!("check_loop_body expected expr_fn_block, not %?", n)
- }
- }
-
- let block_ty = structurally_resolved_type(
- fcx, expr.span, fcx.node_ty(loop_body.id));
- if err_happened {
- fcx.write_error(expr.id);
- fcx.write_error(loop_body.id);
- } else {
- let loop_body_ty =
- ty::replace_closure_return_type(
- tcx, block_ty, ty::mk_bool());
- fcx.write_ty(expr.id, loop_body_ty);
- }
- }
-
let tcx = fcx.ccx.tcx;
let id = expr.id;
match expr.node {
_ => mutability = mutbl
}
let t: ty::t = fcx.infcx().next_ty_var();
- foreach e in args.iter() {
+ for e in args.iter() {
check_expr_has_type(fcx, *e, t);
let arg_t = fcx.expr_ty(*e);
if ty::type_is_error(arg_t) {
fcx.write_ty(id, ty_param_bounds_and_ty.ty);
}
ast::expr_inline_asm(ref ia) => {
- foreach &(_, input) in ia.inputs.iter() {
+ for &(_, input) in ia.inputs.iter() {
check_expr(fcx, input);
}
- foreach &(_, out) in ia.outputs.iter() {
+ for &(_, out) in ia.outputs.iter() {
check_expr(fcx, out);
}
fcx.write_nil(id);
ast::expr_break(_) => { fcx.write_bot(id); }
ast::expr_again(_) => { fcx.write_bot(id); }
ast::expr_ret(expr_opt) => {
- let ret_ty = match fcx.indirect_ret_ty {
- Some(t) => t, None => fcx.ret_ty
- };
+ let ret_ty = fcx.ret_ty;
match expr_opt {
None => match fcx.mk_eqty(false, infer::Misc(expr.span),
ret_ty, ty::mk_nil()) {
check_expr_fn(fcx, expr, None,
decl, body, Vanilla, expected);
}
- ast::expr_loop_body(loop_body) => {
- check_loop_body(fcx, expr, expected, loop_body);
- }
ast::expr_do_body(b) => {
let expected_sty = unpack_expected(fcx,
expected,
}
ast::expr_vec(ref args, mutbl) => {
let t: ty::t = fcx.infcx().next_ty_var();
- foreach e in args.iter() {
+ for e in args.iter() {
check_expr_has_type(fcx, *e, t);
}
let typ = ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutbl},
let mut last_was_bot = false;
let mut any_bot = false;
let mut any_err = false;
- foreach s in blk.stmts.iter() {
+ for s in blk.stmts.iter() {
check_stmt(fcx, *s);
let s_id = ast_util::stmt_id(*s);
let s_ty = fcx.node_ty(s_id);
let mut disr_vals: ~[uint] = ~[];
let mut prev_disr_val: Option<uint> = None;
- foreach v in vs.iter() {
+ for v in vs.iter() {
// If the discriminant value is specified explicitly in the enum check whether the
// initialization expression is valid, otherwise use the last value plus one.
true
});
- foreach (i, b) in tps_used.iter().enumerate() {
+ for (i, b) in tps_used.iter().enumerate() {
if !*b {
ccx.tcx.sess.span_err(
span, fmt!("type parameter `%s` is unused",
fn visit_arm(arm: &ast::arm, (rcx, v): (@mut Rcx, rvt)) {
// see above
- foreach &p in arm.pats.iter() {
+ for &p in arm.pats.iter() {
constrain_bindings_in_pat(p, rcx);
}
}
ast::expr_match(_, ref arms) => {
tcx.region_maps.record_cleanup_scope(expr.id);
- foreach arm in arms.iter() {
- foreach guard in arm.guard.iter() {
+ for arm in arms.iter() {
+ for guard in arm.guard.iter() {
tcx.region_maps.record_cleanup_scope(guard.id);
}
}
// Check any autoderefs or autorefs that appear.
{
let r = rcx.fcx.inh.adjustments.find(&expr.id);
- foreach &adjustment in r.iter() {
+ for &adjustment in r.iter() {
debug!("adjustment=%?", adjustment);
match *adjustment {
@ty::AutoDerefRef(
{
let expr_ty = rcx.resolve_node_type(expr.id);
constrain_derefs(rcx, expr, autoderefs, expr_ty);
- foreach autoref in opt_autoref.iter() {
+ for autoref in opt_autoref.iter() {
guarantor::for_autoref(rcx, expr, autoderefs, autoref);
// Require that the resulting region encompasses
oldvisit::visit_expr(expr, (rcx, v));
}
- ast::expr_loop_body(subexpr) => {
- check_expr_fn_block(rcx, subexpr, v, true);
- }
-
ast::expr_fn_block(*) => {
check_expr_fn_block(rcx, expr, v, false);
}
let callee_scope = call_expr.id;
let callee_region = ty::re_scope(callee_scope);
- foreach &arg_expr in arg_exprs.iter() {
+ for &arg_expr in arg_exprs.iter() {
// ensure that any regions appearing in the argument type are
// valid for at least the lifetime of the function:
constrain_regions_in_type_of_node(
}
// as loop above, but for receiver
- foreach &r in receiver.iter() {
+ for &r in receiver.iter() {
constrain_regions_in_type_of_node(
rcx, r.id, callee_region, infer::CallRcvr(r.span));
if implicitly_ref_args {
*/
let tcx = rcx.fcx.tcx();
let r_deref_expr = ty::re_scope(deref_expr.id);
- foreach i in range(0u, derefs) {
+ for i in range(0u, derefs) {
debug!("constrain_derefs(deref_expr=?, derefd_ty=%s, derefs=%?/%?",
rcx.fcx.infcx().ty_to_str(derefd_ty),
i, derefs);
let tcx = rcx.fcx.ccx.tcx;
debug!("constrain_free_variables(%s, %s)",
region.repr(tcx), expr.repr(tcx));
- foreach freevar in get_freevars(tcx, expr.id).iter() {
+ for freevar in get_freevars(tcx, expr.id).iter() {
debug!("freevar def is %?", freevar.def);
let def = freevar.def;
let en_region = encl_region_of_def(rcx.fcx, def);
debug!("regionck::for_match()");
let discr_guarantor = guarantor(rcx, discr);
debug!("discr_guarantor=%s", discr_guarantor.repr(rcx.tcx()));
- foreach arm in arms.iter() {
- foreach pat in arm.pats.iter() {
+ for arm in arms.iter() {
+ for pat in arm.pats.iter() {
link_ref_bindings_in_pat(rcx, *pat, discr_guarantor);
}
}
sub_region: ty::Region,
sup_region: Option<ty::Region>)
{
- foreach r in sup_region.iter() {
+ for r in sup_region.iter() {
rcx.fcx.mk_subr(true, infer::Reborrow(expr.span),
sub_region, *r);
}
debug!("guarantor::for_by_ref(expr=%?, callee_scope=%?) category=%?",
expr.id, callee_scope, expr_cat);
let minimum_lifetime = ty::re_scope(callee_scope);
- foreach guarantor in expr_cat.guarantor.iter() {
+ for guarantor in expr_cat.guarantor.iter() {
mk_subregion_due_to_derefence(rcx, expr.span,
minimum_lifetime, *guarantor);
}
ast::expr_if(*) |
ast::expr_match(*) |
ast::expr_fn_block(*) |
- ast::expr_loop_body(*) |
ast::expr_do_body(*) |
ast::expr_block(*) |
ast::expr_repeat(*) |
return ct;
}
- foreach _ in range(0u, autoderefs) {
+ for _ in range(0u, autoderefs) {
ct.cat.guarantor = guarantor_of_deref(&ct.cat);
match ty::deref(tcx, ct.ty, true) {
ast::pat_ident(ast::bind_by_ref(_), _, opt_p) => {
link(rcx, pat.span, pat.id, guarantor);
- foreach p in opt_p.iter() {
+ for p in opt_p.iter() {
link_ref_bindings_in_pat(rcx, *p, guarantor);
}
}
ast::pat_ident(_, _, opt_p) => {
- foreach p in opt_p.iter() {
+ for p in opt_p.iter() {
link_ref_bindings_in_pat(rcx, *p, guarantor);
}
}
link_ref_bindings_in_pats(rcx, pats, guarantor);
}
ast::pat_struct(_, ref fpats, _) => {
- foreach fpat in fpats.iter() {
+ for fpat in fpats.iter() {
link_ref_bindings_in_pat(rcx, fpat.pat, guarantor);
}
}
};
link_ref_bindings_in_pats(rcx, before, guarantor1);
- foreach &p in slice.iter() {
+ for &p in slice.iter() {
link_ref_bindings_in_pat(rcx, p, guarantor);
}
link_ref_bindings_in_pats(rcx, after, guarantor1);
fn link_ref_bindings_in_pats(rcx: @mut Rcx,
pats: &~[@ast::pat],
guarantor: Option<ty::Region>) {
- foreach pat in pats.iter() {
+ for pat in pats.iter() {
link_ref_bindings_in_pat(rcx, *pat, guarantor);
}
}
{
let mut all_tys = ty::tys_in_fn_sig(fn_sig);
- foreach &self_ty in opt_self_ty.iter() {
+ for &self_ty in opt_self_ty.iter() {
all_tys.push(self_ty);
}
- foreach &t in opt_self_ty.iter() { all_tys.push(t) }
+ for &t in opt_self_ty.iter() { all_tys.push(t) }
debug!("replace_bound_regions_in_fn_sig(self_ty=%?, fn_sig=%s, \
all_tys=%?)",
*/
let mut the_stack = ~[];
- foreach &r in opt_region.iter() { the_stack.push(r); }
+ for &r in opt_region.iter() { the_stack.push(r); }
walk_ty(tcx, &mut the_stack, ty, relate_op);
fn walk_ty(tcx: ty::ctxt,
r_sub: ty::Region,
relate_op: &fn(ty::Region, ty::Region))
{
- foreach &r in the_stack.iter() {
+ for &r in the_stack.iter() {
if !r.is_bound() && !r_sub.is_bound() {
relate_op(r, r_sub);
}
debug!("relate_free_regions >>");
let mut all_tys = ~[];
- foreach arg in fn_sig.inputs.iter() {
+ for arg in fn_sig.inputs.iter() {
all_tys.push(*arg);
}
- foreach &t in self_ty.iter() {
+ for &t in self_ty.iter() {
all_tys.push(t);
}
- foreach &t in all_tys.iter() {
+ for &t in all_tys.iter() {
debug!("relate_free_regions(t=%s)", ppaux::ty_to_str(tcx, t));
relate_nested_regions(tcx, None, t, |a, b| {
match (&a, &b) {
let impls = tcx.trait_impls.find(&trait_ref.def_id)
.map_default(@mut ~[], |x| **x);
// impls is the list of all impls in scope for trait_ref.
- foreach im in impls.iter() {
+ for im in impls.iter() {
// im is one specific impl of trait_ref.
// First, ensure we haven't processed this impl yet.
Some(mme) => {
{
let r = resolve_type_vars_in_type(fcx, sp, mme.self_ty);
- foreach t in r.iter() {
+ for t in r.iter() {
let method_map = fcx.ccx.method_map;
let new_entry = method_map_entry { self_ty: *t, ..*mme };
debug!("writeback::resolve_method_map_entry(id=%?, \
let mut ret = Some(t);
do fcx.opt_node_ty_substs(id) |substs| {
let mut new_tps = ~[];
- foreach subst in substs.tps.iter() {
+ for subst in substs.tps.iter() {
match resolve_type_vars_in_type(fcx, sp, *subst) {
Some(t) => new_tps.push(t),
None => { wbcx.success = false; ret = None; break }
resolve_method_map_entry(wbcx.fcx, e.span, e.id);
{
let r = e.get_callee_id();
- foreach callee_id in r.iter() {
+ for callee_id in r.iter() {
resolve_method_map_entry(wbcx.fcx, e.span, *callee_id);
}
}
resolve_vtable_map_entry(wbcx.fcx, e.span, e.id);
{
let r = e.get_callee_id();
- foreach callee_id in r.iter() {
+ for callee_id in r.iter() {
resolve_vtable_map_entry(wbcx.fcx, e.span, *callee_id);
}
}
match e.node {
ast::expr_fn_block(ref decl, _) => {
- foreach input in decl.inputs.iter() {
+ for input in decl.inputs.iter() {
let _ = resolve_type_vars_for_node(wbcx, e.span, input.id);
}
}
let wbcx = @mut WbCtxt { fcx: fcx, success: true };
let visit = mk_visitor();
(visit.visit_block)(blk, (wbcx, visit));
- foreach self_info in self_info.iter() {
+ for self_info in self_info.iter() {
resolve_type_vars_for_node(wbcx,
self_info.span,
self_info.self_id);
}
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
(visit.visit_pat)(arg.pat, (wbcx, visit));
// Privacy needs the type for the whole pattern, not just each binding
if !pat_util::pat_is_binding(fcx.tcx().def_map, arg.pat) {
let implementation = self.create_impl_from_item(item);
- foreach associated_trait in associated_traits.iter() {
+ for associated_trait in associated_traits.iter() {
let trait_ref = ty::node_id_to_trait_ref(
self.crate_context.tcx, associated_trait.ref_id);
debug!("(checking implementation) adding impl for trait '%s', item '%s'",
let impl_poly_type = ty::lookup_item_type(tcx, impl_id);
let provided = ty::provided_trait_methods(tcx, trait_ref.def_id);
- foreach trait_method in provided.iter() {
+ for trait_method in provided.iter() {
// Synthesize an ID.
let new_id = parse::next_node_id(tcx.sess.parse_sess);
let new_did = local_def(new_id);
pub fn iter_impls_of_trait(&self, trait_def_id: def_id, f: &fn(@Impl)) {
match self.crate_context.tcx.trait_impls.find(&trait_def_id) {
Some(impls) => {
- foreach &im in impls.iter() {
+ for &im in impls.iter() {
f(im);
}
}
let mut provided_names = HashSet::new();
// Implemented methods
- foreach i in range(0u, all_methods.len()) {
+ for i in range(0u, all_methods.len()) {
provided_names.insert(all_methods[i].ident);
}
let r = ty::trait_methods(tcx, trait_did);
- foreach method in r.iter() {
+ for method in r.iter() {
debug!("checking for %s", method.ident.repr(tcx));
if provided_names.contains(&method.ident) { loop; }
match item.node {
item_impl(_, ref trait_refs, _, ref ast_methods) => {
let mut methods = ~[];
- foreach ast_method in ast_methods.iter() {
+ for ast_method in ast_methods.iter() {
methods.push(ty::method(tcx, local_def(ast_method.id)));
}
- foreach trait_ref in trait_refs.iter() {
+ for trait_ref in trait_refs.iter() {
let ty_trait_ref = ty::node_id_to_trait_ref(
self.crate_context.tcx,
trait_ref.ref_id);
}
// Record all the trait methods.
- foreach trait_ref in associated_traits.iter() {
+ for trait_ref in associated_traits.iter() {
self.add_trait_impl(trait_ref.def_id, implementation);
}
// For any methods that use a default implementation, add them to
// the map. This is a bit unfortunate.
- foreach method in implementation.methods.iter() {
- foreach source in method.provided_source.iter() {
+ for method in implementation.methods.iter() {
+ for source in method.provided_source.iter() {
tcx.provided_method_sources.insert(method.def_id, *source);
}
}
Some(found_impls) => impls = found_impls
}
- foreach impl_info in impls.iter() {
+ for impl_info in impls.iter() {
if impl_info.methods.len() < 1 {
// We'll error out later. For now, just don't ICE.
loop;
let tcx = ccx.tcx;
// Create a set of parameter types shared among all the variants.
- foreach variant in variants.iter() {
+ for variant in variants.iter() {
let region_parameterization =
RegionParameterization::from_variance_and_generics(rp, generics);
// For each method, construct a suitable ty::Method and
// store it into the `tcx.methods` table:
- foreach m in ms.iter() {
+ for m in ms.iter() {
let ty_method = @match m {
&ast::required(ref m) => {
ty_method_of_trait_method(
let self_ty = ty::mk_self(ccx.tcx, local_def(id));
let mut ty_trait_refs: ~[@ty::TraitRef] = ~[];
- foreach ast_trait_ref in ast_trait_refs.iter() {
+ for ast_trait_ref in ast_trait_refs.iter() {
let trait_ref = instantiate_trait_ref(ccx, ast_trait_ref, rp,
generics, self_ty);
return;
}
- foreach (i, trait_param_def) in trait_m.generics.type_param_defs.iter().enumerate() {
+ for (i, trait_param_def) in trait_m.generics.type_param_defs.iter().enumerate() {
// For each of the corresponding impl ty param's bounds...
let impl_param_def = &impl_m.generics.type_param_defs[i];
// For both the trait and the impl, create an argument to
// represent the self argument (unless this is a static method).
// This argument will have the *transformed* self type.
- foreach &t in trait_m.transformed_self_ty.iter() {
+ for &t in trait_m.transformed_self_ty.iter() {
trait_fn_args.push(t);
}
- foreach &t in impl_m.transformed_self_ty.iter() {
+ for &t in impl_m.transformed_self_ty.iter() {
impl_fn_args.push(t);
}
// Trait methods we don't implement must be default methods, but if not
// we'll catch it in coherence
let trait_ms = ty::trait_methods(tcx, trait_ref.def_id);
- foreach impl_m in impl_ms.iter() {
+ for impl_m in impl_ms.iter() {
match trait_ms.iter().find_(|trait_m| trait_m.ident == impl_m.mty.ident) {
Some(trait_m) => {
let num_impl_tps = generics.ty_params.len();
span: span,
generics: &ast::Generics,
thing: &'static str) {
- foreach ty_param in generics.ty_params.iter() {
+ for ty_param in generics.ty_params.iter() {
if ty_param.bounds.len() > 0 {
ccx.tcx.sess.span_err(
span,
let cms = convert_methods(ccx, it.id, *ms, selfty,
&i_ty_generics, generics,
parent_visibility);
- foreach t in opt_trait_ref.iter() {
+ for t in opt_trait_ref.iter() {
check_methods_against_trait(ccx, generics, rp, selfty, t, cms);
}
}
let tcx = ccx.tcx;
// Write the type of each of the members
- foreach f in struct_def.fields.iter() {
+ for f in struct_def.fields.iter() {
convert_field(ccx, rp, tpt.generics.type_param_defs, *f, generics);
}
let (_, substs) = mk_item_substs(ccx, generics, rp, None);
builtin_bounds: ty::EmptyBuiltinBounds(),
trait_bounds: ~[]
};
- foreach ast_bound in ast_bounds.iter() {
+ for ast_bound in ast_bounds.iter() {
match *ast_bound {
TraitTyParamBound(ref b) => {
let ty = ty::mk_param(ccx.tcx, param_ty.idx, param_ty.def_id);
impl ErrorReporting for InferCtxt {
pub fn report_region_errors(@mut self,
errors: &OptVec<RegionResolutionError>) {
- foreach error in errors.iter() {
+ for error in errors.iter() {
match *error {
ConcreteFailure(origin, sub, sup) => {
self.report_concrete_failure(origin, sub, sup);
let mut a_r = None;
let mut b_r = None;
let mut only_new_vars = true;
- foreach r in tainted.iter() {
+ for r in tainted.iter() {
if is_var_in_set(a_vars, *r) {
if a_r.is_some() {
return fresh_bound_variable(this);
fmt!("%s%s", mk_msg(Some(self.ty_to_str(e)), actual_ty), error_str));
}
}
- foreach err in err.iter() {
+ for err in err.iter() {
ty::note_and_explain_type_err(self.tcx, *err)
}
}
pub fn vars_created_since_snapshot(&mut self, snapshot: uint)
-> ~[RegionVid] {
do vec::build |push| {
- foreach i in range(snapshot, self.undo_log.len()) {
+ for i in range(snapshot, self.undo_log.len()) {
match self.undo_log[i] {
AddVar(vid) => push(vid),
_ => ()
&self,
errors: &mut OptVec<RegionResolutionError>)
{
- foreach (constraint, _) in self.constraints.iter() {
+ for (constraint, _) in self.constraints.iter() {
let (sub, sup) = match *constraint {
ConstrainVarSubVar(*) |
ConstrainRegSubVar(*) |
let mut opt_graph = None;
- foreach idx in range(0u, self.num_vars()) {
+ for idx in range(0u, self.num_vars()) {
match var_data[idx].value {
Value(_) => {
/* Inference successful */
let mut graph = graph::Graph::with_capacity(num_vars + 1,
num_edges);
- foreach _ in range(0u, num_vars) {
+ for _ in range(0u, num_vars) {
graph.add_node(());
}
let dummy_idx = graph.add_node(());
- foreach (constraint, _) in self.constraints.iter() {
+ for (constraint, _) in self.constraints.iter() {
match *constraint {
ConstrainVarSubVar(a_id, b_id) => {
graph.add_edge(NodeIndex(a_id.to_uint()),
return;
}
- foreach lower_bound in lower_bounds.iter() {
- foreach upper_bound in upper_bounds.iter() {
+ for lower_bound in lower_bounds.iter() {
+ for upper_bound in upper_bounds.iter() {
if !self.is_subregion_of(lower_bound.region,
upper_bound.region) {
errors.push(SubSupConflict(
return;
}
- foreach upper_bound_1 in upper_bounds.iter() {
- foreach upper_bound_2 in upper_bounds.iter() {
+ for upper_bound_1 in upper_bounds.iter() {
+ for upper_bound_2 in upper_bounds.iter() {
match self.glb_concrete_regions(upper_bound_1.region,
upper_bound_2.region) {
Ok(_) => {}
changed = false;
iteration += 1;
debug!("---- %s Iteration #%u", tag, iteration);
- foreach (constraint, _) in self.constraints.iter() {
+ for (constraint, _) in self.constraints.iter() {
let edge_changed = body(constraint);
if edge_changed {
debug!("Updated due to constraint %s",
do list::each(skol_isr) |pair| {
let (skol_br, skol) = *pair;
let tainted = self.infcx.region_vars.tainted(snapshot, skol);
- foreach tainted_region in tainted.iter() {
+ for tainted_region in tainted.iter() {
// Each skolemized should only be relatable to itself
// or new variables:
match *tainted_region {
impl Env {
pub fn create_region_hierarchy(&self, rh: &RH) {
- foreach child_rh in rh.sub.iter() {
+ for child_rh in rh.sub.iter() {
self.create_region_hierarchy(child_rh);
self.tcx.region_map.insert(child_rh.id, rh.id);
}
idx: uint,
names: &[~str]) -> Option<ast::node_id> {
assert!(idx < names.len());
- foreach item in m.items.iter() {
+ for item in m.items.iter() {
if self.tcx.sess.str_of(item.ident) == names[idx] {
return search(self, *item, idx+1, names);
}
self.infcx.resolve_regions();
if self.err_messages.len() != exp_count {
- foreach msg in self.err_messages.iter() {
+ for msg in self.err_messages.iter() {
debug!("Error encountered: %s", *msg);
}
fmt!("Resolving regions encountered %u errors but expected %u!",
}
fn has_ident(&self, ident: ast::ident) -> bool {
- foreach region_param_name in self.iter() {
+ for region_param_name in self.iter() {
if *region_param_name == ident {
return true;
}
opt_vec::Vec(new_lifetimes.map(|lt| lt.ident)));
}
opt_vec::Vec(ref mut existing_lifetimes) => {
- foreach new_lifetime in new_lifetimes.iter() {
+ for new_lifetime in new_lifetimes.iter() {
existing_lifetimes.push(new_lifetime.ident);
}
}
lint_dict.qsort();
let mut max_key = 0;
- foreach &(_, name) in lint_dict.iter() {
+ for &(_, name) in lint_dict.iter() {
max_key = num::max(name.len(), max_key);
}
fn padded(max: uint, s: &str) -> ~str {
padded(max_key, "name"), "default", "meaning");
printfln!(" %s %7.7s %s\n",
padded(max_key, "----"), "-------", "-------");
- foreach (spec, name) in lint_dict.consume_iter() {
+ for (spec, name) in lint_dict.consume_iter() {
let name = name.replace("_", "-");
printfln!(" %s %7.7s %s",
padded(max_key, name),
pub fn describe_debug_flags() {
printfln!("\nAvailable debug options:\n");
let r = session::debugging_opts_map();
- foreach tuple in r.iter() {
+ for tuple in r.iter() {
match *tuple {
(ref name, ref desc, _) => {
printfln!(" -Z %-20s -- %s", *name, *desc);
to get further details and report the results \
to github.com/mozilla/rust/issues"
];
- foreach note in xs.iter() {
+ for note in xs.iter() {
diagnostic::emit(None, *note, diagnostic::note)
}
}
match e.node {
// Skip inner loops, since a break in the inner loop isn't a
// break inside the outer loop
- ast::expr_loop(*) | ast::expr_while(*)
- | ast::expr_loop_body(*) => {}
+ ast::expr_loop(*) | ast::expr_while(*) => {}
_ => oldvisit::visit_expr(e, (flag, v))
}
};
}
// if there is an id, print that instead of the structural type:
- /*foreach def_id in ty::type_def_id(typ).iter() {
+ /*for def_id in ty::type_def_id(typ).iter() {
// note that this typedef cannot have type parameters
return ast_map::path_to_str(ty::item_path(cx, *def_id),
cx.sess.intr());
match *regions {
ty::ErasedRegions => { }
ty::NonerasedRegions(ref regions) => {
- foreach &r in regions.iter() {
+ for &r in regions.iter() {
strs.push(region_to_str(cx, "", false, r))
}
}
}
- foreach t in tps.iter() {
+ for t in tps.iter() {
strs.push(ty_to_str(cx, *t))
}
});
true
};
- foreach t in self.trait_bounds.iter() {
+ for t in self.trait_bounds.iter() {
res.push(t.repr(tcx));
}
res.connect("+")
let base = ast_map::path_to_str(path, tcx.sess.intr());
if tcx.sess.verbose() && self.substs.self_ty.is_some() {
let mut all_tps = self.substs.tps.clone();
- foreach &t in self.substs.self_ty.iter() { all_tps.push(t); }
+ for &t in self.substs.self_ty.iter() { all_tps.push(t); }
parameterized(tcx, base, &self.substs.regions, all_tps)
} else {
parameterized(tcx, base, &self.substs.regions, self.substs.tps)
println("Usage: rustdoc [options] <cratefile>\n");
println("Options:\n");
let r = opts();
- foreach opt in r.iter() {
+ for opt in r.iter() {
printfln!(" %s", opt.second());
}
println("");
module_: ast::foreign_mod
) -> doc::NmodDoc {
let mut fns = ~[];
- foreach item in module_.items.iter() {
+ for item in module_.items.iter() {
let ItemDoc = mk_itemdoc(item.id, to_str(item.ident));
match item.node {
ast::foreign_item_fn(*) => {
};
let self_ty = doc.self_ty.get_ref();
let mut trait_part = ~"";
- foreach (i, trait_type) in doc.trait_types.iter().enumerate() {
+ for (i, trait_type) in doc.trait_types.iter().enumerate() {
if i == 0 {
trait_part.push_str(" of ");
} else {
}
fn write_sections(ctxt: &Ctxt, sections: &[doc::Section]) {
- foreach section in sections.iter() {
+ for section in sections.iter() {
write_section(ctxt, (*section).clone());
}
}
write_index(ctxt, doc.index.get_ref());
}
- foreach itemTag in doc.items.iter() {
+ for itemTag in doc.items.iter() {
write_item(ctxt, (*itemTag).clone());
}
}
ctxt.w.put_line(~"<div class='index'>");
ctxt.w.put_line(~"");
- foreach entry in index.entries.iter() {
+ for entry in index.entries.iter() {
let header = header_text_(entry.kind, entry.name);
let id = entry.link.clone();
if entry.brief.is_some() {
write_index(ctxt, doc.index.get_ref());
}
- foreach FnDoc in doc.fns.iter() {
+ for FnDoc in doc.fns.iter() {
write_item_header(ctxt, doc::FnTag((*FnDoc).clone()));
write_fn(ctxt, (*FnDoc).clone());
}
write_header_(ctxt, H4, ~"Variants");
- foreach variant in docs.iter() {
+ for variant in docs.iter() {
write_variant(ctxt, (*variant).clone());
}
}
fn write_methods(ctxt: &Ctxt, docs: &[doc::MethodDoc]) {
- foreach doc in docs.iter() {
+ for doc in docs.iter() {
write_method(ctxt, (*doc).clone());
}
}
let mut current_section: Option<doc::Section> = None;
let mut sections = ~[];
- foreach line in desc.get_ref().any_line_iter() {
+ for line in desc.get_ref().any_line_iter() {
match parse_header(line) {
Some(header) => {
if current_section.is_some() {
code.push_str("fn main() {\n");
// It's easy to initialize things if we don't run things...
- foreach (name, var) in self.local_vars.iter() {
+ for (name, var) in self.local_vars.iter() {
let mt = var.mt();
code.push_str(fmt!("let%s %s: %s = fail!();\n", mt, *name, var.ty));
var.alter(*name, &mut code);
None => {}
}
- foreach p in new_locals.iter() {
+ for p in new_locals.iter() {
code.push_str(fmt!("assert_encodable(&%s);\n", *p.first_ref()));
}
code.push_str("};}");
// Using this __tls_map handle, deserialize each variable binding that
// we know about
- foreach (name, var) in self.local_vars.iter() {
+ for (name, var) in self.local_vars.iter() {
let mt = var.mt();
code.push_str(fmt!("let%s %s: %s = {
let data = __tls_map.get_copy(&~\"%s\");
}
let newvars = util::replace(&mut self.newvars, HashMap::new());
- foreach (name, var) in newvars.consume() {
+ for (name, var) in newvars.consume() {
self.local_vars.insert(name, var);
}
// After the input code is run, we can re-serialize everything back out
// into tls map (to be read later on by this task)
- foreach (name, var) in self.local_vars.iter() {
+ for (name, var) in self.local_vars.iter() {
code.push_str(fmt!("{
let local: %s = %s;
let bytes = do ::std::io::with_bytes_writer |io| {
use extra::serialize::*;
%s // view items
", self.externs, self.view_items);
- foreach (_, s) in self.structs.iter() {
+ for (_, s) in self.structs.iter() {
// The structs aren't really useful unless they're encodable
code.push_str("#[deriving(Encodable, Decodable)]");
code.push_str(*s);
code.push_str("\n");
}
- foreach (_, s) in self.items.iter() {
+ for (_, s) in self.items.iter() {
code.push_str(*s);
code.push_str("\n");
}
/// program starts
pub fn set_cache(&self) {
let map = @mut HashMap::new();
- foreach (name, value) in self.local_vars.iter() {
+ for (name, value) in self.local_vars.iter() {
map.insert((*name).clone(), @(value.data).clone());
}
local_data::set(tls_key, map);
pub fn consume_cache(&mut self) {
let map = local_data::pop(tls_key).expect("tls is empty");
let cons_map = util::replace(map, HashMap::new());
- foreach (name, value) in cons_map.consume() {
+ for (name, value) in cons_map.consume() {
match self.local_vars.find_mut(&name) {
Some(v) => { v.data = (*value).clone(); }
None => { fail!("unknown variable %s", name) }
// I'm not an @ pointer, so this has to be done outside.
let cons_newvars = util::replace(newvars, HashMap::new());
- foreach (k, v) in cons_newvars.consume() {
+ for (k, v) in cons_newvars.consume() {
self.newvars.insert(k, v);
}
// helper functions to perform ast iteration
fn each_user_local(blk: &ast::Block, f: &fn(@ast::Local)) {
do find_user_block(blk) |blk| {
- foreach stmt in blk.stmts.iter() {
+ for stmt in blk.stmts.iter() {
match stmt.node {
ast::stmt_decl(d, _) => {
match d.node {
}
fn find_user_block(blk: &ast::Block, f: &fn(&ast::Block)) {
- foreach stmt in blk.stmts.iter() {
+ for stmt in blk.stmts.iter() {
match stmt.node {
ast::stmt_semi(e, _) => {
match e.node {
do find_main(crate, sess) |blk| {
// Fish out all the view items, be sure to record 'extern mod' items
// differently beause they must appear before all 'use' statements
- foreach vi in blk.view_items.iter() {
+ for vi in blk.view_items.iter() {
let s = do with_pp(intr) |pp, _| {
pprust::print_view_item(pp, vi);
};
// Iterate through all of the block's statements, inserting them into
// the correct portions of the program
- foreach stmt in blk.stmts.iter() {
+ for stmt in blk.stmts.iter() {
let s = do with_pp(intr) |pp, _| { pprust::print_stmt(pp, *stmt); };
match stmt.node {
ast::stmt_decl(d, _) => {
fn find_main(crate: @ast::Crate, sess: session::Session,
f: &fn(&ast::Block)) {
- foreach item in crate.module.items.iter() {
+ for item in crate.module.items.iter() {
match item.node {
ast::item_fn(_, _, _, _, ref blk) => {
if item.ident == sess.ident_of("main") {
}
~"load" => {
let mut loaded_crates: ~[~str] = ~[];
- foreach arg in args.iter() {
+ for arg in args.iter() {
let (crate, filename) =
if arg.ends_with(".rs") || arg.ends_with(".rc") {
(arg.slice_to(arg.len() - 3).to_owned(), (*arg).clone())
None => { }
}
}
- foreach crate in loaded_crates.iter() {
+ for crate in loaded_crates.iter() {
let crate_path = Path(*crate);
let crate_dir = crate_path.dirname();
repl.program.record_extern(fmt!("extern mod %s;", *crate));
#[cfg(thiswillneverbeacfgflag)]
fn run_program(prog: &str) {
let mut r = repl();
- foreach cmd in prog.split_iter('\n') {
+ for cmd in prog.split_iter('\n') {
assert!(run_line(&mut r, io::stdin(), io::stdout(),
cmd.to_owned(), false),
"the command '%s' failed", cmd);
pub fn list_installed_packages(f: &fn(&PkgId) -> bool) -> bool {
let workspaces = rust_path();
- foreach p in workspaces.iter() {
+ for p in workspaces.iter() {
let binfiles = os::list_dir(&p.push("bin"));
- foreach exec in binfiles.iter() {
+ for exec in binfiles.iter() {
let exec_path = Path(*exec).filestem();
do exec_path.iter().advance |s| {
f(&PkgId::new(*s, p))
};
}
let libfiles = os::list_dir(&p.push("lib"));
- foreach lib in libfiles.iter() {
+ for lib in libfiles.iter() {
debug!("Full name: %s", *lib);
let lib_path = Path(*lib).filestem();
do lib_path.iter().advance |s| {
return true;
}
else {
- foreach pth in self_id.iter() {
+ for pth in self_id.iter() {
if pth.starts_with("rust_") // because p is already normalized
&& match p.filestem() {
Some(s) => str::eq_slice(s, pth.slice(5, pth.len())),
fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
assert!(p.components.len() > prefix);
let mut sub = Path("");
- foreach c in p.components.slice(prefix, p.components.len()).iter() {
+ for c in p.components.slice(prefix, p.components.len()).iter() {
sub = sub.push(*c);
}
debug!("found crate %s", sub.to_str());
crates: &[Crate],
cfgs: &[~str],
what: OutputType) {
- foreach crate in crates.iter() {
+ for crate in crates.iter() {
let path = &src_dir.push_rel(&crate.file).normalize();
note(fmt!("build_crates: compiling %s", path.to_str()));
note(fmt!("build_crates: destination dir is %s", dst_dir.to_str()));
// Avoid adding duplicates
// could still add dups if someone puts one of these in the RUST_PATH
// manually, though...
- foreach hdir in h.iter() {
+ for hdir in h.iter() {
if !(cwd.is_ancestor_of(hdir) || hdir.is_ancestor_of(&cwd)) {
push_if_exists(&mut env_rust_path, hdir);
}
pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
let src_dir = workspace.push("src");
let dirs = os::list_dir(&src_dir);
- foreach p in dirs.iter() {
+ for p in dirs.iter() {
let p = Path((*p).clone());
debug!("=> p = %s", p.to_str());
if !os::path_is_dir(&src_dir.push_rel(&p)) {
}
else {
let pf = p.filename();
- foreach pf in pf.iter() {
+ for pf in pf.iter() {
let f_ = (*pf).clone();
let g = f_.to_str();
match split_version_general(g, '-') {
/// Returns a src for pkgid that does exist -- None if none of them do
pub fn first_pkgid_src_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
let rs = pkgid_src_in_workspace(pkgid, workspace);
- foreach p in rs.iter() {
+ for p in rs.iter() {
if os::path_exists(p) {
return Some((*p).clone());
}
debug!("lib_prefix = %s and lib_filetype = %s", lib_prefix, lib_filetype);
let mut result_filename = None;
- foreach p in dir_contents.iter() {
+ for p in dir_contents.iter() {
let mut which = 0;
let mut hash = None;
let p_path = Path((*p).clone());
let f_name = match p_path.filename() {
Some(s) => s, None => loop
};
- foreach piece in f_name.split_iter('-') {
+ for piece in f_name.split_iter('-') {
debug!("a piece = %s", piece);
if which == 0 && piece != lib_prefix {
break;
target_exec.to_str(), target_lib,
maybe_executable, maybe_library);
- foreach exec in maybe_executable.iter() {
+ for exec in maybe_executable.iter() {
debug!("Copying: %s -> %s", exec.to_str(), target_exec.to_str());
if !(os::mkdir_recursive(&target_exec.dir_path(), U_RWX) &&
os::copy_file(exec, &target_exec)) {
cond.raise(((*exec).clone(), target_exec.clone()));
}
}
- foreach lib in maybe_library.iter() {
+ for lib in maybe_library.iter() {
let target_lib = target_lib.clone().expect(fmt!("I built %s but apparently \
didn't install it!", lib.to_str()));
debug!("Copying: %s -> %s", lib.to_str(), target_lib.to_str());
let mut result = ~[];
let p_output = command_line_test(args, &os::getcwd());
let test_output = str::from_bytes(p_output.output);
- foreach s in test_output.split_iter('\n') {
+ for s in test_output.split_iter('\n') {
result.push(s.to_owned());
}
result
let mut result = ~[];
let p_output = command_line_test_with_env(args, &os::getcwd(), Some(env));
let test_output = str::from_bytes(p_output.output);
- foreach s in test_output.split_iter('\n') {
+ for s in test_output.split_iter('\n') {
result.push(s.to_owned());
}
result
use conditions::bad_path::cond;
let pkg_src_dir = workspace.push("src").push(pkgid.to_str());
let contents = os::list_dir_path(&pkg_src_dir);
- foreach p in contents.iter() {
+ for p in contents.iter() {
if p.filetype() == Some(~".rs") {
// should be able to do this w/o a process
if run::process_output("touch", [p.to_str()]).status != 0 {
let pkg_src_dir = workspace.push("src").push(pkgid.to_str());
let contents = os::list_dir_path(&pkg_src_dir);
let mut maybe_p = None;
- foreach p in contents.iter() {
+ for p in contents.iter() {
if p.filetype() == Some(~".rs") {
maybe_p = Some(p);
break;
assert!(p.contains(&cwd));
assert!(p.contains(&parent));
assert!(p.contains(&grandparent));
- foreach a_path in p.iter() {
+ for a_path in p.iter() {
assert!(!a_path.components.is_empty());
}
});
let mut cmds = ~[];
let mut had_pkg_do = false;
- foreach attr in item.attrs.iter() {
+ for attr in item.attrs.iter() {
if "pkg_do" == attr.name() {
had_pkg_do = true;
match attr.node.value.node {
ast::MetaList(_, ref mis) => {
- foreach mi in mis.iter() {
+ for mi in mis.iter() {
match mi.node {
ast::MetaWord(cmd) => cmds.push(cmd.to_owned()),
_ => {}
let addl_lib_search_paths = @mut options.addl_lib_search_paths;
// Make sure all the library directories actually exist, since the linker will complain
// otherwise
- foreach p in addl_lib_search_paths.iter() {
+ for p in addl_lib_search_paths.iter() {
assert!(os::path_is_dir(p));
}
debug!("Outputs are %? and output type = %?", outputs, sess.opts.output_type);
debug!("additional libraries:");
- foreach lib in sess.opts.addl_lib_search_paths.iter() {
+ for lib in sess.opts.addl_lib_search_paths.iter() {
debug!("an additional library: %s", lib.to_str());
}
let analysis = driver::phase_3_run_analysis_passes(sess, crate);
what: OutputType) -> bool {
debug!("compile_crate: crate=%s, dir=%s", crate.to_str(), dir.to_str());
debug!("compile_crate: short_name = %s, flags =...", pkg_id.to_str());
- foreach fl in flags.iter() {
+ for fl in flags.iter() {
debug!("+++ %s", *fl);
}
compile_input(ctxt, pkg_id, crate, dir, flags, cfgs, opt, what)
let mut output = None;
let output_text = str::from_bytes(outp.output);
- foreach l in output_text.line_iter() {
+ for l in output_text.line_iter() {
if !l.is_whitespace() {
output = Some(l);
}
~"tag", ~"-l"]);
let output_text = str::from_bytes(outp.output);
debug!("Full output: ( %s ) [%?]", output_text, outp.status);
- foreach l in output_text.line_iter() {
+ for l in output_text.line_iter() {
debug!("A line of output: %s", l);
if !l.is_whitespace() {
output = Some(l);
let s = s.trim();
debug!("Attempting to parse: %s", s);
let mut parse_state = Start;
- foreach c in s.iter() {
+ for c in s.iter() {
if char::is_digit(c) {
parse_state = SawDigit;
}
pub fn split_version_general<'a>(s: &'a str, sep: char) -> Option<(&'a str, Version)> {
// reject strings with multiple '#'s
- foreach st in s.split_iter(sep) {
+ for st in s.split_iter(sep) {
debug!("whole = %s part = %s", s, st);
}
if s.split_iter(sep).len_() > 2 {
pkgid.remote_path.to_str(),
rust_path().to_str());
}
- foreach ws in workspaces.iter() {
+ for ws in workspaces.iter() {
if action(ws) {
break;
}
#[inline]
pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
do build_sized(lhs.len() + rhs.len()) |push| {
- foreach x in lhs.iter() {
+ for x in lhs.iter() {
push((*x).clone());
}
- foreach i in range(0u, rhs.len()) {
+ for i in range(0u, rhs.len()) {
push(rhs[i].clone());
}
}
/// Apply a function to each element of a vector and return the results
pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] {
do build_sized(v.len()) |push| {
- foreach elem in v.iter() {
+ for elem in v.iter() {
push(f(elem));
}
}
let mut av = @[];
unsafe {
raw::reserve(&mut av, v.len());
- foreach x in v.consume_iter() {
+ for x in v.consume_iter() {
raw::push(&mut av, x);
}
av
// Some code that could use that, then:
fn seq_range(lo: uint, hi: uint) -> @[uint] {
do build |push| {
- foreach i in range(lo, hi) {
+ for i in range(lo, hi) {
push(i);
}
}
}
let xs = [Less, Equal, Greater];
- foreach &o in xs.iter() {
+ for &o in xs.iter() {
t(Less, o, Less);
t(Equal, o, o);
t(Greater, o, Greater);
/// A map is a key-value store where values may be looked up by their keys. This
/// trait provides basic operations to operate on these stores.
pub trait Map<K, V>: Container {
- /// Return true if the map contains a value for the specified key
- fn contains_key(&self, key: &K) -> bool;
-
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
+
+ /// Return true if the map contains a value for the specified key
+ fn contains_key(&self, key: &K) -> bool {
+ self.find(key).is_some()
+ }
}
/// This trait provides basic operations to modify the contents of a map.
/// Extracts from a vector of either all the left values
pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
do vec::build_sized(eithers.len()) |push| {
- foreach elt in eithers.iter() {
+ for elt in eithers.iter() {
match *elt {
Left(ref l) => { push((*l).clone()); }
_ => { /* fallthrough */ }
/// Extracts from a vector of either all the right values
pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
do vec::build_sized(eithers.len()) |push| {
- foreach elt in eithers.iter() {
+ for elt in eithers.iter() {
match *elt {
Right(ref r) => { push((*r).clone()); }
_ => { /* fallthrough */ }
pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
let mut lefts: ~[T] = ~[];
let mut rights: ~[U] = ~[];
- foreach elt in eithers.consume_iter() {
+ for elt in eithers.consume_iter() {
match elt {
Left(l) => lefts.push(l),
Right(r) => rights.push(r)
fn result_str(&mut self) -> ~str {
let r = self.result_bytes();
let mut s = ~"";
- foreach b in r.iter() {
+ for b in r.iter() {
s.push_str(uint::to_str_radix(*b as uint, 16u));
}
s
fn to_hex_str(r: &[u8, ..8]) -> ~str {
let mut s = ~"";
- foreach b in r.iter() {
+ for b in r.iter() {
s.push_str(uint::to_str_radix(*b as uint, 16u));
}
s
self.size = 0;
// consume_rev_iter is more efficient
- foreach bucket in old_buckets.consume_rev_iter() {
+ for bucket in old_buckets.consume_rev_iter() {
self.insert_opt_bucket(bucket);
}
}
impl<K:Hash + Eq,V> Mutable for HashMap<K, V> {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) {
- foreach idx in range(0u, self.buckets.len()) {
+ for idx in range(0u, self.buckets.len()) {
self.buckets[idx] = None;
}
self.size = 0;
}
impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
- /// Return true if the map contains a value for the specified key
- fn contains_key(&self, k: &K) -> bool {
- match self.bucket_for_key(k) {
- FoundEntry(_) => {true}
- TableFull | FoundHole(_) => {false}
- }
- }
-
/// Return a reference to the value corresponding to the key
fn find<'a>(&'a self, k: &K) -> Option<&'a V> {
match self.bucket_for_key(k) {
impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
fn clone(&self) -> HashMap<K,V> {
let mut new_map = HashMap::with_capacity(self.len());
- foreach (key, value) in self.iter() {
+ for (key, value) in self.iter() {
new_map.insert((*key).clone(), (*value).clone());
}
new_map
impl<'self, K, V> Iterator<(&'self K, &'self V)> for HashMapIterator<'self, K, V> {
#[inline]
fn next(&mut self) -> Option<(&'self K, &'self V)> {
- foreach elt in self.iter {
+ for elt in self.iter {
match elt {
&Some(ref bucket) => return Some((&bucket.key, &bucket.value)),
&None => {},
impl<'self, K, V> Iterator<(&'self K, &'self mut V)> for HashMapMutIterator<'self, K, V> {
#[inline]
fn next(&mut self) -> Option<(&'self K, &'self mut V)> {
- foreach elt in self.iter {
+ for elt in self.iter {
match elt {
&Some(ref mut bucket) => return Some((&bucket.key, &mut bucket.value)),
&None => {},
impl<K, V> Iterator<(K, V)> for HashMapConsumeIterator<K, V> {
#[inline]
fn next(&mut self) -> Option<(K, V)> {
- foreach elt in self.iter {
+ for elt in self.iter {
match elt {
Some(Bucket {key, value, _}) => return Some((key, value)),
None => {},
impl<'self, K> Iterator<&'self K> for HashSetIterator<'self, K> {
#[inline]
fn next(&mut self) -> Option<&'self K> {
- foreach elt in self.iter {
+ for elt in self.iter {
match elt {
&Some(ref bucket) => return Some(&bucket.key),
&None => {},
impl<K> Iterator<K> for HashSetConsumeIterator<K> {
#[inline]
fn next(&mut self) -> Option<K> {
- foreach elt in self.iter {
+ for elt in self.iter {
match elt {
Some(bucket) => return Some(bucket.key),
None => {},
impl<K: Eq + Hash, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for HashMap<K, V> {
fn extend(&mut self, iter: &mut T) {
- foreach (k, v) in *iter {
+ for (k, v) in *iter {
self.insert(k, v);
}
}
impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {
fn extend(&mut self, iter: &mut T) {
- foreach k in *iter {
+ for k in *iter {
self.insert(k);
}
}
#[test]
fn test_iterate() {
let mut m = HashMap::with_capacity(4);
- foreach i in range(0u, 32) {
+ for i in range(0u, 32) {
assert!(m.insert(i, i*2));
}
let mut observed = 0;
- foreach (k, v) in m.iter() {
+ for (k, v) in m.iter() {
assert_eq!(*v, *k * 2);
observed |= (1 << *k);
}
let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect();
- foreach &(k, v) in xs.iter() {
+ for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
}
}
#[test]
fn test_iterate() {
let mut a = HashSet::new();
- foreach i in range(0u, 32) {
+ for i in range(0u, 32) {
assert!(a.insert(i));
}
let mut observed = 0;
- foreach k in a.iter() {
+ for k in a.iter() {
observed |= (1 << *k);
}
assert_eq!(observed, 0xFFFF_FFFF);
let mut i = 0;
let expected = [3, 5, 11, 77];
- foreach x in a.intersection_iter(&b) {
+ for x in a.intersection_iter(&b) {
assert!(expected.contains(x));
i += 1
}
let mut i = 0;
let expected = [1, 5, 11];
- foreach x in a.difference_iter(&b) {
+ for x in a.difference_iter(&b) {
assert!(expected.contains(x));
i += 1
}
let mut i = 0;
let expected = [-2, 1, 5, 11, 14, 22];
- foreach x in a.symmetric_difference_iter(&b) {
+ for x in a.symmetric_difference_iter(&b) {
assert!(expected.contains(x));
i += 1
}
let mut i = 0;
let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24];
- foreach x in a.union_iter(&b) {
+ for x in a.union_iter(&b) {
assert!(expected.contains(x));
i += 1
}
let set: HashSet<int> = xs.iter().transform(|&x| x).collect();
- foreach x in xs.iter() {
+ for x in xs.iter() {
assert!(set.contains(x));
}
}
fn wb() -> c_int { O_WRONLY as c_int }
let mut fflags: c_int = wb();
- foreach f in flags.iter() {
+ for f in flags.iter() {
match *f {
Append => fflags |= O_APPEND as c_int,
Create => fflags |= O_CREAT as c_int,
if len <= ivals.len() {
assert_eq!(res.len(), len);
}
- foreach (iv, c) in ivals.iter().zip(res.iter()) {
+ for (iv, c) in ivals.iter().zip(res.iter()) {
assert!(*iv == *c as int)
}
}
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).unwrap();
- foreach i in uints.iter() {
+ for i in uints.iter() {
file.write_le_u64(*i);
}
}
// then read them back and check that they are the same
{
let file = io::file_reader(&path).unwrap();
- foreach i in uints.iter() {
+ for i in uints.iter() {
assert_eq!(file.read_le_u64(), *i);
}
}
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).unwrap();
- foreach i in uints.iter() {
+ for i in uints.iter() {
file.write_be_u64(*i);
}
}
// then read them back and check that they are the same
{
let file = io::file_reader(&path).unwrap();
- foreach i in uints.iter() {
+ for i in uints.iter() {
assert_eq!(file.read_be_u64(), *i);
}
}
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).unwrap();
- foreach i in ints.iter() {
+ for i in ints.iter() {
file.write_be_i32(*i);
}
}
// then read them back and check that they are the same
{
let file = io::file_reader(&path).unwrap();
- foreach i in ints.iter() {
+ for i in ints.iter() {
// this tests that the sign extension is working
// (comparing the values as i32 would not test this)
assert_eq!(file.read_be_int_n(4), *i as i64);
/// let mut it = xs.iter().flat_map_(|&x| Counter::new(0u, 1).take_(x));
/// // Check that `it` has the same elements as `ys`
/// let mut i = 0;
- /// foreach x: uint in it {
+ /// for x: uint in it {
/// assert_eq!(x, ys[i]);
/// i += 1;
/// }
/// ~~~ {.rust}
/// use std::iterator::Counter;
///
- /// foreach i in Counter::new(0, 10) {
+ /// for i in Counter::new(0, 10) {
/// printfln!("%d", i);
/// }
/// ~~~
#[inline]
fn last_(&mut self) -> Option<A> {
let mut last = None;
- foreach x in *self { last = Some(x); }
+ for x in *self { last = Some(x); }
last
}
#[inline]
fn all(&mut self, f: &fn(A) -> bool) -> bool {
- foreach x in *self { if !f(x) { return false; } }
+ for x in *self { if !f(x) { return false; } }
true
}
#[inline]
fn any(&mut self, f: &fn(A) -> bool) -> bool {
- foreach x in *self { if f(x) { return true; } }
+ for x in *self { if f(x) { return true; } }
false
}
/// Return the first element satisfying the specified predicate
#[inline]
fn find_(&mut self, predicate: &fn(&A) -> bool) -> Option<A> {
- foreach x in *self {
+ for x in *self {
if predicate(&x) { return Some(x) }
}
None
#[inline]
fn position(&mut self, predicate: &fn(A) -> bool) -> Option<uint> {
let mut i = 0;
- foreach x in *self {
+ for x in *self {
if predicate(x) {
return Some(i);
}
#[inline]
fn count(&mut self, predicate: &fn(A) -> bool) -> uint {
let mut i = 0;
- foreach x in *self {
+ for x in *self {
if predicate(x) { i += 1 }
}
i
impl<'self, A, T: Iterator<A>> Iterator<A> for Filter<'self, A, T> {
#[inline]
fn next(&mut self) -> Option<A> {
- foreach x in self.iter {
+ for x in self.iter {
if (self.predicate)(&x) {
return Some(x);
} else {
impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMap<'self, A, B, T> {
#[inline]
fn next(&mut self) -> Option<B> {
- foreach x in self.iter {
+ for x in self.iter {
match (self.f)(x) {
Some(y) => return Some(y),
None => ()
#[inline]
fn next(&mut self) -> Option<B> {
loop {
- foreach inner in self.frontiter.mut_iter() {
- foreach x in *inner {
+ for inner in self.frontiter.mut_iter() {
+ for x in *inner {
return Some(x)
}
}
#[inline]
fn next_back(&mut self) -> Option<B> {
loop {
- foreach inner in self.backiter.mut_iter() {
+ for inner in self.backiter.mut_iter() {
match inner.next_back() {
None => (),
y => return y
let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
let mut it = xs.iter().chain_(ys.iter());
let mut i = 0;
- foreach &x in it {
+ for &x in it {
assert_eq!(x, expected[i]);
i += 1;
}
let ys = Counter::new(30u, 10).take_(4);
let mut it = xs.iter().transform(|&x| x).chain_(ys);
let mut i = 0;
- foreach x in it {
+ for x in it {
assert_eq!(x, expected[i]);
i += 1;
}
fn test_iterator_enumerate() {
let xs = [0u, 1, 2, 3, 4, 5];
let mut it = xs.iter().enumerate();
- foreach (i, &x) in it {
+ for (i, &x) in it {
assert_eq!(i, x);
}
}
let ys = [0u, 1, 2, 3, 5, 13];
let mut it = xs.iter().take_while(|&x| *x < 15u);
let mut i = 0;
- foreach &x in it {
+ for &x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let ys = [15, 16, 17, 19];
let mut it = xs.iter().skip_while(|&x| *x < 15u);
let mut i = 0;
- foreach &x in it {
+ for &x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let ys = [13, 15, 16, 17, 19, 20, 30];
let mut it = xs.iter().skip(5);
let mut i = 0;
- foreach &x in it {
+ for &x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let ys = [0u, 1, 2, 3, 5];
let mut it = xs.iter().take_(5);
let mut i = 0;
- foreach &x in it {
+ for &x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let mut it = xs.iter().scan(0, add);
let mut i = 0;
- foreach x in it {
+ for x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let ys = [0u, 1, 2, 3, 4, 5, 6, 7, 8];
let mut it = xs.iter().flat_map_(|&x| Counter::new(x, 1).take_(3));
let mut i = 0;
- foreach x in it {
+ for x in it {
assert_eq!(x, ys[i]);
i += 1;
}
let mut it = Unfoldr::new(0, count);
let mut i = 0;
- foreach counted in it {
+ for counted in it {
assert_eq!(counted, i);
i += 1;
}
let cycle_len = 3;
let it = Counter::new(0u, 1).take_(cycle_len).cycle();
assert_eq!(it.size_hint(), (uint::max_value, None));
- foreach (i, x) in it.take_(100).enumerate() {
+ for (i, x) in it.take_(100).enumerate() {
assert_eq!(i % cycle_len, x);
}
#[test]
fn test_iterator_nth() {
let v = &[0, 1, 2, 3, 4];
- foreach i in range(0u, v.len()) {
+ for i in range(0u, v.len()) {
assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
}
}
let mut b = a.clone();
assert_eq!(len, b.indexable());
let mut n = 0;
- foreach (i, elt) in a.enumerate() {
+ for (i, elt) in a.enumerate() {
assert_eq!(Some(elt), b.idx(i));
n += 1;
}
// test .transform and .peek_ that don't implement Clone
let it = xs.iter().peek_(|_| {});
assert_eq!(xs.len(), it.indexable());
- foreach (i, elt) in xs.iter().enumerate() {
+ for (i, elt) in xs.iter().enumerate() {
assert_eq!(Some(elt), it.idx(i));
}
// test .transform and .peek_ that don't implement Clone
let it = xs.iter().transform(|x| *x);
assert_eq!(xs.len(), it.indexable());
- foreach (i, elt) in xs.iter().enumerate() {
+ for (i, elt) in xs.iter().enumerate() {
assert_eq!(Some(*elt), it.idx(i));
}
}
let x = Some(());
let mut y = Some(5);
let mut y2 = 0;
- foreach _x in x.iter() {
+ for _x in x.iter() {
y2 = y.take_unwrap();
}
assert_eq!(y2, 5);
fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
let mut pairs = ~[];
- foreach p in input.iter() {
+ for p in input.iter() {
let vs: ~[&str] = p.splitn_iter('=', 1).collect();
debug!("splitting: len: %u",
vs.len());
unsafe fn load_argc_and_argv(argc: c_int, argv: **c_char) -> ~[~str] {
let mut args = ~[];
- foreach i in range(0u, argc as uint) {
+ for i in range(0u, argc as uint) {
args.push(str::raw::from_c_str(*argv.offset(i as int)));
}
args
let szArgList = unsafe { CommandLineToArgvW(lpCmdLine, lpArgCount) };
let mut args = ~[];
- foreach i in range(0u, nArgs as uint) {
+ for i in range(0u, nArgs as uint) {
unsafe {
// Determine the length of this argument.
let ptr = *szArgList.offset(i as int);
let mut offset: off_t = 0;
let len = round_up(min_len, page_size()) as size_t;
- foreach &o in options.iter() {
+ for &o in options.iter() {
match o {
MapReadable => { prot |= libc::PROT_READ; },
MapWritable => { prot |= libc::PROT_WRITE; },
let mut offset: uint = 0;
let len = round_up(min_len, page_size()) as SIZE_T;
- foreach &o in options.iter() {
+ for &o in options.iter() {
match o {
MapReadable => { readable = true; },
MapWritable => { writable = true; },
fn test_env_getenv() {
let e = env();
assert!(e.len() > 0u);
- foreach p in e.iter() {
+ for p in e.iter() {
let (n, v) = (*p).clone();
debug!(n.clone());
let v2 = getenv(n);
setenv("HOME", "");
assert!(os::homedir().is_none());
- foreach s in oldhome.iter() { setenv("HOME", *s) }
+ for s in oldhome.iter() { setenv("HOME", *s) }
}
#[test]
// Just assuming that we've got some contents in the current directory
assert!(dirs.len() > 0u);
- foreach dir in dirs.iter() {
+ for dir in dirs.iter() {
debug!((*dir).clone());
}
}
fn push_many<S: Str>(&self, cs: &[S]) -> PosixPath {
let mut v = self.components.clone();
- foreach e in cs.iter() {
- foreach s in e.as_slice().split_iter(posix::is_sep) {
+ for e in cs.iter() {
+ for s in e.as_slice().split_iter(posix::is_sep) {
if !s.is_empty() {
v.push(s.to_owned())
}
fn push(&self, s: &str) -> PosixPath {
let mut v = self.components.clone();
- foreach s in s.split_iter(posix::is_sep) {
+ for s in s.split_iter(posix::is_sep) {
if !s.is_empty() {
v.push(s.to_owned())
}
fn push_many<S: Str>(&self, cs: &[S]) -> WindowsPath {
let mut v = self.components.clone();
- foreach e in cs.iter() {
- foreach s in e.as_slice().split_iter(windows::is_sep) {
+ for e in cs.iter() {
+ for s in e.as_slice().split_iter(windows::is_sep) {
if !s.is_empty() {
v.push(s.to_owned())
}
fn push(&self, s: &str) -> WindowsPath {
let mut v = self.components.clone();
- foreach s in s.split_iter(windows::is_sep) {
+ for s in s.split_iter(windows::is_sep) {
if !s.is_empty() {
v.push(s.to_owned())
}
pub fn normalize(components: &[~str]) -> ~[~str] {
let mut cs = ~[];
- foreach c in components.iter() {
+ for c in components.iter() {
if *c == ~"." && components.len() > 1 { loop; }
if *c == ~"" { loop; }
if *c == ~".." && cs.len() != 0 {
let mut data_avail = false;
let mut ready_packet = pkts.len();
- foreach (i, p) in pkts.mut_iter().enumerate() {
+ for (i, p) in pkts.mut_iter().enumerate() {
unsafe {
let p = &mut *p.header();
let old = p.mark_blocked(this);
let event = wait_event(this) as *PacketHeader;
let mut pos = None;
- foreach (i, p) in pkts.mut_iter().enumerate() {
+ for (i, p) in pkts.mut_iter().enumerate() {
if p.header() == event {
pos = Some(i);
break;
debug!("%?", &mut pkts[ready_packet]);
- foreach p in pkts.mut_iter() {
+ for p in pkts.mut_iter() {
unsafe {
(*p.header()).unblock()
}
Option<T>,
~[RecvPacketBuffered<T, Tb>]) {
let mut endpoint_headers = ~[];
- foreach endpoint in endpoints.mut_iter() {
+ for endpoint in endpoints.mut_iter() {
endpoint_headers.push(endpoint.header());
}
use cast;
use clone::Clone;
use option::{Option, Some, None};
-#[cfg(stage0)]
-use sys;
use unstable::intrinsics;
use util::swap;
/// Calculate the offset from a pointer
#[inline]
-#[cfg(stage0)]
-pub fn offset<T>(ptr: *T, count: int) -> *T {
- (ptr as uint + (count as uint) * sys::size_of::<T>()) as *T
-}
-
-/// Calculate the offset from a const pointer
-#[inline]
-#[cfg(stage0)]
-pub fn const_offset<T>(ptr: *const T, count: int) -> *const T {
- (ptr as uint + (count as uint) * sys::size_of::<T>()) as *T
-}
-
-/// Calculate the offset from a mut pointer
-#[inline]
-#[cfg(stage0)]
-pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
- (ptr as uint + (count as uint) * sys::size_of::<T>()) as *mut T
-}
-
-/// Calculate the offset from a pointer
-#[inline]
-#[cfg(not(stage0))]
pub fn offset<T>(ptr: *T, count: int) -> *T {
unsafe { intrinsics::offset(ptr, count) }
}
/// Calculate the offset from a const pointer
#[inline]
-#[cfg(not(stage0))]
pub fn const_offset<T>(ptr: *const T, count: int) -> *const T {
unsafe { intrinsics::offset(ptr as *T, count) }
}
/// Calculate the offset from a mut pointer
#[inline]
-#[cfg(not(stage0))]
pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
unsafe { intrinsics::offset(ptr as *T, count) as *mut T }
}
fn gen_char_from(&mut self, chars: &str) -> char {
assert!(!chars.is_empty());
let mut cs = ~[];
- foreach c in chars.iter() { cs.push(c) }
+ for c in chars.iter() { cs.push(c) }
self.choose(cs)
}
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
-> Option<T> {
let mut total = 0u;
- foreach item in v.iter() {
+ for item in v.iter() {
total += item.weight;
}
if total == 0u {
}
let chosen = self.gen_uint_range(0u, total);
let mut so_far = 0u;
- foreach item in v.iter() {
+ for item in v.iter() {
so_far += item.weight;
if so_far > chosen {
return Some(item.item.clone());
*/
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
let mut r = ~[];
- foreach item in v.iter() {
- foreach _ in range(0u, item.weight) {
+ for item in v.iter() {
+ for _ in range(0u, item.weight) {
r.push(item.item.clone());
}
}
);
let r = [(0, MIDPOINT), (MIDPOINT, 0)];
- foreach &(mr_offset, m2_offset) in r.iter() {
+ for &(mr_offset, m2_offset) in r.iter() {
do uint::range_step(0, MIDPOINT, 4) |base| {
rngstep!(0, 13);
rngstep!(1, -6);
pub fn write_escaped_slice(&self, slice: &str) {
self.writer.write_char('"');
- foreach ch in slice.iter() {
+ for ch in slice.iter() {
self.writer.write_escaped_char(ch);
}
self.writer.write_char('"');
pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
-> Result<~[V],U> {
let mut vs: ~[V] = vec::with_capacity(ts.len());
- foreach t in ts.iter() {
+ for t in ts.iter() {
match op(t) {
Ok(v) => vs.push(v),
Err(u) => return Err(u)
// Copied from `os`.
unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~str] {
let mut args = ~[];
- foreach i in range(0u, argc as uint) {
+ for i in range(0u, argc as uint) {
args.push(str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int)));
}
args
Some(borrow_list) => { // recording borrows
let mut msg = ~"borrowed";
let mut sep = " at ";
- foreach entry in borrow_list.rev_iter() {
+ for entry in borrow_list.rev_iter() {
if entry.box == box {
msg.push_str(sep);
let filename = str::raw::from_c_str(entry.file);
#[deriving(Eq, TotalEq)]
pub enum IpAddr {
- Ipv4(u8, u8, u8, u8, Port),
- Ipv6(u16, u16, u16, u16, u16, u16, u16, u16, Port)
+ Ipv4Addr(u8, u8, u8, u8),
+ Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
impl ToStr for IpAddr {
fn to_str(&self) -> ~str {
match *self {
- Ipv4(a, b, c, d, p) =>
- fmt!("%u.%u.%u.%u:%u",
- a as uint, b as uint, c as uint, d as uint, p as uint),
+ Ipv4Addr(a, b, c, d) =>
+ fmt!("%u.%u.%u.%u",
+ a as uint, b as uint, c as uint, d as uint),
// Ipv4 Compatible address
- Ipv6(0, 0, 0, 0, 0, 0, g, h, p) => {
+ Ipv6Addr(0, 0, 0, 0, 0, 0, g, h) => {
let a = fmt!("%04x", g as uint);
let b = FromStrRadix::from_str_radix(a.slice(2, 4), 16).unwrap();
let a = FromStrRadix::from_str_radix(a.slice(0, 2), 16).unwrap();
let d = FromStrRadix::from_str_radix(c.slice(2, 4), 16).unwrap();
let c = FromStrRadix::from_str_radix(c.slice(0, 2), 16).unwrap();
- fmt!("[::%u.%u.%u.%u]:%u", a, b, c, d, p as uint)
+ fmt!("::%u.%u.%u.%u", a, b, c, d)
}
// Ipv4-Mapped address
- Ipv6(0, 0, 0, 0, 0, 1, g, h, p) => {
+ Ipv6Addr(0, 0, 0, 0, 0, 1, g, h) => {
let a = fmt!("%04x", g as uint);
let b = FromStrRadix::from_str_radix(a.slice(2, 4), 16).unwrap();
let a = FromStrRadix::from_str_radix(a.slice(0, 2), 16).unwrap();
let d = FromStrRadix::from_str_radix(c.slice(2, 4), 16).unwrap();
let c = FromStrRadix::from_str_radix(c.slice(0, 2), 16).unwrap();
- fmt!("[::FFFF:%u.%u.%u.%u]:%u", a, b, c, d, p as uint)
+ fmt!("::FFFF:%u.%u.%u.%u", a, b, c, d)
}
- Ipv6(a, b, c, d, e, f, g, h, p) =>
- fmt!("[%x:%x:%x:%x:%x:%x:%x:%x]:%u",
+ Ipv6Addr(a, b, c, d, e, f, g, h) =>
+ fmt!("%x:%x:%x:%x:%x:%x:%x:%x",
a as uint, b as uint, c as uint, d as uint,
- e as uint, f as uint, g as uint, h as uint, p as uint)
+ e as uint, f as uint, g as uint, h as uint)
+ }
+ }
+}
+
+#[deriving(Eq, TotalEq)]
+pub struct SocketAddr {
+ ip: IpAddr,
+ port: Port,
+}
+
+
+impl ToStr for SocketAddr {
+ fn to_str(&self) -> ~str {
+ match self.ip {
+ Ipv4Addr(*) => fmt!("%s:%u", self.ip.to_str(), self.port as uint),
+ Ipv6Addr(*) => fmt!("[%s]:%u", self.ip.to_str(), self.port as uint),
}
}
}
use option::{Option, Some, None};
use result::{Ok, Err};
-use rt::io::net::ip::IpAddr;
+use rt::io::net::ip::SocketAddr;
use rt::io::{Reader, Writer, Listener};
use rt::io::{io_error, read_error, EndOfFile};
use rt::rtio::{IoFactory, IoFactoryObject,
TcpStream(s)
}
- pub fn connect(addr: IpAddr) -> Option<TcpStream> {
+ pub fn connect(addr: SocketAddr) -> Option<TcpStream> {
let stream = unsafe {
rtdebug!("borrowing io to connect");
let io = Local::unsafe_borrow::<IoFactoryObject>();
}
}
- pub fn peer_name(&mut self) -> Option<IpAddr> {
+ pub fn peer_name(&mut self) -> Option<SocketAddr> {
match (**self).peer_name() {
Ok(pn) => Some(pn),
Err(ioerr) => {
}
}
- pub fn socket_name(&mut self) -> Option<IpAddr> {
+ pub fn socket_name(&mut self) -> Option<SocketAddr> {
match (**self).socket_name() {
Ok(sn) => Some(sn),
Err(ioerr) => {
pub struct TcpListener(~RtioTcpListenerObject);
impl TcpListener {
- pub fn bind(addr: IpAddr) -> Option<TcpListener> {
+ pub fn bind(addr: SocketAddr) -> Option<TcpListener> {
let listener = unsafe {
let io = Local::unsafe_borrow::<IoFactoryObject>();
(*io).tcp_bind(addr)
}
}
- pub fn socket_name(&mut self) -> Option<IpAddr> {
+ pub fn socket_name(&mut self) -> Option<SocketAddr> {
match (**self).socket_name() {
Ok(sn) => Some(sn),
Err(ioerr) => {
use super::*;
use cell::Cell;
use rt::test::*;
- use rt::io::net::ip::Ipv4;
+ use rt::io::net::ip::{Ipv4Addr, SocketAddr};
use rt::io::*;
use prelude::*;
assert!(e.kind == PermissionDenied);
called = true;
}).inside {
- let addr = Ipv4(0, 0, 0, 0, 1);
+ let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
let listener = TcpListener::bind(addr);
assert!(listener.is_none());
}
assert!(e.kind == ConnectionRefused);
called = true;
}).inside {
- let addr = Ipv4(0, 0, 0, 0, 1);
+ let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
let stream = TcpStream::connect(addr);
assert!(stream.is_none());
}
do spawntask {
let mut listener = TcpListener::bind(addr);
- foreach i in range(0, MAX) {
+ for i in range(0, MAX) {
let stream = Cell::new(listener.accept());
rtdebug!("accepted");
// Start another task to handle the connection
connect(0, addr);
- fn connect(i: int, addr: IpAddr) {
+ fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawntask {
do spawntask {
let mut listener = TcpListener::bind(addr);
- foreach i in range(0, MAX) {
+ for i in range(0, MAX) {
let stream = Cell::new(listener.accept());
rtdebug!("accepted");
// Start another task to handle the connection
connect(0, addr);
- fn connect(i: int, addr: IpAddr) {
+ fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawntask {
do spawntask {
let mut listener = TcpListener::bind(addr);
- foreach _ in range(0, MAX) {
+ for _ in range(0, MAX) {
let stream = Cell::new(listener.accept());
rtdebug!("accepted");
// Start another task to handle the connection
connect(0, addr);
- fn connect(i: int, addr: IpAddr) {
+ fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawntask_later {
do spawntask {
let mut listener = TcpListener::bind(addr);
- foreach _ in range(0, MAX) {
+ for _ in range(0, MAX) {
let stream = Cell::new(listener.accept());
rtdebug!("accepted");
// Start another task to handle the connection
connect(0, addr);
- fn connect(i: int, addr: IpAddr) {
+ fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawntask_later {
}
#[cfg(test)]
- fn socket_name(addr: IpAddr) {
+ fn socket_name(addr: SocketAddr) {
do run_in_newsched_task {
do spawntask {
let listener = TcpListener::bind(addr);
}
#[cfg(test)]
- fn peer_name(addr: IpAddr) {
+ fn peer_name(addr: SocketAddr) {
do run_in_newsched_task {
do spawntask {
let mut listener = TcpListener::bind(addr);
use option::{Option, Some, None};
use result::{Ok, Err};
-use rt::io::net::ip::IpAddr;
+use rt::io::net::ip::SocketAddr;
use rt::io::{Reader, Writer};
use rt::io::{io_error, read_error, EndOfFile};
use rt::rtio::{RtioSocket, RtioUdpSocketObject, RtioUdpSocket, IoFactory, IoFactoryObject};
pub struct UdpSocket(~RtioUdpSocketObject);
impl UdpSocket {
- pub fn bind(addr: IpAddr) -> Option<UdpSocket> {
+ pub fn bind(addr: SocketAddr) -> Option<UdpSocket> {
let socket = unsafe { (*Local::unsafe_borrow::<IoFactoryObject>()).udp_bind(addr) };
match socket {
Ok(s) => Some(UdpSocket(s)),
}
}
- pub fn recvfrom(&mut self, buf: &mut [u8]) -> Option<(uint, IpAddr)> {
+ pub fn recvfrom(&mut self, buf: &mut [u8]) -> Option<(uint, SocketAddr)> {
match (**self).recvfrom(buf) {
Ok((nread, src)) => Some((nread, src)),
Err(ioerr) => {
}
}
- pub fn sendto(&mut self, buf: &[u8], dst: IpAddr) {
+ pub fn sendto(&mut self, buf: &[u8], dst: SocketAddr) {
match (**self).sendto(buf, dst) {
Ok(_) => (),
Err(ioerr) => io_error::cond.raise(ioerr),
}
}
- pub fn connect(self, other: IpAddr) -> UdpStream {
+ pub fn connect(self, other: SocketAddr) -> UdpStream {
UdpStream { socket: self, connectedTo: other }
}
- pub fn socket_name(&mut self) -> Option<IpAddr> {
+ pub fn socket_name(&mut self) -> Option<SocketAddr> {
match (***self).socket_name() {
Ok(sn) => Some(sn),
Err(ioerr) => {
pub struct UdpStream {
socket: UdpSocket,
- connectedTo: IpAddr
+ connectedTo: SocketAddr
}
impl UdpStream {
mod test {
use super::*;
use rt::test::*;
- use rt::io::net::ip::Ipv4;
+ use rt::io::net::ip::{Ipv4Addr, SocketAddr};
use rt::io::*;
use option::{Some, None};
assert!(e.kind == PermissionDenied);
called = true;
}).inside {
- let addr = Ipv4(0, 0, 0, 0, 1);
+ let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
let socket = UdpSocket::bind(addr);
assert!(socket.is_none());
}
}
#[cfg(test)]
- fn socket_name(addr: IpAddr) {
+ fn socket_name(addr: SocketAddr) {
do run_in_newsched_task {
do spawntask {
let server = UdpSocket::bind(addr);
let on_exit: ~fn(bool) = |exit_success| {
let mut handles = handles.take();
- foreach handle in handles.mut_iter() {
+ for handle in handles.mut_iter() {
handle.send(Shutdown);
}
rtdebug!("waiting for threads");
// Wait for schedulers
- foreach thread in threads.consume_iter() {
+ for thread in threads.consume_iter() {
thread.join();
}
use result::*;
use rt::io::IoError;
-use super::io::net::ip::IpAddr;
+use super::io::net::ip::{IpAddr, SocketAddr};
use rt::uv::uvio;
// XXX: ~object doesn't work currently so these are some placeholder
}
pub trait IoFactory {
- fn tcp_connect(&mut self, addr: IpAddr) -> Result<~RtioTcpStreamObject, IoError>;
- fn tcp_bind(&mut self, addr: IpAddr) -> Result<~RtioTcpListenerObject, IoError>;
- fn udp_bind(&mut self, addr: IpAddr) -> Result<~RtioUdpSocketObject, IoError>;
+ fn tcp_connect(&mut self, addr: SocketAddr) -> Result<~RtioTcpStreamObject, IoError>;
+ fn tcp_bind(&mut self, addr: SocketAddr) -> Result<~RtioTcpListenerObject, IoError>;
+ fn udp_bind(&mut self, addr: SocketAddr) -> Result<~RtioUdpSocketObject, IoError>;
fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError>;
}
pub trait RtioTcpStream : RtioSocket {
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
- fn peer_name(&mut self) -> Result<IpAddr, IoError>;
+ fn peer_name(&mut self) -> Result<SocketAddr, IoError>;
fn control_congestion(&mut self) -> Result<(), IoError>;
fn nodelay(&mut self) -> Result<(), IoError>;
fn keepalive(&mut self, delay_in_seconds: uint) -> Result<(), IoError>;
}
pub trait RtioSocket {
- fn socket_name(&mut self) -> Result<IpAddr, IoError>;
+ fn socket_name(&mut self) -> Result<SocketAddr, IoError>;
}
pub trait RtioUdpSocket : RtioSocket {
- fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError>;
- fn sendto(&mut self, buf: &[u8], dst: IpAddr) -> Result<(), IoError>;
+ fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, SocketAddr), IoError>;
+ fn sendto(&mut self, buf: &[u8], dst: SocketAddr) -> Result<(), IoError>;
fn join_multicast(&mut self, multi: IpAddr) -> Result<(), IoError>;
fn leave_multicast(&mut self, multi: IpAddr) -> Result<(), IoError>;
let mut task_run_count = 0;
let task_run_count_ptr: *mut uint = &mut task_run_count;
do run_in_newsched_task || {
- foreach _ in range(0u, total) {
+ for _ in range(0u, total) {
do spawntask || {
unsafe { *task_run_count_ptr = *task_run_count_ptr + 1};
}
#[test]
fn test_stress_schedule_task_states() {
let n = stress_factor() * 120;
- foreach _ in range(0, n as int) {
+ for _ in range(0, n as int) {
test_schedule_home_states();
}
}
fail!("can't select on an empty list");
}
- foreach (index, port) in ports.mut_iter().enumerate() {
+ for (index, port) in ports.mut_iter().enumerate() {
if port.optimistic_check() {
return index;
}
do sched.deschedule_running_task_and_then |sched, task| {
let task_handles = task.make_selectable(ports.len());
- foreach (index, (port, task_handle)) in
+ for (index, (port, task_handle)) in
ports.mut_iter().zip(task_handles.consume_iter()).enumerate() {
// If one of the ports has data by now, it will wake the handle.
if port.block_on(sched, task_handle) {
// Task resumes. Now unblock ourselves from all the ports we blocked on.
// If the success index wasn't reset, 'take' will just take all of them.
// Iterate in reverse so the 'earliest' index that's ready gets returned.
- foreach (index, port) in ports.mut_slice(0, ready_index).mut_rev_iter().enumerate() {
+ for (index, port) in ports.mut_slice(0, ready_index).mut_rev_iter().enumerate() {
if port.unblock_from() {
ready_index = index;
}
let (ports, chans) = unzip(from_fn(num_ports, |_| oneshot::<()>()));
let mut dead_chans = ~[];
let mut ports = ports;
- foreach (i, chan) in chans.consume_iter().enumerate() {
+ for (i, chan) in chans.consume_iter().enumerate() {
if send_on_chans.contains(&i) {
chan.send(());
} else {
let (ports, chans) = unzip(from_fn(num_ports, |_| stream::<()>()));
let mut dead_chans = ~[];
let mut ports = ports;
- foreach (i, chan) in chans.consume_iter().enumerate() {
+ for (i, chan) in chans.consume_iter().enumerate() {
if send_on_chans.contains(&i) {
chan.send(());
} else {
let mut ports = ports;
let mut port = Some(port);
let order = [5u,0,4,3,2,6,9,8,7,1];
- foreach &index in order.iter() {
+ for &index in order.iter() {
// put the port in the vector at any index
util::swap(port.get_mut_ref(), &mut ports[index]);
assert!(select(ports) == index);
let send_on_chans = send_on_chans.clone();
do task::spawn {
let mut ports = ~[];
- foreach i in range(0u, NUM_CHANS) {
+ for i in range(0u, NUM_CHANS) {
let (p,c) = oneshot();
ports.push(p);
if send_on_chans.contains(&i) {
use rt::sched::{Scheduler, SchedHandle};
use rt::stack::{StackSegment, StackPool};
use rt::context::Context;
+use unstable::finally::Finally;
use task::spawn::Taskgroup;
use cell::Cell;
pub fn run(&mut self, f: &fn()) {
rtdebug!("run called on task: %u", borrow::to_uint(self));
- self.unwinder.try(f);
- // FIXME(#7544): We pass the taskgroup into death so that it can be
- // dropped while the unkillable counter is set. This should not be
- // necessary except for an extraneous clone() in task/spawn.rs that
- // causes a killhandle to get dropped, which mustn't receive a kill
- // signal since we're outside of the unwinder's try() scope.
- // { let _ = self.taskgroup.take(); }
- self.death.collect_failure(!self.unwinder.unwinding, self.taskgroup.take());
- self.destroy();
- }
- /// must be called manually before finalization to clean up
- /// thread-local resources. Some of the routines here expect
- /// Task to be available recursively so this must be
- /// called unsafely, without removing Task from
- /// thread-local-storage.
- fn destroy(&mut self) {
+ // The only try/catch block in the world. Attempt to run the task's
+ // client-specified code and catch any failures.
+ do self.unwinder.try {
- rtdebug!("DESTROYING TASK: %u", borrow::to_uint(self));
+ // Run the task main function, then do some cleanup.
+ do f.finally {
- do Local::borrow::<Task, ()> |task| {
- assert!(borrow::ref_eq(task, self));
- }
+ // Destroy task-local storage. This may run user dtors.
+ match self.storage {
+ LocalStorage(ptr, Some(ref dtor)) => {
+ (*dtor)(ptr)
+ }
+ _ => ()
+ }
- match self.storage {
- LocalStorage(ptr, Some(ref dtor)) => {
- (*dtor)(ptr)
+ // Destroy remaining boxes. Also may run user dtors.
+ unsafe { cleanup::annihilate(); }
}
- _ => ()
}
- // Destroy remaining boxes
- unsafe { cleanup::annihilate(); }
-
+ // FIXME(#7544): We pass the taskgroup into death so that it can be
+ // dropped while the unkillable counter is set. This should not be
+ // necessary except for an extraneous clone() in task/spawn.rs that
+ // causes a killhandle to get dropped, which mustn't receive a kill
+ // signal since we're outside of the unwinder's try() scope.
+ // { let _ = self.taskgroup.take(); }
+ self.death.collect_failure(!self.unwinder.unwinding, self.taskgroup.take());
self.destroyed = true;
}
use container::Container;
use iterator::{Iterator, range};
use vec::{OwnedVector, MutableVector};
-use super::io::net::ip::{IpAddr, Ipv4, Ipv6};
+use super::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
use rt::sched::Scheduler;
use unstable::run_in_bare_thread;
use rt::thread::Thread;
let mut handles = ~[];
let mut scheds = ~[];
- foreach _ in range(0u, nthreads) {
+ for _ in range(0u, nthreads) {
let loop_ = ~UvEventLoop::new();
let mut sched = ~Scheduler::new(loop_,
work_queue.clone(),
let on_exit: ~fn(bool) = |exit_status| {
let mut handles = handles.take();
// Tell schedulers to exit
- foreach handle in handles.mut_iter() {
+ for handle in handles.mut_iter() {
handle.send(Shutdown);
}
}
// Wait for schedulers
- foreach thread in threads.consume_iter() {
+ for thread in threads.consume_iter() {
thread.join();
}
}
}
/// Get a unique IPv4 localhost:port pair starting at 9600
-pub fn next_test_ip4() -> IpAddr {
- Ipv4(127, 0, 0, 1, next_test_port())
+pub fn next_test_ip4() -> SocketAddr {
+ SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: next_test_port() }
}
/// Get a unique IPv6 localhost:port pair starting at 9600
-pub fn next_test_ip6() -> IpAddr {
- Ipv6(0, 0, 0, 0, 0, 0, 0, 1, next_test_port())
+pub fn next_test_ip6() -> SocketAddr {
+ SocketAddr { ip: Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 1), port: next_test_port() }
}
/*
let mut final_base = base;
- foreach &(dir, base) in bases.iter() {
+ for &(dir, base) in bases.iter() {
if path.contains(dir) {
final_base = base;
break;
sched.enqueue_blocked_task(task);
}
- foreach i in range(0, MAX) {
+ for i in range(0, MAX) {
let j = tube.recv();
assert!(j == i);
}
use cast::transmute;
use ptr::null;
use unstable::finally::Finally;
-use rt::io::net::ip::IpAddr;
+use rt::io::net::ip::SocketAddr;
use rt::io::IoError;
pub type FsCallback = ~fn(FsRequest, Option<UvError>);
pub type TimerCallback = ~fn(TimerWatcher, Option<UvError>);
pub type AsyncCallback = ~fn(AsyncWatcher, Option<UvError>);
-pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, IpAddr, uint, Option<UvError>);
+pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, SocketAddr, uint, Option<UvError>);
pub type UdpSendCallback = ~fn(UdpWatcher, Option<UvError>);
use rt::uv::{AllocCallback, ConnectionCallback, ReadCallback, UdpReceiveCallback, UdpSendCallback};
use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle, NullCallback,
status_to_maybe_uv_error};
-use rt::io::net::ip::{IpAddr, Ipv4, Ipv6};
+use rt::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
use rt::uv::last_uv_error;
use vec;
use str;
use from_str::{FromStr};
use num;
-pub enum UvIpAddr {
- UvIpv4(*sockaddr_in),
- UvIpv6(*sockaddr_in6),
+pub enum UvSocketAddr {
+ UvIpv4SocketAddr(*sockaddr_in),
+ UvIpv6SocketAddr(*sockaddr_in6),
}
-fn sockaddr_to_UvIpAddr(addr: *uvll::sockaddr) -> UvIpAddr {
+fn sockaddr_to_UvSocketAddr(addr: *uvll::sockaddr) -> UvSocketAddr {
unsafe {
assert!((is_ip4_addr(addr) || is_ip6_addr(addr)));
assert!(!(is_ip4_addr(addr) && is_ip6_addr(addr)));
match addr {
- _ if is_ip4_addr(addr) => UvIpv4(addr as *uvll::sockaddr_in),
- _ if is_ip6_addr(addr) => UvIpv6(addr as *uvll::sockaddr_in6),
+ _ if is_ip4_addr(addr) => UvIpv4SocketAddr(addr as *uvll::sockaddr_in),
+ _ if is_ip6_addr(addr) => UvIpv6SocketAddr(addr as *uvll::sockaddr_in6),
_ => fail!(),
}
}
}
-fn ip_as_uv_ip<T>(addr: IpAddr, f: &fn(UvIpAddr) -> T) -> T {
- let malloc = match addr {
- Ipv4(*) => malloc_ip4_addr,
- Ipv6(*) => malloc_ip6_addr,
+fn socket_addr_as_uv_socket_addr<T>(addr: SocketAddr, f: &fn(UvSocketAddr) -> T) -> T {
+ let malloc = match addr.ip {
+ Ipv4Addr(*) => malloc_ip4_addr,
+ Ipv6Addr(*) => malloc_ip6_addr,
};
- let wrap = match addr {
- Ipv4(*) => UvIpv4,
- Ipv6(*) => UvIpv6,
+ let wrap = match addr.ip {
+ Ipv4Addr(*) => UvIpv4SocketAddr,
+ Ipv6Addr(*) => UvIpv6SocketAddr,
};
- let ip_str = match addr {
- Ipv4(x1, x2, x3, x4, _) =>
- fmt!("%u.%u.%u.%u", x1 as uint, x2 as uint, x3 as uint, x4 as uint),
- Ipv6(x1, x2, x3, x4, x5, x6, x7, x8, _) =>
- fmt!("%x:%x:%x:%x:%x:%x:%x:%x",
- x1 as uint, x2 as uint, x3 as uint, x4 as uint,
- x5 as uint, x6 as uint, x7 as uint, x8 as uint),
- };
- let port = match addr {
- Ipv4(_, _, _, _, p) | Ipv6(_, _, _, _, _, _, _, _, p) => p as int
- };
- let free = match addr {
- Ipv4(*) => free_ip4_addr,
- Ipv6(*) => free_ip6_addr,
+ let free = match addr.ip {
+ Ipv4Addr(*) => free_ip4_addr,
+ Ipv6Addr(*) => free_ip6_addr,
};
- let addr = unsafe { malloc(ip_str, port) };
+ let addr = unsafe { malloc(addr.ip.to_str(), addr.port as int) };
do (|| {
f(wrap(addr))
}).finally {
}
}
-fn uv_ip_as_ip<T>(addr: UvIpAddr, f: &fn(IpAddr) -> T) -> T {
+fn uv_socket_addr_as_socket_addr<T>(addr: UvSocketAddr, f: &fn(SocketAddr) -> T) -> T {
let ip_size = match addr {
- UvIpv4(*) => 4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/,
- UvIpv6(*) => 8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/,
+ UvIpv4SocketAddr(*) => 4/*groups of*/ * 3/*digits separated by*/ + 3/*periods*/,
+ UvIpv6SocketAddr(*) => 8/*groups of*/ * 4/*hex digits separated by*/ + 7 /*colons*/,
};
let ip_name = {
let buf = vec::from_elem(ip_size + 1 /*null terminated*/, 0u8);
unsafe {
+ let buf_ptr = vec::raw::to_ptr(buf);
match addr {
- UvIpv4(addr) => uvll::ip4_name(addr, vec::raw::to_ptr(buf), ip_size as size_t),
- UvIpv6(addr) => uvll::ip6_name(addr, vec::raw::to_ptr(buf), ip_size as size_t),
+ UvIpv4SocketAddr(addr) => uvll::ip4_name(addr, buf_ptr, ip_size as size_t),
+ UvIpv6SocketAddr(addr) => uvll::ip6_name(addr, buf_ptr, ip_size as size_t),
}
};
buf
};
let ip_port = unsafe {
let port = match addr {
- UvIpv4(addr) => uvll::ip4_port(addr),
- UvIpv6(addr) => uvll::ip6_port(addr),
+ UvIpv4SocketAddr(addr) => uvll::ip4_port(addr),
+ UvIpv6SocketAddr(addr) => uvll::ip6_port(addr),
};
port as u16
};
let ip_str = str::from_bytes_slice(ip_name).trim_right_chars(&'\x00');
let ip = match addr {
- UvIpv4(*) => {
+ UvIpv4SocketAddr(*) => {
let ip: ~[u8] =
ip_str.split_iter('.')
.transform(|s: &str| -> u8 { FromStr::from_str(s).unwrap() })
.collect();
assert_eq!(ip.len(), 4);
- Ipv4(ip[0], ip[1], ip[2], ip[3], ip_port)
+ SocketAddr {
+ ip: Ipv4Addr(ip[0], ip[1], ip[2], ip[3]),
+ port: ip_port
+ }
},
- UvIpv6(*) => {
+ UvIpv6SocketAddr(*) => {
let ip: ~[u16] = {
let expand_shorthand_and_convert = |s: &str| -> ~[~[u16]] {
let convert_each_segment = |s: &str| -> ~[u16] {
}
};
assert_eq!(ip.len(), 8);
- Ipv6(ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7], ip_port)
+ SocketAddr {
+ ip: Ipv6Addr(ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]),
+ port: ip_port
+ }
},
};
f(ip)
}
-pub fn uv_ip_to_ip(addr: UvIpAddr) -> IpAddr {
+pub fn uv_socket_addr_to_socket_addr(addr: UvSocketAddr) -> SocketAddr {
use util;
- uv_ip_as_ip(addr, util::id)
+ uv_socket_addr_as_socket_addr(addr, util::id)
}
#[cfg(test)]
fn test_ip4_conversion() {
use rt;
let ip4 = rt::test::next_test_ip4();
- assert_eq!(ip4, ip_as_uv_ip(ip4, uv_ip_to_ip));
+ assert_eq!(ip4, socket_addr_as_uv_socket_addr(ip4, uv_socket_addr_to_socket_addr));
}
#[cfg(test)]
fn test_ip6_conversion() {
use rt;
let ip6 = rt::test::next_test_ip6();
- assert_eq!(ip6, ip_as_uv_ip(ip6, uv_ip_to_ip));
+ assert_eq!(ip6, socket_addr_as_uv_socket_addr(ip6, uv_socket_addr_to_socket_addr));
}
// uv_stream_t is the parent class of uv_tcp_t, uv_pipe_t, uv_tty_t
}
}
- pub fn bind(&mut self, address: IpAddr) -> Result<(), UvError> {
- do ip_as_uv_ip(address) |addr| {
+ pub fn bind(&mut self, address: SocketAddr) -> Result<(), UvError> {
+ do socket_addr_as_uv_socket_addr(address) |addr| {
let result = unsafe {
match addr {
- UvIpv4(addr) => uvll::tcp_bind(self.native_handle(), addr),
- UvIpv6(addr) => uvll::tcp_bind6(self.native_handle(), addr),
+ UvIpv4SocketAddr(addr) => uvll::tcp_bind(self.native_handle(), addr),
+ UvIpv6SocketAddr(addr) => uvll::tcp_bind6(self.native_handle(), addr),
}
};
match result {
}
}
- pub fn connect(&mut self, address: IpAddr, cb: ConnectionCallback) {
+ pub fn connect(&mut self, address: SocketAddr, cb: ConnectionCallback) {
unsafe {
assert!(self.get_watcher_data().connect_cb.is_none());
self.get_watcher_data().connect_cb = Some(cb);
let connect_handle = ConnectRequest::new().native_handle();
rtdebug!("connect_t: %x", connect_handle as uint);
- do ip_as_uv_ip(address) |addr| {
+ do socket_addr_as_uv_socket_addr(address) |addr| {
let result = match addr {
- UvIpv4(addr) => uvll::tcp_connect(connect_handle,
+ UvIpv4SocketAddr(addr) => uvll::tcp_connect(connect_handle,
self.native_handle(), addr, connect_cb),
- UvIpv6(addr) => uvll::tcp_connect6(connect_handle,
+ UvIpv6SocketAddr(addr) => uvll::tcp_connect6(connect_handle,
self.native_handle(), addr, connect_cb),
};
assert_eq!(0, result);
}
}
- pub fn bind(&mut self, address: IpAddr) -> Result<(), UvError> {
- do ip_as_uv_ip(address) |addr| {
+ pub fn bind(&mut self, address: SocketAddr) -> Result<(), UvError> {
+ do socket_addr_as_uv_socket_addr(address) |addr| {
let result = unsafe {
match addr {
- UvIpv4(addr) => uvll::udp_bind(self.native_handle(), addr, 0u32),
- UvIpv6(addr) => uvll::udp_bind6(self.native_handle(), addr, 0u32),
+ UvIpv4SocketAddr(addr) => uvll::udp_bind(self.native_handle(), addr, 0u32),
+ UvIpv6SocketAddr(addr) => uvll::udp_bind6(self.native_handle(), addr, 0u32),
}
};
match result {
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref();
let status = status_to_maybe_uv_error(udp_watcher, nread as c_int);
- let addr = uv_ip_to_ip(sockaddr_to_UvIpAddr(addr));
+ let addr = uv_socket_addr_to_socket_addr(sockaddr_to_UvSocketAddr(addr));
(*cb)(udp_watcher, nread as int, buf, addr, flags as uint, status);
}
}
unsafe { uvll::udp_recv_stop(self.native_handle()); }
}
- pub fn send(&mut self, buf: Buf, address: IpAddr, cb: UdpSendCallback) {
+ pub fn send(&mut self, buf: Buf, address: SocketAddr, cb: UdpSendCallback) {
{
let data = self.get_watcher_data();
assert!(data.udp_send_cb.is_none());
}
let req = UdpSendRequest::new();
- do ip_as_uv_ip(address) |addr| {
+ do socket_addr_as_uv_socket_addr(address) |addr| {
let result = unsafe {
match addr {
- UvIpv4(addr) => uvll::udp_send(req.native_handle(),
+ UvIpv4SocketAddr(addr) => uvll::udp_send(req.native_handle(),
self.native_handle(), [buf], addr, send_cb),
- UvIpv6(addr) => uvll::udp_send6(req.native_handle(),
+ UvIpv6SocketAddr(addr) => uvll::udp_send6(req.native_handle(),
self.native_handle(), [buf], addr, send_cb),
}
};
if status.is_none() {
rtdebug!("got %d bytes", nread);
let buf = buf.unwrap();
- foreach byte in buf.slice(0, nread as uint).iter() {
+ for byte in buf.slice(0, nread as uint).iter() {
assert!(*byte == count as u8);
rtdebug!("%u", *byte as uint);
count += 1;
rtdebug!("got %d bytes", nread);
let buf = buf.unwrap();
let r = buf.slice(0, nread as uint);
- foreach byte in r.iter() {
+ for byte in r.iter() {
assert!(*byte == count as u8);
rtdebug!("%u", *byte as uint);
count += 1;
rtdebug!("got %d bytes", nread);
let buf = buf.unwrap();
- foreach &byte in buf.slice(0, nread as uint).iter() {
+ for &byte in buf.slice(0, nread as uint).iter() {
assert!(byte == count as u8);
rtdebug!("%u", byte as uint);
count += 1;
rtdebug!("got %d bytes", nread);
let buf = buf.unwrap();
- foreach &byte in buf.slice(0, nread as uint).iter() {
+ for &byte in buf.slice(0, nread as uint).iter() {
assert!(byte == count as u8);
rtdebug!("%u", byte as uint);
count += 1;
use ptr;
use result::*;
use rt::io::IoError;
-use rt::io::net::ip::{IpAddr, Ipv4, Ipv6};
+use rt::io::net::ip::{SocketAddr, IpAddr};
use rt::io::{standard_error, OtherIoError};
use rt::local::Local;
use rt::rtio::*;
use rt::tube::Tube;
use rt::uv::*;
use rt::uv::idle::IdleWatcher;
-use rt::uv::net::{UvIpv4, UvIpv6};
+use rt::uv::net::{UvIpv4SocketAddr, UvIpv6SocketAddr};
use unstable::sync::Exclusive;
#[cfg(test)] use container::Container;
}
fn socket_name<T, U: Watcher + NativeHandle<*T>>(sk: SocketNameKind,
- handle: U) -> Result<IpAddr, IoError> {
+ handle: U) -> Result<SocketAddr, IoError> {
let getsockname = match sk {
TcpPeer => uvll::rust_uv_tcp_getpeername,
let addr = unsafe {
if uvll::is_ip6_addr(r_addr as *uvll::sockaddr) {
- net::uv_ip_to_ip(UvIpv6(r_addr as *uvll::sockaddr_in6))
+ net::uv_socket_addr_to_socket_addr(UvIpv6SocketAddr(r_addr as *uvll::sockaddr_in6))
} else {
- net::uv_ip_to_ip(UvIpv4(r_addr as *uvll::sockaddr_in))
+ net::uv_socket_addr_to_socket_addr(UvIpv4SocketAddr(r_addr as *uvll::sockaddr_in))
}
};
// Connect to an address and return a new stream
// NB: This blocks the task waiting on the connection.
// It would probably be better to return a future
- fn tcp_connect(&mut self, addr: IpAddr) -> Result<~RtioTcpStreamObject, IoError> {
+ fn tcp_connect(&mut self, addr: SocketAddr) -> Result<~RtioTcpStreamObject, IoError> {
// Create a cell in the task to hold the result. We will fill
// the cell before resuming the task.
let result_cell = Cell::new_empty();
return result_cell.take();
}
- fn tcp_bind(&mut self, addr: IpAddr) -> Result<~RtioTcpListenerObject, IoError> {
+ fn tcp_bind(&mut self, addr: SocketAddr) -> Result<~RtioTcpListenerObject, IoError> {
let mut watcher = TcpWatcher::new(self.uv_loop());
match watcher.bind(addr) {
Ok(_) => Ok(~UvTcpListener::new(watcher)),
}
}
- fn udp_bind(&mut self, addr: IpAddr) -> Result<~RtioUdpSocketObject, IoError> {
+ fn udp_bind(&mut self, addr: SocketAddr) -> Result<~RtioUdpSocketObject, IoError> {
let mut watcher = UdpWatcher::new(self.uv_loop());
match watcher.bind(addr) {
Ok(_) => Ok(~UvUdpSocket(watcher)),
}
impl RtioSocket for UvTcpListener {
- fn socket_name(&mut self) -> Result<IpAddr, IoError> {
+ fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
socket_name(Tcp, self.watcher)
}
}
}
impl RtioSocket for UvTcpStream {
- fn socket_name(&mut self) -> Result<IpAddr, IoError> {
+ fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
socket_name(Tcp, **self)
}
}
return result_cell.take();
}
- fn peer_name(&mut self) -> Result<IpAddr, IoError> {
+ fn peer_name(&mut self) -> Result<SocketAddr, IoError> {
socket_name(TcpPeer, **self)
}
}
impl RtioSocket for UvUdpSocket {
- fn socket_name(&mut self) -> Result<IpAddr, IoError> {
+ fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
socket_name(Udp, **self)
}
}
impl RtioUdpSocket for UvUdpSocket {
- fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError> {
+ fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, SocketAddr), IoError> {
let result_cell = Cell::new_empty();
- let result_cell_ptr: *Cell<Result<(uint, IpAddr), IoError>> = &result_cell;
+ let result_cell_ptr: *Cell<Result<(uint, SocketAddr), IoError>> = &result_cell;
let scheduler = Local::take::<Scheduler>();
let buf_ptr: *&mut [u8] = &buf;
return result_cell.take();
}
- fn sendto(&mut self, buf: &[u8], dst: IpAddr) -> Result<(), IoError> {
+ fn sendto(&mut self, buf: &[u8], dst: SocketAddr) -> Result<(), IoError> {
let result_cell = Cell::new_empty();
let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
let scheduler = Local::take::<Scheduler>();
}
fn join_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
- let ip_str = match multi {
- Ipv4(x1, x2, x3, x4, _) =>
- fmt!("%u.%u.%u.%u", x1 as uint, x2 as uint, x3 as uint, x4 as uint),
- Ipv6(x1, x2, x3, x4, x5, x6, x7, x8, _) =>
- fmt!("%x:%x:%x:%x:%x:%x:%x:%x",
- x1 as uint, x2 as uint, x3 as uint, x4 as uint,
- x5 as uint, x6 as uint, x7 as uint, x8 as uint),
- };
-
let r = unsafe {
- do ip_str.to_c_str().with_ref |m_addr| {
+ do multi.to_str().to_c_str().with_ref |m_addr| {
uvll::udp_set_membership(self.native_handle(), m_addr,
ptr::null(), uvll::UV_JOIN_GROUP)
}
}
fn leave_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
- let ip_str = match multi {
- Ipv4(x1, x2, x3, x4, _) =>
- fmt!("%u.%u.%u.%u", x1 as uint, x2 as uint, x3 as uint, x4 as uint),
- Ipv6(x1, x2, x3, x4, x5, x6, x7, x8, _) =>
- fmt!("%x:%x:%x:%x:%x:%x:%x:%x",
- x1 as uint, x2 as uint, x3 as uint, x4 as uint,
- x5 as uint, x6 as uint, x7 as uint, x8 as uint),
- };
-
let r = unsafe {
- do ip_str.to_c_str().with_ref |m_addr| {
+ do multi.to_str().to_c_str().with_ref |m_addr| {
uvll::udp_set_membership(self.native_handle(), m_addr,
ptr::null(), uvll::UV_LEAVE_GROUP)
}
let mut buf = [0, .. 2048];
let nread = stream.read(buf).unwrap();
assert_eq!(nread, 8);
- foreach i in range(0u, nread) {
+ for i in range(0u, nread) {
rtdebug!("%u", buf[i] as uint);
assert_eq!(buf[i], i as u8);
}
let mut buf = [0, .. 2048];
let (nread,src) = server_socket.recvfrom(buf).unwrap();
assert_eq!(nread, 8);
- foreach i in range(0u, nread) {
+ for i in range(0u, nread) {
rtdebug!("%u", buf[i] as uint);
assert_eq!(buf[i], i as u8);
}
while current < expected {
let nread = stream.read(buf).unwrap();
- foreach i in range(0u, nread) {
+ for i in range(0u, nread) {
let val = buf[i] as uint;
assert_eq!(val, current % 8);
current += 1;
let nread = stream.read(buf).unwrap();
rtdebug!("read %u bytes", nread as uint);
total_bytes_read += nread;
- foreach i in range(0u, nread) {
+ for i in range(0u, nread) {
assert_eq!(buf[i], 1);
}
}
let (nread, src) = res.unwrap();
assert_eq!(src, server_out_addr);
total_bytes_recv += nread;
- foreach i in range(0u, nread) {
+ for i in range(0u, nread) {
assert_eq!(buf[i], 1);
}
}
in_fd, out_fd, err_fd);
unsafe {
- foreach pipe in in_pipe.iter() { libc::close(pipe.input); }
- foreach pipe in out_pipe.iter() { libc::close(pipe.out); }
- foreach pipe in err_pipe.iter() { libc::close(pipe.out); }
+ for pipe in in_pipe.iter() { libc::close(pipe.input); }
+ for pipe in out_pipe.iter() { libc::close(pipe.out); }
+ for pipe in err_pipe.iter() { libc::close(pipe.out); }
}
Process {
* If the child has already been finished then the exit code is returned.
*/
pub fn finish(&mut self) -> int {
- foreach &code in self.exit_code.iter() {
+ for &code in self.exit_code.iter() {
return code;
}
self.close_input();
CloseHandle(si.hStdOutput);
CloseHandle(si.hStdError);
- foreach msg in create_err.iter() {
+ for msg in create_err.iter() {
fail!("failure in CreateProcess: %s", *msg);
}
pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
let mut cmd = ~"";
append_arg(&mut cmd, prog);
- foreach arg in args.iter() {
+ for arg in args.iter() {
cmd.push_char(' ');
append_arg(&mut cmd, *arg);
}
if quote {
cmd.push_char('"');
}
- foreach i in range(0u, arg.len()) {
+ for i in range(0u, arg.len()) {
append_char_at(cmd, arg, i);
}
if quote {
tmps.push(prog.to_c_str());
- foreach arg in args.iter() {
+ for arg in args.iter() {
tmps.push(arg.to_c_str());
}
Some(env) => {
let mut tmps = vec::with_capacity(env.len());
- foreach pair in env.iter() {
+ for pair in env.iter() {
// Use of match here is just to workaround limitations
// in the stage0 irrefutable pattern impl.
let kv = fmt!("%s=%s", pair.first(), pair.second());
Some(env) => {
let mut blk = ~[];
- foreach pair in env.iter() {
+ for pair in env.iter() {
let kv = fmt!("%s=%s", pair.first(), pair.second());
blk.push_all(kv.as_bytes());
blk.push(0);
let output = str::from_bytes(prog.finish_with_output().output);
let r = os::env();
- foreach &(ref k, ref v) in r.iter() {
+ for &(ref k, ref v) in r.iter() {
// don't check windows magical empty-named variables
assert!(k.is_empty() || output.contains(fmt!("%s=%s", *k, *v)));
}
let output = str::from_bytes(prog.finish_with_output().output);
let r = os::env();
- foreach &(k, v) in r.iter() {
+ for &(k, v) in r.iter() {
// don't check android RANDOM variables
if k != ~"RANDOM" {
assert!(output.contains(fmt!("%s=%s", k, v)) ||
pub fn from_chars(chs: &[char]) -> ~str {
let mut buf = ~"";
buf.reserve(chs.len());
- foreach ch in chs.iter() {
+ for ch in chs.iter() {
buf.push_char(*ch)
}
buf
unsafe {
do s.as_mut_buf |buf, _| {
let mut buf = buf;
- foreach ss in self.iter() {
+ for ss in self.iter() {
do ss.as_slice().as_imm_buf |ssbuf, sslen| {
let sslen = sslen - 1;
ptr::copy_memory(buf, ssbuf, sslen);
unsafe {
do s.as_mut_buf |buf, _| {
let mut buf = buf;
- foreach ss in self.iter() {
+ for ss in self.iter() {
do ss.as_slice().as_imm_buf |ssbuf, sslen| {
ptr::copy_memory(buf, ssbuf, sslen);
buf = buf.offset(sslen as int);
do sep.as_imm_buf |sepbuf, seplen| {
let seplen = seplen - 1;
let mut buf = cast::transmute_mut_unsafe(buf);
- foreach ss in self.iter() {
+ for ss in self.iter() {
do ss.as_slice().as_imm_buf |ssbuf, sslen| {
let sslen = sslen - 1;
if first {
do s.as_mut_buf |buf, _| {
do sep.as_imm_buf |sepbuf, seplen| {
let mut buf = buf;
- foreach ss in self.iter() {
+ for ss in self.iter() {
do ss.as_slice().as_imm_buf |ssbuf, sslen| {
if first {
first = false;
pub fn replace(s: &str, from: &str, to: &str) -> ~str {
let mut result = ~"";
let mut last_end = 0;
- foreach (start, end) in s.matches_index_iter(from) {
+ for (start, end) in s.matches_index_iter(from) {
result.push_str(unsafe{raw::slice_bytes(s, last_end, start)});
result.push_str(to);
last_end = end;
// Utility used by various searching functions
fn match_at<'a,'b>(haystack: &'a str, needle: &'b str, at: uint) -> bool {
let mut i = at;
- foreach c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
+ for c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
return true;
}
Section: Misc
*/
-// Return the initial codepoint accumulator for the first byte.
-// The first byte is special, only want bottom 5 bits for width 2, 4 bits
-// for width 3, and 3 bits for width 4
-macro_rules! utf8_first_byte(
- ($byte:expr, $width:expr) => (($byte & (0x7F >> $width)) as uint)
-)
-
-// return the value of $ch updated with continuation byte $byte
-macro_rules! utf8_acc_cont_byte(
- ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as uint)
-)
-
/// Determines if a vector of bytes contains valid UTF-8
pub fn is_utf8(v: &[u8]) -> bool {
let mut i = 0u;
let total = v.len();
+ fn unsafe_get(xs: &[u8], i: uint) -> u8 {
+ unsafe { *xs.unsafe_ref(i) }
+ }
while i < total {
- if v[i] < 128u8 {
+ let v_i = unsafe_get(v, i);
+ if v_i < 128u8 {
i += 1u;
} else {
- let w = utf8_char_width(v[i]);
+ let w = utf8_char_width(v_i);
if w == 0u { return false; }
let nexti = i + w;
if nexti > total { return false; }
- // 1. Make sure the correct number of continuation bytes are present
- // 2. Check codepoint ranges (deny overlong encodings)
- // 2-byte encoding is for codepoints \u0080 to \u07ff
- // 3-byte encoding is for codepoints \u0800 to \uffff
- // 4-byte encoding is for codepoints \u10000 to \u10ffff
-
- // 2-byte encodings are correct if the width and continuation match up
- if v[i + 1] & 192u8 != TAG_CONT_U8 { return false; }
- if w > 2 {
- let mut ch;
- ch = utf8_first_byte!(v[i], w);
- ch = utf8_acc_cont_byte!(ch, v[i + 1]);
- if v[i + 2] & 192u8 != TAG_CONT_U8 { return false; }
- ch = utf8_acc_cont_byte!(ch, v[i + 2]);
- if w == 3 && ch < MAX_TWO_B { return false; }
- if w > 3 {
- if v[i + 3] & 192u8 != TAG_CONT_U8 { return false; }
- ch = utf8_acc_cont_byte!(ch, v[i + 3]);
- if ch < MAX_THREE_B || ch >= MAX_UNICODE { return false; }
- }
+
+ // 2-byte encoding is for codepoints \u0080 to \u07ff
+ // first C2 80 last DF BF
+ // 3-byte encoding is for codepoints \u0800 to \uffff
+ // first E0 A0 80 last EF BF BF
+ // 4-byte encoding is for codepoints \u10000 to \u10ffff
+ // first F0 90 80 80 last F4 8F BF BF
+ //
+ // Use the UTF-8 syntax from the RFC
+ //
+ // https://tools.ietf.org/html/rfc3629
+ // UTF8-1 = %x00-7F
+ // UTF8-2 = %xC2-DF UTF8-tail
+ // UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
+ // %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
+ // UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
+ // %xF4 %x80-8F 2( UTF8-tail )
+ // UTF8-tail = %x80-BF
+ // --
+ // This code allows surrogate pairs: \uD800 to \uDFFF -> ED A0 80 to ED BF BF
+ match w {
+ 2 => if unsafe_get(v, i + 1) & 192u8 != TAG_CONT_U8 {
+ return false
+ },
+ 3 => match (v_i,
+ unsafe_get(v, i + 1),
+ unsafe_get(v, i + 2) & 192u8) {
+ (0xE0 , 0xA0 .. 0xBF, TAG_CONT_U8) => (),
+ (0xE1 .. 0xEF, 0x80 .. 0xBF, TAG_CONT_U8) => (),
+ _ => return false,
+ },
+ _ => match (v_i,
+ unsafe_get(v, i + 1),
+ unsafe_get(v, i + 2) & 192u8,
+ unsafe_get(v, i + 3) & 192u8) {
+ (0xF0 , 0x90 .. 0xBF, TAG_CONT_U8, TAG_CONT_U8) => (),
+ (0xF1 .. 0xF3, 0x80 .. 0xBF, TAG_CONT_U8, TAG_CONT_U8) => (),
+ (0xF4 , 0x80 .. 0x8F, TAG_CONT_U8, TAG_CONT_U8) => (),
+ _ => return false,
+ },
}
i = nexti;
next: uint
}
+// Return the initial codepoint accumulator for the first byte.
+// The first byte is special, only want bottom 5 bits for width 2, 4 bits
+// for width 3, and 3 bits for width 4
+macro_rules! utf8_first_byte(
+ ($byte:expr, $width:expr) => (($byte & (0x7F >> $width)) as uint)
+)
+
+// return the value of $ch updated with continuation byte $byte
+macro_rules! utf8_acc_cont_byte(
+ ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as uint)
+)
+
// UTF-8 tags and ranges
priv static TAG_CONT_U8: u8 = 128u8;
priv static TAG_CONT: uint = 128u;
unsafe fn push_bytes(s: &mut ~str, bytes: &[u8]) {
let new_len = s.len() + bytes.len();
s.reserve_at_least(new_len);
- foreach byte in bytes.iter() { push_byte(&mut *s, *byte); }
+ for byte in bytes.iter() { push_byte(&mut *s, *byte); }
}
/// Removes the last byte from a string and returns it. (Not UTF-8 safe).
impl<'self> TotalOrd for &'self str {
#[inline]
fn cmp(&self, other: & &'self str) -> Ordering {
- foreach (s_b, o_b) in self.byte_iter().zip(other.byte_iter()) {
+ for (s_b, o_b) in self.byte_iter().zip(other.byte_iter()) {
match s_b.cmp(&o_b) {
Greater => return Greater,
Less => return Less,
fn escape_default(&self) -> ~str {
let mut out: ~str = ~"";
out.reserve_at_least(self.len());
- foreach c in self.iter() {
+ for c in self.iter() {
do c.escape_default |c| {
out.push_char(c);
}
fn escape_unicode(&self) -> ~str {
let mut out: ~str = ~"";
out.reserve_at_least(self.len());
- foreach c in self.iter() {
+ for c in self.iter() {
do c.escape_unicode |c| {
out.push_char(c);
}
pub fn replace(&self, from: &str, to: &str) -> ~str {
let mut result = ~"";
let mut last_end = 0;
- foreach (start, end) in self.matches_index_iter(from) {
+ for (start, end) in self.matches_index_iter(from) {
result.push_str(unsafe{raw::slice_bytes(*self, last_end, start)});
result.push_str(to);
last_end = end;
/// Converts to a vector of `u16` encoded as UTF-16.
fn to_utf16(&self) -> ~[u16] {
let mut u = ~[];
- foreach ch in self.iter() {
+ for ch in self.iter() {
// Arithmetic with u32 literals is easier on the eyes than chars.
let mut ch = ch as u32;
/// or `None` if there is no match
fn find<C: CharEq>(&self, search: C) -> Option<uint> {
if search.only_ascii() {
- foreach (i, b) in self.byte_iter().enumerate() {
+ for (i, b) in self.byte_iter().enumerate() {
if search.matches(b as char) { return Some(i) }
}
} else {
let mut index = 0;
- foreach c in self.iter() {
+ for c in self.iter() {
if search.matches(c) { return Some(index); }
index += c.len_utf8_bytes();
}
fn rfind<C: CharEq>(&self, search: C) -> Option<uint> {
let mut index = self.len();
if search.only_ascii() {
- foreach b in self.byte_rev_iter() {
+ for b in self.byte_rev_iter() {
index -= 1;
if search.matches(b as char) { return Some(index); }
}
} else {
- foreach c in self.rev_iter() {
+ for c in self.rev_iter() {
index -= c.len_utf8_bytes();
if search.matches(c) { return Some(index); }
}
/// Apply a function to each character.
fn map_chars(&self, ff: &fn(char) -> char) -> ~str {
let mut result = with_capacity(self.len());
- foreach cc in self.iter() {
+ for cc in self.iter() {
result.push_char(ff(cc));
}
result
let mut dcol = vec::from_fn(tlen + 1, |x| x);
- foreach (i, sc) in self.iter().enumerate() {
+ for (i, sc) in self.iter().enumerate() {
let mut current = i;
dcol[0] = current + 1;
- foreach (j, tc) in t.iter().enumerate() {
+ for (j, tc) in t.iter().enumerate() {
let next = dcol[j + 1];
/// ~~~ {.rust}
/// let string = "a\nb\nc";
/// let mut lines = ~[];
- /// foreach line in string.line_iter() { lines.push(line) }
+ /// for line in string.line_iter() { lines.push(line) }
///
/// assert!(string.subslice_offset(lines[0]) == 0); // &"a"
/// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
let (lower, _) = iterator.size_hint();
let reserve = lower + self.len();
self.reserve_at_least(reserve);
- foreach ch in *iterator {
+ for ch in *iterator {
self.push_char(ch)
}
}
}
#[test]
- fn test_is_utf8_deny_overlong() {
+ fn test_is_utf8() {
assert!(!is_utf8([0xc0, 0x80]));
assert!(!is_utf8([0xc0, 0xae]));
assert!(!is_utf8([0xe0, 0x80, 0x80]));
assert!(!is_utf8([0xe0, 0x80, 0xaf]));
assert!(!is_utf8([0xe0, 0x81, 0x81]));
assert!(!is_utf8([0xf0, 0x82, 0x82, 0xac]));
+ assert!(!is_utf8([0xf4, 0x90, 0x80, 0x80]));
+
+ assert!(is_utf8([0xC2, 0x80]));
+ assert!(is_utf8([0xDF, 0xBF]));
+ assert!(is_utf8([0xE0, 0xA0, 0x80]));
+ assert!(is_utf8([0xEF, 0xBF, 0xBF]));
+ assert!(is_utf8([0xF0, 0x90, 0x80, 0x80]));
+ assert!(is_utf8([0xF4, 0x8F, 0xBF, 0xBF]));
}
let string = "a\nb\nc";
let mut lines = ~[];
- foreach line in string.line_iter() { lines.push(line) }
+ for line in string.line_iter() { lines.push(line) }
assert_eq!(string.subslice_offset(lines[0]), 0);
assert_eq!(string.subslice_offset(lines[1]), 2);
assert_eq!(string.subslice_offset(lines[2]), 4);
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
0x000a_u16 ]) ];
- foreach p in pairs.iter() {
+ for p in pairs.iter() {
let (s, u) = (*p).clone();
assert!(s.to_utf16() == u);
assert!(from_utf16(u) == s);
let s = ~"ศไทย中华Việt Nam";
let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
- foreach ch in v.iter() {
+ for ch in v.iter() {
assert!(s.char_at(pos) == *ch);
pos += from_char(*ch).len();
}
let s = ~"ศไทย中华Việt Nam";
let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = s.len();
- foreach ch in v.rev_iter() {
+ for ch in v.rev_iter() {
assert!(s.char_at_reverse(pos) == *ch);
pos -= from_char(*ch).len();
}
let mut pos = 0;
let mut it = s.iter();
- foreach c in it {
+ for c in it {
assert_eq!(c, v[pos]);
pos += 1;
}
let mut pos = 0;
let mut it = s.rev_iter();
- foreach c in it {
+ for c in it {
assert_eq!(c, v[pos]);
pos += 1;
}
];
let mut pos = 0;
- foreach b in s.byte_iter() {
+ for b in s.byte_iter() {
assert_eq!(b, v[pos]);
pos += 1;
}
];
let mut pos = v.len();
- foreach b in s.byte_rev_iter() {
+ for b in s.byte_rev_iter() {
pos -= 1;
assert_eq!(b, v[pos]);
}
let mut pos = 0;
let mut it = s.char_offset_iter();
- foreach c in it {
+ for c in it {
assert_eq!(c, (p[pos], v[pos]));
pos += 1;
}
let mut pos = 0;
let mut it = s.char_offset_rev_iter();
- foreach c in it {
+ for c in it {
assert_eq!(c, (p[pos], v[pos]));
pos += 1;
}
#[inline]
fn is_ascii(&self) -> bool {
- foreach b in self.iter() {
+ for b in self.iter() {
if !b.is_ascii() { return false; }
}
true
let map = get_local_map(handle);
let key_value = key_to_key_value(key);
- foreach entry in map.mut_iter() {
+ for entry in map.mut_iter() {
match *entry {
Some((k, _, loan)) if k == key_value => {
if loan != NoLoan {
// safe to skip it. This will leave our TaskHandle
// hanging around in the group even after it's freed,
// but that's ok because, by virtue of the group being
- // dead, nobody will ever kill-all (foreach) over it.)
+ // dead, nobody will ever kill-all (for) over it.)
if nobe_is_dead { true } else { forward_blk(tg_opt) }
};
/*##########################################################*
// If we are failing, the whole taskgroup needs to die.
do RuntimeGlue::with_task_handle_and_failing |me, failing| {
if failing {
- foreach x in this.notifier.mut_iter() {
+ for x in this.notifier.mut_iter() {
x.failed = true;
}
// Take everybody down with us.
ancestors: AncestorList,
is_main: bool,
mut notifier: Option<AutoNotify>) -> Taskgroup {
- foreach x in notifier.mut_iter() {
+ for x in notifier.mut_iter() {
x.failed = false;
}
if newstate.is_some() {
let TaskGroupData { members: members, descendants: descendants } =
newstate.unwrap();
- foreach sibling in members.consume() {
+ for sibling in members.consume() {
// Skip self - killing ourself won't do much good.
if &sibling != me {
RuntimeGlue::kill_task(sibling);
}
}
- foreach child in descendants.consume() {
+ for child in descendants.consume() {
assert!(&child != me);
RuntimeGlue::kill_task(child);
}
fn to_str(&self) -> ~str {
let mut acc = ~"{";
let mut first = true;
- foreach (key, value) in self.iter() {
+ for (key, value) in self.iter() {
if first {
first = false;
}
fn to_str(&self) -> ~str {
let mut acc = ~"{";
let mut first = true;
- foreach element in self.iter() {
+ for element in self.iter() {
if first {
first = false;
}
fn to_str(&self) -> ~str {
let mut acc = ~"[";
let mut first = true;
- foreach elt in self.iter() {
+ for elt in self.iter() {
if first {
first = false;
}
fn to_str(&self) -> ~str {
let mut acc = ~"[";
let mut first = true;
- foreach elt in self.iter() {
+ for elt in self.iter() {
if first {
first = false;
}
fn to_str(&self) -> ~str {
let mut acc = ~"[";
let mut first = true;
- foreach elt in self.iter() {
+ for elt in self.iter() {
if first {
first = false;
}
}
impl<T> Map<uint, T> for TrieMap<T> {
- /// Return true if the map contains a value for the specified key
- #[inline]
- fn contains_key(&self, key: &uint) -> bool {
- self.find(key).is_some()
- }
-
/// Return a reference to the value corresponding to the key
#[inline]
fn find<'a>(&'a self, key: &uint) -> Option<&'a T> {
impl<T, Iter: Iterator<(uint, T)>> Extendable<(uint, T), Iter> for TrieMap<T> {
fn extend(&mut self, iter: &mut Iter) {
- foreach (k, v) in *iter {
+ for (k, v) in *iter {
self.insert(k, v);
}
}
impl<Iter: Iterator<uint>> Extendable<uint, Iter> for TrieSet {
fn extend(&mut self, iter: &mut Iter) {
- foreach elem in *iter {
+ for elem in *iter {
self.insert(elem);
}
}
impl<T> TrieNode<T> {
fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
- foreach idx in range(0u, self.children.len()) {
+ for idx in range(0u, self.children.len()) {
match self.children[idx] {
Internal(ref x) => if !x.each(|i,t| f(i,t)) { return false },
External(k, ref v) => if !f(&k, v) { return false },
}
fn mutate_values<'a>(&'a mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
- foreach child in self.children.mut_iter() {
+ for child in self.children.mut_iter() {
match *child {
Internal(ref mut x) => if !x.mutate_values(|i,t| f(i,t)) {
return false
let mut sum = 0;
- foreach x in trie.children.iter() {
+ for x in trie.children.iter() {
match *x {
Nothing => (),
Internal(ref y) => {
true
};
- foreach x in range(0u, n) {
+ for x in range(0u, n) {
assert!(trie.contains_key(&x));
assert!(!trie.insert(x, x + 1));
check_integrity(&trie.root);
let map: TrieMap<int> = xs.iter().transform(|&x| x).collect();
- foreach &(k, v) in xs.iter() {
+ for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
}
}
let set: TrieSet = xs.iter().transform(|&x| x).collect();
- foreach x in xs.iter() {
+ for x in xs.iter() {
assert!(set.contains(x));
}
}
*
* Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
*/
-#[inline] #[cfg(not(stage0))]
+#[inline]
pub fn fence(order: Ordering) {
unsafe {
match order {
let headsize = match head { Some(_) => 1, _ => 0 };
let uwidth : uint = match cv.width {
CountImplied => {
- foreach &c in head.iter() {
+ for &c in head.iter() {
buf.push_char(c);
}
return buf.push_str(s);
};
let strlen = s.char_len() + headsize;
if uwidth <= strlen {
- foreach &c in head.iter() {
+ for &c in head.iter() {
buf.push_char(c);
}
return buf.push_str(s);
let mut padchar = ' ';
let diff = uwidth - strlen;
if have_flag(cv.flags, flag_left_justify) {
- foreach &c in head.iter() {
+ for &c in head.iter() {
buf.push_char(c);
}
buf.push_str(s);
// instead.
if signed && zero_padding {
- foreach &head in head.iter() {
+ for &head in head.iter() {
if head == '+' || head == '-' || head == ' ' {
buf.push_char(head);
buf.push_str(padstr);
}
}
buf.push_str(padstr);
- foreach &c in head.iter() {
+ for &c in head.iter() {
buf.push_char(c);
}
buf.push_str(s);
pub fn atomic_umax_acqrel(dst: &mut int, src: int) -> int;
pub fn atomic_umax_relaxed(dst: &mut int, src: int) -> int;
- #[cfg(not(stage0))]
pub fn atomic_fence();
- #[cfg(not(stage0))]
pub fn atomic_fence_acq();
- #[cfg(not(stage0))]
pub fn atomic_fence_rel();
- #[cfg(not(stage0))]
pub fn atomic_fence_acqrel();
/// The size of a type in bytes.
///
/// This is implemented as an intrinsic to avoid converting to and from an
/// integer, since the conversion would throw away aliasing information.
- #[cfg(not(stage0))]
pub fn offset<T>(dst: *T, offset: int) -> *T;
/// Equivalent to the `llvm.memcpy.p0i8.0i8.i32` intrinsic, with a size of
let total = Exclusive::new(~0);
- foreach _ in range(0u, num_tasks) {
+ for _ in range(0u, num_tasks) {
let total = total.clone();
let (port, chan) = comm::stream();
futures.push(port);
do task::spawn || {
- foreach _ in range(0u, count) {
+ for _ in range(0u, count) {
do total.with |count| {
**count += 1;
}
}
};
- foreach f in futures.iter() { f.recv() }
+ for f in futures.iter() { f.recv() }
do total.with |total| {
assert!(**total == num_tasks * count)
*/
pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] {
let mut result = ~[];
- foreach elem in v.iter() { result.push_all_move(f(elem)); }
+ for elem in v.iter() { result.push_all_move(f(elem)); }
result
}
pub fn connect_vec(&self, sep: &T) -> ~[T] {
let mut r = ~[];
let mut first = true;
- foreach inner in self.iter() {
+ for inner in self.iter() {
if first { first = false; } else { r.push((*sep).clone()); }
r.push_all((*inner).clone());
}
pub fn connect_vec(&self, sep: &T) -> ~[T] {
let mut r = ~[];
let mut first = true;
- foreach &inner in self.iter() {
+ for &inner in self.iter() {
if first { first = false; } else { r.push((*sep).clone()); }
r.push_all(inner);
}
pub fn unzip_slice<T:Clone,U:Clone>(v: &[(T, U)]) -> (~[T], ~[U]) {
let mut ts = ~[];
let mut us = ~[];
- foreach p in v.iter() {
+ for p in v.iter() {
let (t, u) = (*p).clone();
ts.push(t);
us.push(u);
pub fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) {
let mut ts = ~[];
let mut us = ~[];
- foreach p in v.consume_iter() {
+ for p in v.consume_iter() {
let (t, u) = p;
ts.push(t);
us.push(u);
indices.swap(k, l);
indices.mut_slice(k+1, length).reverse();
// fixup permutation based on indices
- foreach i in range(k, length) {
+ for i in range(k, length) {
permutation[i] = values[indices[i]].clone();
}
}
impl<'self,T:TotalOrd> TotalOrd for &'self [T] {
fn cmp(&self, other: & &'self [T]) -> Ordering {
- foreach (s,o) in self.iter().zip(other.iter()) {
+ for (s,o) in self.iter().zip(other.iter()) {
match s.cmp(o) {
Equal => {},
non_eq => { return non_eq; }
impl<'self,T:Ord> Ord for &'self [T] {
fn lt(&self, other: & &'self [T]) -> bool {
- foreach (s,o) in self.iter().zip(other.iter()) {
+ for (s,o) in self.iter().zip(other.iter()) {
if *s < *o { return true; }
if *s > *o { return false; }
}
#[inline]
fn to_owned(&self) -> ~[T] {
let mut result = with_capacity(self.len());
- foreach e in self.iter() {
+ for e in self.iter() {
result.push((*e).clone());
}
result
*
* ~~~ {.rust}
* let v = &[1,2,3,4];
- * foreach win in v.window_iter() {
+ * for win in v.window_iter() {
* printfln!(win);
* }
* ~~~
*
* ~~~ {.rust}
* let v = &[1,2,3,4,5];
- * foreach win in v.chunk_iter() {
+ * for win in v.chunk_iter() {
* printfln!(win);
* }
* ~~~
*/
#[inline]
fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
- foreach (i, t) in self.rev_iter().enumerate() {
+ for (i, t) in self.rev_iter().enumerate() {
if f(t) { return Some(self.len() - i - 1); }
}
None
/// Return true if a vector contains an element with the given value
fn contains(&self, x: &T) -> bool {
- foreach elt in self.iter() { if *x == *elt { return true; } }
+ for elt in self.iter() { if *x == *elt { return true; } }
false
}
}
let mut lefts = ~[];
let mut rights = ~[];
- foreach elt in self.iter() {
+ for elt in self.iter() {
if f(elt) {
lefts.push((*elt).clone());
} else {
///
/// ~~~ {.rust}
/// let v = ~[~"a", ~"b"];
- /// foreach s in v.consume_iter() {
+ /// for s in v.consume_iter() {
/// // s has type ~str, not &~str
/// println(s);
/// }
assert!(newlen <= oldlen);
unsafe {
// This loop is optimized out for non-drop types.
- foreach i in range(newlen, oldlen) {
+ for i in range(newlen, oldlen) {
ptr::read_and_zero_ptr(ptr::mut_offset(p, i as int));
}
}
let len = self.len();
let mut deleted: uint = 0;
- foreach i in range(0u, len) {
+ for i in range(0u, len) {
if !f(&self[i]) {
deleted += 1;
} else if deleted > 0 {
let mut lefts = ~[];
let mut rights = ~[];
- foreach elt in self.consume_iter() {
+ for elt in self.consume_iter() {
if f(&elt) {
lefts.push(elt);
} else {
let new_len = self.len() + rhs.len();
self.reserve(new_len);
- foreach i in range(0u, rhs.len()) {
+ for i in range(0u, rhs.len()) {
self.push(unsafe { raw::get(rhs, i) })
}
}
#[inline]
fn move_from(self, mut src: ~[T], start: uint, end: uint) -> uint {
- foreach (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
+ for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
util::swap(a, b);
}
cmp::min(self.len(), end-start)
impl<'self, T:Clone> MutableCloneableVector<T> for &'self mut [T] {
#[inline]
fn copy_from(self, src: &[T]) -> uint {
- foreach (a, b) in self.mut_iter().zip(src.iter()) {
+ for (a, b) in self.mut_iter().zip(src.iter()) {
*a = b.clone();
}
cmp::min(self.len(), src.len())
fn from_iterator(iterator: &mut T) -> ~[A] {
let (lower, _) = iterator.size_hint();
let mut xs = with_capacity(lower);
- foreach x in *iterator {
+ for x in *iterator {
xs.push(x);
}
xs
let (lower, _) = iterator.size_hint();
let len = self.len();
self.reserve(len + lower);
- foreach x in *iterator {
+ for x in *iterator {
self.push(x);
}
}
fn test_mut_iterator() {
use iterator::*;
let mut xs = [1, 2, 3, 4, 5];
- foreach x in xs.mut_iter() {
+ for x in xs.mut_iter() {
*x += 1;
}
assert_eq!(xs, [2, 3, 4, 5, 6])
let xs = [1, 2, 5, 10, 11];
let ys = [11, 10, 5, 2, 1];
let mut i = 0;
- foreach &x in xs.rev_iter() {
+ for &x in xs.rev_iter() {
assert_eq!(x, ys[i]);
i += 1;
}
fn test_mut_rev_iterator() {
use iterator::*;
let mut xs = [1u, 2, 3, 4, 5];
- foreach (i,x) in xs.mut_rev_iter().enumerate() {
+ for (i,x) in xs.mut_rev_iter().enumerate() {
*x += i;
}
assert_eq!(xs, [5, 5, 5, 5, 5])
{
let (left, right) = values.mut_split(2);
assert_eq!(left.slice(0, left.len()), [1, 2]);
- foreach p in left.mut_iter() {
+ for p in left.mut_iter() {
*p += 1;
}
assert_eq!(right.slice(0, right.len()), [3, 4, 5]);
- foreach p in right.mut_iter() {
+ for p in right.mut_iter() {
*p += 2;
}
}
assert_eq!(v.len(), 3);
let mut cnt = 0;
- foreach f in v.iter() {
+ for f in v.iter() {
assert!(*f == Foo);
cnt += 1;
}
assert_eq!(cnt, 3);
- foreach f in v.slice(1, 3).iter() {
+ for f in v.slice(1, 3).iter() {
assert!(*f == Foo);
cnt += 1;
}
assert_eq!(cnt, 5);
- foreach f in v.mut_iter() {
+ for f in v.mut_iter() {
assert!(*f == Foo);
cnt += 1;
}
assert_eq!(cnt, 8);
- foreach f in v.consume_iter() {
+ for f in v.consume_iter() {
assert!(f == Foo);
cnt += 1;
}
let xs: [Foo, ..3] = [Foo, Foo, Foo];
assert_eq!(fmt!("%?", xs.slice(0, 2).to_owned()), ~"~[{}, {}]");
cnt = 0;
- foreach f in xs.iter() {
+ for f in xs.iter() {
assert!(*f == Foo);
cnt += 1;
}
do bh.iter {
let mut sum = 0;
- foreach x in v.iter() {
+ for x in v.iter() {
sum += *x;
}
// sum == 11806, to stop dead code elimination.
do bh.iter {
let mut i = 0;
- foreach x in v.mut_iter() {
+ for x in v.mut_iter() {
*x = i;
i += 1;
}
let mut abis = ~[];
do self.each |abi| { abis.push(abi); true };
- foreach (i, abi) in abis.iter().enumerate() {
+ for (i, abi) in abis.iter().enumerate() {
let data = abi.data();
- foreach other_abi in abis.slice(0, i).iter() {
+ for other_abi in abis.slice(0, i).iter() {
let other_data = other_abi.data();
debug!("abis=(%?,%?) datas=(%?,%?)",
abi, data.abi_arch,
#[test]
fn indices_are_correct() {
- foreach (i, abi_data) in AbiDatas.iter().enumerate() {
+ for (i, abi_data) in AbiDatas.iter().enumerate() {
assert!(i == abi_data.abi.index());
}
#[cfg(test)]
fn check_arch(abis: &[Abi], arch: Architecture, expect: Option<Abi>) {
let mut set = AbiSet::empty();
- foreach &abi in abis.iter() {
+ for &abi in abis.iter() {
set.add(abi);
}
let r = set.for_arch(arch);
expr_loop(Block, Option<ident>),
expr_match(@expr, ~[arm]),
expr_fn_block(fn_decl, Block),
- // Inner expr is always an expr_fn_block. We need the wrapping node to
- // easily type this (a function returning nil on the inside but bool on
- // the outside).
- expr_loop_body(@expr),
- // Like expr_loop_body but for 'do' blocks
expr_do_body(@expr),
expr_block(Block),
// Expressions which are or might be calls:
{
let r = ex.get_callee_id();
- foreach callee_id in r.iter() {
+ for callee_id in r.iter() {
self.map.insert(*callee_id, node_callee_scope(ex));
}
}
body: &Block,
sp: codemap::span,
id: NodeId) {
- foreach a in decl.inputs.iter() {
+ for a in decl.inputs.iter() {
self.map.insert(a.id, node_arg);
}
visit::visit_fn(self as @Visitor<()>, fk, decl, body, sp, id, ());
match i.node {
item_impl(_, _, _, ref ms) => {
let impl_did = ast_util::local_def(i.id);
- foreach m in ms.iter() {
+ for m in ms.iter() {
self.map_method(impl_did, self.extend(i.ident), *m, false)
}
}
item_enum(ref enum_definition, _) => {
- foreach v in (*enum_definition).variants.iter() {
+ for v in (*enum_definition).variants.iter() {
// FIXME #2543: bad clone
self.map.insert(v.node.id,
node_variant((*v).clone(),
}
}
item_foreign_mod(ref nm) => {
- foreach nitem in nm.items.iter() {
+ for nitem in nm.items.iter() {
// Compute the visibility for this native item.
let visibility = match nitem.vis {
public => public,
i.ident)
}
item_trait(_, ref traits, ref methods) => {
- foreach p in traits.iter() {
+ for p in traits.iter() {
self.map.insert(p.ref_id, node_item(i, item_path));
}
- foreach tm in methods.iter() {
+ for tm in methods.iter() {
let id = ast_util::trait_method_to_ty_method(tm).id;
let d_id = ast_util::local_def(i.id);
self.map.insert(id,
-> (~[TypeMethod], ~[@method]) {
let mut reqd = ~[];
let mut provd = ~[];
- foreach trt_method in trait_methods.iter() {
+ for trt_method in trait_methods.iter() {
match *trt_method {
required(ref tm) => reqd.push((*tm).clone()),
provided(m) => provd.push(m)
impl IdVisitor {
fn visit_generics_helper(@mut self, generics: &Generics) {
- foreach type_parameter in generics.ty_params.iter() {
+ for type_parameter in generics.ty_params.iter() {
(self.visit_callback)(type_parameter.id)
}
- foreach lifetime in generics.lifetimes.iter() {
+ for lifetime in generics.lifetimes.iter() {
(self.visit_callback)(lifetime.id)
}
}
(self.visit_callback)(node_id)
}
view_item_use(ref view_paths) => {
- foreach view_path in view_paths.iter() {
+ for view_path in view_paths.iter() {
match view_path.node {
view_path_simple(_, _, node_id) |
view_path_glob(_, node_id) => {
}
view_path_list(_, ref paths, node_id) => {
(self.visit_callback)(node_id);
- foreach path in paths.iter() {
+ for path in paths.iter() {
(self.visit_callback)(path.node.id)
}
}
(self.visit_callback)(item.id);
match item.node {
item_enum(ref enum_definition, _) => {
- foreach variant in enum_definition.variants.iter() {
+ for variant in enum_definition.variants.iter() {
(self.visit_callback)(variant.node.id)
}
}
fn visit_expr(@mut self, expression: @expr, env: ()) {
{
let optional_callee_id = expression.get_callee_id();
- foreach callee_id in optional_callee_id.iter() {
+ for callee_id in optional_callee_id.iter() {
(self.visit_callback)(*callee_id)
}
}
visit::fk_anon(_) | visit::fk_fn_block => {}
}
- foreach argument in function_declaration.inputs.iter() {
+ for argument in function_declaration.inputs.iter() {
(self.visit_callback)(argument.id)
}
*/
pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] {
let mut result = ~[];
- foreach attr in attrs.iter().filter(|at| "link" == at.name()) {
+ for attr in attrs.iter().filter(|at| "link" == at.name()) {
match attr.meta().node {
MetaList(_, ref items) => result.push_all(*items),
_ => ()
pub fn require_unique_names(diagnostic: @span_handler,
metas: &[@MetaItem]) {
let mut set = HashSet::new();
- foreach meta in metas.iter() {
+ for meta in metas.iter() {
let name = meta.name();
// FIXME: How do I silence the warnings? --pcw (#2619)
let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi);
let mut lines = ~[];
- foreach i in range(lo.line - 1u, hi.line as uint) {
+ for i in range(lo.line - 1u, hi.line as uint) {
lines.push(i);
};
return @FileLines {file: lo.file, lines: lines};
}
pub fn get_filemap(&self, filename: &str) -> @FileMap {
- foreach fm in self.files.iter() { if filename == fm.name { return *fm; } }
+ for fm in self.files.iter() { if filename == fm.name { return *fm; } }
//XXjdm the following triggers a mismatched type bug
// (or expected function, found _|_)
fail!(); // ("asking for " + filename + " which we don't know about");
// The number of extra bytes due to multibyte chars in the FileMap
let mut total_extra_bytes = 0;
- foreach mbc in map.multibyte_chars.iter() {
+ for mbc in map.multibyte_chars.iter() {
debug!("codemap: %?-byte char at %?", mbc.bytes, mbc.pos);
if mbc.pos < bpos {
total_extra_bytes += mbc.bytes;
elided = true;
}
// Print the offending lines
- foreach line in display_lines.iter() {
+ for line in display_lines.iter() {
io::stderr().write_str(fmt!("%s:%u ", fm.name, *line + 1u));
let s = fm.get_line(*line as int) + "\n";
io::stderr().write_str(s);
s.push_char(' ');
}
let orig = fm.get_line(lines.lines[0] as int);
- foreach pos in range(0u, left-skip) {
+ for pos in range(0u, left-skip) {
let curChar = (orig[pos] as char);
// Whenever a tab occurs on the previous line, we insert one on
// the error-point-squiggly-line as well (instead of a space).
}
fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
- foreach ei in sp.expn_info.iter() {
+ for ei in sp.expn_info.iter() {
let ss = ei.callee.span.map_default(~"", |span| cm.span_to_str(*span));
print_diagnostic(ss, note,
fmt!("in expansion of %s!", ei.callee.name));
let exprs = get_exprs_from_tts(cx, sp, tts);
let mut bytes = ~[];
- foreach expr in exprs.iter() {
+ for expr in exprs.iter() {
match expr.node {
// expression is a literal
ast::expr_lit(lit) => match lit.node {
// string literal, push each byte to vector expression
ast::lit_str(s) => {
- foreach byte in s.byte_iter() {
+ for byte in s.byte_iter() {
bytes.push(cx.expr_u8(sp, byte));
}
}
pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
let mut res_str = ~"";
- foreach (i, e) in tts.iter().enumerate() {
+ for (i, e) in tts.iter().enumerate() {
if i & 1 == 1 {
match *e {
ast::tt_tok(_, token::COMMA) => (),
cx.expr_ident(span, substr.type_ident)
} else {
let mut fields = vec::with_capacity(n);
- foreach i in range(0, n) {
+ for i in range(0, n) {
fields.push(getarg(fmt!("_field%u", i).to_managed(), i));
}
cx.expr_call_ident(span, substr.type_ident, fields)
let mut variants = ~[];
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
- foreach (i, f) in fields.iter().enumerate() {
+ for (i, f) in fields.iter().enumerate() {
let (name, parts) = match *f { (i, ref p) => (i, p) };
variants.push(cx.expr_str(span, cx.str_of(name)));
cx.expr_ident(span, name)
} else {
let mut fields = vec::with_capacity(n);
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
fields.push(getarg(i));
}
cx.expr_call_ident(span, name, fields)
Struct(ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
let mut stmts = ~[];
- foreach (i, f) in fields.iter().enumerate() {
+ for (i, f) in fields.iter().enumerate() {
let (name, val) = match *f {
(Some(id), e, _) => (cx.str_of(id), e),
(None, e, _) => (fmt!("_field%u", i).to_managed(), e)
let encoder = cx.expr_ident(span, blkarg);
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
let mut stmts = ~[];
- foreach (i, f) in fields.iter().enumerate() {
+ for (i, f) in fields.iter().enumerate() {
let val = match *f { (_, e, _) => e };
let enc = cx.expr_method_call(span, val, encode, ~[blkencoder]);
let lambda = cx.lambda_expr_1(span, enc, blkarg);
_mitem: @ast::MetaItem,
in_items: ~[@ast::item]) -> ~[@ast::item] {
let mut result = ~[];
- foreach item in in_items.iter() {
+ for item in in_items.iter() {
result.push(*item);
match item.node {
ast::item_struct(struct_def, ref generics) => {
let mut trait_generics = self.generics.to_generics(cx, span, type_ident, generics);
// Copy the lifetimes
- foreach l in generics.lifetimes.iter() {
+ for l in generics.lifetimes.iter() {
trait_generics.lifetimes.push(*l)
};
// Create the type parameters.
- foreach ty_param in generics.ty_params.iter() {
+ for ty_param in generics.ty_params.iter() {
// I don't think this can be moved out of the loop, since
// a TyParamBound requires an ast id
let mut bounds = opt_vec::from(
None => respan(span, ast::sty_static),
};
- foreach (i, ty) in self.args.iter().enumerate() {
+ for (i, ty) in self.args.iter().enumerate() {
let ast_ty = ty.to_ty(cx, span, type_ident, generics);
let ident = cx.ident_of(fmt!("__arg_%u", i));
arg_tys.push((ident, ast_ty));
let mut raw_fields = ~[]; // ~[[fields of self],
// [fields of next Self arg], [etc]]
let mut patterns = ~[];
- foreach i in range(0u, self_args.len()) {
+ for i in range(0u, self_args.len()) {
let (pat, ident_expr) = create_struct_pattern(cx, span,
type_ident, struct_def,
fmt!("__self_%u", i), ast::m_imm);
// make a series of nested matches, to destructure the
// structs. This is actually right-to-left, but it shoudn't
// matter.
- foreach (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
+ for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
body = cx.expr_match(span, arg_expr,
~[ cx.arm(span, ~[pat], body) ])
}
let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
- foreach triple in matches_so_far.tail().iter() {
+ for triple in matches_so_far.tail().iter() {
match triple {
&(_, _, ref other_fields) => {
- foreach (i, pair) in other_fields.iter().enumerate() {
+ for (i, pair) in other_fields.iter().enumerate() {
enum_matching_fields[i].push(pair.second());
}
}
}
} else {
// create an arm matching on each variant
- foreach (index, variant) in enum_def.variants.iter().enumerate() {
+ for (index, variant) in enum_def.variants.iter().enumerate() {
let (pattern, idents) = create_enum_variant_pattern(cx, span,
variant,
current_match_str,
struct_def: &struct_def) -> Either<uint, ~[ident]> {
let mut named_idents = ~[];
let mut unnamed_count = 0;
- foreach field in struct_def.fields.iter() {
+ for field in struct_def.fields.iter() {
match field.node.kind {
ast::named_field(ident, _) => named_idents.push(ident),
ast::unnamed_field => unnamed_count += 1,
let mut ident_expr = ~[];
let mut struct_type = Unknown;
- foreach (i, struct_field) in struct_def.fields.iter().enumerate() {
+ for (i, struct_field) in struct_def.fields.iter().enumerate() {
let opt_id = match struct_field.node.kind {
ast::named_field(ident, _) if (struct_type == Unknown ||
struct_type == Record) => {
// must be nonempty to reach here
let pattern = if struct_type == Record {
let field_pats = do vec::build |push| {
- foreach (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
+ for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
// id is guaranteed to be Some
push(ast::field_pat { ident: id.get(), pat: pat })
}
let mut paths = ~[];
let mut ident_expr = ~[];
- foreach i in range(0u, variant_args.len()) {
+ for i in range(0u, variant_args.len()) {
let path = cx.path_ident(span,
cx.ident_of(fmt!("%s_%u", prefix, i)));
_ => cx.span_bug(span, "Impossible substructure in `deriving(IterBytes)`")
}
- foreach &(_, field, _) in fields.iter() {
+ for &(_, field, _) in fields.iter() {
exprs.push(call_iterbytes(field));
}
stmts.push(cx.stmt_expr(call));
};
- foreach (i, &(name, e, _)) in fields.iter().enumerate() {
+ for (i, &(name, e, _)) in fields.iter().enumerate() {
if i > 0 {
push(cx.expr_str(span, @", "));
}
}
// Desugar expr_for_loop
- // From: `foreach <src_pat> in <src_expr> <src_loop_block>`
+ // From: `for <src_pat> in <src_expr> <src_loop_block>`
ast::expr_for_loop(src_pat, src_expr, ref src_loop_block) => {
let src_pat = src_pat.clone();
let src_expr = src_expr.clone();
_ => ()
}
// visit optional subpattern of pat_ident:
- foreach subpat in inner.iter() {
+ for subpat in inner.iter() {
self.visit_pat(*subpat, ())
}
}
fn make_rt_conv_expr(cx: @ExtCtxt, sp: span, cnv: &Conv) -> @ast::expr {
fn make_flags(cx: @ExtCtxt, sp: span, flags: &[Flag]) -> @ast::expr {
let mut tmp_expr = make_rt_path_expr(cx, sp, "flag_none");
- foreach f in flags.iter() {
+ for f in flags.iter() {
let fstr = match *f {
FlagLeftJustify => "flag_left_justify",
FlagLeftZeroPad => "flag_left_zero_pad",
option::None => (),
_ => cx.span_unimpl(sp, unsupported)
}
- foreach f in cnv.flags.iter() {
+ for f in cnv.flags.iter() {
match *f {
FlagLeftJustify => (),
FlagSignAlways => {
Some(p) => { debug!("param: %s", p.to_str()); }
_ => debug!("param: none")
}
- foreach f in c.flags.iter() {
+ for f in c.flags.iter() {
match *f {
FlagLeftJustify => debug!("flag: left justify"),
FlagLeftZeroPad => debug!("flag: left zero pad"),
corresponding function in std::unstable::extfmt. Each function takes a
buffer to insert data into along with the data being formatted. */
let npieces = pieces.len();
- foreach (i, pc) in pieces.consume_iter().enumerate() {
+ for (i, pc) in pieces.consume_iter().enumerate() {
match pc {
/* Raw strings get appended via str::push_str */
PieceString(s) => {
fn mk_tts(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> ~[@ast::stmt] {
let mut ss = ~[];
- foreach tt in tts.iter() {
+ for tt in tts.iter() {
ss.push_all_move(mk_tt(cx, sp, tt));
}
ss
pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
-> ~MatcherPos {
let mut match_idx_hi = 0u;
- foreach elt in ms.iter() {
+ for elt in ms.iter() {
match elt.node {
match_tok(_) => (),
match_seq(_,_,_,_,hi) => {
match *m {
codemap::spanned {node: match_tok(_), _} => (),
codemap::spanned {node: match_seq(ref more_ms, _, _, _, _), _} => {
- foreach next_m in more_ms.iter() {
+ for next_m in more_ms.iter() {
n_rec(p_s, next_m, res, ret_val)
};
}
}
}
let mut ret_val = HashMap::new();
- foreach m in ms.iter() { n_rec(p_s, m, res, &mut ret_val) }
+ for m in ms.iter() { n_rec(p_s, m, res, &mut ret_val) }
ret_val
}
// most of the time.
// Only touch the binders we have actually bound
- foreach idx in range(ei.match_lo, ei.match_hi) {
+ for idx in range(ei.match_lo, ei.match_hi) {
let sub = ei.matches[idx].clone();
new_pos.matches[idx]
.push(@matched_seq(sub,
let mut new_ei = ei.clone();
new_ei.idx += 1u;
//we specifically matched zero repeats.
- foreach idx in range(match_idx_lo, match_idx_hi) {
+ for idx in range(match_idx_lo, match_idx_hi) {
new_ei.matches[idx].push(@matched_seq(~[], sp));
}
if tok == EOF {
if eof_eis.len() == 1u {
let mut v = ~[];
- foreach dv in eof_eis[0u].matches.mut_iter() {
+ for dv in eof_eis[0u].matches.mut_iter() {
v.push(dv.pop());
}
return success(nameize(sess, ms, v));
let s_d = cx.parse_sess().span_diagnostic;
- foreach (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
+ for (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
match *lhs {
@matched_nonterminal(nt_matchers(ref mtcs)) => {
// `none` is because we're not interpolating
pub fn noop_fold_block(b: &Block, fld: @ast_fold) -> Block {
let view_items = b.view_items.map(|x| fld.fold_view_item(x));
let mut stmts = ~[];
- foreach stmt in b.stmts.iter() {
+ for stmt in b.stmts.iter() {
match fld.fold_stmt(*stmt) {
None => {}
Some(stmt) => stmts.push(stmt)
fld.fold_expr(ohs)
)
}
- expr_loop_body(f) => expr_loop_body(fld.fold_expr(f)),
expr_do_body(f) => expr_do_body(fld.fold_expr(f)),
expr_lit(_) => (*e).clone(),
expr_cast(expr, ref ty) => {
_sp: span,
_id: NodeId,
(e, v): (E, vt<E>)) {
- foreach vi in m.view_items.iter() {
+ for vi in m.view_items.iter() {
(v.visit_view_item)(vi, (e.clone(), v));
}
- foreach i in m.items.iter() {
+ for i in m.items.iter() {
(v.visit_item)(*i, (e.clone(), v));
}
}
}
item_mod(ref m) => (v.visit_mod)(m, i.span, i.id, (e, v)),
item_foreign_mod(ref nm) => {
- foreach vi in nm.view_items.iter() {
+ for vi in nm.view_items.iter() {
(v.visit_view_item)(vi, (e.clone(), v));
}
- foreach ni in nm.items.iter() {
+ for ni in nm.items.iter() {
(v.visit_foreign_item)(*ni, (e.clone(), v));
}
}
}
item_impl(ref tps, ref traits, ref ty, ref methods) => {
(v.visit_generics)(tps, (e.clone(), v));
- foreach p in traits.iter() {
+ for p in traits.iter() {
visit_trait_ref(p, (e.clone(), v));
}
(v.visit_ty)(ty, (e.clone(), v));
- foreach m in methods.iter() {
+ for m in methods.iter() {
visit_method_helper(*m, (e.clone(), v))
}
}
}
item_trait(ref generics, ref traits, ref methods) => {
(v.visit_generics)(generics, (e.clone(), v));
- foreach p in traits.iter() {
+ for p in traits.iter() {
visit_path(&p.path, (e.clone(), v));
}
- foreach m in methods.iter() {
+ for m in methods.iter() {
(v.visit_trait_method)(m, (e.clone(), v));
}
}
pub fn visit_enum_def<E:Clone>(enum_definition: &ast::enum_def,
tps: &Generics,
(e, v): (E, vt<E>)) {
- foreach vr in enum_definition.variants.iter() {
+ for vr in enum_definition.variants.iter() {
match vr.node.kind {
tuple_variant_kind(ref variant_args) => {
- foreach va in variant_args.iter() {
+ for va in variant_args.iter() {
(v.visit_ty)(&va.ty, (e.clone(), v));
}
}
}
}
// Visit the disr expr if it exists
- foreach ex in vr.node.disr_expr.iter() {
+ for ex in vr.node.disr_expr.iter() {
(v.visit_expr)(*ex, (e.clone(), v))
}
}
(v.visit_ty)(mt.ty, (e, v));
},
ty_tup(ref ts) => {
- foreach tt in ts.iter() {
+ for tt in ts.iter() {
(v.visit_ty)(tt, (e.clone(), v));
}
},
ty_closure(ref f) => {
- foreach a in f.decl.inputs.iter() {
+ for a in f.decl.inputs.iter() {
(v.visit_ty)(&a.ty, (e.clone(), v));
}
(v.visit_ty)(&f.decl.output, (e.clone(), v));
};
},
ty_bare_fn(ref f) => {
- foreach a in f.decl.inputs.iter() {
+ for a in f.decl.inputs.iter() {
(v.visit_ty)(&a.ty, (e.clone(), v));
}
(v.visit_ty)(&f.decl.output, (e, v));
}
pub fn visit_path<E:Clone>(p: &Path, (e, v): (E, vt<E>)) {
- foreach tp in p.types.iter() { (v.visit_ty)(tp, (e.clone(), v)); }
+ for tp in p.types.iter() { (v.visit_ty)(tp, (e.clone(), v)); }
}
pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) {
match p.node {
pat_enum(ref path, ref children) => {
visit_path(path, (e.clone(), v));
- foreach children in children.iter() {
- foreach child in children.iter() {
+ for children in children.iter() {
+ for child in children.iter() {
(v.visit_pat)(*child, (e.clone(), v));
}
}
}
pat_struct(ref path, ref fields, _) => {
visit_path(path, (e.clone(), v));
- foreach f in fields.iter() {
+ for f in fields.iter() {
(v.visit_pat)(f.pat, (e.clone(), v));
}
}
pat_tup(ref elts) => {
- foreach elt in elts.iter() {
+ for elt in elts.iter() {
(v.visit_pat)(*elt, (e.clone(), v))
}
},
},
pat_ident(_, ref path, ref inner) => {
visit_path(path, (e.clone(), v));
- foreach subpat in inner.iter() {
+ for subpat in inner.iter() {
(v.visit_pat)(*subpat, (e.clone(), v))
}
}
}
pat_wild => (),
pat_vec(ref before, ref slice, ref after) => {
- foreach elt in before.iter() {
+ for elt in before.iter() {
(v.visit_pat)(*elt, (e.clone(), v));
}
- foreach elt in slice.iter() {
+ for elt in slice.iter() {
(v.visit_pat)(*elt, (e.clone(), v));
}
- foreach tail in after.iter() {
+ for tail in after.iter() {
(v.visit_pat)(*tail, (e.clone(), v));
}
}
pub fn visit_ty_param_bounds<E:Clone>(bounds: &OptVec<TyParamBound>,
(e, v): (E, vt<E>)) {
- foreach bound in bounds.iter() {
+ for bound in bounds.iter() {
match *bound {
TraitTyParamBound(ref ty) => visit_trait_ref(ty, (e.clone(), v)),
RegionTyParamBound => {}
}
pub fn visit_generics<E:Clone>(generics: &Generics, (e, v): (E, vt<E>)) {
- foreach tp in generics.ty_params.iter() {
+ for tp in generics.ty_params.iter() {
visit_ty_param_bounds(&tp.bounds, (e.clone(), v));
}
}
pub fn visit_fn_decl<E:Clone>(fd: &fn_decl, (e, v): (E, vt<E>)) {
- foreach a in fd.inputs.iter() {
+ for a in fd.inputs.iter() {
(v.visit_pat)(a.pat, (e.clone(), v));
(v.visit_ty)(&a.ty, (e.clone(), v));
}
}
pub fn visit_ty_method<E:Clone>(m: &TypeMethod, (e, v): (E, vt<E>)) {
- foreach a in m.decl.inputs.iter() {
+ for a in m.decl.inputs.iter() {
(v.visit_ty)(&a.ty, (e.clone(), v));
}
(v.visit_generics)(&m.generics, (e.clone(), v));
_id: NodeId,
(e, v): (E, vt<E>)
) {
- foreach f in sd.fields.iter() {
+ for f in sd.fields.iter() {
(v.visit_struct_field)(*f, (e.clone(), v));
}
}
}
pub fn visit_block<E:Clone>(b: &Block, (e, v): (E, vt<E>)) {
- foreach vi in b.view_items.iter() {
+ for vi in b.view_items.iter() {
(v.visit_view_item)(vi, (e.clone(), v));
}
- foreach s in b.stmts.iter() {
+ for s in b.stmts.iter() {
(v.visit_stmt)(*s, (e.clone(), v));
}
visit_expr_opt(b.expr, (e, v));
}
pub fn visit_exprs<E:Clone>(exprs: &[@expr], (e, v): (E, vt<E>)) {
- foreach ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); }
+ for ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); }
}
pub fn visit_mac<E>(_m: &mac, (_e, _v): (E, vt<E>)) {
}
expr_struct(ref p, ref flds, base) => {
visit_path(p, (e.clone(), v));
- foreach f in flds.iter() {
+ for f in flds.iter() {
(v.visit_expr)(f.expr, (e.clone(), v));
}
visit_expr_opt(base, (e.clone(), v));
}
expr_tup(ref elts) => {
- foreach el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) }
+ for el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) }
}
expr_call(callee, ref args, _) => {
visit_exprs(*args, (e.clone(), v));
}
expr_method_call(_, callee, _, ref tys, ref args, _) => {
visit_exprs(*args, (e.clone(), v));
- foreach tp in tys.iter() {
+ for tp in tys.iter() {
(v.visit_ty)(tp, (e.clone(), v));
}
(v.visit_expr)(callee, (e.clone(), v));
(v.visit_expr)(b, (e.clone(), v));
}
expr_addr_of(_, x) | expr_unary(_, _, x) |
- expr_loop_body(x) | expr_do_body(x) => (v.visit_expr)(x, (e.clone(), v)),
+ expr_do_body(x) => (v.visit_expr)(x, (e.clone(), v)),
expr_lit(_) => (),
expr_cast(x, ref t) => {
(v.visit_expr)(x, (e.clone(), v));
expr_loop(ref b, _) => (v.visit_block)(b, (e.clone(), v)),
expr_match(x, ref arms) => {
(v.visit_expr)(x, (e.clone(), v));
- foreach a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); }
+ for a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); }
}
expr_fn_block(ref decl, ref body) => {
(v.visit_fn)(
}
expr_field(x, _, ref tys) => {
(v.visit_expr)(x, (e.clone(), v));
- foreach tp in tys.iter() {
+ for tp in tys.iter() {
(v.visit_ty)(tp, (e.clone(), v));
}
}
expr_mac(ref mac) => visit_mac(mac, (e.clone(), v)),
expr_paren(x) => (v.visit_expr)(x, (e.clone(), v)),
expr_inline_asm(ref a) => {
- foreach &(_, input) in a.inputs.iter() {
+ for &(_, input) in a.inputs.iter() {
(v.visit_expr)(input, (e.clone(), v));
}
- foreach &(_, out) in a.outputs.iter() {
+ for &(_, out) in a.outputs.iter() {
(v.visit_expr)(out, (e.clone(), v));
}
}
}
pub fn visit_arm<E:Clone>(a: &arm, (e, v): (E, vt<E>)) {
- foreach p in a.pats.iter() { (v.visit_pat)(*p, (e.clone(), v)); }
+ for p in a.pats.iter() { (v.visit_pat)(*p, (e.clone(), v)); }
visit_expr_opt(a.guard, (e.clone(), v));
(v.visit_block)(&a.body, (e.clone(), v));
}
let mut i = uint::max_value;
let mut can_trim = true;
let mut first = true;
- foreach line in lines.iter() {
- foreach (j, c) in line.iter().enumerate() {
+ for line in lines.iter() {
+ for (j, c) in line.iter().enumerate() {
if j > i || !"* \t".contains_char(c) {
can_trim = false;
break;
// check that the given reader produces the desired stream
// of tokens (stop checking after exhausting the expected vec)
fn check_tokenization (env: Env, expected: ~[token::Token]) {
- foreach expected_tok in expected.iter() {
+ for expected_tok in expected.iter() {
let TokenAndSpan {tok:actual_tok, sp: _} =
env.string_reader.next_token();
assert_eq!(&actual_tok,expected_tok);
hi = self.span.hi;
} else if self.eat_keyword(keywords::If) {
return self.parse_if_expr();
- } else if self.eat_keyword(keywords::ForEach) {
- return self.parse_for_expr();
} else if self.eat_keyword(keywords::For) {
return self.parse_for_expr();
} else if self.eat_keyword(keywords::Do) {
} = self.parse_items_and_view_items(first_item_attrs,
false, false);
- foreach item in items.iter() {
+ for item in items.iter() {
let decl = @spanned(item.span.lo, item.span.hi, decl_item(*item));
stmts.push(@spanned(item.span.lo, item.span.hi,
stmt_decl(decl, self.get_id())));
fields = ~[];
while *self.token != token::RBRACE {
let r = self.parse_struct_decl_field();
- foreach struct_field in r.iter() {
+ for struct_field in r.iter() {
fields.push(*struct_field)
}
}
Some(i) => {
let stack = &self.sess.included_mod_stack;
let mut err = ~"circular modules: ";
- foreach p in stack.slice(i, stack.len()).iter() {
+ for p in stack.slice(i, stack.len()).iter() {
err.push_str(p.to_str());
err.push_str(" -> ");
}
let mut fields: ~[@struct_field] = ~[];
while *self.token != token::RBRACE {
let r = self.parse_struct_decl_field();
- foreach struct_field in r.iter() {
+ for struct_field in r.iter() {
fields.push(*struct_field);
}
}
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_ty(false)
);
- foreach ty in arg_tys.consume_iter() {
+ for ty in arg_tys.consume_iter() {
args.push(ast::variant_arg {
ty: ty,
id: self.get_id(),
self.bump();
let the_string = ident_to_str(&s);
let mut abis = AbiSet::empty();
- foreach word in the_string.word_iter() {
+ for word in the_string.word_iter() {
match abi::lookup(word) {
Some(abi) => {
if abis.contains(abi) {
"use", // 61
"while", // 62
"in", // 63
- "foreach", // 64
- "be", // 65
- "pure", // 66
+ "be", // 64
+ "pure", // 65
];
@ident_interner {
False,
Fn,
For,
- ForEach,
If,
Impl,
In,
False => ident { name: 39, ctxt: 0 },
Fn => ident { name: 40, ctxt: 0 },
For => ident { name: 41, ctxt: 0 },
- ForEach => ident { name: 64, ctxt: 0 },
If => ident { name: 42, ctxt: 0 },
Impl => ident { name: 43, ctxt: 0 },
In => ident { name: 63, ctxt: 0 },
Once => ident { name: 50, ctxt: 0 },
Priv => ident { name: 51, ctxt: 0 },
Pub => ident { name: 52, ctxt: 0 },
- Pure => ident { name: 66, ctxt: 0 },
+ Pure => ident { name: 65, ctxt: 0 },
Ref => ident { name: 53, ctxt: 0 },
Return => ident { name: 54, ctxt: 0 },
Static => ident { name: 27, ctxt: 0 },
Unsafe => ident { name: 60, ctxt: 0 },
Use => ident { name: 61, ctxt: 0 },
While => ident { name: 62, ctxt: 0 },
- Be => ident { name: 65, ctxt: 0 },
+ Be => ident { name: 64, ctxt: 0 },
}
}
}
pub fn is_any_keyword(tok: &Token) -> bool {
match *tok {
token::IDENT(sid, false) => match sid.name {
- 8 | 27 | 32 .. 66 => true,
+ 8 | 27 | 32 .. 65 => true,
_ => false,
},
_ => false
pub fn is_strict_keyword(tok: &Token) -> bool {
match *tok {
token::IDENT(sid, false) => match sid.name {
- 8 | 27 | 32 .. 64 => true,
+ 8 | 27 | 32 .. 63 => true,
_ => false,
},
_ => false,
pub fn is_reserved_keyword(tok: &Token) -> bool {
match *tok {
token::IDENT(sid, false) => match sid.name {
- 65 .. 66 => true,
+ 64 .. 65 => true,
_ => false,
},
_ => false,
pub fn commasep<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) {
box(s, 0u, b);
let mut first = true;
- foreach elt in elts.iter() {
+ for elt in elts.iter() {
if first { first = false; } else { word_space(s, ","); }
op(s, elt);
}
box(s, 0u, b);
let len = elts.len();
let mut i = 0u;
- foreach elt in elts.iter() {
+ for elt in elts.iter() {
maybe_print_comment(s, get_span(elt).hi);
op(s, elt);
i += 1u;
pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: &[ast::Attribute]) {
print_inner_attributes(s, attrs);
- foreach vitem in _mod.view_items.iter() {
+ for vitem in _mod.view_items.iter() {
print_view_item(s, vitem);
}
- foreach item in _mod.items.iter() { print_item(s, *item); }
+ for item in _mod.items.iter() { print_item(s, *item); }
}
pub fn print_foreign_mod(s: @ps, nmod: &ast::foreign_mod,
attrs: &[ast::Attribute]) {
print_inner_attributes(s, attrs);
- foreach vitem in nmod.view_items.iter() {
+ for vitem in nmod.view_items.iter() {
print_view_item(s, vitem);
}
- foreach item in nmod.items.iter() { print_foreign_item(s, *item); }
+ for item in nmod.items.iter() { print_foreign_item(s, *item); }
}
pub fn print_opt_lifetime(s: @ps, lifetime: &Option<ast::Lifetime>) {
- foreach l in lifetime.iter() {
+ for l in lifetime.iter() {
print_lifetime(s, l);
nbsp(s);
}
word(s.s, ";");
} else {
bopen(s);
- foreach meth in methods.iter() {
+ for meth in methods.iter() {
print_method(s, *meth);
}
bclose(s, item.span);
print_generics(s, generics);
if traits.len() != 0u {
word(s.s, ":");
- foreach (i, trait_) in traits.iter().enumerate() {
+ for (i, trait_) in traits.iter().enumerate() {
nbsp(s);
if i != 0 {
word_space(s, "+");
}
word(s.s, " ");
bopen(s);
- foreach meth in methods.iter() {
+ for meth in methods.iter() {
print_trait_method(s, meth);
}
bclose(s, item.span);
variants: &[ast::variant],
span: codemap::span) {
bopen(s);
- foreach v in variants.iter() {
+ for v in variants.iter() {
space_if_not_bol(s);
maybe_print_comment(s, v.span.lo);
print_outer_attributes(s, v.node.attrs);
bopen(s);
hardbreak_if_not_bol(s);
- foreach field in struct_def.fields.iter() {
+ for field in struct_def.fields.iter() {
match field.node.kind {
ast::unnamed_field => fail!("unexpected unnamed field"),
ast::named_field(ident, visibility) => {
}
ast::tt_seq(_, ref tts, ref sep, zerok) => {
word(s.s, "$(");
- foreach tt_elt in (*tts).iter() { print_tt(s, tt_elt); }
+ for tt_elt in (*tts).iter() { print_tt(s, tt_elt); }
word(s.s, ")");
match (*sep) {
Some(ref tk) => word(s.s, parse::token::to_str(s.intr, tk)),
pub fn print_tts(s: @ps, tts: & &[ast::token_tree]) {
ibox(s, 0);
- foreach (i, tt) in tts.iter().enumerate() {
+ for (i, tt) in tts.iter().enumerate() {
if i != 0 {
space(s.s);
}
pub fn print_outer_attributes(s: @ps, attrs: &[ast::Attribute]) {
let mut count = 0;
- foreach attr in attrs.iter() {
+ for attr in attrs.iter() {
match attr.node.style {
ast::AttrOuter => { print_attribute(s, attr); count += 1; }
_ => {/* fallthrough */ }
pub fn print_inner_attributes(s: @ps, attrs: &[ast::Attribute]) {
let mut count = 0;
- foreach attr in attrs.iter() {
+ for attr in attrs.iter() {
match attr.node.style {
ast::AttrInner => {
print_attribute(s, attr);
print_inner_attributes(s, attrs);
- foreach vi in blk.view_items.iter() { print_view_item(s, vi); }
- foreach st in blk.stmts.iter() {
+ for vi in blk.view_items.iter() { print_view_item(s, vi); }
+ for st in blk.stmts.iter() {
print_stmt(s, *st);
}
match blk.expr {
nbsp(s);
match blk.get().node {
// need to handle closures specifically
- ast::expr_do_body(e) | ast::expr_loop_body(e) => {
+ ast::expr_do_body(e) => {
end(s); // we close our head box; closure
// will create it's own.
print_expr(s, e);
print_block(s, blk);
}
ast::expr_for_loop(pat, iter, ref blk) => {
- head(s, "foreach");
+ head(s, "for");
print_pat(s, pat);
space(s.s);
word_space(s, "in");
print_block(s, blk);
}
ast::expr_loop(ref blk, opt_ident) => {
- foreach ident in opt_ident.iter() {
+ for ident in opt_ident.iter() {
word(s.s, "'");
print_ident(s, *ident);
word_space(s, ":");
space(s.s);
bopen(s);
let len = arms.len();
- foreach (i, arm) in arms.iter().enumerate() {
+ for (i, arm) in arms.iter().enumerate() {
space(s.s);
cbox(s, indent_unit);
ibox(s, 0u);
let mut first = true;
- foreach p in arm.pats.iter() {
+ for p in arm.pats.iter() {
if first {
first = false;
} else { space(s.s); word_space(s, "|"); }
// empty box to satisfy the close.
ibox(s, 0);
}
- ast::expr_loop_body(body) => {
- print_expr(s, body);
- }
ast::expr_do_body(body) => {
print_expr(s, body);
}
ast::expr_break(opt_ident) => {
word(s.s, "break");
space(s.s);
- foreach ident in opt_ident.iter() {
+ for ident in opt_ident.iter() {
word(s.s, "'");
print_ident(s, *ident);
space(s.s);
ast::expr_again(opt_ident) => {
word(s.s, "loop");
space(s.s);
- foreach ident in opt_ident.iter() {
+ for ident in opt_ident.iter() {
word(s.s, "'");
print_ident(s, *ident);
space(s.s)
popen(s);
print_string(s, a.asm);
word_space(s, ":");
- foreach &(co, o) in a.outputs.iter() {
+ for &(co, o) in a.outputs.iter() {
print_string(s, co);
popen(s);
print_expr(s, o);
word_space(s, ",");
}
word_space(s, ":");
- foreach &(co, o) in a.inputs.iter() {
+ for &(co, o) in a.inputs.iter() {
print_string(s, co);
popen(s);
print_expr(s, o);
maybe_print_comment(s, path.span.lo);
if path.global { word(s.s, "::"); }
let mut first = true;
- foreach id in path.idents.iter() {
+ for id in path.idents.iter() {
if first { first = false; } else { word(s.s, "::"); }
print_ident(s, *id);
}
if path.rp.is_some() || !path.types.is_empty() {
word(s.s, "<");
- foreach r in path.rp.iter() {
+ for r in path.rp.iter() {
print_lifetime(s, r);
if !path.types.is_empty() {
word_space(s, ",");
do commasep(s, inconsistent, *before) |s, &p| {
print_pat(s, p);
}
- foreach &p in slice.iter() {
+ for &p in slice.iter() {
if !before.is_empty() { word_space(s, ","); }
word(s.s, "..");
print_pat(s, p);
// self type and the args all in the same box.
box(s, 0u, inconsistent);
let mut first = true;
- foreach explicit_self in opt_explicit_self.iter() {
+ for explicit_self in opt_explicit_self.iter() {
first = !print_explicit_self(s, *explicit_self);
}
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
if first { first = false; } else { word_space(s, ","); }
print_arg(s, arg);
}
if !bounds.is_empty() {
word(s.s, ":");
let mut first = true;
- foreach bound in bounds.iter() {
+ for bound in bounds.iter() {
nbsp(s);
if first {
first = false;
}
let mut ints = ~[];
- foreach i in range(0u, total) {
+ for i in range(0u, total) {
ints.push(i);
}
// self type and the args all in the same box.
box(s, 0u, inconsistent);
let mut first = true;
- foreach explicit_self in opt_explicit_self.iter() {
+ for explicit_self in opt_explicit_self.iter() {
first = !print_explicit_self(s, *explicit_self);
}
- foreach arg in decl.inputs.iter() {
+ for arg in decl.inputs.iter() {
if first { first = false; } else { word_space(s, ","); }
print_arg(s, arg);
}
}
comments::isolated => {
pprust::hardbreak_if_not_bol(s);
- foreach line in cmnt.lines.iter() {
+ for line in cmnt.lines.iter() {
// Don't print empty lines because they will end up as trailing
// whitespace
if !line.is_empty() { word(s.s, *line); }
hardbreak(s.s);
} else {
ibox(s, 0u);
- foreach line in cmnt.lines.iter() {
+ for line in cmnt.lines.iter() {
if !line.is_empty() { word(s.s, *line); }
hardbreak(s.s);
}
pub fn prefill(init: &[T]) -> Interner<T> {
let rv = Interner::new();
- foreach v in init.iter() {
+ for v in init.iter() {
rv.intern((*v).clone());
}
rv
pub fn prefill(init: &[&str]) -> StrInterner {
let rv = StrInterner::new();
- foreach &v in init.iter() { rv.intern(v); }
+ for &v in init.iter() { rv.intern(v); }
rv
}
}
pub fn visit_mod<E:Clone>(visitor: @Visitor<E>, module: &_mod, env: E) {
- foreach view_item in module.view_items.iter() {
+ for view_item in module.view_items.iter() {
visitor.visit_view_item(view_item, env.clone())
}
- foreach item in module.items.iter() {
+ for item in module.items.iter() {
visitor.visit_item(*item, env.clone())
}
}
visitor.visit_mod(module, item.span, item.id, env)
}
item_foreign_mod(ref foreign_module) => {
- foreach view_item in foreign_module.view_items.iter() {
+ for view_item in foreign_module.view_items.iter() {
visitor.visit_view_item(view_item, env.clone())
}
- foreach foreign_item in foreign_module.items.iter() {
+ for foreign_item in foreign_module.items.iter() {
visitor.visit_foreign_item(*foreign_item, env.clone())
}
}
ref typ,
ref methods) => {
visitor.visit_generics(type_parameters, env.clone());
- foreach trait_reference in trait_references.iter() {
+ for trait_reference in trait_references.iter() {
visit_trait_ref(visitor, trait_reference, env.clone())
}
visitor.visit_ty(typ, env.clone());
- foreach method in methods.iter() {
+ for method in methods.iter() {
visit_method_helper(visitor, *method, env.clone())
}
}
}
item_trait(ref generics, ref trait_paths, ref methods) => {
visitor.visit_generics(generics, env.clone());
- foreach trait_path in trait_paths.iter() {
+ for trait_path in trait_paths.iter() {
visit_path(visitor, &trait_path.path, env.clone())
}
- foreach method in methods.iter() {
+ for method in methods.iter() {
visitor.visit_trait_method(method, env.clone())
}
}
enum_definition: &ast::enum_def,
generics: &Generics,
env: E) {
- foreach variant in enum_definition.variants.iter() {
+ for variant in enum_definition.variants.iter() {
match variant.node.kind {
tuple_variant_kind(ref variant_arguments) => {
- foreach variant_argument in variant_arguments.iter() {
+ for variant_argument in variant_arguments.iter() {
visitor.visit_ty(&variant_argument.ty, env.clone())
}
}
visitor.visit_ty(mutable_type.ty, env)
}
ty_tup(ref tuple_element_types) => {
- foreach tuple_element_type in tuple_element_types.iter() {
+ for tuple_element_type in tuple_element_types.iter() {
visitor.visit_ty(tuple_element_type, env.clone())
}
}
ty_closure(ref function_declaration) => {
- foreach argument in function_declaration.decl.inputs.iter() {
+ for argument in function_declaration.decl.inputs.iter() {
visitor.visit_ty(&argument.ty, env.clone())
}
visitor.visit_ty(&function_declaration.decl.output, env.clone());
- foreach bounds in function_declaration.bounds.iter() {
+ for bounds in function_declaration.bounds.iter() {
visit_ty_param_bounds(visitor, bounds, env.clone())
}
}
ty_bare_fn(ref function_declaration) => {
- foreach argument in function_declaration.decl.inputs.iter() {
+ for argument in function_declaration.decl.inputs.iter() {
visitor.visit_ty(&argument.ty, env.clone())
}
visitor.visit_ty(&function_declaration.decl.output, env.clone())
}
ty_path(ref path, ref bounds, _) => {
visit_path(visitor, path, env.clone());
- foreach bounds in bounds.iter() {
+ for bounds in bounds.iter() {
visit_ty_param_bounds(visitor, bounds, env.clone())
}
}
}
pub fn visit_path<E:Clone>(visitor: @Visitor<E>, path: &Path, env: E) {
- foreach typ in path.types.iter() {
+ for typ in path.types.iter() {
visitor.visit_ty(typ, env.clone())
}
}
match pattern.node {
pat_enum(ref path, ref children) => {
visit_path(visitor, path, env.clone());
- foreach children in children.iter() {
- foreach child in children.iter() {
+ for children in children.iter() {
+ for child in children.iter() {
visitor.visit_pat(*child, env.clone())
}
}
}
pat_struct(ref path, ref fields, _) => {
visit_path(visitor, path, env.clone());
- foreach field in fields.iter() {
+ for field in fields.iter() {
visitor.visit_pat(field.pat, env.clone())
}
}
pat_tup(ref tuple_elements) => {
- foreach tuple_element in tuple_elements.iter() {
+ for tuple_element in tuple_elements.iter() {
visitor.visit_pat(*tuple_element, env.clone())
}
}
}
pat_wild => (),
pat_vec(ref prepattern, ref slice_pattern, ref postpatterns) => {
- foreach prepattern in prepattern.iter() {
+ for prepattern in prepattern.iter() {
visitor.visit_pat(*prepattern, env.clone())
}
- foreach slice_pattern in slice_pattern.iter() {
+ for slice_pattern in slice_pattern.iter() {
visitor.visit_pat(*slice_pattern, env.clone())
}
- foreach postpattern in postpatterns.iter() {
+ for postpattern in postpatterns.iter() {
visitor.visit_pat(*postpattern, env.clone())
}
}
pub fn visit_ty_param_bounds<E:Clone>(visitor: @Visitor<E>,
bounds: &OptVec<TyParamBound>,
env: E) {
- foreach bound in bounds.iter() {
+ for bound in bounds.iter() {
match *bound {
TraitTyParamBound(ref typ) => {
visit_trait_ref(visitor, typ, env.clone())
pub fn visit_generics<E:Clone>(visitor: @Visitor<E>,
generics: &Generics,
env: E) {
- foreach type_parameter in generics.ty_params.iter() {
+ for type_parameter in generics.ty_params.iter() {
visit_ty_param_bounds(visitor, &type_parameter.bounds, env.clone())
}
}
pub fn visit_fn_decl<E:Clone>(visitor: @Visitor<E>,
function_declaration: &fn_decl,
env: E) {
- foreach argument in function_declaration.inputs.iter() {
+ for argument in function_declaration.inputs.iter() {
visitor.visit_pat(argument.pat, env.clone());
visitor.visit_ty(&argument.ty, env.clone())
}
pub fn visit_ty_method<E:Clone>(visitor: @Visitor<E>,
method_type: &TypeMethod,
env: E) {
- foreach argument_type in method_type.decl.inputs.iter() {
+ for argument_type in method_type.decl.inputs.iter() {
visitor.visit_ty(&argument_type.ty, env.clone())
}
visitor.visit_generics(&method_type.generics, env.clone());
_: &Generics,
_: NodeId,
env: E) {
- foreach field in struct_definition.fields.iter() {
+ for field in struct_definition.fields.iter() {
visitor.visit_struct_field(*field, env.clone())
}
}
}
pub fn visit_block<E:Clone>(visitor: @Visitor<E>, block: &Block, env: E) {
- foreach view_item in block.view_items.iter() {
+ for view_item in block.view_items.iter() {
visitor.visit_view_item(view_item, env.clone())
}
- foreach statement in block.stmts.iter() {
+ for statement in block.stmts.iter() {
visitor.visit_stmt(*statement, env.clone())
}
visit_expr_opt(visitor, block.expr, env)
pub fn visit_exprs<E:Clone>(visitor: @Visitor<E>,
expressions: &[@expr],
env: E) {
- foreach expression in expressions.iter() {
+ for expression in expressions.iter() {
visitor.visit_expr(*expression, env.clone())
}
}
}
expr_struct(ref path, ref fields, optional_base) => {
visit_path(visitor, path, env.clone());
- foreach field in fields.iter() {
+ for field in fields.iter() {
visitor.visit_expr(field.expr, env.clone())
}
visit_expr_opt(visitor, optional_base, env.clone())
}
expr_tup(ref subexpressions) => {
- foreach subexpression in subexpressions.iter() {
+ for subexpression in subexpressions.iter() {
visitor.visit_expr(*subexpression, env.clone())
}
}
expr_call(callee_expression, ref arguments, _) => {
- foreach argument in arguments.iter() {
+ for argument in arguments.iter() {
visitor.visit_expr(*argument, env.clone())
}
visitor.visit_expr(callee_expression, env.clone())
}
expr_method_call(_, callee, _, ref types, ref arguments, _) => {
visit_exprs(visitor, *arguments, env.clone());
- foreach typ in types.iter() {
+ for typ in types.iter() {
visitor.visit_ty(typ, env.clone())
}
visitor.visit_expr(callee, env.clone())
}
expr_addr_of(_, subexpression) |
expr_unary(_, _, subexpression) |
- expr_loop_body(subexpression) |
expr_do_body(subexpression) => {
visitor.visit_expr(subexpression, env.clone())
}
expr_loop(ref block, _) => visitor.visit_block(block, env.clone()),
expr_match(subexpression, ref arms) => {
visitor.visit_expr(subexpression, env.clone());
- foreach arm in arms.iter() {
+ for arm in arms.iter() {
visitor.visit_arm(arm, env.clone())
}
}
}
expr_field(subexpression, _, ref types) => {
visitor.visit_expr(subexpression, env.clone());
- foreach typ in types.iter() {
+ for typ in types.iter() {
visitor.visit_ty(typ, env.clone())
}
}
visitor.visit_expr(subexpression, env.clone())
}
expr_inline_asm(ref assembler) => {
- foreach &(_, input) in assembler.inputs.iter() {
+ for &(_, input) in assembler.inputs.iter() {
visitor.visit_expr(input, env.clone())
}
- foreach &(_, output) in assembler.outputs.iter() {
+ for &(_, output) in assembler.outputs.iter() {
visitor.visit_expr(output, env.clone())
}
}
}
pub fn visit_arm<E:Clone>(visitor: @Visitor<E>, arm: &arm, env: E) {
- foreach pattern in arm.pats.iter() {
+ for pattern in arm.pats.iter() {
visitor.visit_pat(*pattern, env.clone())
}
visit_expr_opt(visitor, arm.guard, env.clone());
-Subproject commit 2e9f0d21fe321849a4759a01fc28eae82ef196d6
+Subproject commit f67442eee27d3d075a65cf7f9a70f7ec6649ffd1
void
rust_task::reset_stack_limit() {
uintptr_t sp = get_sp();
+ bool reseted = false;
while (!sp_in_stk_seg(sp, stk)) {
+ reseted = true;
prev_stack();
assert(stk != NULL && "Failed to find the current stack");
}
+
+ // Each call to prev_stack will record the stack limit. If we *didn't*
+ // call prev_stack then we still need to record it now to catch a corner case:
+ // the throw to initiate unwinding starts on the C stack while sp limit is 0.
+ // If we don't set the limit here then the rust code run subsequently will
+ // will veer into the red zone. Lame!
+ if (!reseted) {
+ record_stack_limit();
+ }
}
void
virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
unsigned SectionID, bool isReadOnly);
+ bool finalizeMemory(std::string *ErrMsg) { return false; }
virtual bool applyPermissions(std::string *Str);
std::string Err;
TargetOptions Options;
- Options.JITExceptionHandling = true;
Options.JITEmitDebugInfo = true;
Options.NoFramePointerElim = true;
Options.EnableSegmentedStacks = EnableSegmentedStacks;
extern "C" LLVMValueRef LLVMBuildAtomicFence(LLVMBuilderRef B, AtomicOrdering order) {
return wrap(unwrap(B)->CreateFence(order));
}
-extern "C" LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,
- AtomicRMWInst::BinOp op,
- LLVMValueRef target,
- LLVMValueRef source,
- AtomicOrdering order) {
- return wrap(unwrap(B)->CreateAtomicRMW(op,
- unwrap(target), unwrap(source),
- order));
-}
extern "C" void LLVMSetDebug(int Enabled) {
#ifndef NDEBUG
# If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
# The actual contents of this file do not matter, but to trigger a change on the
# build bots then the contents should be changed so git updates the mtime.
-2013-07-03
+2013-07-04
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
#include "llvm/Linker.h"
#include "llvm/PassManager.h"
#include "llvm/IR/InlineAsm.h"
+S 2013-08-03 18e3db7
+ freebsd-x86_64 addf91b20416bf21a7c53ea9508bc302ec957ce9
+ linux-i386 ce103c323c0a0b75d1307014f1d6f8ff4d03c873
+ linux-x86_64 6828d854d174c7b514a4350dfdd92c059df059d6
+ macos-i386 ef4b67859146cacce54367f9243b5da9f9fde386
+ macos-x86_64 936d4e170d8207b40df64c5eca3a3a27b3eee08a
+ winnt-i386 332f0181fb68fcbeaaae342d5fb22889aa902152
+
S 2013-07-31 389aba0
freebsd-x86_64 c9783bb5723404be8ae371d265bbb9a1c679e4db
linux-i386 7413d98325b23dc461ced92757e5e19bec750dbd
k: A)
-> B {
let eq_fn = lst.eq_fn;
- foreach entry in lst.data.iter() {
+ for entry in lst.data.iter() {
if eq_fn(entry.key.clone(), k.clone()) {
return entry.value.clone();
}
io::println(" Ascending integers:");
do timed("insert") {
- foreach i in range(0u, n_keys) {
+ for i in range(0u, n_keys) {
map.insert(i, i + 1);
}
}
do timed("search") {
- foreach i in range(0u, n_keys) {
+ for i in range(0u, n_keys) {
assert_eq!(map.find(&i).unwrap(), &(i + 1));
}
}
do timed("remove") {
- foreach i in range(0, n_keys) {
+ for i in range(0, n_keys) {
assert!(map.remove(&i));
}
}
fn vector<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) {
do timed("insert") {
- foreach i in range(0u, n_keys) {
+ for i in range(0u, n_keys) {
map.insert(dist[i], i + 1);
}
}
do timed("search") {
- foreach i in range(0u, n_keys) {
+ for i in range(0u, n_keys) {
assert_eq!(map.find(&dist[i]).unwrap(), &(i + 1));
}
}
do timed("remove") {
- foreach i in range(0u, n_keys) {
+ for i in range(0u, n_keys) {
assert!(map.remove(&dist[i]));
}
}
{
let mut set = f();
do timed(&mut self.sequential_ints) {
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
set.insert(i);
}
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
assert!(set.contains(&i));
}
}
{
let mut set = f();
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
set.insert(i);
}
do timed(&mut self.delete_ints) {
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
assert!(set.remove(&i));
}
}
{
let mut set = f();
do timed(&mut self.sequential_strings) {
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
let s = uint::to_str(i);
set.insert(s);
}
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
let s = uint::to_str(i);
assert!(set.contains(&s));
}
{
let mut set = f();
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
set.insert(uint::to_str(i));
}
do timed(&mut self.delete_strings) {
- foreach i in range(0u, num_keys) {
+ for i in range(0u, num_keys) {
assert!(set.remove(&uint::to_str(i)));
}
}
let path = Path(env!("CFG_SRC_DIR"))
.push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
- foreach _ in range(0, 3) {
+ for _ in range(0, 3) {
let reader = io::file_reader(&path).unwrap();
while !reader.eof() {
reader.read_line();
let mut r = rand::rng();
let mut v = ~[];
- foreach i in range(0u, 1500) {
+ for i in range(0u, 1500) {
let mut rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
if r.gen() {
v.push_all(rv);
fn is_utf8_ascii() {
let mut v : ~[u8] = ~[];
- foreach _ in range(0u, 20000) {
+ for _ in range(0u, 20000) {
v.push('b' as u8);
if !str::is_utf8(v) {
fail!("is_utf8 failed");
fn is_utf8_multibyte() {
let s = "b¢€𤭢";
let mut v : ~[u8]= ~[];
- foreach _ in range(0u, 5000) {
+ for _ in range(0u, 5000) {
v.push_all(s.as_bytes());
if !str::is_utf8(v) {
fail!("is_utf8 failed");
let n = uint::from_str(args[1]).get();
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
let x = uint::to_str(i);
info!(x);
}
HashSet::new()
};
- foreach e in edges.iter() {
+ for e in edges.iter() {
match *e {
(i, j) => {
graph[i].insert(j);
do graph.consume_iter().transform |v| {
let mut vec = ~[];
- foreach i in v.consume() {
+ for i in v.consume() {
vec.push(i);
}
vec
}
}
let mut vec = ~[];
- foreach i in keys.consume() {
+ for i in keys.consume() {
vec.push(i);
}
return vec;
let stop = time::precise_time_s();
let mut total_edges = 0;
- foreach edges in graph.iter() { total_edges += edges.len(); }
+ for edges in graph.iter() { total_edges += edges.len(); }
io::stdout().write_line(fmt!("Generated graph with %? edges in %? seconds.",
total_edges / 2,
let num_bytes = 100;
let start = extra::time::precise_time_s();
let mut worker_results = ~[];
- foreach _ in range(0u, workers) {
+ for _ in range(0u, workers) {
let to_child = to_child.clone();
let mut builder = task::task();
builder.future_result(|r| worker_results.push(r));
do builder.spawn {
- foreach _ in range(0u, size / workers) {
+ for _ in range(0u, size / workers) {
//error!("worker %?: sending %? bytes", i, num_bytes);
to_child.send(bytes(num_bytes));
}
server(&from_parent, &to_parent);
}
- foreach r in worker_results.iter() {
+ for r in worker_results.iter() {
r.recv();
}
let num_bytes = 100;
let start = extra::time::precise_time_s();
let mut worker_results = ~[];
- foreach _ in range(0u, workers) {
+ for _ in range(0u, workers) {
let to_child = to_child.clone();
let mut builder = task::task();
builder.future_result(|r| worker_results.push(r));
do builder.spawn {
- foreach _ in range(0u, size / workers) {
+ for _ in range(0u, size / workers) {
//error!("worker %?: sending %? bytes", i, num_bytes);
to_child.send(bytes(num_bytes));
}
server(&from_parent, &to_parent);
}
- foreach r in worker_results.iter() {
+ for r in worker_results.iter() {
r.recv();
}
let mut num_chan = Some(num_chan);
let mut num_port = Some(num_port);
// Send/Receive lots of messages.
- foreach j in range(0u, count) {
+ for j in range(0u, count) {
//error!("task %?, iter %?", i, j);
let num_chan2 = num_chan.take_unwrap();
let num_port2 = num_port.take_unwrap();
// create the ring
let mut futures = ~[];
- foreach i in range(1u, num_tasks) {
+ for i in range(1u, num_tasks) {
//error!("spawning %?", i);
let (new_chan, num_port) = init();
let num_chan2 = Cell::new(num_chan.take());
thread_ring(0, msg_per_task, num_chan.take(), num_port);
// synchronize
- foreach f in futures.mut_iter() {
+ for f in futures.mut_iter() {
f.get()
}
let mut num_chan = Some(num_chan);
let mut num_port = Some(num_port);
// Send/Receive lots of messages.
- foreach j in range(0u, count) {
+ for j in range(0u, count) {
//error!("task %?, iter %?", i, j);
let num_chan2 = num_chan.take_unwrap();
let num_port2 = num_port.take_unwrap();
// create the ring
let mut futures = ~[];
- foreach i in range(1u, num_tasks) {
+ for i in range(1u, num_tasks) {
//error!("spawning %?", i);
let (new_chan, num_port) = init();
let num_chan2 = Cell::new(num_chan.take());
thread_ring(0, msg_per_task, num_chan.take(), num_port);
// synchronize
- foreach f in futures.mut_iter() {
+ for f in futures.mut_iter() {
let _ = f.get();
}
pub fn new() -> Noise2DContext {
let mut r = rand::rng();
let mut rgradients = [ Vec2 { x: 0.0, y: 0.0 }, ..256 ];
- foreach i in range(0, 256) {
+ for i in range(0, 256) {
rgradients[i] = random_gradient(&mut r);
}
let mut permutations = [ 0, ..256 ];
- foreach i in range(0, 256) {
+ for i in range(0, 256) {
permutations[i] = i;
}
r.shuffle_mut(permutations);
let mut pixels = [0f32, ..256*256];
let n2d = ~Noise2DContext::new();
do 100.times {
- foreach y in range(0, 256) {
- foreach x in range(0, 256) {
+ for y in range(0, 256) {
+ for x in range(0, 256) {
let v = n2d.get(
x as f32 * 0.1f32,
y as f32 * 0.1f32
};
};
- foreach y in range(0, 256) {
- foreach x in range(0, 256) {
+ for y in range(0, 256) {
+ for x in range(0, 256) {
print(symbols[(pixels[y*256+x] / 0.2f32) as int]);
}
println("");
fn print_complements() {
let all = [Blue, Red, Yellow];
- foreach aa in all.iter() {
- foreach bb in all.iter() {
+ for aa in all.iter() {
+ for bb in all.iter() {
println(show_color(*aa) + " + " + show_color(*bb) +
" -> " + show_color(transform(*aa, *bb)));
}
fn show_color_list(set: ~[color]) -> ~str {
let mut out = ~"";
- foreach col in set.iter() {
+ for col in set.iter() {
out.push_char(' ');
out.push_str(show_color(*col));
}
}
// tell each creature to stop
- foreach to_one in to_creature.iter() {
+ for to_one in to_creature.iter() {
to_one.send(None);
}
// save each creature's meeting stats
let mut report = ~[];
- foreach _to_one in to_creature.iter() {
+ for _to_one in to_creature.iter() {
report.push(from_creatures_log.recv());
}
io::println(show_color_list(set));
// print each creature's stats
- foreach rep in report.iter() {
+ for rep in report.iter() {
io::println(*rep);
}
r -= 1;
}
- foreach (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
+ for (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
*perm_i = *perm1_i;
}
}
let k2 = (k+1) >> 1;
- foreach i in range(0i32, k2) {
+ for i in range(0i32, k2) {
let (perm_i, perm_k_i) = {
(perm.unsafe_get(i as uint),
perm.unsafe_get((k-i) as uint))
fn sum_and_scale(a: &'static [AminoAcid]) -> ~[AminoAcid] {
let mut result = ~[];
let mut p = 0f32;
- foreach a_i in a.iter() {
+ for a_i in a.iter() {
let mut a_i = *a_i;
p += a_i.p;
a_i.p = p * LOOKUP_SCALE;
fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] {
let mut lookup = [ NULL_AMINO_ACID, ..LOOKUP_SIZE ];
let mut j = 0;
- foreach (i, slot) in lookup.mut_iter().enumerate() {
+ for (i, slot) in lookup.mut_iter().enumerate() {
while a[j].p < (i as f32) {
j += 1;
}
fn nextc(&mut self) -> u8 {
let r = self.rng(1.0);
- foreach a in self.lookup.iter() {
+ for a in self.lookup.iter() {
if a.p >= r {
return a.c;
}
let mut buf = [0, ..LINE_LEN + 1];
do lines.times {
- foreach i in range(0u, LINE_LEN) {
+ for i in range(0u, LINE_LEN) {
buf[i] = self.nextc();
}
buf[LINE_LEN] = '\n' as u8;
1,
self.stdout);
}
- foreach i in range(0u, chars_left) {
+ for i in range(0u, chars_left) {
buf[i] = self.nextc();
}
fwrite(transmute(&buf[0]), chars_left as size_t, 1, self.stdout);
fn make_cumulative(aa: ~[AminoAcids]) -> ~[AminoAcids] {
let mut cp: u32 = 0u32;
let mut ans: ~[AminoAcids] = ~[];
- foreach a in aa.iter() {
+ for a in aa.iter() {
cp += a.prob;
ans.push(AminoAcids {ch: a.ch, prob: cp});
}
last: rng.next()
};
let mut op: ~str = ~"";
- foreach _ in range(0u, n as uint) {
+ for _ in range(0u, n as uint) {
op.push_char(select_random(myrandom_next(rng, 100u32),
genelist.clone()));
if op.len() >= LINE_LENGTH {
wr.write_line(~">" + id + " " + desc);
let mut op = str::with_capacity( LINE_LENGTH );
let sl = s.len();
- foreach i in range(0u, n as uint) {
+ for i in range(0u, n as uint) {
if (op.len() >= LINE_LENGTH) {
wr.write_line( op );
op = str::with_capacity( LINE_LENGTH );
let mut pairs = ~[];
// map -> [(k,%)]
- foreach (key, &val) in mm.iter() {
+ for (key, &val) in mm.iter() {
pairs.push(((*key).clone(), pct(val, total)));
}
let mut buffer = ~"";
- foreach kv in pairs_sorted.iter() {
+ for kv in pairs_sorted.iter() {
let (k,v) = (*kv).clone();
unsafe {
let b = str::raw::from_bytes(k);
(_, true) => {
let line_bytes = line.as_bytes();
- foreach (ii, _sz) in sizes.iter().enumerate() {
+ for (ii, _sz) in sizes.iter().enumerate() {
let lb = line_bytes.to_owned();
to_child[ii].send(lb);
}
}
// finish...
- foreach (ii, _sz) in sizes.iter().enumerate() {
+ for (ii, _sz) in sizes.iter().enumerate() {
to_child[ii].send(~[]);
}
// now fetch and print result messages
- foreach (ii, _sz) in sizes.iter().enumerate() {
+ for (ii, _sz) in sizes.iter().enumerate() {
io::println(from_child[ii].recv());
}
}
fn pack(string: &str) -> Code {
let mut code = Code(0u64);
- foreach i in range(0u, string.len()) {
+ for i in range(0u, string.len()) {
code = code.push_char(string[i]);
}
code
let mode = "w";
let stdout = fdopen(STDOUT_FILENO as c_int, transmute(&mode[0]));
- foreach y in range(0i32, h) {
+ for y in range(0i32, h) {
let y = y as f64;
- foreach x in range(0i32, w) {
+ for x in range(0i32, w) {
let mut Zr = 0f64;
let mut Zi = 0f64;
let mut Tr = 0f64;
let Cr = 2.0 * (x as f64) / (w as f64) - 1.5;
let Ci = 2.0 * (y as f64) / (h as f64) - 1.0;
- foreach _ in range(0i32, ITER as i32) {
+ for _ in range(0i32, ITER as i32) {
if Tr + Ti > LIMIT * LIMIT {
break;
}
fn advance(bodies: &mut [Planet, ..N_BODIES], dt: f64, steps: i32) {
let mut d = [ 0.0, ..3 ];
do (steps as uint).times {
- foreach i in range(0u, N_BODIES) {
- foreach j in range(i + 1, N_BODIES) {
+ for i in range(0u, N_BODIES) {
+ for j in range(i + 1, N_BODIES) {
d[0] = bodies[i].x[0] - bodies[j].x[0];
d[1] = bodies[i].x[1] - bodies[j].x[1];
d[2] = bodies[i].x[2] - bodies[j].x[2];
}
}
- foreach a in bodies.mut_iter() {
+ for a in bodies.mut_iter() {
a.x[0] += dt * a.v[0];
a.x[1] += dt * a.v[1];
a.x[2] += dt * a.v[2];
fn energy(bodies: &[Planet, ..N_BODIES]) -> f64 {
let mut e = 0.0;
let mut d = [ 0.0, ..3 ];
- foreach i in range(0u, N_BODIES) {
- foreach k in range(0u, 3) {
+ for i in range(0u, N_BODIES) {
+ for k in range(0u, 3) {
e += bodies[i].mass * bodies[i].v[k] * bodies[i].v[k] / 2.0;
}
- foreach j in range(i + 1, N_BODIES) {
- foreach k in range(0u, 3) {
+ for j in range(i + 1, N_BODIES) {
+ for k in range(0u, 3) {
d[k] = bodies[i].x[k] - bodies[j].x[k];
}
let dist = (d[0]*d[0] + d[1]*d[1] + d[2]*d[2]).sqrt();
}
fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) {
- foreach i in range(0u, N_BODIES) {
- foreach k in range(0u, 3) {
+ for i in range(0u, N_BODIES) {
+ for k in range(0u, 3) {
bodies[0].v[k] -= bodies[i].v[k] * bodies[i].mass / SOLAR_MASS;
}
}
fn stress(num_tasks: int) {
let mut results = ~[];
- foreach i in range(0, num_tasks) {
+ for i in range(0, num_tasks) {
let mut builder = task::task();
builder.future_result(|r| results.push(r));
do builder.spawn {
stress_task(i);
}
}
- foreach r in results.iter() {
+ for r in results.iter() {
r.recv();
}
}
let out = io::stdout();
- foreach n in range(1, max + 1) {
- foreach _ in range(0, num_trials) {
+ for n in range(1, max + 1) {
+ for _ in range(0, num_trials) {
let start = time::precise_time_ns();
let fibn = fib(n);
let stop = time::precise_time_ns();
fn dot(v: &[f64], u: &[f64]) -> f64 {
let mut sum = 0.0;
- foreach (i, &v_i) in v.iter().enumerate() {
+ for (i, &v_i) in v.iter().enumerate() {
sum += v_i * u[i];
}
sum
}
fn mult_Av(v: &mut [f64], out: &mut [f64]) {
- foreach (i, out_i) in out.mut_iter().enumerate() {
+ for (i, out_i) in out.mut_iter().enumerate() {
let mut sum = 0.0;
- foreach (j, &v_j) in v.mut_iter().enumerate() {
+ for (j, &v_j) in v.mut_iter().enumerate() {
sum += v_j / (A(i as i32, j as i32) as f64);
}
*out_i = sum;
}
fn mult_Atv(v: &mut [f64], out: &mut [f64]) {
- foreach (i, out_i) in out.mut_iter().enumerate() {
+ for (i, out_i) in out.mut_iter().enumerate() {
let mut sum = 0.0;
- foreach (j, &v_j) in v.mut_iter().enumerate() {
+ for (j, &v_j) in v.mut_iter().enumerate() {
sum += v_j / (A(j as i32, i as i32) as f64);
}
*out_i = sum;
use std::uint;
fn append_sequential(min: uint, max: uint, map: &mut SmallIntMap<uint>) {
- foreach i in range(min, max) {
+ for i in range(min, max) {
map.insert(i, i + 22u);
}
}
fn check_sequential(min: uint, max: uint, map: &SmallIntMap<uint>) {
- foreach i in range(min, max) {
+ for i in range(min, max) {
assert_eq!(*map.get(&i), i + 22u);
}
}
let mut checkf = 0.0;
let mut appendf = 0.0;
- foreach _ in range(0u, rep) {
+ for _ in range(0u, rep) {
let mut map = SmallIntMap::new();
let start = extra::time::precise_time_s();
append_sequential(0u, max, &mut map);
}
pub fn equal(&self, other: &Sudoku) -> bool {
- foreach row in range(0u8, 9u8) {
- foreach col in range(0u8, 9u8) {
+ for row in range(0u8, 9u8) {
+ for col in range(0u8, 9u8) {
if self.grid[row][col] != other.grid[row][col] {
return false;
}
}
pub fn write(&self, writer: @io::Writer) {
- foreach row in range(0u8, 9u8) {
+ for row in range(0u8, 9u8) {
writer.write_str(fmt!("%u", self.grid[row][0] as uint));
- foreach col in range(1u8, 9u8) {
+ for col in range(1u8, 9u8) {
writer.write_str(fmt!(" %u", self.grid[row][col] as uint));
}
writer.write_char('\n');
// solve sudoku grid
pub fn solve(&mut self) {
let mut work: ~[(u8, u8)] = ~[]; /* queue of uncolored fields */
- foreach row in range(0u8, 9u8) {
- foreach col in range(0u8, 9u8) {
+ for row in range(0u8, 9u8) {
+ for col in range(0u8, 9u8) {
let color = self.grid[row][col];
if color == 0u8 {
work.push((row, col));
// find colors available in neighbourhood of (row, col)
fn drop_colors(&mut self, avail: &mut Colors, row: u8, col: u8) {
- foreach idx in range(0u8, 9u8) {
+ for idx in range(0u8, 9u8) {
avail.remove(self.grid[idx][col]); /* check same column fields */
avail.remove(self.grid[row][idx]); /* check same row fields */
}
// check same block fields
let row0 = (row / 3u8) * 3u8;
let col0 = (col / 3u8) * 3u8;
- foreach alt_row in range(row0, row0 + 3u8) {
- foreach alt_col in range(col0, col0 + 3u8) {
+ for alt_row in range(row0, row0 + 3u8) {
+ for alt_col in range(col0, col0 + 3u8) {
avail.remove(self.grid[alt_row][alt_col]);
}
}
impl Foo {
pub fn foo(&mut self, fun: &fn(&int)) {
- foreach f in self.n.iter() {
+ for f in self.n.iter() {
fun(f);
}
}
fn main() {
let v = @mut [ 1, 2, 3 ];
- foreach _x in v.iter() {
+ for _x in v.iter() {
v[1] = 4; //~ ERROR cannot assign
}
}
impl<A> vec_monad<A> for ~[A] {
fn bind<B>(&self, f: &fn(A) -> ~[B]) {
let mut r = fail!();
- foreach elt in self.iter() { r = r + f(*elt); }
+ for elt in self.iter() { r = r + f(*elt); }
//~^ WARNING unreachable expression
//~^^ ERROR the type of this value must be known
}
fn fail_len(v: ~[int]) -> uint {
let mut i = 3;
fail!();
- foreach x in v.iter() { i += 1u; }
+ for x in v.iter() { i += 1u; }
//~^ ERROR: unreachable statement
return i;
}
('c', 'd'),
('e', 'f')];
- foreach &(x,y) in v.iter() {} // should be OK
+ for &(x,y) in v.iter() {} // should be OK
// Make sure none of the errors above were fatal
let x: char = true; //~ ERROR expected `char` but found `bool`
fn main() {
let mut xs = ~[1, 2, 3, 4];
- foreach x in xs.mut_iter() {
+ for x in xs.mut_iter() {
xs.push(1) //~ ERROR cannot borrow `xs` as mutable
}
}
'\xA0', '\u1680', '\u180E', '\u2000', '\u2001', '\u2002', '\u2003',
'\u2004', '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200A',
'\u2028', '\u2029', '\u202F', '\u205F', '\u3000'];
- foreach c in chars.iter() {
+ for c in chars.iter() {
let ws = c.is_whitespace();
println(fmt!("%? %?" , c , ws));
}
'\xA0', '\u1680', '\u180E', '\u2000', '\u2001', '\u2002', '\u2003',
'\u2004', '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200A',
'\u2028', '\u2029', '\u202F', '\u205F', '\u3000'];
- foreach c in chars.iter() {
+ for c in chars.iter() {
let ws = c.is_whitespace();
println(fmt!("%? %?", c , ws));
}
fn f(v: &[int]) {
let mut n = 0;
- foreach e in v.iter() {
+ for e in v.iter() {
n = *e; // This comment once triggered pretty printer bug
}
}
// error-pattern:moop
extern mod extra;
-fn main() { foreach _ in range(0u, 10u) { fail!("moop"); } }
+fn main() { for _ in range(0u, 10u) { fail!("moop"); } }
let count = @mut 0u;
let mut map = std::hashmap::HashMap::new();
let mut arr = ~[];
- foreach i in range(0u, 10u) {
+ for i in range(0u, 10u) {
arr.push(@~"key stuff");
map.insert(arr.clone(), arr + &[@~"value stuff"]);
if arr.len() == 5 {
pub fn main() {
let mut sum = 0;
let xs = ~[1, 2, 3, 4, 5];
- foreach x in xs.iter() {
+ for x in xs.iter() {
sum += *x;
}
assert_eq!(sum, 15);
let v = ~[-1f, 0f, 1f, 2f, 3f];
// Statement form does not require parentheses:
- foreach i in v.iter() {
+ for i in v.iter() {
info!("%?", *i);
}
// xfail-fast
-fn iter_vec<T>(v: ~[T], f: &fn(&T)) { foreach x in v.iter() { f(x); } }
+fn iter_vec<T>(v: ~[T], f: &fn(&T)) { for x in v.iter() { f(x); } }
pub fn main() {
let v = ~[1, 2, 3, 4, 5, 6, 7];
// xfail-fast
-fn iter_vec<T>(v: ~[T], f: &fn(&T)) { foreach x in v.iter() { f(x); } }
+fn iter_vec<T>(v: ~[T], f: &fn(&T)) { for x in v.iter() { f(x); } }
pub fn main() {
let v = ~[1, 2, 3, 4, 5];
fn sum_slice(x: &[int]) -> int {
let mut sum = 0;
- foreach i in x.iter() { sum += *i; }
+ for i in x.iter() { sum += *i; }
return sum;
}
fn want_slice(v: &[int]) -> int {
let mut sum = 0;
- foreach i in v.iter() { sum += *i; }
+ for i in v.iter() { sum += *i; }
sum
}
impl Wizard {
pub fn cast(&mut self) {
- foreach &spell in self.spells.iter() {
+ for &spell in self.spells.iter() {
println(spell);
}
}
loop { i += 1; if i == 20 { break; } }
assert_eq!(i, 20);
let xs = [1, 2, 3, 4, 5, 6];
- foreach x in xs.iter() {
+ for x in xs.iter() {
if *x == 3 { break; } assert!((*x <= 3));
}
i = 0;
if i >= 10 { break; }
}
let ys = ~[1, 2, 3, 4, 5, 6];
- foreach x in ys.iter() {
+ for x in ys.iter() {
if *x % 2 == 0 { loop; }
assert!((*x % 2 != 0));
}
fn annoy_neighbors(critter: @noisy) {
- foreach i in range(0u, 10) { critter.speak(); }
+ for i in range(0u, 10) { critter.speak(); }
}
pub fn main() {
pub fn main() {
let nyan : cat = cat(0, 2, "nyan");
- foreach _ in range(1u, 5u) { nyan.speak(); }
+ for _ in range(1u, 5u) { nyan.speak(); }
// cat returns true if uint input is greater than
// the number of meows so far
assert!((nyan.get(1)));
pub fn main() {
let mut nyan: cat<~str> = cat::new(0, 2, ~"nyan");
- foreach _ in range(1u, 5) { nyan.speak(); }
+ for _ in range(1u, 5) { nyan.speak(); }
assert!(*nyan.find(&1).unwrap() == ~"nyan");
assert_eq!(nyan.find(&10), None);
let mut spotty: cat<cat_type> = cat::new(2, 57, tuxedo);
- foreach _ in range(0u, 6) { spotty.speak(); }
+ for _ in range(0u, 6) { spotty.speak(); }
assert_eq!(spotty.len(), 8);
assert!((spotty.contains_key(&2)));
assert_eq!(spotty.get(&3), &tuxedo);
let mut nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert!((!nyan.eat()));
- foreach _ in range(1u, 10u) { nyan.speak(); };
+ for _ in range(1u, 10u) { nyan.speak(); };
assert!((nyan.eat()));
}
let mut nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert!((!nyan.eat()));
- foreach _ in range(1u, 10u) {
+ for _ in range(1u, 10u) {
make_speak(nyan.clone());
}
}
}
fn annoy_neighbors<T:noisy>(critter: T) {
- foreach i in range(0u, 10u) {
+ for i in range(0u, 10u) {
let what = critter.speak();
info!("%u %d", i, what);
}
let mut nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert!((!nyan.eat()));
- foreach _ in range(1u, 10u) { nyan.speak(); };
+ for _ in range(1u, 10u) { nyan.speak(); };
assert!((nyan.eat()));
}
let mut nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert!((!nyan.eat()));
- foreach _ in range(1u, 10u) { nyan.speak(); };
+ for _ in range(1u, 10u) { nyan.speak(); };
assert!((nyan.eat()));
}
fn sum(x: &[int]) -> int {
let mut sum = 0;
- foreach y in x.iter() { sum += *y; }
+ for y in x.iter() { sum += *y; }
return sum;
}
static closures: &'static [S<'static>] = &[S(f), S(f)];
pub fn main() {
- foreach &bare_fn in bare_fns.iter() { bare_fn() }
- foreach &closure in closures.iter() { (*closure)() }
+ for &bare_fn in bare_fns.iter() { bare_fn() }
+ for &closure in closures.iter() { (*closure)() }
}
// in order for both Ord and TotalOrd
let es = [e0, e11, e12, e21, e22];
- foreach (i, e1) in es.iter().enumerate() {
- foreach (j, e2) in es.iter().enumerate() {
+ for (i, e1) in es.iter().enumerate() {
+ for (j, e2) in es.iter().enumerate() {
let ord = i.cmp(&j);
let eq = i == j;
// in order for both Ord and TotalOrd
let ss = [s1, s2];
- foreach (i, s1) in ss.iter().enumerate() {
- foreach (j, s2) in ss.iter().enumerate() {
+ for (i, s1) in ss.iter().enumerate() {
+ for (j, s2) in ss.iter().enumerate() {
let ord = i.cmp(&j);
let eq = i == j;
// in order for both Ord and TotalOrd
let tss = [ts1, ts2];
- foreach (i, ts1) in tss.iter().enumerate() {
- foreach (j, ts2) in tss.iter().enumerate() {
+ for (i, ts1) in tss.iter().enumerate() {
+ for (j, ts2) in tss.iter().enumerate() {
let ord = i.cmp(&j);
let eq = i == j;
impl Box {
pub fn set_many(&mut self, xs: &[uint]) {
- foreach x in xs.iter() { self.x = *x; }
+ for x in xs.iter() { self.x = *x; }
}
pub fn set_many2(@mut self, xs: &[uint]) {
- foreach x in xs.iter() { self.x = *x; }
+ for x in xs.iter() { self.x = *x; }
}
}
pub fn main() {
let v : &[(int,int)] = &[ (1, 2), (3, 4), (5, 6) ];
- foreach &(x, y) in v.iter() {
+ for &(x, y) in v.iter() {
println(y.to_str());
println(x.to_str());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn main() { let x: ~[int] = ~[]; foreach _ in x.iter() { fail!("moop"); } }
+pub fn main() { let x: ~[int] = ~[]; for _ in x.iter() { fail!("moop"); } }
fn main() {
let x = [1,..100];
let mut y = 0;
- foreach i in x.iter() {
+ for i in x.iter() {
if y > 10 {
break;
}
fn main() {
let mut h = HashMap::new();
let kvs = [(1, 10), (2, 20), (3, 30)];
- foreach &(k,v) in kvs.iter() {
+ for &(k,v) in kvs.iter() {
h.insert(k,v);
}
let mut x = 0;
let mut i = h.iter();
- foreach (&k,&v) in i {
+ for (&k,&v) in i {
x += k;
y += v;
break;
}
- foreach (&k,&v) in i {
+ for (&k,&v) in i {
x += k;
y += v;
}
fn main() {
let mut h = HashMap::new();
let kvs = [(1, 10), (2, 20), (3, 30)];
- foreach &(k,v) in kvs.iter() {
+ for &(k,v) in kvs.iter() {
h.insert(k,v);
}
let mut x = 0;
let mut y = 0;
- foreach (&k,&v) in h.iter() {
+ for (&k,&v) in h.iter() {
x += k;
y += v;
}
fn main() {
let x = [1,..100];
let mut y = 0;
- foreach (n,i) in x.iter().enumerate() {
+ for (n,i) in x.iter().enumerate() {
if n < 10 {
loop;
}
let y = [2,..100];
let mut p = 0;
let mut q = 0;
- foreach i in x.iter() {
- foreach j in y.iter() {
+ for i in x.iter() {
+ for j in y.iter() {
p += *j;
}
q += *i + p;
fn main() {
let x = [1,..100];
let mut y = 0;
- foreach i in x.iter() {
+ for i in x.iter() {
y += *i
}
assert!(y == 100);
impl<T> vec_utils<T> for ~[T] {
fn map_<U>(x: &~[T], f: &fn(&T) -> U) -> ~[U] {
let mut r = ~[];
- foreach elt in x.iter() {
+ for elt in x.iter() {
r.push(f(elt));
}
r
enum ctrl_proto { find_reducer(~[u8], Chan<int>), mapper_done, }
fn start_mappers(ctrl: SharedChan<ctrl_proto>, inputs: ~[~str]) {
- foreach i in inputs.iter() {
+ for i in inputs.iter() {
let ctrl = ctrl.clone();
let i = i.clone();
task::spawn(|| map_task(ctrl.clone(), i.clone()) );
let mut grid = ~[];
do input.each_line |line| {
let mut row = ~[];
- foreach c in line.iter() {
+ for c in line.iter() {
row.push(square_from_char(c))
}
grid.push(row);
true
};
let width = grid[0].len();
- foreach row in grid.iter() { assert!(row.len() == width) }
+ for row in grid.iter() { assert!(row.len() == width) }
grid
}
let bools = ~[false, false, true, false, false, true, true, false];
let bools2 = to_bools(Storage{storage: ~[0b01100100]});
- foreach i in range(0u, 8) {
+ for i in range(0u, 8) {
printfln!("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint);
}
}
fn print_str_vector(vector: ~[~str]) {
- foreach string in vector.iter() {
+ for string in vector.iter() {
println(*string);
}
}
trait Canvas {
fn add_point(&self, point: &int);
fn add_points(&self, shapes: &[int]) {
- foreach pt in shapes.iter() {
+ for pt in shapes.iter() {
self.add_point(pt)
}
}
// Unlike interfaces traits support default implementations.
// Got an ICE as soon as I added this method.
fn add_points(&mut self, shapes: &[Point]) {
- foreach pt in shapes.iter() {self.add_point(*pt)};
+ for pt in shapes.iter() {self.add_point(*pt)};
}
}
fn add_rect(&mut self, shape: Rect) {
// Add the top and bottom lines.
- foreach x in range(shape.top_left.x, shape.top_left.x + shape.size.width) {
+ for x in range(shape.top_left.x, shape.top_left.x + shape.size.width) {
self.add_pt(x, shape.top_left.y);
self.add_pt(x, shape.top_left.y + shape.size.height - 1);
}
// Add the left and right lines.
- foreach y in range(shape.top_left.y, shape.top_left.y + shape.size.height) {
+ for y in range(shape.top_left.y, shape.top_left.y + shape.size.height) {
self.add_pt(shape.top_left.x, y);
self.add_pt(shape.top_left.x + shape.size.width - 1, y);
}
let callback: SamplesFn =
|buffer|
{
- foreach i in range(0u, buffer.len()) {
+ for i in range(0u, buffer.len()) {
error!("%?: %f", i, buffer[i])
}
};
let mut res = ~"*";
res.push_str(cmd.len().to_str());
res.push_str("\r\n");
- foreach s in cmd.iter() {
+ for s in cmd.iter() {
res.push_str([~"$", s.len().to_str(), ~"\r\n",
(*s).clone(), ~"\r\n"].concat() );
}
pub fn main() {
let x = os::args();
- foreach arg in x.iter() {
+ for arg in x.iter() {
match arg.clone() {
s => { }
}
pub fn main() {
let x = ~[1, 2, 3];
let mut y = 0;
- foreach i in x.iter() { info!(*i); y += *i; }
+ for i in x.iter() { info!(*i); y += *i; }
info!(y);
assert_eq!(y, 6);
let s = ~"hello there";
let mut i: int = 0;
- foreach c in s.byte_iter() {
+ for c in s.byte_iter() {
if i == 0 { assert!((c == 'h' as u8)); }
if i == 1 { assert!((c == 'e' as u8)); }
if i == 2 { assert!((c == 'l' as u8)); }
pub fn main() {
let x = ~[10, 20, 30];
let mut sum = 0;
- foreach x in x.iter() { sum += *x; }
+ for x in x.iter() { sum += *x; }
assert_eq!(sum, 60);
}
}
pub fn main() {
- foreach _ in range(0u, 100u) {
+ for _ in range(0u, 100u) {
task::spawn_unlinked(|| iloop() );
}
}
impl<A> vec_monad<A> for ~[A] {
fn bind<B>(&self, f: &fn(&A) -> ~[B]) -> ~[B] {
let mut r = ~[];
- foreach elt in self.iter() {
+ for elt in self.iter() {
r.push_all_move(f(elt));
}
r
calllink10
];
let mut rng = rand::rng();
- foreach f in fns.iter() {
+ for f in fns.iter() {
let f = *f;
let sz = rng.next() % 256u32 + 256u32;
let frame_backoff = rng.next() % 10u32 + 1u32;
pub fn main() {
let x = ~Triple{x: 1, y: 2, z: 3};
- foreach _ in range(0u, 10000u) {
+ for _ in range(0u, 10000u) {
assert_eq!(test(true, x.clone()), 2);
}
assert_eq!(test(false, x), 5);
pub fn main() {
let x = @Triple{x: 1, y: 2, z: 3};
- foreach i in range(0u, 10000u) {
+ for i in range(0u, 10000u) {
assert_eq!(test(true, x), 2);
}
assert_eq!(test(false, x), 5);
fn test2() {
let mut ints = [0, ..32];
- foreach i in ints.mut_iter() { *i += 22; }
- foreach i in ints.iter() { assert!(*i == 22); }
+ for i in ints.mut_iter() { *i += 22; }
+ for i in ints.iter() { assert!(*i == 22); }
}
pub fn main() {
impl<K:Eq,V:Clone> Index<K,V> for AssociationList<K,V> {
fn index(&self, index: &K) -> V {
- foreach pair in self.pairs.iter() {
+ for pair in self.pairs.iter() {
if pair.key == *index {
return pair.value.clone();
}
~BarStruct{ x: 2 } as ~FooTrait
];
- foreach i in range(0u, foos.len()) {
+ for i in range(0u, foos.len()) {
assert_eq!(i, foos[i].foo());
}
}
assert_eq!(sys::size_of::<[Foo, .. 10]>(), 90);
- foreach i in range(0u, 10) {
+ for i in range(0u, 10) {
assert_eq!(foos[i], Foo { bar: 1, baz: 2});
}
- foreach &foo in foos.iter() {
+ for &foo in foos.iter() {
assert_eq!(foo, Foo { bar: 1, baz: 2 });
}
}
match Some(src) {
Some(src_id) => {
- foreach i in range(0u, 10u) {
+ for i in range(0u, 10u) {
let yyy = src_id;
assert_eq!(yyy, 0u);
}
}
impl cat {
- fn nap(&mut self) { foreach _ in range(1u, 10u) { } }
+ fn nap(&mut self) { for _ in range(1u, 10u) { } }
}
fn cat(in_x : uint, in_y : int) -> cat {
visit_tydesc(td, v);
let r = u.vals.clone();
- foreach s in r.iter() {
+ for s in r.iter() {
printfln!("val: %s", *s);
}
error!("%?", u.vals.clone());
visit_ty::<i16>(vv);
visit_ty::<~[int]>(vv);
- foreach s in v.types.iter() {
+ for s in v.types.iter() {
printfln!("type: %s", (*s).clone());
}
assert_eq!((*v.types).clone(), ~[~"bool", ~"int", ~"i8", ~"i16", ~"[", ~"int", ~"]"]);
pub fn main() {
let mut x = 4;
- foreach i in range(0u, 3) {
+ for i in range(0u, 3) {
// ensure that the borrow in this alt
// does not inferfere with the swap
// below. note that it would it you
}
pub fn main() {
- foreach _ in range(0u, 16u) {
+ for _ in range(0u, 16u) {
task::spawn_unlinked(|| iloop() );
}
}
match none::<int> {
some::<int>(_) => {
- foreach i in c.iter() {
+ for i in c.iter() {
info!(a);
let a = 17;
b.push(a);
match io::file_writer(&path, [io::Create, io::Truncate]) {
Err(ref e) => fail!(e.clone()),
Ok(f) => {
- foreach _ in range(0u, 1000) {
+ for _ in range(0u, 1000) {
f.write_u8(0);
}
}
impl<T> vec_utils<T> for ~[T] {
fn length_(&self) -> uint { self.len() }
- fn iter_(&self, f: &fn(&T)) { foreach x in self.iter() { f(x); } }
+ fn iter_(&self, f: &fn(&T)) { for x in self.iter() { f(x); } }
fn map_<U>(&self, f: &fn(&T) -> U) -> ~[U] {
let mut r = ~[];
- foreach elt in self.iter() {
+ for elt in self.iter() {
r.push(f(elt));
}
r
// Read from spawned tasks...
let mut sum = 0;
- foreach r in results.iter() {
+ for r in results.iter() {
i = 0;
while i < number_of_messages {
let value = po.recv();
}
// Join spawned tasks...
- foreach r in results.iter() { r.recv(); }
+ for r in results.iter() { r.recv(); }
info!("Completed: Final number is: ");
error!(sum);
fn check_legs(arc: arc::Arc<~[~Pet:Freeze+Send]>) {
let mut legs = 0;
- foreach pet in arc.get().iter() {
+ for pet in arc.get().iter() {
legs += pet.num_legs();
}
assert!(legs == 12);
}
fn check_names(arc: arc::Arc<~[~Pet:Freeze+Send]>) {
- foreach pet in arc.get().iter() {
+ for pet in arc.get().iter() {
do pet.name |name| {
assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8);
}
}
}
fn check_pedigree(arc: arc::Arc<~[~Pet:Freeze+Send]>) {
- foreach pet in arc.get().iter() {
+ for pet in arc.get().iter() {
assert!(pet.of_good_pedigree());
}
}
fn map<U>(&self, f: &fn(&T) -> U) -> ~[U] {
let mut r = ~[];
// FIXME: #7355 generates bad code with VecIterator
- foreach i in range(0u, self.len()) {
+ for i in range(0u, self.len()) {
r.push(f(&self[i]));
}
r
let mut it = Unfoldr::new(0, count);
let mut i = 0;
- foreach counted in it {
+ for counted in it {
assert_eq!(counted, i);
i += 1;
}
let ch = SharedChan::new(ch);
let n = 100u;
let mut expected = 0u;
- foreach i in range(0u, n) {
+ for i in range(0u, n) {
let ch = ch.clone();
task::spawn(|| child(&ch, i) );
expected += i;
}
let mut actual = 0u;
- foreach _ in range(0u, n) {
+ for _ in range(0u, n) {
let j = p.recv();
actual += *j;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// xfail-test
+// xfail-fast
+
extern mod extra;
use std::comm::*;
fn check_str_eq(a: ~str, b: ~str) {
let mut i: int = 0;
- foreach ab in a.byte_iter() {
+ for ab in a.byte_iter() {
info!(i);
info!(ab);
let bb: u8 = b[i];
projects / rust.git / commitdiff