#[no_core];
#[legacy_exports];
+#[legacy_modes];
+
#[allow(vecs_implicitly_copyable,
non_implicitly_copyable_typarams)];
#[allow(non_camel_case_types)];
use common::mode;
use util::logv;
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let config = parse_config(args);
log_config(config);
run_tests(config);
(SendPacketBuffered(p), RecvPacketBuffered(p))
}
+#[cfg(stage0)]
#[abi = "rust-intrinsic"]
#[doc(hidden)]
extern mod rusti {
#[legacy_exports];
- fn atomic_xchg(dst: &mut int, src: int) -> int;
- fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
- fn atomic_xchg_rel(dst: &mut int, src: int) -> int;
+ fn atomic_xchg(dst: &mut int, ++src: int) -> int;
+ fn atomic_xchg_acq(dst: &mut int, ++src: int) -> int;
+ fn atomic_xchg_rel(dst: &mut int, ++src: int) -> int;
- fn atomic_xadd_acq(dst: &mut int, src: int) -> int;
- fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
+ fn atomic_xadd_acq(dst: &mut int, ++src: int) -> int;
+ fn atomic_xsub_rel(dst: &mut int, ++src: int) -> int;
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[abi = "rust-intrinsic"]
+#[doc(hidden)]
+extern mod rusti {
+ #[legacy_exports];
+ fn atomic_xchg(dst: &mut int, +src: int) -> int;
+ fn atomic_xchg_acq(dst: &mut int, +src: int) -> int;
+ fn atomic_xchg_rel(dst: &mut int, +src: int) -> int;
+
+ fn atomic_xadd_acq(dst: &mut int, +src: int) -> int;
+ fn atomic_xsub_rel(dst: &mut int, +src: int) -> int;
}
// If I call the rusti versions directly from a polymorphic function,
}
vec::raw::form_slice(ptr::offset(p, i),
- len - i, f)
+ len - i, f)
}
}
}
* not bytes).
*/
#[inline(always)]
- unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn(&&v: &[T]) -> U) -> U {
+ unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn(v: &[T]) -> U) -> U {
let pair = (p, len * sys::size_of::<T>());
let v : *(&blk/[T]) =
::cast::reinterpret_cast(&ptr::addr_of(pair));
extern mod rusti {
#[legacy_exports];
fn get_tydesc<T>() -> *();
- fn visit_tydesc(td: *TyDesc, &&tv: TyVisitor);
+ fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor);
}
}
export type_is_pod;
export type_is_scalar;
export type_is_immediate;
+export type_is_borrowed;
export type_is_sequence;
export type_is_signed;
export type_is_structural;
}
fn default_arg_mode_for_ty(tcx: ctxt, ty: ty::t) -> ast::rmode {
- return if ty::type_is_immediate(ty) {
- ast::by_val
- } else if tcx.legacy_modes || type_is_fn(ty) {
- // ^^^^^^^^^^^^^^
+ return if type_is_fn(ty) {
+ // ^^^^^^^^^^^^^^
// FIXME(#2202) --- We retain by-ref by default to workaround a memory
// leak that otherwise results when @fn is upcast to &fn.
ast::by_ref
+ } else if tcx.legacy_modes {
+ if type_is_borrowed(ty) {
+ // the old mode default was ++ for things like &ptr, but to be
+ // forward-compatible with non-legacy, we should use +
+ ast::by_copy
+ } else if ty::type_is_immediate(ty) {
+ ast::by_val
+ } else {
+ ast::by_ref
+ }
} else {
ast::by_copy
};
_ => false
}
}
+
+ fn type_is_borrowed(ty: t) -> bool {
+ match ty::get(ty).sty {
+ ty::ty_rptr(*) => true,
+ ty_evec(_, vstore_slice(_)) => true,
+ ty_estr(vstore_slice(_)) => true,
+
+ // technically, we prob ought to include
+ // &fn(), but that is treated specially due to #2202
+ _ => false
+ }
+ }
}
// Returns the narrowest lifetime enclosing the evaluation of the expression
type_is_unique(ty) || type_is_region_ptr(ty);
}
-
fn type_needs_drop(cx: ctxt, ty: t) -> bool {
match cx.needs_drop_cache.find(ty) {
Some(result) => return result,
}
}
-fn arg_is_argv_ty(_tcx: ty::ctxt, a: ty::arg) -> bool {
+fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool {
+ match ty::resolved_mode(tcx, a.mode) {
+ ast::by_val => { /*ok*/ }
+ _ => {
+ return false;
+ }
+ }
+
match ty::get(a.ty).sty {
ty::ty_evec(mt, vstore_uniq) => {
if mt.mutbl != ast::m_imm { return false; }
tcx.sess.span_err(
main_span,
fmt!("Wrong type in main function: found `%s`, \
- expected `extern fn(~[str]) -> ()` \
+ expected `extern fn(++v: ~[~str]) -> ()` \
or `extern fn() -> ()`",
ty_to_str(tcx, main_t)));
}
~"atomic_xchg" | ~"atomic_xadd" | ~"atomic_xsub" |
~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
- (0u, ~[arg(ast::by_val,
+ (0u, ~[arg(ast::by_copy,
ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)),
ty::mk_int(tcx))),
- arg(ast::by_val, ty::mk_int(tcx))],
+ arg(ast::by_copy, ty::mk_int(tcx))],
ty::mk_int(tcx))
}
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let num_keys = {
if args.len() == 2 {
uint::from_str(args[1]).get()
use io::{Reader, ReaderUtil};
-fn main(argv: ~[~str]) {
+fn main(++argv: ~[~str]) {
#macro[
[#bench[id],
maybe_run_test(argv, #stringify(id), id)
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"10000000"]
} else if args.len() <= 1u {
return dvec::unwrap(move result);
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"50000000"]
} else if args.len() <= 1u {
true
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"15", ~"48"]
} else if args.len() <= 1u {
assert result == num_bytes * size;
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"1000000", ~"10000"]
} else if args.len() <= 1u {
assert result == num_bytes * size;
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"1000000", ~"8"]
} else if args.len() <= 1u {
};
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100", ~"10000"]
} else if args.len() <= 1u {
};
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100", ~"10000"]
} else if args.len() <= 1u {
};
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100", ~"10000"]
} else if args.len() <= 1u {
};
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100", ~"10000"]
} else if args.len() <= 1u {
io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput));
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"1000000", ~"10000"]
} else if args.len() <= 1u {
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"12"]
} else if args.len() <= 1u {
return arena.alloc(|| nil);
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"17"]
} else if args.len() <= 1u {
io::println(show_number(creatures_met));
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"200000"]
} else if args.len() <= 1u {
fn perm1init(i: uint) -> int { return i as int; }
let perm = vec::to_mut(vec::from_elem(n as uint, 0));
- let perm1 = vec::to_mut(vec::from_fn(n as uint, perm1init));
+ let perm1 = vec::to_mut(vec::from_fn(n as uint, |i| perm1init(i)));
let count = vec::to_mut(vec::from_elem(n as uint, 0));
let mut f = 0;
let mut i = 0;
return flips;
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"10"]
} else if args.len() <= 1u {
fn acid(ch: char, prob: u32) -> aminoacids { return {ch: ch, prob: prob}; }
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
// alioth tests k-nucleotide with this data at 25,000,000
~[~"", ~"5000000"]
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"40"]
} else if args.len() <= 1u {
}
// given a FASTA file on stdin, process sequence THREE
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let rdr = if os::getenv(~"RUST_BENCH").is_some() {
// FIXME: Using this compile-time env variable is a crummy way to
// get to this massive data set, but #include_bin chokes on it (#2598)
}
// given a FASTA file on stdin, process sequence THREE
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let rdr = if os::getenv(~"RUST_BENCH").is_some() {
// FIXME: Using this compile-time env variable is a crummy way to
// get to this massive data set, but #include_bin chokes on it (#2598)
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"4000", ~"10"]
} else {
fn sqrt(n: float) -> float;
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"4000000"]
} else if args.len() <= 1u {
for results.each |r| { future::get(r); }
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"20"]
} else if args.len() <= 1u {
eval_At_times_u(v, AtAu);
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"2000"]
} else if args.len() <= 1u {
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"2000000"]
} else if args.len() <= 1u {
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100000", ~"100"]
} else if args.len() <= 1u {
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let grid = if vec::len(args) == 1u {
// FIXME create sudoku inline since nested vec consts dont work yet
// (#571)
}
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100000"]
} else if args.len() <= 1u {
assert x == task::Success;
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100000"]
} else if args.len() <= 1u {
comm::send(parent_ch, done(sum + 1));
}
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"100000"]
} else if args.len() <= 1u {
fn g() { }
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let args = if os::getenv(~"RUST_BENCH").is_some() {
~[~"", ~"400"]
} else if args.len() <= 1u {
}
}
-fn main(argv: ~[~str]) {
+fn main(++argv: ~[~str]) {
if vec::len(argv) < 2u && !os::getenv(~"RUST_BENCH").is_some() {
let out = io::stdout();
-// error-pattern:expected `extern fn(~[str])
+// error-pattern:expected `extern fn(++v: ~[~str])
fn main(x: int) { }
}
log(debug, sys::refcount(s));
assert (sys::refcount(s) == count + 1u);
+ let _ = sys::refcount(s); // don't get bitten by last-use.
}
fn main() {
-fn main(args: ~[~str]) {
+fn main(++args: ~[~str]) {
let vs: ~[~str] = ~[~"hi", ~"there", ~"this", ~"is", ~"a", ~"vec"];
let vvs: ~[~[~str]] = ~[args, vs];
for vvs.each |vs| { for vs.each |s| { log(debug, *s); } }
-fn main(args: ~[~str]) { log(debug, args[0]); }
+fn main(++args: ~[~str]) { log(debug, args[0]); }
extern mod baz {
#[legacy_exports]; }
-fn main(args: ~[~str]) { }
+fn main() { }
fn bar() { debug!("bar"); }
}
-fn main(args: ~[~str]) { let zed = 42; bar(); }
+fn main() { let zed = 42; bar(); }
}
}
-fn main(args: ~[~str]) { bar(); }
+fn main() { bar(); }
#[legacy_exports]; }
}
}
-fn main(args: ~[~str]) { baz(); }
+fn main() { baz(); }
error!("%?", streams[0]);
}
-fn main(args: ~[~str]) {
+fn main() {
//os::getenv("FOO");
rendezvous();
-}
\ No newline at end of file
+}
-fn main(args: ~[~str]) { for args.each |s| { log(debug, *s); } }
+fn main(++args: ~[~str]) { for args.each |s| { log(debug, *s); } }
--- /dev/null
+struct X {
+ repr: int
+}
+
+fn apply<T>(x: T, f: fn(T)) {
+ f(x);
+}
+
+fn check_int(x: int) {
+ assert x == 22;
+}
+
+fn check_struct(x: X) {
+ check_int(x.repr);
+}
+
+fn main() {
+ apply(22, check_int);
+ apply(X {repr: 22}, check_struct);
+}
-fn main(args: ~[~str]) {
+fn main() {
let thing = ~"{{ f }}";
let f = str::find_str(thing, ~"{{");
if f.is_none() {
io::println(~"None!");
}
-}
\ No newline at end of file
+}
fn bar(offset: uint) { }
}
-fn main(args: ~[~str]) { foo::bar(0u); }
+fn main() { foo::bar(0u); }
-fn swap<T>(v: ~[mut T], i: int, j: int) { v[i] <-> v[j]; }
+fn swap<T>(v: &[mut T], i: int, j: int) { v[i] <-> v[j]; }
fn main() {
let a: ~[mut int] = ~[mut 0, 1, 2, 3, 4, 5, 6];
fn baz() { zed(nil); }
}
-fn main(args: ~[~str]) { }
+fn main() { }
type lteq<T> = extern fn(T) -> bool;
-fn main(args: ~[~str]) { }
+fn main() { }
fn g(a: *int) -> *int { let b = f(a); return b; }
-fn main(args: ~[~str]) { return; }
+fn main() { return; }
projects / rust.git / commitdiff