[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
# arm-linux-androideabi configuration
CC_arm-linux-androideabi=$(CFG_ANDROID_CROSS_PATH)/bin/arm-linux-androideabi-gcc
CXX_arm-linux-androideabi=$(CFG_ANDROID_CROSS_PATH)/bin/arm-linux-androideabi-g++
-CPP_arm-linux-androideabi=$(CFG_ANDROID_CROSS_PATH)/bin/arm-linux-androideabi-gcc
+CPP_arm-linux-androideabi=$(CFG_ANDROID_CROSS_PATH)/bin/arm-linux-androideabi-gcc -E
AR_arm-linux-androideabi=$(CFG_ANDROID_CROSS_PATH)/bin/arm-linux-androideabi-ar
CFG_LIB_NAME_arm-linux-androideabi=lib$(1).so
CFG_LIB_GLOB_arm-linux-androideabi=lib$(1)-*.so
CFG_LIB_NAME_arm-unknown-linux-gnueabihf=lib$(1).so
CFG_LIB_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.so
CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabihf := -Wall -g -fPIC
+CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabihf := -Wall -g -fPIC -D__arm__
CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabihf := -fno-rtti
CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabihf := -shared -fPIC -g
CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabihf := -Wl,--export-dynamic,--dynamic-list=
CFG_RUN_TARG_arm-unknown-linux-gnueabihf=
RUSTC_FLAGS_arm-unknown-linux-gnueabihf := --linker=$(CC_arm-unknown-linux-gnueabihf)
+# arm-unknown-linux-gnueabi configuration
+CC_arm-unknown-linux-gnueabi=arm-linux-gnueabi-gcc
+CXX_arm-unknown-linux-gnueabi=arm-linux-gnueabi-g++
+CPP_arm-unknown-linux-gnueabi=arm-linux-gnueabi-gcc -E
+AR_arm-unknown-linux-gnueabi=arm-linux-gnueabi-ar
+CFG_LIB_NAME_arm-unknown-linux-gnueabi=lib$(1).so
+CFG_LIB_GLOB_arm-unknown-linux-gnueabi=lib$(1)-*.so
+CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabi=lib$(1)-*.dylib.dSYM
+CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabi := -Wall -g -fPIC -D__arm__
+CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabi := -fno-rtti
+CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabi := -shared -fPIC -g
+CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-list=
+CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-no-whole-archive
+CFG_DEF_SUFFIX_arm-unknown-linux-gnueabi := .linux.def
+CFG_INSTALL_NAME_ar,-unknown-linux-gnueabi =
+CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabi =
+CFG_EXE_SUFFIX_arm-unknown-linux-gnueabi :=
+CFG_WINDOWSY_arm-unknown-linux-gnueabi :=
+CFG_UNIXY_arm-unknown-linux-gnueabi := 1
+CFG_PATH_MUNGE_arm-unknown-linux-gnueabi := true
+CFG_LDPATH_arm-unknown-linux-gnueabi :=
+CFG_RUN_arm-unknown-linux-gnueabi=
+CFG_RUN_TARG_arm-unknown-linux-gnueabi=
+RUSTC_FLAGS_arm-unknown-linux-gnueabi := --linker=$(CC_arm-unknown-linux-gnueabi)
+
# mips-unknown-linux-gnu configuration
CC_mips-unknown-linux-gnu=mips-linux-gnu-gcc
CXX_mips-unknown-linux-gnu=mips-linux-gnu-g++
$$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
$$(call CFG_INSTALL_NAME_$(1),$$(4))
- ifneq ($(1),arm-linux-androideabi)
+ ifneq ($(HOST_$(1)),arm)
# We're using llvm-mc as our assembler because it supports
# .cfi pseudo-ops on mac
-o=$$(1)
else
- # For the Android cross, use the Android assembler
+ # For the ARM crosses, use the toolchain assembler
# XXX: We should be able to use the LLVM assembler
- CFG_ASSEMBLE_$(1)=$$(CPP_$(1)) $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
+ CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
endif
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"
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(),
}
priv chunks: @mut MutList<Chunk>,
}
-#[unsafe_destructor]
-impl Drop for Arena {
- fn drop(&self) {
- unsafe {
- destroy_chunk(&self.head);
- do self.chunks.each |chunk| {
- if !chunk.is_pod {
- destroy_chunk(chunk);
- }
- true
- };
+impl Arena {
+ pub fn new() -> Arena {
+ Arena::new_with_size(32u)
+ }
+
+ pub fn new_with_size(initial_size: uint) -> Arena {
+ Arena {
+ head: chunk(initial_size, false),
+ pod_head: chunk(initial_size, true),
+ chunks: @mut MutNil,
}
}
}
}
}
-pub fn arena_with_size(initial_size: uint) -> Arena {
- Arena {
- head: chunk(initial_size, false),
- pod_head: chunk(initial_size, true),
- chunks: @mut MutNil,
+#[unsafe_destructor]
+impl Drop for Arena {
+ fn drop(&self) {
+ unsafe {
+ destroy_chunk(&self.head);
+ do self.chunks.each |chunk| {
+ if !chunk.is_pod {
+ destroy_chunk(chunk);
+ }
+ true
+ };
+ }
}
}
-pub fn Arena() -> Arena {
- arena_with_size(32u)
-}
-
#[inline]
fn round_up_to(base: uint, align: uint) -> uint {
(base + (align - 1)) & !(align - 1)
#[test]
fn test_arena_destructors() {
- let arena = Arena();
- foreach i in range(0u, 10) {
+ let arena = Arena::new();
+ for i in range(0u, 10) {
// Arena allocate something with drop glue to make sure it
// doesn't leak.
do arena.alloc { @i };
#[should_fail]
#[ignore(cfg(windows))]
fn test_arena_destructors_fail() {
- let arena = Arena();
+ let arena = Arena::new();
// 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;
}
}
use std::comm::{GenericChan, GenericSmartChan, GenericPort};
-use std::comm::{Chan, Port, Selectable, Peekable};
+use std::comm::{Chan, Port, Peekable};
use std::comm;
-use std::pipes;
/// An extension of `pipes::stream` that allows both sending and receiving.
pub struct DuplexStream<T, U> {
}
}
-impl<T:Send,U:Send> Selectable for DuplexStream<T, U> {
- fn header(&mut self) -> *mut pipes::PacketHeader {
- self.port.header()
- }
-}
-
/// Creates a bidirectional stream.
pub fn DuplexStream<T:Send,U:Send>()
-> (DuplexStream<T, U>, DuplexStream<U, T>)
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 {
Some(unsafe { cast::transmute(self.p) })
}
}
+
+ /// Return the `Rawlink` and replace with `Rawlink::none()`
+ fn take(&mut self) -> Rawlink<T> {
+ util::replace(self, Rawlink::none())
+ }
}
impl<T> Clone for Rawlink<T> {
/// Add all elements from `other` to the end of the list
///
/// O(1)
- pub fn append(&mut self, other: DList<T>) {
+ pub fn append(&mut self, mut other: DList<T>) {
match self.list_tail.resolve() {
None => *self = other,
Some(tail) => {
- match other {
- DList{list_head: None, _} => return,
- DList{list_head: Some(node), list_tail: o_tail, length: o_length} => {
+ // Carefully empty `other`.
+ let o_tail = other.list_tail.take();
+ let o_length = other.length;
+ match other.list_head.take() {
+ None => return,
+ Some(node) => {
tail.next = link_with_prev(node, self.list_tail);
self.list_tail = o_tail;
self.length += o_length;
}
}
+#[unsafe_destructor]
+impl<T> Drop for DList<T> {
+ fn drop(&self) {
+ let mut_self = unsafe {
+ cast::transmute_mut(self)
+ };
+ // Dissolve the dlist in backwards direction
+ // Just dropping the list_head can lead to stack exhaustion
+ // when length is >> 1_000_000
+ let mut tail = mut_self.list_tail;
+ loop {
+ match tail.resolve() {
+ None => break,
+ Some(prev) => {
+ prev.next.take(); // release ~Node<T>
+ tail = prev.prev;
+ }
+ }
+ }
+ mut_self.length = 0;
+ mut_self.list_head = None;
+ mut_self.list_tail = Rawlink::none();
+ }
+}
+
+
impl<'self, A> Iterator<&'self A> for DListIterator<'self, A> {
#[inline]
fn next(&mut self) -> Option<&'self A> {
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 => {}
/// 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; }
/// Get a lazy iterator over the key-value pairs in the map.
/// Requires that it be frozen (immutable).
pub fn iter<'a>(&'a self) -> TreeMapIterator<'a, K, V> {
- TreeMapIterator{stack: ~[], node: &self.root, remaining: self.length}
+ TreeMapIterator {
+ stack: ~[],
+ node: &self.root,
+ remaining_min: self.length,
+ remaining_max: self.length
+ }
+ }
+
+ /// Get a lazy iterator that should be initialized using
+ /// `iter_traverse_left`/`iter_traverse_right`/`iter_traverse_complete`.
+ fn iter_for_traversal<'a>(&'a self) -> TreeMapIterator<'a, K, V> {
+ TreeMapIterator {
+ stack: ~[],
+ node: &self.root,
+ remaining_min: 0,
+ remaining_max: self.length
+ }
+ }
+
+ /// Return a lazy iterator to the first key-value pair whose key is not less than `k`
+ /// If all keys in map are less than `k` an empty iterator is returned.
+ pub fn lower_bound_iter<'a>(&'a self, k: &K) -> TreeMapIterator<'a, K, V> {
+ let mut iter: TreeMapIterator<'a, K, V> = self.iter_for_traversal();
+ loop {
+ match *iter.node {
+ Some(ref r) => {
+ match k.cmp(&r.key) {
+ Less => iter_traverse_left(&mut iter),
+ Greater => iter_traverse_right(&mut iter),
+ Equal => {
+ iter_traverse_complete(&mut iter);
+ return iter;
+ }
+ }
+ }
+ None => {
+ iter_traverse_complete(&mut iter);
+ return iter;
+ }
+ }
+ }
+ }
+
+ /// Return a lazy iterator to the first key-value pair whose key is greater than `k`
+ /// If all keys in map are not greater than `k` an empty iterator is returned.
+ pub fn upper_bound_iter<'a>(&'a self, k: &K) -> TreeMapIterator<'a, K, V> {
+ let mut iter: TreeMapIterator<'a, K, V> = self.iter_for_traversal();
+ loop {
+ match *iter.node {
+ Some(ref r) => {
+ match k.cmp(&r.key) {
+ Less => iter_traverse_left(&mut iter),
+ Greater => iter_traverse_right(&mut iter),
+ Equal => iter_traverse_right(&mut iter)
+ }
+ }
+ None => {
+ iter_traverse_complete(&mut iter);
+ return iter;
+ }
+ }
+ }
}
/// Get a lazy iterator that consumes the treemap.
pub struct TreeMapIterator<'self, K, V> {
priv stack: ~[&'self ~TreeNode<K, V>],
priv node: &'self Option<~TreeNode<K, V>>,
- priv remaining: uint
+ priv remaining_min: uint,
+ priv remaining_max: uint
}
impl<'self, K, V> Iterator<(&'self K, &'self V)> for TreeMapIterator<'self, K, V> {
None => {
let res = self.stack.pop();
self.node = &res.right;
- self.remaining -= 1;
+ self.remaining_max -= 1;
+ if self.remaining_min > 0 {
+ self.remaining_min -= 1;
+ }
return Some((&res.key, &res.value));
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
- (self.remaining, Some(self.remaining))
+ (self.remaining_min, Some(self.remaining_max))
+ }
+}
+
+/// iter_traverse_left, iter_traverse_right and iter_traverse_complete are used to
+/// initialize TreeMapIterator pointing to element inside tree structure.
+///
+/// They should be used in following manner:
+/// - create iterator using TreeMap::iter_for_traversal
+/// - find required node using `iter_traverse_left`/`iter_traverse_right`
+/// (current node is `TreeMapIterator::node` field)
+/// - complete initialization with `iter_traverse_complete`
+#[inline]
+fn iter_traverse_left<'a, K, V>(it: &mut TreeMapIterator<'a, K, V>) {
+ let node = it.node.get_ref();
+ it.stack.push(node);
+ it.node = &node.left;
+}
+
+#[inline]
+fn iter_traverse_right<'a, K, V>(it: &mut TreeMapIterator<'a, K, V>) {
+ it.node = &(it.node.get_ref().right);
+}
+
+/// iter_traverse_left, iter_traverse_right and iter_traverse_complete are used to
+/// initialize TreeMapIterator pointing to element inside tree structure.
+///
+/// Completes traversal. Should be called before using iterator.
+/// Iteration will start from `self.node`.
+/// If `self.node` is None iteration will start from last node from which we
+/// traversed left.
+#[inline]
+fn iter_traverse_complete<'a, K, V>(it: &mut TreeMapIterator<'a, K, V>) {
+ static none: Option<~TreeNode<K, V>> = None;
+ match *it.node {
+ Some(ref n) => {
+ it.stack.push(n);
+ it.node = &none;
+ }
+ None => ()
}
}
TreeSetIterator{iter: self.map.iter()}
}
+ /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal).
+ /// If all elements in the set are less than `v` empty iterator is returned.
+ #[inline]
+ pub fn lower_bound_iter<'a>(&'a self, v: &T) -> TreeSetIterator<'a, T> {
+ TreeSetIterator{iter: self.map.lower_bound_iter(v)}
+ }
+
+ /// Get a lazy iterator pointing to the first value greater than `v`.
+ /// If all elements in the set are not greater than `v` empty iterator is returned.
+ #[inline]
+ pub fn upper_bound_iter<'a>(&'a self, v: &T) -> TreeSetIterator<'a, T> {
+ TreeSetIterator{iter: self.map.upper_bound_iter(v)}
+ }
+
/// Visit all values in reverse order
#[inline]
pub fn each_reverse(&self, f: &fn(&T) -> bool) -> bool {
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;
}
+ assert_eq!(n, 5);
+ }
+
+ #[test]
+ fn test_interval_iteration() {
+ let mut m = TreeMap::new();
+ for i in range(1, 100) {
+ assert!(m.insert(i * 2, i * 4));
+ }
+
+ for i in range(1, 198) {
+ let mut lb_it = m.lower_bound_iter(&i);
+ let (&k, &v) = lb_it.next().unwrap();
+ let lb = i + i % 2;
+ assert_eq!(lb, k);
+ assert_eq!(lb * 2, v);
+
+ let mut ub_it = m.upper_bound_iter(&i);
+ let (&k, &v) = ub_it.next().unwrap();
+ let ub = i + 2 - i % 2;
+ assert_eq!(ub, k);
+ assert_eq!(ub * 2, v);
+ }
+ let mut end_it = m.lower_bound_iter(&199);
+ assert_eq!(end_it.next(), None);
}
#[test]
(&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() {
- printfln!(x);
+ for x in m.iter() {
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));
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[forbid(deprecated_mode)];
#[allow(missing_doc)];
pub mod icu {
pub static UCHAR_INVALID_CODE : UProperty = -1;
pub mod libicu {
- #[link_name = "icuuc"]
+ use unicode::icu::*;
+
+ // #[link_name = "icuuc"]
+ #[link_args = "-licuuc"]
#[abi = "cdecl"]
extern {
pub fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
}
pub fn is_XID_start(c: char) -> bool {
- return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
- == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
+ == icu::TRUE;
+ }
}
pub fn is_XID_continue(c: char) -> bool {
- return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
- == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_hasBinaryProperty(c, icu::UCHAR_XID_START)
+ == icu::TRUE;
+ }
}
/*
Returns true if a character is a digit.
*/
pub fn is_digit(c: char) -> bool {
- return icu::libicu::u_isdigit(c) == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_isdigit(c) == icu::TRUE;
+ }
}
/*
Returns true if a character is a lowercase letter.
*/
pub fn is_lower(c: char) -> bool {
- return icu::libicu::u_islower(c) == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_islower(c) == icu::TRUE;
+ }
}
/*
Returns true if a character is space.
*/
pub fn is_space(c: char) -> bool {
- return icu::libicu::u_isspace(c) == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_isspace(c) == icu::TRUE;
+ }
}
/*
Returns true if a character is an uppercase letter.
*/
pub fn is_upper(c: char) -> bool {
- return icu::libicu::u_isupper(c) == icu::TRUE;
+ unsafe {
+ return icu::libicu::u_isupper(c) == icu::TRUE;
+ }
}
#[cfg(test)]
mod tests {
+ use unicode::*;
#[test]
fn test_is_digit() {
- assert!((unicode::icu::is_digit('0')));
- assert!((!unicode::icu::is_digit('m')));
+ assert!((is_digit('0')));
+ assert!((!is_digit('m')));
}
#[test]
fn test_is_lower() {
- assert!((unicode::icu::is_lower('m')));
- assert!((!unicode::icu::is_lower('M')));
+ assert!((is_lower('m')));
+ assert!((!is_lower('M')));
}
#[test]
fn test_is_space() {
- assert!((unicode::icu::is_space(' ')));
- assert!((!unicode::icu::is_space('m')));
+ assert!((is_space(' ')));
+ assert!((!is_space('m')));
}
#[test]
fn test_is_upper() {
- assert!((unicode::icu::is_upper('M')));
- assert!((!unicode::icu::is_upper('m')));
+ assert!((is_upper('M')));
+ assert!((!is_upper('m')));
}
}
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());
}
outputs: &OutputFilenames) {
// NB: Android hack
- if sess.targ_cfg.arch == abi::Arm &&
+ if sess.targ_cfg.os == session::os_android &&
(sess.opts.output_type == link::output_type_object ||
sess.opts.output_type == link::output_type_exe) {
let output_type = link::output_type_assembly;
}
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; }
}
#[deriving(Eq)]
pub enum EntryFnType {
EntryMain,
- EntryStart
+ EntryStart,
+ EntryNone,
}
pub struct Session_ {
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;
return;
}
+ // If the user wants no main function at all, then stop here.
+ if attr::contains_name(crate.attrs, "no_main") {
+ *session.entry_type = Some(session::EntryNone);
+ return
+ }
+
let ctxt = @mut EntryContext {
session: session,
ast_map: ast_map,
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);
}
}
// Create a _rust_main(args: ~[str]) function which will be called from the
// runtime rust_start function
pub fn create_entry_wrapper(ccx: @mut CrateContext,
- _sp: span, main_llfn: ValueRef) {
+ _sp: span,
+ main_llfn: ValueRef) {
let et = ccx.sess.entry_type.unwrap();
- if et == session::EntryMain {
- let llfn = create_main(ccx, main_llfn);
- create_entry_fn(ccx, llfn, true);
- } else {
- create_entry_fn(ccx, main_llfn, false);
+ match et {
+ session::EntryMain => {
+ let llfn = create_main(ccx, main_llfn);
+ create_entry_fn(ccx, llfn, true);
+ }
+ session::EntryStart => create_entry_fn(ccx, main_llfn, false),
+ session::EntryNone => {} // Do nothing.
}
fn create_main(ccx: @mut CrateContext, main_llfn: ValueRef) -> ValueRef {
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!",
Some((id, sp)) => match *tcx.sess.entry_type {
Some(session::EntryMain) => check_main_fn_ty(ccx, id, sp),
Some(session::EntryStart) => check_start_fn_ty(ccx, id, sp),
+ Some(session::EntryNone) => {}
None => tcx.sess.bug("entry function without a type")
},
- None => tcx.sess.bug("type checking without entry function")
+ None => {}
}
}
}
}
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);
#[allow(missing_doc)];
-use cast::transmute;
use either::{Either, Left, Right};
use kinds::Send;
use option::{Option, Some};
use rtcomm = rt::comm;
use rt;
-use pipes::{wait_many, PacketHeader};
-
-// FIXME #5160: Making this public exposes some plumbing from
-// pipes. Needs some refactoring
-pub use pipes::Selectable;
-
/// A trait for things that can send multiple messages.
pub trait GenericChan<T> {
/// Sends a message.
}
}
-impl<T: Send> Selectable for Port<T> {
- fn header(&mut self) -> *mut PacketHeader {
- match self.inner {
- Left(ref mut port) => port.header(),
- Right(_) => fail!("can't select on newsched ports")
- }
- }
-}
-
/// A channel that can be shared between many senders.
pub struct SharedChan<T> {
inner: Either<Exclusive<pipesy::Chan<T>>, rtcomm::SharedChan<T>>
use kinds::Send;
use option::{Option, Some, None};
- use pipes::{recv, try_recv, peek, PacketHeader};
- use super::{GenericChan, GenericSmartChan, GenericPort, Peekable, Selectable};
+ use pipes::{recv, try_recv, peek};
+ use super::{GenericChan, GenericSmartChan, GenericPort, Peekable};
use cast::transmute_mut;
/*proto! oneshot (
}
}
- impl<T: Send> Selectable for Port<T> {
- fn header(&mut self) -> *mut PacketHeader {
- match self.endp {
- Some(ref mut endp) => endp.header(),
- None => fail!("peeking empty stream")
- }
- }
-}
-
-}
-
-/// Returns the index of an endpoint that is ready to receive.
-pub fn selecti<T: Selectable>(endpoints: &mut [T]) -> uint {
- wait_many(endpoints)
-}
-
-/// Returns 0 or 1 depending on which endpoint is ready to receive
-pub fn select2i<A:Selectable, B:Selectable>(a: &mut A, b: &mut B)
- -> Either<(), ()> {
- let mut endpoints = [ a.header(), b.header() ];
- match wait_many(endpoints) {
- 0 => Left(()),
- 1 => Right(()),
- _ => fail!("wait returned unexpected index"),
- }
-}
-
-/// Receive a message from one of two endpoints.
-pub trait Select2<T: Send, U: Send> {
- /// Receive a message or return `None` if a connection closes.
- fn try_select(&mut self) -> Either<Option<T>, Option<U>>;
- /// Receive a message or fail if a connection closes.
- fn select(&mut self) -> Either<T, U>;
-}
-
-impl<T:Send,
- U:Send,
- Left:Selectable + GenericPort<T>,
- Right:Selectable + GenericPort<U>>
- Select2<T, U>
- for (Left, Right) {
- fn select(&mut self) -> Either<T, U> {
- // XXX: Bad borrow check workaround.
- unsafe {
- let this: &(Left, Right) = transmute(self);
- match *this {
- (ref lp, ref rp) => {
- let lp: &mut Left = transmute(lp);
- let rp: &mut Right = transmute(rp);
- match select2i(lp, rp) {
- Left(()) => Left(lp.recv()),
- Right(()) => Right(rp.recv()),
- }
- }
- }
- }
- }
-
- fn try_select(&mut self) -> Either<Option<T>, Option<U>> {
- // XXX: Bad borrow check workaround.
- unsafe {
- let this: &(Left, Right) = transmute(self);
- match *this {
- (ref lp, ref rp) => {
- let lp: &mut Left = transmute(lp);
- let rp: &mut Right = transmute(rp);
- match select2i(lp, rp) {
- Left(()) => Left (lp.try_recv()),
- Right(()) => Right(rp.try_recv()),
- }
- }
- }
- }
- }
}
#[cfg(test)]
use either::Right;
use super::{Chan, Port, oneshot, stream};
- #[test]
- fn test_select2() {
- let (p1, c1) = stream();
- let (p2, c2) = stream();
-
- c1.send(~"abc");
-
- let mut tuple = (p1, p2);
- match tuple.select() {
- Right(_) => fail!(),
- _ => (),
- }
-
- c2.send(123);
- }
-
#[test]
fn test_oneshot() {
let (p, c) = oneshot();
/// 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)
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[doc(hidden)];
-#[allow(non_uppercase_statics)];
-
-/*! Precise garbage collector
-
-The precise GC exposes two functions, gc and
-cleanup_stack_for_failure. The gc function is the entry point to the
-garbage collector itself. The cleanup_stack_for_failure is the entry
-point for GC-based cleanup.
-
-Precise GC depends on changes to LLVM's GC which add support for
-automatic rooting and addrspace-based metadata marking. Rather than
-explicitly rooting pointers with LLVM's gcroot intrinsic, the GC
-merely creates allocas for pointers, and allows an LLVM pass to
-automatically infer roots based on the allocas present in a function
-(and live at a given location). The compiler communicates the type of
-the pointer to LLVM by setting the addrspace of the pointer type. The
-compiler then emits a map from addrspace to tydesc, which LLVM then
-uses to match pointers with their tydesc. The GC reads the metadata
-table produced by LLVM, and uses it to determine which glue functions
-to call to free objects on their respective heaps.
-
-GC-based cleanup is a replacement for landing pads which relies on the
-GC infrastructure to find pointers on the stack to cleanup. Whereas
-the normal GC needs to walk task-local heap allocations, the cleanup
-code needs to walk exchange heap allocations and stack-allocations
-with destructors.
-
-*/
-
-use cast;
-use container::{Set, MutableSet};
-use io;
-use libc::{uintptr_t};
-use option::{None, Option, Some};
-use ptr;
-use hashmap::HashSet;
-use stackwalk::walk_stack;
-use sys;
-use unstable::intrinsics::{TyDesc};
-
-pub use stackwalk::Word;
-
-// Mirrors rust_stack.h stk_seg
-pub struct StackSegment {
- prev: *StackSegment,
- next: *StackSegment,
- end: uintptr_t,
- // And other fields which we don't care about...
-}
-
-pub mod rustrt {
- use stackwalk::Word;
- use super::StackSegment;
-
- #[link_name = "rustrt"]
- extern {
- #[rust_stack]
- pub fn rust_gc_metadata() -> *Word;
-
- pub fn rust_get_stack_segment() -> *StackSegment;
- pub fn rust_get_c_stack() -> *StackSegment;
- }
-}
-
-unsafe fn bump<T, U>(ptr: *T, count: uint) -> *U {
- return ptr::offset(ptr, count as int) as *U;
-}
-
-unsafe fn align_to_pointer<T>(ptr: *T) -> *T {
- let align = sys::min_align_of::<*T>();
- let ptr = ptr as uint;
- let ptr = (ptr + (align - 1)) & -align;
- return ptr as *T;
-}
-
-unsafe fn get_safe_point_count() -> uint {
- let module_meta = rustrt::rust_gc_metadata();
- return *module_meta;
-}
-
-struct SafePoint {
- sp_meta: *Word,
- fn_meta: *Word,
-}
-
-// Returns the safe point metadata for the given program counter, if
-// any.
-unsafe fn is_safe_point(pc: *Word) -> Option<SafePoint> {
- let module_meta = rustrt::rust_gc_metadata();
- let num_safe_points = *module_meta;
- let safe_points: *Word = bump(module_meta, 1);
-
- if ptr::is_null(pc) {
- return None;
- }
-
- // FIXME (#2997): Use binary rather than linear search.
- let mut spi = 0;
- while spi < num_safe_points {
- let sp: **Word = bump(safe_points, spi*3);
- let sp_loc = *sp;
- if sp_loc == pc {
- return Some(SafePoint {
- sp_meta: *bump(sp, 1),
- fn_meta: *bump(sp, 2),
- });
- }
- spi += 1;
- }
- return None;
-}
-
-type Visitor<'self> = &'self fn(root: **Word, tydesc: *TyDesc);
-
-// Walks the list of roots for the given safe point, and calls visitor
-// on each root.
-unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
- let fp_bytes = fp as *u8;
- let sp_meta = sp.sp_meta as *u32;
-
- let num_stack_roots = *sp_meta as uint;
- let num_reg_roots = *ptr::offset(sp_meta, 1) as uint;
-
- let stack_roots: *u32 = bump(sp_meta, 2);
- let reg_roots: *u8 = bump(stack_roots, num_stack_roots);
- let addrspaces: *Word = align_to_pointer(bump(reg_roots, num_reg_roots));
- let tydescs: ***TyDesc = bump(addrspaces, num_stack_roots);
-
- // Stack roots
- let mut sri = 0;
- while sri < num_stack_roots {
- if *ptr::offset(addrspaces, sri as int) >= 1 {
- let root =
- ptr::offset(fp_bytes, *ptr::offset(stack_roots, sri as int) as int)
- as **Word;
- let tydescpp = ptr::offset(tydescs, sri as int);
- let tydesc = if ptr::is_not_null(tydescpp) &&
- ptr::is_not_null(*tydescpp) {
- **tydescpp
- } else {
- ptr::null()
- };
- visitor(root, tydesc);
- }
- sri += 1;
- }
-
- // Register roots
- let mut rri = 0;
- while rri < num_reg_roots {
- if *ptr::offset(addrspaces, (num_stack_roots + rri) as int) == 1 {
- // FIXME(#2997): Need to find callee saved registers on the stack.
- }
- rri += 1;
- }
-}
-
-unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
- _walk_safe_point(fp, sp, visitor)
-}
-
-// Is fp contained in segment?
-unsafe fn is_frame_in_segment(fp: *Word, segment: *StackSegment) -> bool {
- let begin = segment as Word;
- let end = (*segment).end as Word;
- let frame = fp as Word;
-
- return begin <= frame && frame <= end;
-}
-
-struct Segment { segment: *StackSegment, boundary: bool }
-
-// Find and return the segment containing the given frame pointer. At
-// stack segment boundaries, returns true for boundary, so that the
-// caller can do any special handling to identify where the correct
-// return address is in the stack frame.
-unsafe fn find_segment_for_frame(fp: *Word, segment: *StackSegment)
- -> Segment {
- // Check if frame is in either current frame or previous frame.
- let in_segment = is_frame_in_segment(fp, segment);
- let in_prev_segment = ptr::is_not_null((*segment).prev) &&
- is_frame_in_segment(fp, (*segment).prev);
-
- // If frame is not in either segment, walk down segment list until
- // we find the segment containing this frame.
- if !in_segment && !in_prev_segment {
- let mut segment = segment;
- while ptr::is_not_null((*segment).next) &&
- is_frame_in_segment(fp, (*segment).next) {
- segment = (*segment).next;
- }
- return Segment {segment: segment, boundary: false};
- }
-
- // If frame is in previous frame, then we're at a boundary.
- if !in_segment && in_prev_segment {
- return Segment {segment: (*segment).prev, boundary: true};
- }
-
- // Otherwise, we're somewhere on the inside of the frame.
- return Segment {segment: segment, boundary: false};
-}
-
-type Memory = uint;
-
-static task_local_heap: Memory = 1;
-static exchange_heap: Memory = 2;
-static stack: Memory = 4;
-
-static need_cleanup: Memory = exchange_heap | stack;
-
-// Walks stack, searching for roots of the requested type, and passes
-// each root to the visitor.
-unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
- let mut segment = rustrt::rust_get_stack_segment();
- let mut last_ret: *Word = ptr::null();
- // To avoid collecting memory used by the GC itself, skip stack
- // frames until past the root GC stack frame. The root GC stack
- // frame is marked by a sentinel, which is a box pointer stored on
- // the stack.
- let mut reached_sentinel = ptr::is_null(sentinel);
- do walk_stack |frame| {
- let pc = last_ret;
- let Segment {segment: next_segment, boundary: boundary} =
- find_segment_for_frame(frame.fp, segment);
- segment = next_segment;
- // Each stack segment is bounded by a morestack frame. The
- // morestack frame includes two return addresses, one for
- // morestack itself, at the normal offset from the frame
- // pointer, and then a second return address for the
- // function prologue (which called morestack after
- // determining that it had hit the end of the stack).
- // Since morestack itself takes two parameters, the offset
- // for this second return address is 3 greater than the
- // return address for morestack.
- let ret_offset = if boundary { 4 } else { 1 };
- last_ret = *ptr::offset(frame.fp, ret_offset as int) as *Word;
-
- if !ptr::is_null(pc) {
-
- let mut delay_reached_sentinel = reached_sentinel;
- let sp = is_safe_point(pc);
- match sp {
- Some(sp_info) => {
- do walk_safe_point(frame.fp, sp_info) |root, tydesc| {
- // Skip roots until we see the sentinel.
- if !reached_sentinel && root == sentinel {
- delay_reached_sentinel = true;
- }
-
- // Skip null pointers, which can occur when a
- // unique pointer has already been freed.
- if reached_sentinel && !ptr::is_null(*root) {
- if ptr::is_null(tydesc) {
- // Root is a generic box.
- let refcount = **root;
- if mem | task_local_heap != 0 && refcount != -1 {
- visitor(root, tydesc);
- } else if mem | exchange_heap != 0 && refcount == -1 {
- visitor(root, tydesc);
- }
- } else {
- // Root is a non-immediate.
- if mem | stack != 0 {
- visitor(root, tydesc);
- }
- }
- }
- }
- }
- None => ()
- }
- reached_sentinel = delay_reached_sentinel;
- }
- }
-}
-
-unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
- _walk_gc_roots(mem, sentinel, visitor)
-}
-pub fn gc() {
- unsafe {
- // Abort when GC is disabled.
- if get_safe_point_count() == 0 {
- return;
- }
-
- do walk_gc_roots(task_local_heap, ptr::null()) |_root, _tydesc| {
- // FIXME(#2997): Walk roots and mark them.
- io::stdout().write([46]); // .
- }
- }
-}
-
-#[cfg(gc)]
-fn expect_sentinel() -> bool { true }
-
-#[cfg(nogc)]
-fn expect_sentinel() -> bool { false }
-
-// Entry point for GC-based cleanup. Walks stack looking for exchange
-// heap and stack allocations requiring drop, and runs all
-// destructors.
-//
-// This should only be called from fail!, as it will drop the roots
-// which are *live* on the stack, rather than dropping those that are
-// dead.
-pub fn cleanup_stack_for_failure() {
- unsafe {
- // Abort when GC is disabled.
- if get_safe_point_count() == 0 {
- return;
- }
-
- // Leave a sentinel on the stack to mark the current frame. The
- // stack walker will ignore any frames above the sentinel, thus
- // avoiding collecting any memory being used by the stack walker
- // itself.
- //
- // However, when core itself is not compiled with GC, then none of
- // the functions in core will have GC metadata, which means we
- // won't be able to find the sentinel root on the stack. In this
- // case, we can safely skip the sentinel since we won't find our
- // own stack roots on the stack anyway.
- let sentinel_box = ~0;
- let sentinel: **Word = if expect_sentinel() {
- cast::transmute(&sentinel_box)
- } else {
- ptr::null()
- };
-
- let mut roots = HashSet::new();
- do walk_gc_roots(need_cleanup, sentinel) |root, tydesc| {
- // Track roots to avoid double frees.
- if !roots.contains(&*root) {
- roots.insert(*root);
-
- if ptr::is_null(tydesc) {
- // FIXME #4420: Destroy this box
- // FIXME #4330: Destroy this box
- } else {
- ((*tydesc).drop_glue)(*root as *i8);
- }
- }
- }
- }
-}
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 + 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));
}
}
fn newsched_log_str(msg: ~str) {
use rt::task::Task;
use rt::local::Local;
- use str::StrSlice;
- use container::Container;
-
- // Truncate the string
- let buf_bytes = 256;
- let msg = if msg.len() > buf_bytes {
- msg.slice(0, buf_bytes) + "[...]"
- } else {
- msg
- };
unsafe {
match Local::try_unsafe_borrow::<Task>() {
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());
}
pub fn make_some<T>(val: T) -> Option<T> { Some(val) }
pub fn make_none<T>() -> Option<T> { None }
}
-
-#[cfg(test)]
-mod test {
- use either::Right;
- use comm::{Chan, Port, oneshot, recv_one, stream, Select2,
- GenericChan, Peekable};
-
- #[test]
- fn test_select2() {
- let (p1, c1) = stream();
- let (p2, c2) = stream();
-
- c1.send(~"abc");
-
- let mut tuple = (p1, p2);
- match tuple.select() {
- Right(_) => fail!(),
- _ => (),
- }
-
- c2.send(123);
- }
-
- #[test]
- fn test_oneshot() {
- let (p, c) = oneshot();
-
- c.send(());
-
- recv_one(p)
- }
-
- #[test]
- fn test_peek_terminated() {
- let (port, chan): (Port<int>, Chan<int>) = stream();
-
- {
- // Destroy the channel
- let _chan = chan;
- }
-
- assert!(!port.peek());
- }
-}
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);
#[cfg(test)]
mod test {
+ use unstable::run_in_bare_thread;
use rt::test::*;
use super::*;
use rt::task::Task;
#[test]
fn thread_local_task_smoke_test() {
- local_ptr::init_tls_key();
- let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, || {});
- Local::put(task);
- let task: ~Task = Local::take();
- cleanup_task(task);
+ do run_in_bare_thread {
+ local_ptr::init_tls_key();
+ let mut sched = ~new_test_uv_sched();
+ let task = ~Task::new_root(&mut sched.stack_pool, || {});
+ Local::put(task);
+ let task: ~Task = Local::take();
+ cleanup_task(task);
+ }
}
#[test]
fn thread_local_task_two_instances() {
- local_ptr::init_tls_key();
- let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, || {});
- Local::put(task);
- let task: ~Task = Local::take();
- cleanup_task(task);
- let task = ~Task::new_root(&mut sched.stack_pool, || {});
- Local::put(task);
- let task: ~Task = Local::take();
- cleanup_task(task);
+ do run_in_bare_thread {
+ local_ptr::init_tls_key();
+ let mut sched = ~new_test_uv_sched();
+ let task = ~Task::new_root(&mut sched.stack_pool, || {});
+ Local::put(task);
+ let task: ~Task = Local::take();
+ cleanup_task(task);
+ let task = ~Task::new_root(&mut sched.stack_pool, || {});
+ Local::put(task);
+ let task: ~Task = Local::take();
+ cleanup_task(task);
+ }
}
#[test]
fn borrow_smoke_test() {
- local_ptr::init_tls_key();
- let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, || {});
- Local::put(task);
-
- unsafe {
- let _task: *mut Task = Local::unsafe_borrow();
+ do run_in_bare_thread {
+ local_ptr::init_tls_key();
+ let mut sched = ~new_test_uv_sched();
+ let task = ~Task::new_root(&mut sched.stack_pool, || {});
+ Local::put(task);
+
+ unsafe {
+ let _task: *mut Task = Local::unsafe_borrow();
+ }
+ let task: ~Task = Local::take();
+ cleanup_task(task);
}
- let task: ~Task = Local::take();
- cleanup_task(task);
}
#[test]
fn borrow_with_return() {
- local_ptr::init_tls_key();
- let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, || {});
- Local::put(task);
-
- let res = do Local::borrow::<Task,bool> |_task| {
- true
- };
- assert!(res)
- let task: ~Task = Local::take();
- cleanup_task(task);
+ do run_in_bare_thread {
+ local_ptr::init_tls_key();
+ let mut sched = ~new_test_uv_sched();
+ let task = ~Task::new_root(&mut sched.stack_pool, || {});
+ Local::put(task);
+
+ let res = do Local::borrow::<Task,bool> |_task| {
+ true
+ };
+ assert!(res)
+ let task: ~Task = Local::take();
+ cleanup_task(task);
+ }
}
}
pub unsafe fn take<T>() -> ~T {
let key = tls_key();
let void_ptr: *mut c_void = tls::get(key);
- rtassert!(void_ptr.is_not_null());
+ if void_ptr.is_null() {
+ rtabort!("thread-local pointer is null. bogus!");
+ }
let ptr: ~T = cast::transmute(void_ptr);
tls::set(key, ptr::mut_null());
return ptr;
}
}
-/// Borrow the thread-local scheduler from thread-local storage.
-/// While the scheduler is borrowed it is not available in TLS.
+/// Borrow the thread-local value from thread-local storage.
+/// While the value is borrowed it is not available in TLS.
///
/// # Safety note
///
}
}
-/// Borrow a mutable reference to the thread-local Scheduler
+/// Borrow a mutable reference to the thread-local value
///
/// # Safety Note
///
-/// Because this leaves the Scheduler in thread-local storage it is possible
+/// Because this leaves the value in thread-local storage it is possible
/// For the Scheduler pointer to be aliased
pub unsafe fn unsafe_borrow<T>() -> *mut T {
let key = tls_key();
- let mut void_sched: *mut c_void = tls::get(key);
- rtassert!(void_sched.is_not_null());
+ let mut void_ptr: *mut c_void = tls::get(key);
+ if void_ptr.is_null() {
+ rtabort!("thread-local pointer is null. bogus!");
+ }
{
- let sched: *mut *mut c_void = &mut void_sched;
- let sched: *mut ~T = sched as *mut ~T;
- let sched: *mut T = &mut **sched;
- return sched;
+ let ptr: *mut *mut c_void = &mut void_ptr;
+ let ptr: *mut ~T = ptr as *mut ~T;
+ let ptr: *mut T = &mut **ptr;
+ return ptr;
}
}
use either::*;
use libc;
+use str::StrSlice;
pub trait Logger {
fn log(&mut self, msg: Either<~str, &'static str>);
s
}
};
- let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
- dbg.write_str(s);
- dbg.write_str("\n");
- dbg.flush();
+
+ // Truncate the string
+ let buf_bytes = 256;
+ if s.len() > buf_bytes {
+ let s = s.slice(0, buf_bytes) + "[...]";
+ print(s);
+ } else {
+ print(s)
+ };
+
+ fn print(s: &str) {
+ let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
+ dbg.write_str(s);
+ dbg.write_str("\n");
+ dbg.flush();
+ }
}
}
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();
}
pub fn rust_try_get_task() -> *rust_task;
}
}
-
-#[test]
-fn test_context() {
- use unstable::run_in_bare_thread;
-
- assert_eq!(context(), OldTaskContext);
- do run_in_bare_thread {
- assert_eq!(context(), GlobalContext);
- }
-}
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>;
rtdebug!("stopping scheduler %u", stask.sched.get_ref().sched_id());
+ // Should not have any messages
+ let message = stask.sched.get_mut_ref().message_queue.pop();
+ assert!(message.is_none());
+
stask.destroyed = true;
}
let mut this = self;
match this.message_queue.pop() {
Some(PinnedTask(task)) => {
+ this.event_loop.callback(Scheduler::run_sched_once);
let mut task = task;
task.give_home(Sched(this.make_handle()));
this.resume_task_immediately(task);
return None;
}
Some(TaskFromFriend(task)) => {
+ this.event_loop.callback(Scheduler::run_sched_once);
+ rtdebug!("got a task from a friend. lovely!");
return this.sched_schedule_task(task);
}
Some(Wake) => {
+ this.event_loop.callback(Scheduler::run_sched_once);
this.sleepy = false;
return Some(this);
}
Some(Shutdown) => {
+ this.event_loop.callback(Scheduler::run_sched_once);
if this.sleepy {
// There may be an outstanding handle on the
// sleeper list. Pop them all to make sure that's
/// Take a non-homed task we aren't allowed to run here and send
/// it to the designated friend scheduler to execute.
fn send_to_friend(&mut self, task: ~Task) {
+ rtdebug!("sending a task to friend");
match self.friend_handle {
Some(ref mut handle) => {
handle.send(TaskFromFriend(task));
Scheduler::send_task_home(task);
return Some(this);
} else {
+ this.event_loop.callback(Scheduler::run_sched_once);
task.give_home(Sched(home_handle));
this.resume_task_immediately(task);
return None;
}
}
AnySched if this.run_anything => {
+ this.event_loop.callback(Scheduler::run_sched_once);
task.give_home(AnySched);
this.resume_task_immediately(task);
return None;
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) {
_ => ()
}
+ // FIXME #8302: Dear diary. I'm so tired and confused.
+ // There's some interaction in rustc between the box
+ // annihilator and the TLS dtor by which TLS is
+ // accessed from annihilated box dtors *after* TLS is
+ // destroyed. Somehow setting TLS back to null, as the
+ // old runtime did, makes this work, but I don't currently
+ // understand how. I would expect that, if the annihilator
+ // reinvokes TLS while TLS is uninitialized, that
+ // TLS would be reinitialized but never destroyed,
+ // but somehow this works. I have no idea what's going
+ // on but this seems to make things magically work. FML.
+ self.storage = LocalStorage(ptr::null(), None);
+
// Destroy remaining boxes. Also may run user dtors.
unsafe { cleanup::annihilate(); }
}
impl Drop for Task {
fn drop(&self) {
rtdebug!("called drop for a task: %u", borrow::to_uint(self));
- assert!(self.destroyed)
+ rtassert!(self.destroyed)
}
}
impl Coroutine {
pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Coroutine {
- static MIN_STACK_SIZE: uint = 2000000; // XXX: Too much stack
+ static MIN_STACK_SIZE: uint = 3000000; // XXX: Too much stack
let start = Coroutine::build_start_wrapper(start);
let mut stack = stack_pool.take_segment(MIN_STACK_SIZE);
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 libc::{c_int, c_uint, c_void};
use ptr;
use rt::io::IoError;
-use rt::io::net::ip::{IpAddr, Ipv4, Ipv6};
+use rt::io::net::ip::{SocketAddr, IpAddr};
use rt::uv::*;
use rt::uv::idle::IdleWatcher;
-use rt::uv::net::{UvIpv4, UvIpv6};
+use rt::uv::net::{UvIpv4SocketAddr, UvIpv6SocketAddr};
use rt::rtio::*;
use rt::sched::Scheduler;
use rt::io::{standard_error, OtherIoError};
}
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.as_c_str |m_addr| {
+ do multi.to_str().as_c_str |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.as_c_str |m_addr| {
+ do multi.to_str().as_c_str |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 {
cb: &fn(**libc::c_char) -> T) -> T {
let mut argptrs = ~[prog.as_c_str(|b| b)];
let mut tmps = ~[];
- foreach arg in args.iter() {
+ for arg in args.iter() {
let t = @(*arg).clone();
tmps.push(t);
argptrs.push(t.as_c_str(|b| b));
let mut tmps = ~[];
let mut ptrs = ~[];
- foreach pair in es.iter() {
+ for pair in es.iter() {
// Use of match here is just to workaround limitations
// in the stage0 irrefutable pattern impl.
match pair {
match env {
Some(es) => {
let mut blk = ~[];
- foreach pair in es.iter() {
+ for pair in es.iter() {
let kv = fmt!("%s=%s", pair.first(), pair.second());
blk.push_all(kv.to_bytes_with_null());
}
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)) ||
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[allow(missing_doc)];
-
-use cast::transmute;
-use unstable::intrinsics;
-
-pub type Word = uint;
-
-pub struct Frame {
- fp: *Word
-}
-
-pub fn Frame(fp: *Word) -> Frame {
- Frame {
- fp: fp
- }
-}
-
-pub fn walk_stack(visit: &fn(Frame)) {
-
- debug!("beginning stack walk");
-
- do frame_address |frame_pointer| {
- let mut frame_address: *Word = unsafe {
- transmute(frame_pointer)
- };
- loop {
- let fr = Frame(frame_address);
-
- debug!("frame: %x", unsafe { transmute(fr.fp) });
- visit(fr);
-
- unsafe {
- let next_fp: **Word = transmute(frame_address);
- frame_address = *next_fp;
- if *frame_address == 0u {
- debug!("encountered task_start_wrapper. ending walk");
- // This is the task_start_wrapper_frame. There is
- // no stack beneath it and it is a foreign frame.
- break;
- }
- }
- }
- }
-}
-
-#[test]
-fn test_simple() {
- do walk_stack |_frame| {
- }
-}
-
-#[test]
-fn test_simple_deep() {
- fn run(i: int) {
- if i == 0 { return }
-
- do walk_stack |_frame| {
- // Would be nice to test something here...
- }
- run(i - 1);
- }
-
- run(10);
-}
-
-fn frame_address(f: &fn(x: *u8)) {
- unsafe {
- intrinsics::frame_address(f)
- }
-}
/* Runtime and platform support */
-pub mod gc;
pub mod libc;
pub mod os;
pub mod path;
mod unicode;
#[path = "num/cmath.rs"]
mod cmath;
-mod stackwalk;
// XXX: This shouldn't be pub, and it should be reexported under 'unstable'
// but name resolution doesn't work without it being pub.
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);
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 {
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
#[allow(missing_doc)];
use cast;
-use gc;
use io;
use libc;
use libc::{c_char, size_t};
match context {
OldTaskContext => {
unsafe {
- gc::cleanup_stack_for_failure();
rustrt::rust_upcall_fail(msg, file, line);
cast::transmute(())
}
msg, file, line as int);
}
- gc::cleanup_stack_for_failure();
-
let task = Local::unsafe_borrow::<Task>();
if (*task).unwinder.unwinding {
rtabort!("unwinding again");
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, 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
.globl get_sp
record_sp_limit:
+ // First, try to read TLS address from coprocessor
mrc p15, #0, r3, c13, c0, #3
+ cmp r3, #0
+ // Otherwise, try to read from magic address 0xFFFF0FF0
+ mvneq r3, #0xF000
+ ldreq r3, [r3, #-15]
+
#if __ANDROID__
add r3, r3, #252
#elif __linux__
add r3, r3, #4
#endif
+
str r0, [r3]
mov pc, lr
get_sp_limit:
+ // First, try to read TLS address from coprocessor
mrc p15, #0, r3, c13, c0, #3
+ cmp r3, #0
+ // Otherwise, try to read from magic address 0xFFFF0FF0
+ mvneq r3, #0xF000
+ ldreq r3, [r3, #-15]
+
#if __ANDROID__
add r3, r3, #252
#elif __linux__
add r3, r3, #4
#endif
+
ldr r0, [r3]
mov pc, lr
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("");
// except according to those terms.
extern mod extra;
-use extra::arena;
+use extra::arena::Arena;
enum Tree<'self> {
Nil,
}
}
-fn bottom_up_tree<'r>(arena: &'r arena::Arena, item: int, depth: int)
+fn bottom_up_tree<'r>(arena: &'r Arena, item: int, depth: int)
-> &'r Tree<'r> {
if depth > 0 {
return arena.alloc(
max_depth = n;
}
- let stretch_arena = arena::Arena();
+ let stretch_arena = Arena::new();
let stretch_depth = max_depth + 1;
let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
stretch_depth,
item_check(stretch_tree));
- let long_lived_arena = arena::Arena();
+ let long_lived_arena = Arena::new();
let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
let mut depth = min_depth;
while depth <= max_depth {
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);
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// xfail-fast
-// xfail-win32 #7999
-
-use std::comm::{Select2, Selectable};
-use std::comm;
-use std::task;
-
-pub fn main() {
- let (p,c) = comm::stream();
- do task::try || {
- let (p2,c2) = comm::stream();
- do task::spawn || {
- p2.recv();
- error!("sibling fails");
- fail!();
- }
- let (p3,c3) = comm::stream();
- c.send(c3);
- c2.send(());
- error!("child blocks");
- let (p, c) = comm::stream();
- let mut tuple = (p, p3);
- tuple.select();
- c.send(());
- };
- error!("parent tries");
- assert!(!p.recv().try_send(()));
- error!("all done!");
-}
}
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);
}
// except according to those terms.
extern mod extra;
-use extra::arena;
+use extra::arena::Arena;
pub fn main() {
- let mut arena = arena::Arena();
+ let mut arena = Arena::new();
let p = &mut arena;
let x = p.alloc(|| 4u);
printf!("%u", *x);
}
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];