user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename std::ivec to std::vec

Browse source
This commit is contained in:
Brian Anderson 2011-08-15 16:38:23 -07:00
parent 38c2363c45
commit f05a91a0dc
102 changed files with 739 additions and 744 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/comp/back/link.rs
View file

@ -7,7 +7,7 @@ import metadata::encoder;
import middle::trans_common::crate_ctxt;
import std::str;
import std::fs;
import std::ivec;
import std::vec;
import std::option;
import option::some;
import option::none;
@ -358,8 +358,8 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
{
let os =
str::split(fs::basename(output), '.' as u8);
assert (ivec::len(os) >= 2u);
ivec::pop(os);
assert (vec::len(os) >= 2u);
vec::pop(os);
str::connect(os, ".")
};
warn_missing(sess, "name", name);

16
src/comp/driver/rustc.rs
View file

@ -27,7 +27,7 @@ import std::option;
import std::option::some;
import std::option::none;
import std::str;
import std::ivec;
import std::vec;
import std::int;
import std::io;
import std::run;
@ -441,8 +441,8 @@ fn opts() -> [getopts::opt] {
}
fn main(args: vec[str]) {
let args_ivec = ivec::from_vec(args);
let binary = ivec::shift(args_ivec);
let args_ivec = vec::from_vec(args);
let binary = vec::shift(args_ivec);
let binary_dir = fs::dirname(binary);
let match =
alt getopts::getopts(args_ivec, opts()) {
@ -462,7 +462,7 @@ fn main(args: vec[str]) {
}
let sopts = build_session_options(binary, match, binary_dir);
let sess = build_session(sopts);
let n_inputs = ivec::len[str](match.free);
let n_inputs = vec::len[str](match.free);
let output_file = getopts::opt_maybe_str(match, "o");
let glue = opt_present(match, "glue");
if glue {
@ -523,7 +523,7 @@ fn main(args: vec[str]) {
} else {
~["default", "rs"]
};
ivec::pop(parts);
vec::pop(parts);
saved_out_filename = str::connect(parts, ".");
let suffix = alt sopts.output_type {
link::output_type_none. { "none" }
@ -580,7 +580,7 @@ fn main(args: vec[str]) {
}(config, _);
fn rmext(filename: str) -> str {
let parts = str::split(filename, '.' as u8);
ivec::pop(parts);
vec::pop(parts);
ret str::connect(parts, ".");
}
ret alt config.os {
@ -639,8 +639,6 @@ fn main(args: vec[str]) {
#[cfg(test)]
mod test {
import std::ivec;
// When the user supplies --test we should implicitly supply --cfg test
#[test]
fn test_switch_implies_cfg_test() {
@ -666,7 +664,7 @@ mod test {
let sess = build_session(sessopts);
let cfg = build_configuration(sess, "whatever", "whatever");
let test_items = attr::find_meta_items_by_name(cfg, "test");
assert (ivec::len(test_items) == 1u);
assert (vec::len(test_items) == 1u);
}
}

10
src/comp/front/attr.rs
View file

@ -1,6 +1,6 @@
// Functions dealing with attributes and meta_items
import std::ivec;
import std::vec;
import std::str;
import std::map;
import std::option;
@ -50,7 +50,7 @@ fn find_attrs_by_name(attrs: &[ast::attribute], name: ast::ident) ->
option::some(a)
} else { option::none }
}(_, name);
ret ivec::filter_map(filter, attrs);
ret vec::filter_map(filter, attrs);
}
fn get_attr_name(attr: &ast::attribute) -> ast::ident {
@ -66,7 +66,7 @@ fn find_meta_items_by_name(metas: &[@ast::meta_item], name: ast::ident) ->
option::some(m)
} else { option::none }
}(_, name);
ret ivec::filter_map(filter, metas);
ret vec::filter_map(filter, metas);
}
fn get_meta_item_name(meta: &@ast::meta_item) -> ast::ident {
@ -135,7 +135,7 @@ fn contains(haystack: &[@ast::meta_item], needle: @ast::meta_item) -> bool {
fn contains_name(metas: &[@ast::meta_item], name: ast::ident) -> bool {
let matches = find_meta_items_by_name(metas, name);
ret ivec::len(matches) > 0u;
ret vec::len(matches) > 0u;
}
// FIXME: This needs to sort by meta_item variant in addition to the item name
@ -173,7 +173,7 @@ fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
} else { option::none }
}(_, name);
ret ivec::filter_map(filter, items);
ret vec::filter_map(filter, items);
}
fn require_unique_names(sess: &session::session,

20
src/comp/front/config.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::option;
import syntax::ast;
import syntax::fold;
@ -32,9 +32,9 @@ fn filter_item(cfg: &ast::crate_cfg, item: &@ast::item) ->
fn fold_mod(cfg: &ast::crate_cfg, m: &ast::_mod, fld: fold::ast_fold) ->
ast::_mod {
let filter = bind filter_item(cfg, _);
let filtered_items = ivec::filter_map(filter, m.items);
ret {view_items: ivec::map(fld.fold_view_item, m.view_items),
items: ivec::map(fld.fold_item, filtered_items)};
let filtered_items = vec::filter_map(filter, m.items);
ret {view_items: vec::map(fld.fold_view_item, m.view_items),
items: vec::map(fld.fold_item, filtered_items)};
}
fn filter_native_item(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
@ -47,10 +47,10 @@ fn filter_native_item(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
fn fold_native_mod(cfg: &ast::crate_cfg, nm: &ast::native_mod,
fld: fold::ast_fold) -> ast::native_mod {
let filter = bind filter_native_item(cfg, _);
let filtered_items = ivec::filter_map(filter, nm.items);
let filtered_items = vec::filter_map(filter, nm.items);
ret {native_name: nm.native_name,
abi: nm.abi,
view_items: ivec::map(fld.fold_view_item, nm.view_items),
view_items: vec::map(fld.fold_view_item, nm.view_items),
items: filtered_items};
}
@ -74,8 +74,8 @@ fn filter_stmt(cfg: &ast::crate_cfg, stmt: &@ast::stmt) ->
fn fold_block(cfg: &ast::crate_cfg, b: &ast::blk_, fld: fold::ast_fold) ->
ast::blk_ {
let filter = bind filter_stmt(cfg, _);
let filtered_stmts = ivec::filter_map(filter, b.stmts);
ret {stmts: ivec::map(fld.fold_stmt, filtered_stmts),
let filtered_stmts = vec::filter_map(filter, b.stmts);
ret {stmts: vec::map(fld.fold_stmt, filtered_stmts),
expr: option::map(fld.fold_expr, b.expr),
id: b.id};
}
@ -95,7 +95,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
// The "cfg" attributes on the item
let item_cfg_attrs = attr::find_attrs_by_name(attrs, "cfg");
let item_has_cfg_attrs = ivec::len(item_cfg_attrs) > 0u;
let item_has_cfg_attrs = vec::len(item_cfg_attrs) > 0u;
if !item_has_cfg_attrs { ret true; }
// Pull the inner meta_items from the #[cfg(meta_item, ...)] attributes,
@ -115,7 +115,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
}
}
let cfg_metas = attr::attr_metas(item_cfg_attrs);
ivec::foldl(extract_metas, ~[], cfg_metas)
vec::foldl(extract_metas, ~[], cfg_metas)
};
for cfg_mi: @ast::meta_item in item_cfg_metas {

16
src/comp/front/test.rs
View file

@ -1,7 +1,7 @@
// Code that generates a test runner to run all the tests in a crate
import std::option;
import std::ivec;
import std::vec;
import syntax::ast;
import syntax::fold;
import syntax::print::pprust;
@ -69,7 +69,7 @@ fn fold_mod(cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold) -> ast::_mod {
}
let mod_nomain =
{view_items: m.view_items, items: ivec::filter_map(nomain, m.items)};
{view_items: m.view_items, items: vec::filter_map(nomain, m.items)};
ret fold::noop_fold_mod(mod_nomain, fld);
}
@ -93,24 +93,24 @@ fn fold_item(cx: &test_ctxt, i: &@ast::item, fld: fold::ast_fold) ->
log "this is a test function";
let test = {path: cx.path, ignore: is_ignored(i)};
cx.testfns += ~[test];
log #fmt("have %u test functions", ivec::len(cx.testfns));
log #fmt("have %u test functions", vec::len(cx.testfns));
}
let res = fold::noop_fold_item(i, fld);
ivec::pop(cx.path);
vec::pop(cx.path);
ret res;
}
fn is_test_fn(i: &@ast::item) -> bool {
let has_test_attr =
ivec::len(attr::find_attrs_by_name(i.attrs, "test")) > 0u;
vec::len(attr::find_attrs_by_name(i.attrs, "test")) > 0u;
fn has_test_signature(i: &@ast::item) -> bool {
alt i.node {
ast::item_fn(f, tps) {
let input_cnt = ivec::len(f.decl.inputs);
let input_cnt = vec::len(f.decl.inputs);
let no_output = f.decl.output.node == ast::ty_nil;
let tparm_cnt = ivec::len(tps);
let tparm_cnt = vec::len(tps);
input_cnt == 0u && no_output && tparm_cnt == 0u
}
_ { false }
@ -227,7 +227,7 @@ fn mk_test_desc_ivec_ty(cx: &test_ctxt) -> @ast::ty {
}
fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
log #fmt("building test vector from %u tests", ivec::len(cx.testfns));
log #fmt("building test vector from %u tests", vec::len(cx.testfns));
let descs = ~[];
for test: test in cx.testfns {
let test_ = test; // Satisfy alias analysis

50
src/comp/lib/llvm.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::str;
import std::str::rustrt::sbuf;
@ -928,8 +928,8 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
fn AggregateRet(RetVals: &[ValueRef]) -> ValueRef {
assert (!*terminated);
*terminated = true;
ret llvm::LLVMBuildAggregateRet(B, ivec::to_ptr(RetVals),
ivec::len(RetVals));
ret llvm::LLVMBuildAggregateRet(B, vec::to_ptr(RetVals),
vec::len(RetVals));
}
fn Br(Dest: BasicBlockRef) -> ValueRef {
@ -961,7 +961,7 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
Catch: BasicBlockRef) -> ValueRef {
assert (!*terminated);
*terminated = true;
ret llvm::LLVMBuildInvoke(B, Fn, ivec::to_ptr(Args), ivec::len(Args),
ret llvm::LLVMBuildInvoke(B, Fn, vec::to_ptr(Args), vec::len(Args),
Then, Catch, str::buf(""));
}
@ -1163,14 +1163,14 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
fn GEP(Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
assert (!*terminated);
ret llvm::LLVMBuildGEP(B, Pointer, ivec::to_ptr(Indices),
ivec::len(Indices), str::buf(""));
ret llvm::LLVMBuildGEP(B, Pointer, vec::to_ptr(Indices),
vec::len(Indices), str::buf(""));
}
fn InBoundsGEP(Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
assert (!*terminated);
ret llvm::LLVMBuildInBoundsGEP(B, Pointer, ivec::to_ptr(Indices),
ivec::len(Indices), str::buf(""));
ret llvm::LLVMBuildInBoundsGEP(B, Pointer, vec::to_ptr(Indices),
vec::len(Indices), str::buf(""));
}
fn StructGEP(Pointer: ValueRef, Idx: uint) -> ValueRef {
@ -1303,29 +1303,29 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
ValueRef {
assert (!*terminated);
let phi = llvm::LLVMBuildPhi(B, Ty, str::buf(""));
assert (ivec::len[ValueRef](vals) == ivec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, ivec::to_ptr(vals), ivec::to_ptr(bbs),
ivec::len(vals));
assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
vec::len(vals));
ret phi;
}
fn AddIncomingToPhi(phi: ValueRef, vals: &[ValueRef],
bbs: &[BasicBlockRef]) {
assert (ivec::len[ValueRef](vals) == ivec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, ivec::to_ptr(vals), ivec::to_ptr(bbs),
ivec::len(vals));
assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
vec::len(vals));
}
fn Call(Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
assert (!*terminated);
ret llvm::LLVMBuildCall(B, Fn, ivec::to_ptr(Args), ivec::len(Args),
ret llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
str::buf(""));
}
fn FastCall(Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
assert (!*terminated);
let v =
llvm::LLVMBuildCall(B, Fn, ivec::to_ptr(Args), ivec::len(Args),
llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
str::buf(""));
llvm::LLVMSetInstructionCallConv(v, LLVMFastCallConv);
ret v;
@ -1334,7 +1334,7 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
fn CallWithConv(Fn: ValueRef, Args: &[ValueRef], Conv: uint) -> ValueRef {
assert (!*terminated);
let v =
llvm::LLVMBuildCall(B, Fn, ivec::to_ptr(Args), ivec::len(Args),
llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
str::buf(""));
llvm::LLVMSetInstructionCallConv(v, Conv);
ret v;
@ -1403,7 +1403,7 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
llvm::LLVMGetNamedFunction(M, str::buf("llvm.trap"));
assert (T as int != 0);
let Args: [ValueRef] = ~[];
ret llvm::LLVMBuildCall(B, T, ivec::to_ptr(Args), ivec::len(Args),
ret llvm::LLVMBuildCall(B, T, vec::to_ptr(Args), vec::len(Args),
str::buf(""));
}
@ -1503,8 +1503,8 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
let s = "fn(";
let out_ty: TypeRef = llvm::LLVMGetReturnType(ty);
let n_args: uint = llvm::LLVMCountParamTypes(ty);
let args: [TypeRef] = ivec::init_elt[TypeRef](0 as TypeRef, n_args);
llvm::LLVMGetParamTypes(ty, ivec::to_ptr(args));
let args: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_args);
llvm::LLVMGetParamTypes(ty, vec::to_ptr(args));
s += tys_str(names, outer, args);
s += ") -> ";
s += type_to_str_inner(names, outer, out_ty);
@ -1515,8 +1515,8 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
9 {
let s: str = "{";
let n_elts: uint = llvm::LLVMCountStructElementTypes(ty);
let elts: [TypeRef] = ivec::init_elt[TypeRef](0 as TypeRef, n_elts);
llvm::LLVMGetStructElementTypes(ty, ivec::to_ptr(elts));
let elts: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_elts);
llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts));
s += tys_str(names, outer, elts);
s += "}";
ret s;
@ -1534,7 +1534,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
for tout: TypeRef in outer0 {
i += 1u;
if tout as int == ty as int {
let n: uint = ivec::len[TypeRef](outer0) - i;
let n: uint = vec::len[TypeRef](outer0) - i;
ret "*\\" + std::int::str(n as int);
}
}
@ -1563,8 +1563,8 @@ fn float_width(llt: TypeRef) -> uint {
}
fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] {
let args = ivec::init_elt(0 as TypeRef, llvm::LLVMCountParamTypes(fn_ty));
llvm::LLVMGetParamTypes(fn_ty, ivec::to_ptr(args));
let args = vec::init_elt(0 as TypeRef, llvm::LLVMCountParamTypes(fn_ty));
llvm::LLVMGetParamTypes(fn_ty, vec::to_ptr(args));
ret args;
}

8
src/comp/metadata/creader.rs
View file

@ -12,7 +12,7 @@ import syntax::visit;
import syntax::codemap::span;
import back::x86;
import util::common;
import std::ivec;
import std::vec;
import std::str;
import std::fs;
import std::io;
@ -94,7 +94,7 @@ fn metadata_matches(crate_data: &@[u8], metas: &[@ast::meta_item]) -> bool {
let linkage_metas = attr::find_linkage_metas(attrs);
log #fmt("matching %u metadata requirements against %u items",
ivec::len(metas), ivec::len(linkage_metas));
vec::len(metas), vec::len(linkage_metas));
for needed: @ast::meta_item in metas {
if !attr::contains(linkage_metas, needed) {
@ -126,7 +126,7 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
// is using the wrong type of meta item
let crate_name = {
let name_items = attr::find_meta_items_by_name(metas, "name");
alt ivec::last(name_items) {
alt vec::last(name_items) {
some(i) {
alt attr::get_meta_item_value_str(i) {
some(n) { n }
@ -196,7 +196,7 @@ fn get_metadata_section(filename: str) -> option::t[@[u8]] {
let cbuf = llvm::LLVMGetSectionContents(si.llsi);
let csz = llvm::LLVMGetSectionSize(si.llsi);
let cvbuf: *u8 = std::unsafe::reinterpret_cast(cbuf);
ret option::some[@[u8]](@ivec::unsafe::from_buf(cvbuf, csz));
ret option::some[@[u8]](@vec::unsafe::from_buf(cvbuf, csz));
}
llvm::LLVMMoveToNextSection(si.llsi);
}

6
src/comp/metadata/cstore.rs
View file

@ -1,7 +1,7 @@
// The crate store - a central repo for information collected about external
// crates and libraries
import std::ivec;
import std::vec;
import std::map;
import std::str;
import syntax::ast;
@ -83,7 +83,7 @@ iter iter_crate_data(cstore: &cstore) ->
}
fn add_used_crate_file(cstore: &cstore, lib: &str) {
if !ivec::member(lib, p(cstore).used_crate_files) {
if !vec::member(lib, p(cstore).used_crate_files) {
p(cstore).used_crate_files += ~[lib];
}
}
@ -95,7 +95,7 @@ fn get_used_crate_files(cstore: &cstore) -> [str] {
fn add_used_library(cstore: &cstore, lib: &str) -> bool {
if lib == "" { ret false; }
if ivec::member(lib, p(cstore).used_libraries) { ret false; }
if vec::member(lib, p(cstore).used_libraries) { ret false; }
p(cstore).used_libraries += ~[lib];
ret true;

14
src/comp/metadata/decoder.rs
View file

@ -1,7 +1,7 @@
// Decoding metadata from a single crate's metadata
import std::ebml;
import std::ivec;
import std::vec;
import std::option;
import std::str;
import std::io;
@ -48,7 +48,7 @@ fn lookup_hash(d: &ebml::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
let belt = tag_index_buckets_bucket_elt;
for each elt: ebml::doc in ebml::tagged_docs(bucket, belt) {
let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
if eq_fn(ivec::slice[u8](*elt.data, elt.start + 4u, elt.end)) {
if eq_fn(vec::slice[u8](*elt.data, elt.start + 4u, elt.end)) {
result += ~[ebml::doc_at(d.data, pos)];
}
}
@ -62,7 +62,7 @@ fn maybe_find_item(item_id: int, items: &ebml::doc) ->
}
let eqer = bind eq_item(_, item_id);
let found = lookup_hash(items, eqer, hash_node_id(item_id));
if ivec::len(found) == 0u {
if vec::len(found) == 0u {
ret option::none[ebml::doc];
} else { ret option::some[ebml::doc](found.(0)); }
}
@ -166,7 +166,7 @@ fn resolve_path(path: &[ast::ident], data: @[u8]) -> [ast::def_id] {
// Crate metadata queries
fn lookup_defs(data: &@[u8], cnum: ast::crate_num, path: &[ast::ident]) ->
[ast::def] {
ret ivec::map(bind lookup_def(cnum, data, _), resolve_path(path, data));
ret vec::map(bind lookup_def(cnum, data, _), resolve_path(path, data));
}
@ -213,7 +213,7 @@ fn get_type(data: @[u8], def: ast::def_id, tcx: &ty::ctxt,
}
fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
ret ivec::len(get_type_param_kinds(data, id));
ret vec::len(get_type_param_kinds(data, id));
}
fn get_type_param_kinds(data: @[u8], id: ast::node_id) -> [ast::kind] {
@ -269,7 +269,7 @@ fn family_has_type_params(fam_ch: u8) -> bool {
fn read_path(d: &ebml::doc) -> {path: str, pos: uint} {
let desc = ebml::doc_data(d);
let pos = ebml::be_uint_from_bytes(@desc, 0u, 4u);
let pathbytes = ivec::slice[u8](desc, 4u, ivec::len[u8](desc));
let pathbytes = vec::slice[u8](desc, 4u, vec::len[u8](desc));
let path = str::unsafe_from_bytes(pathbytes);
ret {path: path, pos: pos};
}
@ -331,7 +331,7 @@ fn get_attributes(md: &ebml::doc) -> [ast::attribute] {
let meta_items = get_meta_items(attr_doc);
// Currently it's only possible to have a single meta item on
// an attribute
assert (ivec::len(meta_items) == 1u);
assert (vec::len(meta_items) == 1u);
let meta_item = meta_items.(0);
attrs +=
~[{node: {style: ast::attr_outer, value: *meta_item},

12
src/comp/metadata/encoder.rs
View file

@ -1,6 +1,6 @@
// Metadata encoding
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::io;
@ -176,7 +176,7 @@ fn def_to_str(did: &def_id) -> str { ret #fmt("%d:%d", did.crate, did.node); }
fn encode_type_param_kinds(ebml_w: &ebml::writer, tps: &[ty_param]) {
ebml::start_tag(ebml_w, tag_items_data_item_ty_param_kinds);
ebml::write_vint(ebml_w.writer, ivec::len[ty_param](tps));
ebml::write_vint(ebml_w.writer, vec::len[ty_param](tps));
for tp: ty_param in tps {
let c = alt tp.kind {
kind_unique. { 'u' }
@ -236,7 +236,7 @@ fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
encode_tag_id(ebml_w, local_def(id));
encode_type(ecx, ebml_w,
node_id_to_monotype(ecx.ccx.tcx, variant.node.id));
if ivec::len[variant_arg](variant.node.args) > 0u {
if vec::len[variant_arg](variant.node.args) > 0u {
encode_symbol(ecx, ebml_w, variant.node.id);
}
encode_discriminant(ecx, ebml_w, variant.node.id);
@ -563,9 +563,9 @@ fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
// Return just the names
fn name(kv: &numname) -> str { kv.ident }
// mutable -> immutable hack for ivec::map
let immpairs = ivec::slice(pairs, 0u, ivec::len(pairs));
ret ivec::map(name, immpairs);
// mutable -> immutable hack for vec::map
let immpairs = vec::slice(pairs, 0u, vec::len(pairs));
ret vec::map(name, immpairs);
}
// We're just going to write a list of crate names, with the assumption

8
src/comp/metadata/tydecode.rs
View file

@ -1,6 +1,6 @@
// Type decoding
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::option;
@ -409,14 +409,14 @@ fn parse_ty_fn(st: @pstate, sd: str_def) ->
// Rust metadata parsing
fn parse_def_id(buf: &[u8]) -> ast::def_id {
let colon_idx = 0u;
let len = ivec::len[u8](buf);
let len = vec::len[u8](buf);
while colon_idx < len && buf.(colon_idx) != ':' as u8 { colon_idx += 1u; }
if colon_idx == len {
log_err "didn't find ':' when parsing def id";
fail;
}
let crate_part = ivec::slice[u8](buf, 0u, colon_idx);
let def_part = ivec::slice[u8](buf, colon_idx + 1u, len);
let crate_part = vec::slice[u8](buf, 0u, colon_idx);
let def_part = vec::slice[u8](buf, colon_idx + 1u, len);
let crate_part_vec = ~[];
let def_part_vec = ~[];

28
src/comp/middle/alias.rs
View file

@ -7,7 +7,7 @@ import ast::def_id;
import syntax::codemap::span;
import syntax::visit;
import visit::vt;
import std::ivec;
import std::vec;
import std::str;
import std::option;
import std::option::some;
@ -218,7 +218,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope) ->
}
i += 1u;
}
if ivec::len(unsafe_ts) > 0u {
if vec::len(unsafe_ts) > 0u {
alt f.node {
ast::expr_path(_) {
if def_is_local(cx.tcx.def_map.get(f.id), true) {
@ -319,9 +319,9 @@ fn check_alt(cx: &ctx, input: &@ast::expr, arms: &[ast::arm], sc: &scope,
for a: ast::arm in arms {
let dnums = arm_defnums(a);
let new_sc = sc;
if ivec::len(dnums) > 0u {
if vec::len(dnums) > 0u {
new_sc = @(*sc + ~[@{root_vars: roots,
block_defnum: dnums.(ivec::len(dnums) - 1u),
block_defnum: dnums.(vec::len(dnums) - 1u),
bindings: dnums,
tys: forbidden_tp,
depends_on: deps(sc, roots),
@ -343,7 +343,7 @@ fn check_for_each(cx: &ctx, local: &@ast::local, call: &@ast::expr,
let data = check_call(cx, f, args, sc);
let bindings = ast::pat_binding_ids(local.node.pat);
let new_sc = @{root_vars: data.root_vars,
block_defnum: bindings.(ivec::len(bindings) - 1u),
block_defnum: bindings.(vec::len(bindings) - 1u),
bindings: bindings,
tys: data.unsafe_ts,
depends_on: deps(sc, data.root_vars),
@ -376,7 +376,7 @@ fn check_for(cx: &ctx, local: &@ast::local, seq: &@ast::expr, blk: &ast::blk,
}
let bindings = ast::pat_binding_ids(local.node.pat);
let new_sc = @{root_vars: root_def,
block_defnum: bindings.(ivec::len(bindings) - 1u),
block_defnum: bindings.(vec::len(bindings) - 1u),
bindings: bindings,
tys: unsafe,
depends_on: deps(sc, root_def),
@ -399,7 +399,7 @@ fn check_var(cx: &ctx, ex: &@ast::expr, p: &ast::path, id: ast::node_id,
r.ok = val_taken(ex.span, p);
}
}
} else if (ivec::member(my_defnum, r.bindings)) {
} else if (vec::member(my_defnum, r.bindings)) {
test_scope(cx, sc, r, p);
}
}
@ -416,14 +416,14 @@ fn check_lval(cx: &@ctx, dest: &@ast::expr, sc: &scope, v: &vt[scope]) {
"assigning to immutable obj field");
}
for r: restrict in *sc {
if ivec::member(dnum, r.root_vars) {
if vec::member(dnum, r.root_vars) {
r.ok = overwritten(dest.span, p);
}
}
}
_ {
let root = expr_root(*cx, dest, false);
if ivec::len(*root.ds) == 0u {
if vec::len(*root.ds) == 0u {
cx.tcx.sess.span_err(dest.span, "assignment to non-lvalue");
} else if (!root.ds.(0).mut) {
let name =
@ -456,7 +456,7 @@ fn check_move_rhs(cx: &@ctx, src: &@ast::expr, sc: &scope, v: &vt[scope]) {
let root = expr_root(*cx, src, false);
// Not a path and no-derefs means this is a temporary.
if ivec::len(*root.ds) != 0u {
if vec::len(*root.ds) != 0u {
cx.tcx.sess.span_err(src.span, "moving out of a data structure");
}
}
@ -476,7 +476,7 @@ fn is_immutable_alias(cx: &ctx, sc: &scope, dnum: node_id) -> bool {
_ { }
}
for r: restrict in *sc {
if ivec::member(dnum, r.bindings) { ret true; }
if vec::member(dnum, r.bindings) { ret true; }
}
ret false;
}
@ -511,7 +511,7 @@ fn deps(sc: &scope, roots: &[node_id]) -> [uint] {
let result = ~[];
for r: restrict in *sc {
for dn: node_id in roots {
if ivec::member(dn, r.bindings) { result += ~[i]; }
if vec::member(dn, r.bindings) { result += ~[i]; }
}
i += 1u;
}
@ -546,8 +546,8 @@ fn expr_root(cx: &ctx, ex: @ast::expr, autoderef: bool) ->
}
ty::ty_tag(did, tps) {
let variants = ty::tag_variants(cx.tcx, did);
if ivec::len(variants) != 1u ||
ivec::len(variants.(0).args) != 1u {
if vec::len(variants) != 1u ||
vec::len(variants.(0).args) != 1u {
break;
}
ds += ~[@{mut: false, kind: unbox, outer_t: t}];

2
src/comp/middle/check_alt.rs
View file

@ -126,7 +126,7 @@ fn is_refutable(tcx: &ty::ctxt, pat: &@pat) -> bool {
}
pat_tag(_, args) {
let vdef = variant_def_ids(tcx.def_map.get(pat.id));
if std::ivec::len(ty::tag_variants(tcx, vdef.tg)) != 1u {
if std::vec::len(ty::tag_variants(tcx, vdef.tg)) != 1u {
ret true;
}
for p: @pat in args {

1
src/comp/middle/freevars.rs
View file

@ -3,7 +3,6 @@
import std::map;
import std::map::*;
import std::ivec;
import std::option;
import std::int;
import std::option::*;

6
src/comp/middle/kind.rs
View file

@ -74,7 +74,7 @@
import syntax::ast;
import syntax::visit;
import std::ivec;
import std::vec;
import ast::kind;
import ast::kind_unique;
@ -145,11 +145,11 @@ fn check_expr(tcx: &ty::ctxt, e: &@ast::expr) {
// If we have typarams, we're calling an item; we need to check
// that all the types we're supplying as typarams conform to the
// typaram kind constraints on that item.
if ivec::len(tpt.params) != 0u {
if vec::len(tpt.params) != 0u {
let callee_def = ast::def_id_of_def(tcx.def_map.get(callee.id));
let item_tk = ty::lookup_item_type(tcx, callee_def);
let i = 0;
assert ivec::len(item_tk.kinds) == ivec::len(tpt.params);
assert vec::len(item_tk.kinds) == vec::len(tpt.params);
for k_need: ast::kind in item_tk.kinds {
let t = tpt.params.(i);
let k = ty::type_kind(tcx, t);

24
src/comp/middle/resolve.rs
View file

@ -19,7 +19,7 @@ import syntax::ast::respan;
import middle::ty::constr_table;
import syntax::visit;
import visit::vt;
import std::ivec;
import std::vec;
import std::int;
import std::map::hashmap;
import std::list;
@ -401,7 +401,7 @@ fn visit_expr_with_scope(x: &@ast::expr, sc: &scopes, v: &vt[scopes]) {
fn follow_import(e: &env, sc: &scopes, path: &[ident], sp: &span) ->
option::t[def] {
let path_len = ivec::len(path);
let path_len = vec::len(path);
let dcur = lookup_in_scope_strict(e, sc, sp, path.(0), ns_module);
let i = 1u;
while true && option::is_some(dcur) {
@ -455,7 +455,7 @@ fn resolve_import(e: &env, it: &@ast::view_item, sc_in: &scopes) {
}
}
e.imports.insert(defid.node, resolving(it.span));
let n_idents = ivec::len(ids);
let n_idents = vec::len(ids);
let end_id = ids.(n_idents - 1u);
// Ignore the current scope if this import would shadow itself.
let sc =
@ -573,7 +573,7 @@ fn mk_unresolved_msg(id: &ident, kind: &str) -> str {
// Lookup helpers
fn lookup_path_strict(e: &env, sc: &scopes, sp: &span, pth: &ast::path_,
ns: namespace) -> option::t[def] {
let n_idents = ivec::len(pth.idents);
let n_idents = vec::len(pth.idents);
let headns = if n_idents == 1u { ns } else { ns_module };
let first_scope;
@ -783,7 +783,7 @@ fn lookup_in_obj(name: &ident, ob: &ast::_obj, ty_params: &[ast::ty_param],
fn lookup_in_block(name: &ident, b: &ast::blk_, pos: uint, loc_pos: uint,
ns: namespace) -> option::t[def] {
let i = ivec::len(b.stmts);
let i = vec::len(b.stmts);
while i > 0u {
i -= 1u;
let st = b.stmts.(i);
@ -792,7 +792,7 @@ fn lookup_in_block(name: &ident, b: &ast::blk_, pos: uint, loc_pos: uint,
alt d.node {
ast::decl_local(locs) {
if i <= pos {
let j = ivec::len(locs);
let j = vec::len(locs);
while j > 0u {
j -= 1u;
let loc = locs.(j);
@ -998,11 +998,11 @@ fn lookup_glob_in_mod(e: &env, info: @indexed_mod, sp: &span, id: &ident,
}
let matches =
ivec::filter_map(bind lookup_in_mod_(e, _, sp, id, ns, dr),
vec::filter_map(bind lookup_in_mod_(e, _, sp, id, ns, dr),
{ info.glob_imports });
if ivec::len(matches) == 0u {
if vec::len(matches) == 0u {
ret none;
} else if (ivec::len(matches) == 1u) {
} else if (vec::len(matches) == 1u) {
ret some(matches.(0).def);
} else {
for match: glob_imp_def in matches {
@ -1271,7 +1271,7 @@ fn check_arm(e: &@env, a: &ast::arm, x: &(), v: &vt[()]) {
let ch0 = checker(*e, "binding");
check_pat(ch0, a.pats.(0));
let seen0 = ch0.seen;
let i = ivec::len(a.pats);
let i = vec::len(a.pats);
while i > 1u {
i -= 1u;
let ch = checker(*e, "binding");
@ -1279,12 +1279,12 @@ fn check_arm(e: &@env, a: &ast::arm, x: &(), v: &vt[()]) {
// Ensure the bindings introduced in this pattern are the same as in
// the first pattern.
if ivec::len(ch.seen) != ivec::len(seen0) {
if vec::len(ch.seen) != vec::len(seen0) {
e.sess.span_err(a.pats.(i).span,
"inconsistent number of bindings");
} else {
for name: ident in ch.seen {
if is_none(ivec::find(bind str::eq(name, _), seen0)) {
if is_none(vec::find(bind str::eq(name, _), seen0)) {
// Fight the alias checker
let name_ = name;
e.sess.span_err(a.pats.(i).span,

46
src/comp/middle/shape.rs
View file

@ -26,7 +26,7 @@ import syntax::codemap::span;
import syntax::util::interner;
import util::common;
import std::ivec;
import std::vec;
import std::map::hashmap;
import std::option::none;
import std::option::some;
@ -138,10 +138,10 @@ fn largest_variants(ccx : &@crate_ctxt, tag_id : &ast::def_id) -> [uint] {
// Throw out any variant that we know has size and alignment at least as
// small as some other variant.
let i = 0u;
while i < ivec::len(ranges) - 1u {
while i < vec::len(ranges) - 1u {
if candidates.(i) {
let j = i + 1u;
while (j < ivec::len(ranges)) {
while (j < vec::len(ranges)) {
if candidates.(j) {
if ranges.(i).size.bounded && ranges.(i).align.bounded &&
ranges.(j).size.bounded &&
@ -166,7 +166,7 @@ fn largest_variants(ccx : &@crate_ctxt, tag_id : &ast::def_id) -> [uint] {
// Return the resulting set.
let result = ~[];
i = 0u;
while i < ivec::len(candidates) {
while i < vec::len(candidates) {
if candidates.(i) { result += ~[i]; }
i += 1u;
}
@ -208,7 +208,7 @@ fn compute_static_tag_size(ccx : &@crate_ctxt, largest_variants : &[uint],
// Add space for the tag if applicable.
// FIXME (issue #792): This is wrong. If the tag starts with an 8 byte
// aligned quantity, we don't align it.
if ivec::len(variants) > 1u {
if vec::len(variants) > 1u {
max_size += 4u16;
max_align = 4u8;
}
@ -224,11 +224,11 @@ tag tag_kind {
fn tag_kind(ccx : &@crate_ctxt, did : &ast::def_id) -> tag_kind {
let variants = ty::tag_variants(ccx.tcx, did);
if ivec::len(variants) == 0u { ret tk_complex; }
if vec::len(variants) == 0u { ret tk_complex; }
for v : ty::variant_info in variants {
if ivec::len(v.args) > 0u { ret tk_complex; }
if vec::len(v.args) > 0u { ret tk_complex; }
}
if ivec::len(variants) == 1u { ret tk_unit; }
if vec::len(variants) == 1u { ret tk_unit; }
ret tk_enum;
}
@ -272,7 +272,7 @@ fn add_u16(dest : &mutable [u8], val : u16) {
}
fn add_substr(dest : &mutable [u8], src : &[u8]) {
add_u16(dest, ivec::len(src) as u16);
add_u16(dest, vec::len(src) as u16);
dest += src;
}
@ -326,10 +326,10 @@ fn shape_of(ccx : &@crate_ctxt, t : ty::t) -> [u8] {
}
add_u16(sub, id as u16);
add_u16(sub, ivec::len(tps) as u16);
add_u16(sub, vec::len(tps) as u16);
for tp : ty::t in tps {
let subshape = shape_of(ccx, tp);
add_u16(sub, ivec::len(subshape) as u16);
add_u16(sub, vec::len(subshape) as u16);
sub += subshape;
}
@ -388,7 +388,7 @@ fn shape_of(ccx : &@crate_ctxt, t : ty::t) -> [u8] {
s += ~[shape_res];
add_u16(s, id as u16);
add_u16(s, ivec::len(tps) as u16);
add_u16(s, vec::len(tps) as u16);
let sub = ~[];
for tp : ty::t in tps { add_substr(s, sub); }
@ -429,12 +429,12 @@ fn gen_tag_shapes(ccx : &@crate_ctxt) -> ValueRef {
// must do this first.
let i = 0u;
let data = ~[]; let offsets = ~[];
while (i < ivec::len(ccx.shape_cx.tag_order)) {
while (i < vec::len(ccx.shape_cx.tag_order)) {
let did = ccx.shape_cx.tag_order.(i);
let variants = ty::tag_variants(ccx.tcx, did);
for v : ty::variant_info in variants {
offsets += ~[ivec::len(data) as u16];
offsets += ~[vec::len(data) as u16];
let variant_shape = shape_of_variant(ccx, v);
add_substr(data, variant_shape);
@ -449,14 +449,14 @@ fn gen_tag_shapes(ccx : &@crate_ctxt) -> ValueRef {
let header = ~[]; let info = ~[];
let header_sz = 2u16 * ccx.shape_cx.next_tag_id;
let data_sz = ivec::len(data) as u16;
let data_sz = vec::len(data) as u16;
let info_sz = 0u16;
for did_ : ast::def_id in ccx.shape_cx.tag_order {
let did = did_; // Satisfy alias checker.
let variants = ty::tag_variants(ccx.tcx, did);
add_u16(header, header_sz + info_sz);
info_sz += 2u16 * ((ivec::len(variants) as u16) + 2u16) + 3u16;
info_sz += 2u16 * ((vec::len(variants) as u16) + 2u16) + 3u16;
}
// Construct the info tables, which contain offsets to the shape of each
@ -468,14 +468,14 @@ fn gen_tag_shapes(ccx : &@crate_ctxt) -> ValueRef {
for did_ : ast::def_id in ccx.shape_cx.tag_order {
let did = did_; // Satisfy alias checker.
let variants = ty::tag_variants(ccx.tcx, did);
add_u16(info, ivec::len(variants) as u16);
add_u16(info, vec::len(variants) as u16);
// Construct the largest-variants table.
add_u16(info, header_sz + info_sz + data_sz +
(ivec::len(lv_table) as u16));
(vec::len(lv_table) as u16));
let lv = largest_variants(ccx, did);
add_u16(lv_table, ivec::len(lv) as u16);
add_u16(lv_table, vec::len(lv) as u16);
for v : uint in lv { add_u16(lv_table, v as u16); }
// Determine whether the tag has dynamic size.
@ -504,10 +504,10 @@ fn gen_tag_shapes(ccx : &@crate_ctxt) -> ValueRef {
}
}
assert (i == ivec::len(offsets));
assert (header_sz == (ivec::len(header) as u16));
assert (info_sz == (ivec::len(info) as u16));
assert (data_sz == (ivec::len(data) as u16));
assert (i == vec::len(offsets));
assert (header_sz == (vec::len(header) as u16));
assert (info_sz == (vec::len(info) as u16));
assert (data_sz == (vec::len(data) as u16));
header += info;
header += data;

92
src/comp/middle/trans.rs
View file

@ -262,7 +262,7 @@ fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
fn type_of_tag(cx: &@crate_ctxt, sp: &span, did: &ast::def_id, t: &ty::t) ->
TypeRef {
let degen = std::ivec::len(ty::tag_variants(cx.tcx, did)) == 1u;
let degen = std::vec::len(ty::tag_variants(cx.tcx, did)) == 1u;
if ty::type_has_dynamic_size(cx.tcx, t) {
if degen { ret T_i8(); } else { ret T_opaque_tag(cx.tn); }
} else {
@ -279,7 +279,7 @@ fn type_of_ty_param_kinds_and_ty(lcx: @local_ctxt, sp: &span,
alt ty::struct(lcx.ccx.tcx, tpt.ty) {
ty::ty_fn(_, _, _, _, _) {
let llfnty = type_of_fn_from_ty(lcx.ccx, sp, tpt.ty,
std::ivec::len(tpt.kinds));
std::vec::len(tpt.kinds));
ret T_fn_pair(*lcx.ccx, llfnty);
}
_ {
@ -382,7 +382,7 @@ fn get_extern_const(externs: &hashmap[str, ValueRef], llmod: ModuleRef,
fn get_simple_extern_fn(externs: &hashmap[str, ValueRef], llmod: ModuleRef,
name: &str, n_args: int) -> ValueRef {
let inputs = std::ivec::init_elt[TypeRef](T_int(), n_args as uint);
let inputs = std::vec::init_elt[TypeRef](T_int(), n_args as uint);
let output = T_int();
let t = T_fn(inputs, output);
ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t);
@ -392,7 +392,7 @@ fn trans_native_call(b: &builder, glues: @glue_fns, lltaskptr: ValueRef,
externs: &hashmap[str, ValueRef], tn: &type_names,
llmod: ModuleRef, name: &str, pass_task: bool,
args: &[ValueRef]) -> ValueRef {
let n: int = std::ivec::len[ValueRef](args) as int;
let n: int = std::vec::len[ValueRef](args) as int;
let llnative: ValueRef = get_simple_extern_fn(externs, llmod, name, n);
let call_args: [ValueRef] = ~[];
for a: ValueRef in args { call_args += ~[b.ZExtOrBitCast(a, T_int())]; }
@ -607,7 +607,7 @@ fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result {
}
let max_size_val = bcx.build.Load(max_size);
let total_size =
if std::ivec::len(variants) != 1u {
if std::vec::len(variants) != 1u {
bcx.build.Add(max_size_val, llsize_of(T_int()))
} else { max_size_val };
ret rslt(bcx, total_size);
@ -715,7 +715,7 @@ fn GEP_tup_like(cx: &@block_ctxt, t: &ty::t, base: ValueRef, ixs: &[int]) ->
fn split_type(ccx: &@crate_ctxt, t: &ty::t, ixs: &[int], n: uint) ->
{prefix: [ty::t], target: ty::t} {
let len: uint = std::ivec::len[int](ixs);
let len: uint = std::vec::len[int](ixs);
// We don't support 0-index or 1-index GEPs: The former is nonsense
// and the latter would only be meaningful if we supported non-0
// values for the 0th index (we don't).
@ -957,8 +957,8 @@ fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool,
let bcx = new_raw_block_ctxt(cx.fcx, cx.fcx.llderivedtydescs);
let n_params: uint = ty::count_ty_params(bcx_tcx(bcx), t);
let tys = linearize_ty_params(bcx, t);
assert (n_params == std::ivec::len[uint](tys.params));
assert (n_params == std::ivec::len[ValueRef](tys.descs));
assert (n_params == std::vec::len[uint](tys.params));
assert (n_params == std::vec::len[ValueRef](tys.descs));
let root_ti = get_static_tydesc(bcx, t, tys.params);
static_ti = some[@tydesc_info](root_ti);
lazily_emit_all_tydesc_glue(cx, static_ti);
@ -1017,7 +1017,7 @@ fn get_tydesc(cx: &@block_ctxt, orig_t: &ty::t, escapes: bool,
// Is the supplied type a type param? If so, return the passed-in tydesc.
alt ty::type_param(bcx_tcx(cx), t) {
some(id) {
if id < std::ivec::len(cx.fcx.lltydescs) {
if id < std::vec::len(cx.fcx.lltydescs) {
ret rslt(cx, cx.fcx.lltydescs.(id));
}
else {
@ -1153,7 +1153,7 @@ fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t,
if ty::type_has_dynamic_size(cx.ccx.tcx, t) {
llty = T_ptr(T_i8());
} else { llty = T_ptr(type_of(cx.ccx, sp, t)); }
let ty_param_count = std::ivec::len[uint](ty_params);
let ty_param_count = std::vec::len[uint](ty_params);
let lltyparams = llvm::LLVMGetParam(llfn, 3u);
let copy_args_bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
let lltydescs = ~[mutable];
@ -1161,7 +1161,7 @@ fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t,
while p < ty_param_count {
let llparam = copy_args_bcx.build.GEP(lltyparams, ~[C_int(p as int)]);
llparam = copy_args_bcx.build.Load(llparam);
std::ivec::grow_set(lltydescs, ty_params.(p), 0 as ValueRef, llparam);
std::vec::grow_set(lltydescs, ty_params.(p), 0 as ValueRef, llparam);
p += 1u;
}
@ -1524,7 +1524,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id,
let val_llty =
lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType
(llvm::LLVMTypeOf(dtor_addr)))
.(std::ivec::len(args));
.(std::vec::len(args));
let val_cast = cx.build.BitCast(val.val, val_llty);
cx.build.FastCall(dtor_addr, args + ~[val_cast]);
@ -1800,7 +1800,7 @@ fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t,
fn iter_variant(cx: @block_ctxt, a_tup: ValueRef,
variant: &ty::variant_info, tps: &[ty::t],
tid: &ast::def_id, f: &val_and_ty_fn) -> result {
if std::ivec::len[ty::t](variant.args) == 0u {
if std::vec::len[ty::t](variant.args) == 0u {
ret rslt(cx, C_nil());
}
let fn_ty = variant.ctor_ty;
@ -1855,7 +1855,7 @@ fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t,
}
ty::ty_tag(tid, tps) {
let variants = ty::tag_variants(bcx_tcx(cx), tid);
let n_variants = std::ivec::len(variants);
let n_variants = std::vec::len(variants);
// Cast the tags to types we can GEP into.
if n_variants == 1u {
@ -3309,8 +3309,8 @@ fn autoderef(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> result_t {
}
ty::ty_tag(did, tps) {
let variants = ty::tag_variants(ccx.tcx, did);
if std::ivec::len(variants) != 1u ||
std::ivec::len(variants.(0).args) != 1u {
if std::vec::len(variants) != 1u ||
std::vec::len(variants.(0).args) != 1u {
break;
}
t1 =
@ -3387,13 +3387,13 @@ fn join_results(parent_cx: &@block_ctxt, t: TypeRef, ins: &[result]) ->
bbs += ~[r.bcx.llbb];
}
}
alt std::ivec::len[result](live) {
alt std::vec::len[result](live) {
0u {
// No incoming edges are live, so we're in dead-code-land.
// Arbitrarily pick the first dead edge, since the caller
// is just going to propagate it outward.
assert (std::ivec::len[result](ins) >= 1u);
assert (std::vec::len[result](ins) >= 1u);
ret ins.(0);
}
_ {/* fall through */ }
@ -3517,10 +3517,10 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
// Make a vector that contains ty_param_count copies of tydesc_ty.
// (We'll need room for that many tydescs in the closure.)
let ty_param_count = std::ivec::len(lltydescs);
let ty_param_count = std::vec::len(lltydescs);
let tydesc_ty: ty::t = ty::mk_type(bcx_tcx(bcx));
let captured_tys: [ty::t] =
std::ivec::init_elt(tydesc_ty, ty_param_count);
std::vec::init_elt(tydesc_ty, ty_param_count);
// Get all the types we've got (some of which we synthesized
// ourselves) into a vector. The whole things ends up looking
@ -3662,7 +3662,7 @@ fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt,
// Populate the type parameters from the environment. We need to
// do this first because the tydescs are needed to index into
// the bindings if they are dynamically sized.
let tydesc_count = std::ivec::len(enclosing_cx.fcx.lltydescs);
let tydesc_count = std::vec::len(enclosing_cx.fcx.lltydescs);
let lltydescs = find_environment_tydescs(bcx, envty, llclosure);
let i = 0u;
while i < tydesc_count {
@ -3865,7 +3865,7 @@ fn lval_generic_fn(cx: &@block_ctxt, tpt: &ty::ty_param_kinds_and_ty,
lv = lval_val(cx, trans_external_path(cx, fn_id, tpt));
}
let tys = ty::node_id_to_type_params(bcx_tcx(cx), id);
if std::ivec::len[ty::t](tys) != 0u {
if std::vec::len[ty::t](tys) != 0u {
let bcx = lv.res.bcx;
let tydescs: [ValueRef] = ~[];
let tis: [option::t[@tydesc_info]] = ~[];
@ -3946,7 +3946,7 @@ fn trans_var(cx: &@block_ctxt, sp: &span, id: ast::node_id) ->
let lltagty = type_of_tag(ccx, sp, tid, tag_ty);
let bcx = alloc_result.bcx;
let lltagptr = bcx.build.PointerCast(lltagblob, T_ptr(lltagty));
if std::ivec::len(ty::tag_variants(ccx.tcx, tid)) != 1u {
if std::vec::len(ty::tag_variants(ccx.tcx, tid)) != 1u {
let lldiscrim_gv = lookup_discriminant(bcx.fcx.lcx, tid, vid);
let lldiscrim = bcx.build.Load(lldiscrim_gv);
let lldiscrimptr =
@ -4165,8 +4165,8 @@ fn trans_lval(cx: &@block_ctxt, e: &@ast::expr) -> lval_result {
alt lv.generic {
some(gi) {
let t = ty::expr_ty(bcx_tcx(cx), e);
let n_args = std::ivec::len(ty::ty_fn_args(bcx_tcx(cx), t));
let args = std::ivec::init_elt(none[@ast::expr], n_args);
let n_args = std::vec::len(ty::ty_fn_args(bcx_tcx(cx), t));
let args = std::vec::init_elt(none[@ast::expr], n_args);
let bound = trans_bind_1(lv.res.bcx, e, lv, args, e.id);
ret lval_val(bound.bcx, bound.val);
}
@ -4463,8 +4463,8 @@ fn trans_bind_1(cx: &@block_ctxt, f: &@ast::expr, f_res: &lval_result,
}
}
let ty_param_count = std::ivec::len(lltydescs);
if std::ivec::len(bound) == 0u && ty_param_count == 0u {
let ty_param_count = std::vec::len(lltydescs);
if std::vec::len(bound) == 0u && ty_param_count == 0u {
// Trivial 'binding': just return the static pair-ptr.
ret f_res.res;
}
@ -4794,7 +4794,7 @@ fn trans_vec(cx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
let unit_sz = size_of(bcx, unit_ty);
bcx = unit_sz.bcx;
let data_sz =
bcx.build.Mul(C_uint(std::ivec::len[@ast::expr](args)), unit_sz.val);
bcx.build.Mul(C_uint(std::vec::len[@ast::expr](args)), unit_sz.val);
// FIXME: pass tydesc properly.
let vec_val =
@ -4807,8 +4807,8 @@ fn trans_vec(cx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
let body = bcx.build.GEP(vec_val, ~[C_int(0), C_int(abi::vec_elt_data)]);
let pseudo_tup_ty =
ty::mk_tup(bcx_tcx(cx),
std::ivec::init_elt[ty::t](unit_ty,
std::ivec::len(args)));
std::vec::init_elt[ty::t](unit_ty,
std::vec::len(args)));
let i: int = 0;
for e: @ast::expr in args {
let src = trans_lval(bcx, e);
@ -4860,12 +4860,12 @@ fn trans_ivec(bcx: @block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
add_clean_temp(bcx, llvecptr, typ);
let lllen = bcx.build.Mul(C_uint(std::ivec::len(args)), unit_sz);
let lllen = bcx.build.Mul(C_uint(std::vec::len(args)), unit_sz);
// Allocate the vector pieces and store length and allocated length.
let llfirsteltptr;
if std::ivec::len(args) > 0u &&
std::ivec::len(args) <= abi::ivec_default_length {
if std::vec::len(args) > 0u &&
std::vec::len(args) <= abi::ivec_default_length {
// Interior case.
bcx.build.Store(lllen,
@ -4890,7 +4890,7 @@ fn trans_ivec(bcx: @block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
let llstubptr = bcx.build.PointerCast(llvecptr, T_ptr(llstubty));
bcx.build.Store(C_int(0), bcx.build.InBoundsGEP(llstubptr, stub_z));
let llheapty = T_ivec_heap_part(llunitty);
if std::ivec::len(args) == 0u {
if std::vec::len(args) == 0u {
// Null heap pointer indicates a zero-length vector.
bcx.build.Store(llalen, bcx.build.InBoundsGEP(llstubptr, stub_a));
@ -5594,9 +5594,9 @@ fn trans_block_cleanups(cx: &@block_ctxt, cleanup_cx: &@block_ctxt) ->
@block_ctxt {
let bcx = cx;
if cleanup_cx.kind == NON_SCOPE_BLOCK {
assert (std::ivec::len[cleanup](cleanup_cx.cleanups) == 0u);
assert (std::vec::len[cleanup](cleanup_cx.cleanups) == 0u);
}
let i = std::ivec::len[cleanup](cleanup_cx.cleanups);
let i = std::vec::len[cleanup](cleanup_cx.cleanups);
while i > 0u {
i -= 1u;
let c = cleanup_cx.cleanups.(i);
@ -5949,7 +5949,7 @@ fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) {
// its magic.
let fields_tup_ty = ty::mk_tup(fcx.lcx.ccx.tcx, field_tys);
let n_typarams = std::ivec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams);
let n_typarams = std::vec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams);
let llobj_box_ty: TypeRef = T_obj_ptr(*bcx_ccx(bcx), n_typarams);
let box_cell =
bcx.build.GEP(llself.v, ~[C_int(0), C_int(abi::obj_field_box)]);
@ -6145,7 +6145,7 @@ fn trans_res_ctor(cx: @local_ctxt, sp: &span, dtor: &ast::_fn,
fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
variant: &ast::variant, index: int, is_degen: bool,
ty_params: &[ast::ty_param]) {
if std::ivec::len[ast::variant_arg](variant.node.args) == 0u {
if std::vec::len[ast::variant_arg](variant.node.args) == 0u {
ret; // nullary constructors are just constants
}
@ -6298,7 +6298,7 @@ fn trans_item(cx: @local_ctxt, item: &ast::item) {
}
ast::item_tag(variants, tps) {
let sub_cx = extend_path(cx, item.ident);
let degen = std::ivec::len(variants) == 1u;
let degen = std::vec::len(variants) == 1u;
let i = 0;
for variant: ast::variant in variants {
trans_tag_variant(sub_cx, item.id, variant, i, degen, tps);
@ -6336,12 +6336,12 @@ fn decl_fn_and_pair_full(ccx: &@crate_ctxt, sp: &span, path: &[str],
flav: str, ty_params: &[ast::ty_param],
node_id: ast::node_id, node_type: ty::t) {
let llfty = type_of_fn_from_ty(ccx, sp, node_type,
std::ivec::len(ty_params));
std::vec::len(ty_params));
alt ty::struct(ccx.tcx, node_type) {
ty::ty_fn(proto, inputs, output, _, _) {
llfty =
type_of_fn(ccx, sp, proto, inputs, output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
}
_ { ccx.sess.bug("decl_fn_and_pair(): fn item doesn't have fn type!"); }
}
@ -6374,7 +6374,7 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span,
let main_mode = alt ty::struct(ccx.tcx, main_node_type) {
ty::ty_fn(_, args, _ ,_ ,_) {
if std::ivec::len(args) == 0u {
if std::vec::len(args) == 0u {
mm_nil
} else {
alt ty::struct(ccx.tcx, args.(0).ty) {
@ -6550,7 +6550,7 @@ fn native_fn_ty_param_count(cx: &@crate_ctxt, id: ast::node_id) -> uint {
actually a fn");
}
ast::native_item_fn(_, _, tps) {
count = std::ivec::len[ast::ty_param](tps);
count = std::vec::len[ast::ty_param](tps);
}
}
ret count;
@ -6837,7 +6837,7 @@ fn collect_tag_ctor(ccx: @crate_ctxt, i: &@ast::item, pt: &[str],
alt i.node {
ast::item_tag(variants, tps) {
for variant: ast::variant in variants {
if std::ivec::len(variant.node.args) != 0u {
if std::vec::len(variant.node.args) != 0u {
decl_fn_and_pair(ccx, i.span, new_pt + ~[variant.node.name],
"tag", tps, variant.node.id);
}
@ -6863,7 +6863,7 @@ fn trans_constant(ccx: @crate_ctxt, it: &@ast::item, pt: &[str],
alt it.node {
ast::item_tag(variants, _) {
let i = 0u;
let n_variants = std::ivec::len[ast::variant](variants);
let n_variants = std::vec::len[ast::variant](variants);
while i < n_variants {
let variant = variants.(i);
let p = new_pt + ~[it.ident, variant.node.name, "discrim"];
@ -7032,7 +7032,7 @@ fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef {
mapname = ccx.link_meta.name;
} else { mapname = "toplevel"; }
let sym_name = "_rust_crate_map_" + mapname;
let arrtype = T_array(T_int(), std::ivec::len[ValueRef](subcrates));
let arrtype = T_array(T_int(), std::vec::len[ValueRef](subcrates));
let maptype = T_struct(~[T_int(), arrtype]);
let map = llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf(sym_name));
llvm::LLVMSetLinkage(map,

44
src/comp/middle/trans_alt.rs
View file

@ -1,5 +1,5 @@
import std::str;
import std::ivec;
import std::vec;
import std::option;
import option::some;
import option::none;
@ -85,8 +85,8 @@ fn enter_match(m: &match, col: uint, val: ValueRef, e: &enter_pat) -> match {
alt e(br.pats.(col)) {
some(sub) {
let pats =
ivec::slice(br.pats, 0u, col) + sub +
ivec::slice(br.pats, col + 1u, ivec::len(br.pats));
vec::slice(br.pats, 0u, col) + sub +
vec::slice(br.pats, col + 1u, vec::len(br.pats));
let new_br = @{pats: pats with *br};
result += ~[new_br];
bind_for_pat(br.pats.(col), new_br, val);
@ -118,7 +118,7 @@ fn enter_opt(ccx: &@crate_ctxt, m: &match, opt: &opt, col: uint,
ast::pat_lit(l) {
ret if opt_eq(lit(l), opt) { some(~[]) } else { none };
}
_ { ret some(ivec::init_elt(dummy, size)); }
_ { ret some(vec::init_elt(dummy, size)); }
}
}
ret enter_match(m, col, val, bind e(ccx, dummy, opt, tag_size, _));
@ -141,7 +141,7 @@ fn enter_rec(m: &match, col: uint, fields: &[ast::ident], val: ValueRef) ->
}
ret some(pats);
}
_ { ret some(ivec::init_elt(dummy, ivec::len(fields))); }
_ { ret some(vec::init_elt(dummy, vec::len(fields))); }
}
}
ret enter_match(m, col, val, bind e(dummy, fields, _));
@ -153,7 +153,7 @@ fn enter_tup(m: &match, col: uint, val: ValueRef, n_elts: uint) -> match {
-> option::t[[@ast::pat]] {
alt p.node {
ast::pat_tup(elts) { ret some(elts); }
_ { ret some(ivec::init_elt(dummy, n_elts)); }
_ { ret some(vec::init_elt(dummy, n_elts)); }
}
}
ret enter_match(m, col, val, bind e(dummy, n_elts, _));
@ -198,8 +198,8 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
let variants = ty::tag_variants(ccx.tcx, vdefs.tg);
let args = ~[];
let size =
ivec::len(ty::tag_variant_with_id(ccx.tcx, vdefs.tg, vdefs.var).args);
if size > 0u && ivec::len(variants) != 1u {
vec::len(ty::tag_variant_with_id(ccx.tcx, vdefs.tg, vdefs.var).args);
if size > 0u && vec::len(variants) != 1u {
let tagptr =
bcx.build.PointerCast(val,
trans_common::T_opaque_tag_ptr(ccx.tn));
@ -223,7 +223,7 @@ fn collect_record_fields(m: &match, col: uint) -> [ast::ident] {
alt br.pats.(col).node {
ast::pat_rec(fs, _) {
for f: ast::field_pat in fs {
if !ivec::any(bind str::eq(f.ident, _), fields) {
if !vec::any(bind str::eq(f.ident, _), fields) {
fields += ~[f.ident];
}
}
@ -252,7 +252,7 @@ type exit_node = {bound: bind_map, from: BasicBlockRef, to: BasicBlockRef};
type mk_fail = fn() -> BasicBlockRef;
fn pick_col(m: &match) -> uint {
let scores = ivec::init_elt_mut(0u, ivec::len(m.(0).pats));
let scores = vec::init_elt_mut(0u, vec::len(m.(0).pats));
for br: match_branch in m {
let i = 0u;
for p: @ast::pat in br.pats {
@ -283,8 +283,8 @@ fn pick_col(m: &match) -> uint {
fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
f: &mk_fail, exits: &mutable [exit_node]) {
if ivec::len(m) == 0u { bcx.build.Br(f()); ret; }
if ivec::len(m.(0).pats) == 0u {
if vec::len(m) == 0u { bcx.build.Br(f()); ret; }
if vec::len(m.(0).pats) == 0u {
exits += ~[{bound: m.(0).bound, from: bcx.llbb, to: m.(0).body}];
bcx.build.Br(m.(0).body);
ret;
@ -292,8 +292,8 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
let col = pick_col(m);
let val = vals.(col);
let vals_left = ivec::slice(vals, 0u, col) +
ivec::slice(vals, col + 1u, ivec::len(vals));
let vals_left = vec::slice(vals, 0u, col) +
vec::slice(vals, col + 1u, vec::len(vals));
let ccx = bcx.fcx.lcx.ccx;
let pat_id = 0;
for br: match_branch in m {
@ -304,7 +304,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
let rec_fields = collect_record_fields(m, col);
// Separate path for extracting and binding record fields
if ivec::len(rec_fields) > 0u {
if vec::len(rec_fields) > 0u {
let rec_ty = ty::node_id_to_monotype(ccx.tcx, pat_id);
let fields =
alt ty::struct(ccx.tcx, rec_ty) { ty::ty_rec(fields) { fields } };
@ -324,7 +324,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
if any_tup_pat(m, col) {
let tup_ty = ty::node_id_to_monotype(ccx.tcx, pat_id);
let n_tup_elts = alt ty::struct(ccx.tcx, tup_ty) {
ty::ty_tup(elts) { ivec::len(elts) }
ty::ty_tup(elts) { vec::len(elts) }
};
let tup_vals = ~[], i = 0u;
while i < n_tup_elts {
@ -355,10 +355,10 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
tag branch_kind { no_branch; single; switch; compare; }
let kind = no_branch;
let test_val = val;
if ivec::len(opts) > 0u {
if vec::len(opts) > 0u {
alt opts.(0) {
var(_, vdef) {
if ivec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
if vec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
kind = single;
} else {
let tagptr = bcx.build.PointerCast
@ -381,7 +381,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
};
let sw =
if kind == switch {
bcx.build.Switch(test_val, else_cx.llbb, ivec::len(opts))
bcx.build.Switch(test_val, else_cx.llbb, vec::len(opts))
} else { C_int(0) }; // Placeholder for when not using a switch
// Compile subtrees for each option
@ -410,7 +410,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
alt opt {
var(_, vdef) {
let args = extract_variant_args(opt_cx, pat_id, vdef, val);
size = ivec::len(args.vals);
size = vec::len(args.vals);
unpacked = args.vals;
opt_cx = args.bcx;
}
@ -451,7 +451,7 @@ fn make_phi_bindings(bcx: &@block_ctxt, map: &[exit_node],
}
}
}
if ivec::len(vals) > 0u {
if vec::len(vals) > 0u {
let phi = bcx.build.Phi(val_ty(vals.(0)), vals, llbbs);
bcx.fcx.lllocals.insert(item.val, phi);
} else { success = false; }
@ -537,7 +537,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: &@ast::pat, val: ValueRef,
}
}
ast::pat_tag(_, sub) {
if ivec::len(sub) == 0u { ret bcx; }
if vec::len(sub) == 0u { ret bcx; }
let vdefs = ast::variant_def_ids(ccx.tcx.def_map.get(pat.id));
let args = extract_variant_args(bcx, pat.id, vdefs, val);
let i = 0;

44
src/comp/middle/trans_common.rs
View file

@ -4,7 +4,7 @@
*/
import std::int;
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::str::rustrt::sbuf;
@ -312,9 +312,9 @@ fn revoke_clean(cx: &@block_ctxt, val: ValueRef) {
if found == -1 { ret; }
// We found the cleanup and remove it
sc_cx.cleanups =
std::ivec::slice(sc_cx.cleanups, 0u, found as uint) +
std::ivec::slice(sc_cx.cleanups, (found as uint) + 1u,
std::ivec::len(sc_cx.cleanups));
std::vec::slice(sc_cx.cleanups, 0u, found as uint) +
std::vec::slice(sc_cx.cleanups, (found as uint) + 1u,
std::vec::len(sc_cx.cleanups));
}
fn get_res_dtor(ccx : &@crate_ctxt, sp : &span, did : &ast::def_id,
@ -424,8 +424,8 @@ fn val_str(tn: type_names, v: ValueRef) -> str { ret ty_str(tn, val_ty(v)); }
fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef {
let elt_count = llvm::LLVMCountStructElementTypes(llstructty);
assert (n < elt_count);
let elt_tys = std::ivec::init_elt(T_nil(), elt_count);
llvm::LLVMGetStructElementTypes(llstructty, std::ivec::to_ptr(elt_tys));
let elt_tys = std::vec::init_elt(T_nil(), elt_count);
llvm::LLVMGetStructElementTypes(llstructty, std::vec::to_ptr(elt_tys));
ret llvm::LLVMGetElementType(elt_tys.(n));
}
@ -509,8 +509,8 @@ fn T_size_t() -> TypeRef {
}
fn T_fn(inputs: &[TypeRef], output: TypeRef) -> TypeRef {
ret llvm::LLVMFunctionType(output, std::ivec::to_ptr(inputs),
std::ivec::len[TypeRef](inputs), False);
ret llvm::LLVMFunctionType(output, std::vec::to_ptr(inputs),
std::vec::len[TypeRef](inputs), False);
}
fn T_fn_pair(cx: &crate_ctxt, tfn: TypeRef) -> TypeRef {
@ -520,7 +520,7 @@ fn T_fn_pair(cx: &crate_ctxt, tfn: TypeRef) -> TypeRef {
fn T_ptr(t: TypeRef) -> TypeRef { ret llvm::LLVMPointerType(t, 0u); }
fn T_struct(elts: &[TypeRef]) -> TypeRef {
ret llvm::LLVMStructType(std::ivec::to_ptr(elts), std::ivec::len(elts),
ret llvm::LLVMStructType(std::vec::to_ptr(elts), std::vec::len(elts),
False);
}
@ -530,7 +530,7 @@ fn T_named_struct(name: &str) -> TypeRef {
}
fn set_struct_body(t: TypeRef, elts: &[TypeRef]) {
llvm::LLVMStructSetBody(t, std::ivec::to_ptr(elts), std::ivec::len(elts),
llvm::LLVMStructSetBody(t, std::vec::to_ptr(elts), std::vec::len(elts),
False);
}
@ -570,9 +570,9 @@ fn T_tydesc_field(cx: &crate_ctxt, field: int) -> TypeRef {
// Bit of a kludge: pick the fn typeref out of the tydesc..
let tydesc_elts: [TypeRef] =
std::ivec::init_elt[TypeRef](T_nil(), abi::n_tydesc_fields as uint);
std::vec::init_elt[TypeRef](T_nil(), abi::n_tydesc_fields as uint);
llvm::LLVMGetStructElementTypes(cx.tydesc_type,
std::ivec::to_ptr[TypeRef](tydesc_elts));
std::vec::to_ptr[TypeRef](tydesc_elts));
let t = llvm::LLVMGetElementType(tydesc_elts.(field));
ret t;
}
@ -742,7 +742,7 @@ fn T_opaque_tag_ptr(tn: &type_names) -> TypeRef {
}
fn T_captured_tydescs(cx: &crate_ctxt, n: uint) -> TypeRef {
ret T_struct(std::ivec::init_elt[TypeRef](T_ptr(cx.tydesc_type), n));
ret T_struct(std::vec::init_elt[TypeRef](T_ptr(cx.tydesc_type), n));
}
fn T_obj_ptr(cx: &crate_ctxt, n_captured_tydescs: uint) -> TypeRef {
@ -845,28 +845,28 @@ fn C_zero_byte_arr(size: uint) -> ValueRef {
let i = 0u;
let elts: [ValueRef] = ~[];
while i < size { elts += ~[C_u8(0u)]; i += 1u; }
ret llvm::LLVMConstArray(T_i8(), std::ivec::to_ptr(elts),
std::ivec::len(elts));
ret llvm::LLVMConstArray(T_i8(), std::vec::to_ptr(elts),
std::vec::len(elts));
}
fn C_struct(elts: &[ValueRef]) -> ValueRef {
ret llvm::LLVMConstStruct(std::ivec::to_ptr(elts), std::ivec::len(elts),
ret llvm::LLVMConstStruct(std::vec::to_ptr(elts), std::vec::len(elts),
False);
}
fn C_named_struct(T: TypeRef, elts: &[ValueRef]) -> ValueRef {
ret llvm::LLVMConstNamedStruct(T, std::ivec::to_ptr(elts),
std::ivec::len(elts));
ret llvm::LLVMConstNamedStruct(T, std::vec::to_ptr(elts),
std::vec::len(elts));
}
fn C_array(ty: TypeRef, elts: &[ValueRef]) -> ValueRef {
ret llvm::LLVMConstArray(ty, std::ivec::to_ptr(elts),
std::ivec::len(elts));
ret llvm::LLVMConstArray(ty, std::vec::to_ptr(elts),
std::vec::len(elts));
}
fn C_bytes(bytes : &[u8]) -> ValueRef {
ret llvm::LLVMConstString(unsafe::reinterpret_cast(ivec::to_ptr(bytes)),
ivec::len(bytes), False);
ret llvm::LLVMConstString(unsafe::reinterpret_cast(vec::to_ptr(bytes)),
vec::len(bytes), False);
}
fn C_shape(ccx : &@crate_ctxt, bytes : &[u8]) -> ValueRef {

4
src/comp/middle/trans_dps.rs
View file

@ -12,7 +12,7 @@ import syntax::ast;
import syntax::codemap::span;
import util::ppaux;
import trans_common::*;
import std::ivec;
import std::vec;
import std::option::none;
import std::option::some;
import std::str;
@ -466,7 +466,7 @@ fn trans_lit_str_common(ccx: &@crate_ctxt, s: &str, expand: bool) ->
llheappartopt = none;
} else if (len < abi::ivec_default_length - 1u)
{ // minus one for the null
while ivec::len(array) < abi::ivec_default_length {
while vec::len(array) < abi::ivec_default_length {
array += ~[tc::C_u8(0u)];
}

20
src/comp/middle/trans_objects.rs
View file

@ -95,8 +95,8 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
// typarams, and fields.
let llbox_ty: TypeRef = T_ptr(T_empty_struct());
if std::ivec::len[ast::ty_param](ty_params) == 0u &&
std::ivec::len[ty::arg](arg_tys) == 0u {
if std::vec::len[ast::ty_param](ty_params) == 0u &&
std::vec::len[ty::arg](arg_tys) == 0u {
// If the object we're translating has no fields or type parameters,
// there's not much to do.
@ -235,7 +235,7 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: &span, anon_obj: &ast::anon_obj,
// methods, not inner ones.
let wrapper_obj: ast::_obj =
{fields:
std::ivec::map(ast::obj_field_from_anon_obj_field,
std::vec::map(ast::obj_field_from_anon_obj_field,
additional_fields),
methods: anon_obj.methods};
@ -295,7 +295,7 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: &span, anon_obj: &ast::anon_obj,
// typarams, fields, and a pointer to our inner_obj.
let llbox_ty: TypeRef = T_ptr(T_empty_struct());
if std::ivec::len[ast::anon_obj_field](additional_fields) == 0u &&
if std::vec::len[ast::anon_obj_field](additional_fields) == 0u &&
anon_obj.inner_obj == none {
// If the object we're translating has no fields and no inner_obj,
@ -496,7 +496,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t,
// Filter out any methods that we don't need forwarding slots for
// because they're being overridden.
let f = bind filtering_fn(cx, _, ob.methods);
meths = std::ivec::filter_map[vtbl_mthd, vtbl_mthd](f, meths);
meths = std::vec::filter_map[vtbl_mthd, vtbl_mthd](f, meths);
// And now add the additional ones, both overriding ones and entirely
// new ones. These will just be normal methods.
@ -615,7 +615,7 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
// Get the backwarding function's type and declare it.
let llbackwarding_fn_ty: TypeRef =
type_of_fn_full(cx.ccx, sp, m.proto, true, m.inputs, m.output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
let llbackwarding_fn: ValueRef =
decl_internal_fastcall_fn(cx.ccx.llmod, s, llbackwarding_fn_ty);
@ -684,7 +684,7 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
type_of_fn_full(bcx_ccx(bcx), sp,
ty::ty_fn_proto(bcx_tcx(bcx), outer_mthd_ty), true,
m.inputs, m.output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
llouter_mthd =
bcx.build.PointerCast(llouter_mthd, T_ptr(T_ptr(llouter_mthd_ty)));
llouter_mthd = bcx.build.Load(llouter_mthd);
@ -747,7 +747,7 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
// Get the forwarding function's type and declare it.
let llforwarding_fn_ty: TypeRef =
type_of_fn_full(cx.ccx, sp, m.proto, true, m.inputs, m.output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
let llforwarding_fn: ValueRef =
decl_internal_fastcall_fn(cx.ccx.llmod, s, llforwarding_fn_ty);
@ -844,7 +844,7 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
type_of_fn_full(bcx_ccx(bcx), sp,
ty::ty_fn_proto(bcx_tcx(bcx), orig_mthd_ty), true,
m.inputs, m.output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
llorig_mthd =
bcx.build.PointerCast(llorig_mthd, T_ptr(T_ptr(llorig_mthd_ty)));
llorig_mthd = bcx.build.Load(llorig_mthd);
@ -923,7 +923,7 @@ fn process_normal_mthd(cx: @local_ctxt, m: @ast::method, self_ty: ty::t,
ty::ty_fn(proto, inputs, output, _, _) {
llfnty =
type_of_fn_full(cx.ccx, m.span, proto, true, inputs, output,
std::ivec::len[ast::ty_param](ty_params));
std::vec::len[ast::ty_param](ty_params));
}
}
let mcx: @local_ctxt =

26
src/comp/middle/tstate/auxiliary.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::int::str;
import std::str;
import std::option;
@ -170,8 +170,8 @@ fn log_states_err(pp: &pre_and_post_state) {
fn print_ident(i: &ident) { log " " + i + " "; }
fn print_idents(idents: &mutable [ident]) {
if ivec::len[ident](idents) == 0u { ret; }
log "an ident: " + ivec::pop[ident](idents);
if vec::len[ident](idents) == 0u { ret; }
log "an ident: " + vec::pop[ident](idents);
print_idents(idents);
}
@ -311,15 +311,15 @@ fn get_fn_info(ccx: &crate_ctxt, id: node_id) -> fn_info {
}
fn add_node(ccx: &crate_ctxt, i: node_id, a: &ts_ann) {
let sz = ivec::len(*ccx.node_anns);
let sz = vec::len(*ccx.node_anns);
if sz <= i as uint {
ivec::grow_mut(*ccx.node_anns, (i as uint) - sz + 1u, empty_ann(0u));
vec::grow_mut(*ccx.node_anns, (i as uint) - sz + 1u, empty_ann(0u));
}
ccx.node_anns.(i) = a;
}
fn get_ts_ann(ccx: &crate_ctxt, i: node_id) -> option::t[ts_ann] {
if i as uint < ivec::len(*ccx.node_anns) {
if i as uint < vec::len(*ccx.node_anns) {
ret some[ts_ann](ccx.node_anns.(i));
} else { ret none[ts_ann]; }
}
@ -690,7 +690,7 @@ fn substitute_constr_args(cx: &ty::ctxt, actuals: &[@expr], c: &@ty::constr)
fn substitute_arg(cx: &ty::ctxt, actuals: &[@expr], a: @constr_arg) ->
@constr_arg_use {
let num_actuals = ivec::len(actuals);
let num_actuals = vec::len(actuals);
alt a.node {
carg_ident(i) {
if i < num_actuals {
@ -744,7 +744,7 @@ fn find_instances(fcx: &fn_ctxt, subst: &subst, c: &constraint) ->
[{from: uint, to: uint}] {
let rslt = ~[];
if ivec::len(subst) == 0u { ret rslt; }
if vec::len(subst) == 0u { ret rslt; }
alt c {
cinit(_, _, _) {/* this is dealt with separately */ }
@ -822,7 +822,7 @@ fn replace(subst: subst, d: pred_args) -> [constr_arg_general_[inst]] {
}
fn path_to_ident(cx: &ty::ctxt, p: &path) -> ident {
alt ivec::last(p.node.idents) {
alt vec::last(p.node.idents) {
none. { cx.sess.span_fatal(p.span, "Malformed path"); }
some(i) { ret i; }
}
@ -1029,7 +1029,7 @@ fn args_mention[T](args: &[@constr_arg_use], q: fn(&[T], node_id) -> bool ,
case (_) { false }
}
}
ret ivec::any(bind mentions(s,q,_), args);
ret vec::any(bind mentions(s,q,_), args);
*/
for a: @constr_arg_use in args {
@ -1040,7 +1040,7 @@ fn args_mention[T](args: &[@constr_arg_use], q: fn(&[T], node_id) -> bool ,
fn use_var(fcx: &fn_ctxt, v: &node_id) { *fcx.enclosing.used_vars += ~[v]; }
// FIXME: This should be a function in std::ivec::.
// FIXME: This should be a function in std::vec::.
fn vec_contains(v: &@mutable [node_id], i: &node_id) -> bool {
for d: node_id in *v { if d == i { ret true; } }
ret false;
@ -1090,7 +1090,7 @@ fn local_to_bindings(loc : &@local) -> binding {
}
fn locals_to_bindings(locals : &[@local]) -> [binding] {
ivec::map(local_to_bindings, locals)
vec::map(local_to_bindings, locals)
}
fn callee_modes(fcx: &fn_ctxt, callee: node_id) -> [ty::mode] {
@ -1120,7 +1120,7 @@ fn callee_arg_init_ops(fcx: &fn_ctxt, callee: node_id) -> [init_op] {
_ { init_assign }
}
}
ivec::map(mode_to_op, callee_modes(fcx, callee))
vec::map(mode_to_op, callee_modes(fcx, callee))
}
fn anon_bindings(ops: &[init_op], es : &[@expr]) -> [binding] {

16
src/comp/middle/tstate/bitvectors.rs
View file

@ -1,6 +1,6 @@
import syntax::ast::*;
import syntax::visit;
import std::ivec;
import std::vec;
import std::option::*;
import aux::*;
import tstate::ann::pre_and_post;
@ -77,10 +77,10 @@ fn seq_tritv(p: &postcond, q: &postcond) {
}
fn seq_postconds(fcx: &fn_ctxt, ps: &[postcond]) -> postcond {
let sz = ivec::len(ps);
let sz = vec::len(ps);
if sz >= 1u {
let prev = tritv_clone(ps.(0));
for p: postcond in ivec::slice(ps, 1u, sz) { seq_tritv(prev, p); }
for p: postcond in vec::slice(ps, 1u, sz) { seq_tritv(prev, p); }
ret prev;
} else { ret ann::empty_poststate(num_constraints(fcx.enclosing)); }
}
@ -90,12 +90,12 @@ fn seq_postconds(fcx: &fn_ctxt, ps: &[postcond]) -> postcond {
// So, if e0's post is {x} and e1's pre is {x, y, z}, the entire
// precondition shouldn't include x.
fn seq_preconds(fcx: &fn_ctxt, pps: &[pre_and_post]) -> precond {
let sz: uint = ivec::len(pps);
let sz: uint = vec::len(pps);
let num_vars: uint = num_constraints(fcx.enclosing);
fn seq_preconds_go(fcx: &fn_ctxt, pps: &[pre_and_post],
first: &pre_and_post) -> precond {
let sz: uint = ivec::len(pps);
let sz: uint = vec::len(pps);
if sz >= 1u {
let second = pps.(0);
assert (pps_len(second) == num_constraints(fcx.enclosing));
@ -105,7 +105,7 @@ fn seq_preconds(fcx: &fn_ctxt, pps: &[pre_and_post]) -> precond {
union(next_first, second_pre);
let next_first_post = clone(first.postcondition);
seq_tritv(next_first_post, second.postcondition);
ret seq_preconds_go(fcx, ivec::slice(pps, 1u, sz),
ret seq_preconds_go(fcx, vec::slice(pps, 1u, sz),
@{precondition: next_first,
postcondition: next_first_post});
} else { ret first.precondition; }
@ -115,7 +115,7 @@ fn seq_preconds(fcx: &fn_ctxt, pps: &[pre_and_post]) -> precond {
if sz >= 1u {
let first = pps.(0);
assert (pps_len(first) == num_vars);
ret seq_preconds_go(fcx, ivec::slice(pps, 1u, sz), first);
ret seq_preconds_go(fcx, vec::slice(pps, 1u, sz), first);
} else { ret true_precond(num_vars); }
}
@ -197,7 +197,7 @@ fn kill_poststate(fcx: &fn_ctxt, id: node_id, c: &tsconstr) -> bool {
fn clear_in_poststate_expr(fcx: &fn_ctxt, e: &@expr, t: &poststate) {
alt e.node {
expr_path(p) {
alt ivec::last(p.node.idents) {
alt vec::last(p.node.idents) {
some(i) {
alt local_node_id_to_def(fcx, e.id) {
some(def_local(d_id)) {

4
src/comp/middle/tstate/collect_locals.rs
View file

@ -1,6 +1,6 @@
import std::uint;
import std::int;
import std::ivec;
import std::vec;
import syntax::ast::*;
import util::ppaux::fn_ident_to_string;
import std::option::*;
@ -127,7 +127,7 @@ fn mk_fn_info(ccx: &crate_ctxt, f: &_fn, tp: &[ty_param], f_sp: &span,
{constrs: res_map,
num_constraints:
// add 2 to account for the i_return and i_diverge constraints
ivec::len(*cx.cs) + ivec::len(f.decl.constraints) + 2u,
vec::len(*cx.cs) + vec::len(f.decl.constraints) + 2u,
cf: f.decl.cf,
i_return: ninit(id, name),
i_diverge: ninit(diverges_id, diverges_name),

10
src/comp/middle/tstate/pre_post_conditions.rs
View file

@ -1,5 +1,5 @@
import std::ivec;
import std::vec;
import std::option;
import std::option::none;
import std::option::some;
@ -115,7 +115,7 @@ fn find_pre_post_item(ccx: &crate_ctxt, i: &item) {
the preconditions for <args>, and the postcondition in a to
be the union of all postconditions for <args> */
fn find_pre_post_exprs(fcx: &fn_ctxt, args: &[@expr], id: node_id) {
if ivec::len[@expr](args) > 0u {
if vec::len[@expr](args) > 0u {
log "find_pre_post_exprs: oper =";
log_expr(*args.(0));
}
@ -125,10 +125,10 @@ fn find_pre_post_exprs(fcx: &fn_ctxt, args: &[@expr], id: node_id) {
fn get_pp(ccx: crate_ctxt, e: &@expr) -> pre_and_post {
ret expr_pp(ccx, e);
}
let pps = ivec::map[@expr, pre_and_post](bind get_pp(fcx.ccx, _), args);
let pps = vec::map[@expr, pre_and_post](bind get_pp(fcx.ccx, _), args);
set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps),
seq_postconds(fcx, ivec::map(get_post, pps)));
seq_postconds(fcx, vec::map(get_post, pps)));
}
fn find_pre_post_loop(fcx: &fn_ctxt, l: &@local, index: &@expr, body: &blk,
@ -525,7 +525,7 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
postcondition: false_postcond(num_local_vars)};
let g = bind combine_pp(antec_pp, fcx, _, _);
let alts_overall_pp =
ivec::foldl[pre_and_post, pre_and_post](g, e_pp, alt_pps);
vec::foldl[pre_and_post, pre_and_post](g, e_pp, alt_pps);
set_pre_and_post(fcx.ccx, e.id, alts_overall_pp.precondition,
alts_overall_pp.postcondition);
}

20
src/comp/middle/tstate/states.rs
View file

@ -1,6 +1,6 @@
import syntax::print::pprust::path_to_str;
import util::ppaux::ty_to_str;
import std::ivec;
import std::vec;
import std::option;
import std::option::get;
import std::option::is_none;
@ -165,11 +165,11 @@ fn find_pre_post_state_call(fcx: &fn_ctxt, pres: &prestate, a: &@expr,
id: node_id, ops: &[init_op], bs: &[@expr],
cf: controlflow) -> bool {
let changed = find_pre_post_state_expr(fcx, pres, a);
if ivec::len(bs) != ivec::len(ops) {
if vec::len(bs) != vec::len(ops) {
fcx.ccx.tcx.sess.span_bug(a.span,
#fmt("mismatched arg lengths: \
%u exprs vs. %u ops",
ivec::len(bs), ivec::len(ops)));
vec::len(bs), vec::len(ops)));
}
ret find_pre_post_state_exprs(fcx, expr_poststate(fcx.ccx, a), id,
ops, bs, cf)
@ -313,8 +313,8 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
alt e.node {
expr_vec(elts, _, _) {
ret find_pre_post_state_exprs(fcx, pres, e.id,
ivec::init_elt(init_assign,
ivec::len(elts)),
vec::init_elt(init_assign,
vec::len(elts)),
elts, return);
}
expr_call(operator, operands) {
@ -372,8 +372,8 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
expr_rec(fields, maybe_base) {
let changed =
find_pre_post_state_exprs(fcx, pres, e.id,
ivec::init_elt(init_assign,
ivec::len(fields)),
vec::init_elt(init_assign,
vec::len(fields)),
field_exprs(fields),
return);
alt maybe_base {
@ -389,8 +389,8 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
}
expr_tup(elts) {
ret find_pre_post_state_exprs(fcx, pres, e.id,
ivec::init_elt(init_assign,
ivec::len(elts)),
vec::init_elt(init_assign,
vec::len(elts)),
elts, return);
}
expr_copy(a) {
@ -554,7 +554,7 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
find_pre_post_state_expr(fcx, pres, val);
let e_post = expr_poststate(fcx.ccx, val);
let a_post;
if ivec::len(alts) > 0u {
if vec::len(alts) > 0u {
a_post = false_postcond(num_constrs);
for an_alt: arm in alts {
changed |=

74
src/comp/middle/ty.rs
View file

@ -1,5 +1,5 @@
import std::int;
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::box;
@ -393,7 +393,7 @@ fn populate_type_store(cx: &ctxt) {
intern(cx, ty_task, none);
intern(cx, ty_type, none);
intern(cx, ty_bot, none);
assert (ivec::len(cx.ts.vect) == idx_first_others);
assert (vec::len(cx.ts.vect) == idx_first_others);
}
fn mk_rcache() -> creader_cache {
@ -1195,7 +1195,7 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
ty_istr. { ret false; }
ty_tag(_, subtys) {
let i = 0u;
while i < ivec::len[t](subtys) {
while i < vec::len[t](subtys) {
if type_has_dynamic_size(cx, subtys.(i)) { ret true; }
i += 1u;
}
@ -1210,7 +1210,7 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
ty_task. { ret false; }
ty_rec(fields) {
let i = 0u;
while i < ivec::len[field](fields) {
while i < vec::len[field](fields) {
if type_has_dynamic_size(cx, fields.(i).mt.ty) { ret true; }
i += 1u;
}
@ -1453,7 +1453,7 @@ fn type_autoderef(cx: &ctxt, t: &ty::t) -> ty::t {
}
ty::ty_tag(did, tps) {
let variants = tag_variants(cx, did);
if ivec::len(variants) != 1u || ivec::len(variants.(0).args) != 1u
if vec::len(variants) != 1u || vec::len(variants.(0).args) != 1u
{
break;
}
@ -1643,7 +1643,7 @@ fn constr_eq(c: &@constr, d: &@constr) -> bool {
}
fn constrs_eq(cs: &[@constr], ds: &[@constr]) -> bool {
if ivec::len(cs) != ivec::len(ds) { ret false; }
if vec::len(cs) != vec::len(ds) { ret false; }
let i = 0u;
for c: @constr in cs { if !constr_eq(c, ds.(i)) { ret false; } i += 1u; }
ret true;
@ -1656,8 +1656,8 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
fn equal_fn(args_a: &[arg], rty_a: &t, args_b: &[arg], rty_b: &t) ->
bool {
if !eq_ty(rty_a, rty_b) { ret false; }
let len = ivec::len[arg](args_a);
if len != ivec::len[arg](args_b) { ret false; }
let len = vec::len[arg](args_a);
if len != vec::len[arg](args_b) { ret false; }
let i = 0u;
while i < len {
let arg_a = args_a.(i);
@ -1693,8 +1693,8 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
alt b {
ty_tag(id_b, tys_b) {
if !equal_def(id_a, id_b) { ret false; }
let len = ivec::len[t](tys_a);
if len != ivec::len[t](tys_b) { ret false; }
let len = vec::len[t](tys_a);
if len != vec::len[t](tys_b) { ret false; }
let i = 0u;
while i < len {
if !eq_ty(tys_a.(i), tys_b.(i)) { ret false; }
@ -1727,8 +1727,8 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
ty_rec(flds_a) {
alt b {
ty_rec(flds_b) {
let len = ivec::len[field](flds_a);
if len != ivec::len[field](flds_b) { ret false; }
let len = vec::len[field](flds_a);
if len != vec::len[field](flds_b) { ret false; }
let i = 0u;
while i < len {
let fld_a = flds_a.(i);
@ -1747,8 +1747,8 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
ty_tup(ts_a) {
alt (b) {
ty_tup(ts_b) {
let len = ivec::len(ts_a);
if len != ivec::len(ts_b) { ret false; }
let len = vec::len(ts_a);
if len != vec::len(ts_b) { ret false; }
let i = 0u;
while i < len {
if !eq_ty(ts_a.(i), ts_b.(i)) { ret false; }
@ -1780,8 +1780,8 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
ty_obj(methods_a) {
alt b {
ty_obj(methods_b) {
let len = ivec::len[method](methods_a);
if len != ivec::len[method](methods_b) { ret false; }
let len = vec::len[method](methods_a);
if len != vec::len[method](methods_b) { ret false; }
let i = 0u;
while i < len {
let m_a = methods_a.(i);
@ -1898,7 +1898,7 @@ fn node_id_to_type_params(cx: &ctxt, id: &ast::node_id) -> [t] {
}
fn node_id_has_type_params(cx: &ctxt, id: &ast::node_id) -> bool {
ret ivec::len(node_id_to_type_params(cx, id)) > 0u;
ret vec::len(node_id_to_type_params(cx, id)) > 0u;
}
@ -1938,7 +1938,7 @@ fn count_ty_params(cx: &ctxt, ty: t) -> uint {
let param_indices: @mutable [uint] = @mutable ~[];
let f = bind counter(cx, param_indices, _);
walk_ty(cx, f, ty);
ret ivec::len[uint](*param_indices);
ret vec::len[uint](*param_indices);
}
fn type_contains_vars(cx: &ctxt, typ: &t) -> bool {
@ -2079,7 +2079,7 @@ fn occurs_check_fails(tcx: &ctxt, sp: &option::t[span], vid: int, rt: &t)
ret false;
}
// Occurs check!
if ivec::member(vid, vars_in_type(tcx, rt)) {
if vec::member(vid, vars_in_type(tcx, rt)) {
alt sp {
some (s) {
// Maybe this should be span_err -- however, there's an
@ -2211,8 +2211,8 @@ mod unify {
// pairwise equal.
fn unify_constrs(base_t: &t, expected: [@type_constr],
actual: &[@type_constr]) -> result {
let expected_len = ivec::len(expected);
let actual_len = ivec::len(actual);
let expected_len = vec::len(expected);
let actual_len = vec::len(actual);
if expected_len != actual_len {
ret ures_err(terr_constr_len(expected_len, actual_len));
@ -2231,8 +2231,8 @@ mod unify {
let ok_res = ures_ok(base_t);
let err_res = ures_err(terr_constr_mismatch(expected, actual_constr));
if expected.node.id != actual_constr.node.id { ret err_res; }
let expected_arg_len = ivec::len(expected.node.args);
let actual_arg_len = ivec::len(actual_constr.node.args);
let expected_arg_len = vec::len(expected.node.args);
let actual_arg_len = vec::len(actual_constr.node.args);
if expected_arg_len != actual_arg_len { ret err_res; }
let i = 0u;
let actual;
@ -2276,8 +2276,8 @@ mod unify {
expected_inputs: &[arg], expected_output: &t,
actual_inputs: &[arg], actual_output: &t) ->
fn_common_res {
let expected_len = ivec::len[arg](expected_inputs);
let actual_len = ivec::len[arg](actual_inputs);
let expected_len = vec::len[arg](expected_inputs);
let actual_len = vec::len[arg](actual_inputs);
if expected_len != actual_len {
ret fn_common_res_err(ures_err(terr_arg_count));
}
@ -2373,8 +2373,8 @@ mod unify {
result {
let result_meths: [method] = ~[];
let i: uint = 0u;
let expected_len: uint = ivec::len[method](expected_meths);
let actual_len: uint = ivec::len[method](actual_meths);
let expected_len: uint = vec::len[method](expected_meths);
let actual_len: uint = vec::len[method](actual_meths);
if expected_len != actual_len { ret ures_err(terr_meth_count); }
while i < expected_len {
let e_meth = expected_meths.(i);
@ -2515,7 +2515,7 @@ mod unify {
// TODO: factor this cruft out
let result_tps: [t] = ~[];
let i = 0u;
let expected_len = ivec::len[t](expected_tps);
let expected_len = vec::len[t](expected_tps);
while i < expected_len {
let expected_tp = expected_tps.(i);
let actual_tp = actual_tps.(i);
@ -2684,8 +2684,8 @@ mod unify {
ty::ty_rec(expected_fields) {
alt struct(cx.tcx, actual) {
ty::ty_rec(actual_fields) {
let expected_len = ivec::len[field](expected_fields);
let actual_len = ivec::len[field](actual_fields);
let expected_len = vec::len[field](expected_fields);
let actual_len = vec::len[field](actual_fields);
if expected_len != actual_len {
let err = terr_record_size(expected_len, actual_len);
ret ures_err(err);
@ -2730,8 +2730,8 @@ mod unify {
ty::ty_tup(expected_elems) {
alt struct(cx.tcx, actual) {
ty::ty_tup(actual_elems) {
let expected_len = ivec::len(expected_elems);
let actual_len = ivec::len(actual_elems);
let expected_len = vec::len(expected_elems);
let actual_len = vec::len(actual_elems);
if (expected_len != actual_len) {
let err = terr_tuple_size(expected_len, actual_len);
ret ures_err(err);
@ -2825,10 +2825,10 @@ mod unify {
}
fn dump_var_bindings(tcx: ty_ctxt, vb: @var_bindings) {
let i = 0u;
while i < ivec::len[ufind::node](vb.sets.nodes) {
while i < vec::len[ufind::node](vb.sets.nodes) {
let sets = "";
let j = 0u;
while j < ivec::len[option::t[uint]](vb.sets.nodes) {
while j < vec::len[option::t[uint]](vb.sets.nodes) {
if ufind::find(vb.sets, j) == i {
sets += #fmt(" %u", j);
}
@ -2951,7 +2951,7 @@ fn bind_params_in_type(sp: &span, cx: &ctxt, next_ty_var: fn() -> int ,
while i < ty_param_count { *param_var_ids += ~[next_ty_var()]; i += 1u; }
fn binder(sp: span, cx: ctxt, param_var_ids: @mutable [int],
next_ty_var: fn() -> int , index: uint, kind: ast::kind) -> t {
if index < ivec::len(*param_var_ids) {
if index < vec::len(*param_var_ids) {
ret mk_var(cx, param_var_ids.(index));
} else {
cx.sess.span_fatal(sp, "Unbound type parameter in callee's type");
@ -3015,7 +3015,7 @@ fn tag_variants(cx: &ctxt, id: &ast::def_id) -> [variant_info] {
for variant: ast::variant in variants {
let ctor_ty = node_id_to_monotype(cx, variant.node.id);
let arg_tys: [t] = ~[];
if std::ivec::len(variant.node.args) > 0u {
if std::vec::len(variant.node.args) > 0u {
for a: arg in ty_fn_args(cx, ctor_ty) {
arg_tys += ~[a.ty];
}
@ -3039,7 +3039,7 @@ fn tag_variant_with_id(cx: &ctxt, tag_id: &ast::def_id,
variant_id: &ast::def_id) -> variant_info {
let variants = tag_variants(cx, tag_id);
let i = 0u;
while i < ivec::len[variant_info](variants) {
while i < vec::len[variant_info](variants) {
let variant = variants.(i);
if def_eq(variant.id, variant_id) { ret variant; }
i += 1u;

80
src/comp/middle/typeck.rs
View file

@ -34,7 +34,7 @@ import middle::ty::unify::fixup_result;
import middle::ty::unify::fix_ok;
import middle::ty::unify::fix_err;
import std::int;
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::map;
@ -158,15 +158,15 @@ fn ty_param_kinds_and_ty_for_def(fcx: &@fn_ctxt, sp: &span, defn: &ast::def)
fn instantiate_path(fcx: &@fn_ctxt, pth: &ast::path,
tpt: &ty_param_kinds_and_ty, sp: &span) ->
ty_param_substs_opt_and_ty {
let ty_param_count = ivec::len(tpt.kinds);
let ty_param_count = vec::len(tpt.kinds);
let bind_result =
bind_params_in_type(sp, fcx.ccx.tcx, bind next_ty_var_id(fcx), tpt.ty,
ty_param_count);
let ty_param_vars = bind_result.ids;
let ty_substs_opt;
let ty_substs_len = ivec::len[@ast::ty](pth.node.types);
let ty_substs_len = vec::len[@ast::ty](pth.node.types);
if ty_substs_len > 0u {
let param_var_len = ivec::len(ty_param_vars);
let param_var_len = vec::len(ty_param_vars);
if param_var_len == 0u {
fcx.ccx.tcx.sess.span_fatal
(sp, "this item does not take type parameters");
@ -287,7 +287,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
// "foo = int" like OCaml?
let ty_param_kinds_and_ty = getter(id);
if ivec::len(ty_param_kinds_and_ty.kinds) == 0u {
if vec::len(ty_param_kinds_and_ty.kinds) == 0u {
ret ty_param_kinds_and_ty.ty;
}
// The typedef is type-parametric. Do the type substitution.
@ -297,8 +297,8 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
for ast_ty: @ast::ty in args {
param_bindings += ~[ast_ty_to_ty(tcx, getter, ast_ty)];
}
if ivec::len(param_bindings) !=
ivec::len(ty_param_kinds_and_ty.kinds) {
if vec::len(param_bindings) !=
vec::len(ty_param_kinds_and_ty.kinds) {
tcx.sess.span_fatal(sp,
"Wrong number of type arguments for a \
polymorphic type");
@ -341,7 +341,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
typ = ty::mk_chan(tcx, ast_ty_to_ty(tcx, getter, t));
}
ast::ty_tup(fields) {
let flds = ivec::map(bind ast_ty_to_ty(tcx, getter, _), fields);
let flds = vec::map(bind ast_ty_to_ty(tcx, getter, _), fields);
typ = ty::mk_tup(tcx, flds);
}
ast::ty_rec(fields) {
@ -752,7 +752,7 @@ mod collect {
// constructors get turned into functions.
let result_ty;
if ivec::len[ast::variant_arg](variant.node.args) == 0u {
if vec::len[ast::variant_arg](variant.node.args) == 0u {
result_ty = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
} else {
// As above, tell ast_ty_to_ty() that trans_ty_item_to_ty()
@ -813,7 +813,7 @@ mod collect {
// ty_of_obj().)
let method_types = get_obj_method_types(cx, object);
let i = 0u;
while i < ivec::len[@ast::method](object.methods) {
while i < vec::len[@ast::method](object.methods) {
write::ty_only(cx.tcx, object.methods.(i).node.id,
ty::method_ty_to_fn_ty(cx.tcx,
method_types.(i)));
@ -825,7 +825,7 @@ mod collect {
// an assertion in trans.
let args = ty::ty_fn_args(cx.tcx, tpt.ty);
i = 0u;
while i < ivec::len[ty::arg](args) {
while i < vec::len[ty::arg](args) {
let fld = object.fields.(i);
write::ty_only(cx.tcx, fld.id, args.(i).ty);
i += 1u;
@ -919,7 +919,7 @@ fn do_autoderef(fcx: &@fn_ctxt, sp: &span, t: &ty::t) -> ty::t {
}
ty::ty_tag(did, tps) {
let variants = ty::tag_variants(fcx.ccx.tcx, did);
if ivec::len(variants) != 1u || ivec::len(variants.(0).args) != 1u
if vec::len(variants) != 1u || vec::len(variants.(0).args) != 1u
{
ret t1;
}
@ -1370,11 +1370,11 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
let arg_types =
variant_arg_types(fcx.ccx, pat.span, v_def_ids.var,
expected_tps);
let subpats_len = std::ivec::len[@ast::pat](subpats);
if std::ivec::len[ty::t](arg_types) > 0u {
let subpats_len = std::vec::len[@ast::pat](subpats);
if std::vec::len[ty::t](arg_types) > 0u {
// N-ary variant.
let arg_len = ivec::len[ty::t](arg_types);
let arg_len = vec::len[ty::t](arg_types);
if arg_len != subpats_len {
// TODO: note definition of tag variant
// TODO (issue #448): Wrap a #fmt string over multiple
@ -1388,7 +1388,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
fcx.ccx.tcx.sess.span_fatal(pat.span, s);
}
// TODO: ivec::iter2
// TODO: vec::iter2
let i = 0u;
for subpat: @ast::pat in subpats {
@ -1431,8 +1431,8 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
expected)));
}
}
let f_count = ivec::len(fields);
let ex_f_count = ivec::len(ex_fields);
let f_count = vec::len(fields);
let ex_f_count = vec::len(ex_fields);
if ex_f_count < f_count || !etc && ex_f_count > f_count {
fcx.ccx.tcx.sess.span_fatal
(pat.span, #fmt("mismatched types: expected a record \
@ -1443,7 +1443,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
ret str::eq(name, f.ident);
}
for f: ast::field_pat in fields {
alt ivec::find(bind matches(f.ident, _), ex_fields) {
alt vec::find(bind matches(f.ident, _), ex_fields) {
some(field) { check_pat(fcx, map, f.pat, field.mt.ty); }
none. {
fcx.ccx.tcx.sess.span_fatal(pat.span,
@ -1466,12 +1466,12 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
expected)));
}
}
let e_count = ivec::len(elts);
if e_count != ivec::len(ex_elts) {
let e_count = vec::len(elts);
if e_count != vec::len(ex_elts) {
fcx.ccx.tcx.sess.span_fatal
(pat.span, #fmt("mismatched types: expected a tuple \
with %u fields, found one with %u \
fields", ivec::len(ex_elts), e_count));
fields", vec::len(ex_elts), e_count));
}
let i = 0u;
for elt in elts {
@ -1593,8 +1593,8 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
}
// Check that the correct number of arguments were supplied.
let expected_arg_count = ivec::len[ty::arg](arg_tys);
let supplied_arg_count = ivec::len[option::t[@ast::expr]](args);
let expected_arg_count = vec::len[ty::arg](arg_tys);
let supplied_arg_count = vec::len[option::t[@ast::expr]](args);
if expected_arg_count != supplied_arg_count {
fcx.ccx.tcx.sess.span_fatal(sp,
#fmt("this function takes %u \
@ -1828,8 +1828,8 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
ty::ty_res(_, inner, _) { oper_t = inner; }
ty::ty_tag(id, tps) {
let variants = ty::tag_variants(tcx, id);
if ivec::len(variants) != 1u ||
ivec::len(variants.(0).args) != 1u {
if vec::len(variants) != 1u ||
vec::len(variants.(0).args) != 1u {
tcx.sess.span_fatal
(expr.span, "can only dereference tags " +
"with a single variant which has a "
@ -1877,7 +1877,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
} else {
// The definition doesn't take type parameters. If the programmer
// supplied some, that's an error.
if ivec::len[@ast::ty](pth.node.types) > 0u {
if vec::len[@ast::ty](pth.node.types) > 0u {
tcx.sess.span_fatal(expr.span,
"this kind of value does not \
take type parameters");
@ -2116,7 +2116,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
// For each blank argument, add the type of that argument
// to the resulting function type.
let i = 0u;
while i < ivec::len[option::t[@ast::expr]](args) {
while i < vec::len[option::t[@ast::expr]](args) {
alt args.(i) {
some(_) {/* no-op */ }
none. { arg_tys_1 += ~[arg_tys.(i)]; }
@ -2239,7 +2239,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
}
ast::expr_tup(elts) {
let elt_ts = ~[];
ivec::reserve(elt_ts, ivec::len(elts));
vec::reserve(elt_ts, vec::len(elts));
for e in elts {
check_expr(fcx, e);
let ety = expr_ty(fcx.ccx.tcx, e);
@ -2264,7 +2264,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
alt base {
none. {
fn get_node(f: &spanned[field]) -> field { f.node }
let typ = ty::mk_rec(tcx, ivec::map(get_node, fields_t));
let typ = ty::mk_rec(tcx, vec::map(get_node, fields_t));
write::ty_only_fixup(fcx, id, typ);
}
some(bexpr) {
@ -2304,7 +2304,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
ty::ty_rec(fields) {
let ix: uint =
ty::field_idx(tcx.sess, expr.span, field, fields);
if ix >= ivec::len[ty::field](fields) {
if ix >= vec::len[ty::field](fields) {
tcx.sess.span_fatal(expr.span, "bad index on record");
}
write::ty_only_fixup(fcx, id, fields.(ix).mt.ty);
@ -2312,7 +2312,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
ty::ty_obj(methods) {
let ix: uint =
ty::method_idx(tcx.sess, expr.span, field, methods);
if ix >= ivec::len[ty::method](methods) {
if ix >= vec::len[ty::method](methods) {
tcx.sess.span_fatal(expr.span, "bad index on obj");
}
let meth = methods.(ix);
@ -2444,7 +2444,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
}
fcx.ccx.obj_infos +=
~[anon_obj(ivec::map(ast::obj_field_from_anon_obj_field,
~[anon_obj(vec::map(ast::obj_field_from_anon_obj_field,
fields), inner_obj_sty)];
// Whenever an outer method overrides an inner, we need to remove
@ -2474,7 +2474,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
let f = bind filtering_fn(fcx.ccx, _, ao.methods);
inner_obj_methods =
std::ivec::filter_map[ty::method,
std::vec::filter_map[ty::method,
ty::method](f, inner_obj_methods);
method_types += inner_obj_methods;
@ -2487,7 +2487,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
// Write the methods into the node type table. (This happens in
// collect::convert for regular objects.)
let i = 0u;
while i < ivec::len[@ast::method](ao.methods) {
while i < vec::len[@ast::method](ao.methods) {
write::ty_only(tcx, ao.methods.(i).node.id,
ty::method_ty_to_fn_ty(tcx,
method_types.(i)));
@ -2500,7 +2500,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
}
// Now remove the info from the stack.
ivec::pop[obj_info](fcx.ccx.obj_infos);
vec::pop[obj_info](fcx.ccx.obj_infos);
}
ast::expr_uniq(x) {
let t = next_ty_var(fcx);
@ -2528,7 +2528,7 @@ fn next_ty_var(fcx: &@fn_ctxt) -> ty::t {
}
fn get_obj_info(ccx: &@crate_ctxt) -> option::t[obj_info] {
ret ivec::last[obj_info](ccx.obj_infos);
ret vec::last[obj_info](ccx.obj_infos);
}
fn check_decl_initializer(fcx: &@fn_ctxt, nid: ast::node_id,
@ -2707,7 +2707,7 @@ fn check_item(ccx: @crate_ctxt, it: &@ast::item) {
for method: @ast::method in ob.methods { check_method(ccx, method); }
// Now remove the info from the stack.
ivec::pop[obj_info](ccx.obj_infos);
vec::pop[obj_info](ccx.obj_infos);
}
_ {/* nothing to do */ }
}
@ -2738,9 +2738,9 @@ fn check_main_fn_ty(tcx: &ty::ctxt, main_id: &ast::node_id) {
let main_t = ty::node_id_to_monotype(tcx, main_id);
alt ty::struct(tcx, main_t) {
ty::ty_fn(ast::proto_fn., args, rs, ast::return., constrs) {
let ok = ivec::len(constrs) == 0u;
let ok = vec::len(constrs) == 0u;
ok &= ty::type_is_nil(tcx, rs);
let num_args = ivec::len(args);
let num_args = vec::len(args);
ok &=
num_args == 0u || num_args == 1u && arg_is_argv_ty(tcx, args.(0));
if !ok {

1
src/comp/syntax/ast.rs
View file

@ -1,6 +1,5 @@
// The Rust abstract syntax tree.
import std::ivec;
import std::option;
import std::str;
import codemap::span;

16
src/comp/syntax/codemap.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::uint;
import std::str;
import std::term;
@ -40,14 +40,14 @@ type lookup_fn = fn(file_pos) -> uint ;
fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc {
let a = 0u;
let b = ivec::len(map.files);
let b = vec::len(map.files);
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(map.files.(m).start_pos) > pos { b = m; } else { a = m; }
}
let f = map.files.(a);
a = 0u;
b = ivec::len(f.lines);
b = vec::len(f.lines);
while b - a > 1u {
let m = (a + b) / 2u;
if lookup(f.lines.(m)) > pos { b = m; } else { a = m; }
@ -137,8 +137,8 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
let max_lines = 6u;
let elided = false;
let display_lines = lines.lines;
if ivec::len(display_lines) > max_lines {
display_lines = ivec::slice(display_lines, 0u, max_lines);
if vec::len(display_lines) > max_lines {
display_lines = vec::slice(display_lines, 0u, max_lines);
elided = true;
}
// Print the offending lines
@ -149,7 +149,7 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
io::stdout().write_str(s);
}
if elided {
let last_line = display_lines.(ivec::len(display_lines) - 1u);
let last_line = display_lines.(vec::len(display_lines) - 1u);
let s = #fmt("%s:%u ", fm.name, last_line + 1u);
let indent = str::char_len(s);
let out = "";
@ -160,7 +160,7 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
// If there's one line at fault we can easily point to the problem
if ivec::len(lines.lines) == 1u {
if vec::len(lines.lines) == 1u {
let lo = lookup_char_pos(cm, option::get(sp).lo);
let digits = 0u;
let num = lines.lines.(0) / 10u;
@ -212,7 +212,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
fn get_line(fm: filemap, line: int, file: &str) -> str {
let begin: uint = fm.lines.(line).byte - fm.start_pos.byte;
let end: uint;
if line as uint < ivec::len(fm.lines) - 1u {
if line as uint < vec::len(fm.lines) - 1u {
end = fm.lines.(line + 1).byte - fm.start_pos.byte;
} else {
// If we're not done parsing the file, we're at the limit of what's

4
src/comp/syntax/ext/base.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::option;
import std::map::hashmap;
import driver::session::session;
@ -113,7 +113,7 @@ fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: str) -> str {
fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
alt expr.node {
ast::expr_path(p) {
if ivec::len(p.node.types) > 0u || ivec::len(p.node.idents) != 1u {
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
cx.span_fatal(expr.span, error);
} else { ret p.node.idents.(0); }
}

1
src/comp/syntax/ext/concat_idents.rs
View file

@ -1,4 +1,3 @@
import std::ivec;
import std::option;
import base::*;
import syntax::ast;

4
src/comp/syntax/ext/env.rs
View file

@ -4,7 +4,7 @@
* should all get sucked into either the compiler syntax extension plugin
* interface.
*/
import std::ivec;
import std::vec;
import std::option;
import std::generic_os;
import base::*;
@ -16,7 +16,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
ast::expr_vec(elts, _, _) { elts }
_ { cx.span_fatal(sp, "#env requires arguments of the form `[...]`.") }
};
if ivec::len[@ast::expr](args) != 1u {
if vec::len[@ast::expr](args) != 1u {
cx.span_fatal(sp, "malformed #env call");
}
// FIXME: if this was more thorough it would manufacture an

4
src/comp/syntax/ext/expand.rs
View file

@ -4,7 +4,7 @@ import std::option::none;
import std::option::some;
import std::map::hashmap;
import std::ivec;
import std::vec;
import syntax::ast::crate;
import syntax::ast::expr_;
@ -21,7 +21,7 @@ fn expand_expr(exts: &hashmap[str, syntax_extension], cx: &ext_ctxt,
expr_mac(mac) {
alt mac.node {
mac_invoc(pth, args, body) {
assert (ivec::len(pth.node.idents) > 0u);
assert (vec::len(pth.node.idents) > 0u);
let extname = pth.node.idents.(0);
alt exts.find(extname) {
none. {

8
src/comp/syntax/ext/fmt.rs
View file

@ -5,7 +5,7 @@
* should all get sucked into either the standard library extfmt module or the
* compiler syntax extension plugin interface.
*/
import std::ivec;
import std::vec;
import std::str;
import std::option;
import std::option::none;
@ -21,7 +21,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
ast::expr_vec(elts, _, _) { elts }
_ { cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.") }
};
if ivec::len[@ast::expr](args) == 0u {
if vec::len[@ast::expr](args) == 0u {
cx.span_fatal(sp, "#fmt requires a format string");
}
let fmt =
@ -130,7 +130,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
// through the rec that these flags are a member of, so
// this is a hack placeholder flag
if ivec::len[@ast::expr](flagexprs) == 0u {
if vec::len[@ast::expr](flagexprs) == 0u {
flagexprs += ~[make_rt_path_expr(cx, sp, "flag_none")];
}
ret make_vec_expr(cx, sp, flagexprs);
@ -307,7 +307,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
let fmt_sp = args.(0).span;
let n = 0u;
let tmp_expr = make_new_str(cx, sp, "");
let nargs = ivec::len[@ast::expr](args);
let nargs = vec::len[@ast::expr](args);
for pc: piece in pieces {
alt pc {
piece_string(s) {

4
src/comp/syntax/ext/ident_to_str.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::option;
import base::*;
import syntax::ast;
@ -9,7 +9,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
ast::expr_vec(elts, _, _) { elts }
_ { cx.span_fatal(sp, "#ident_to_str requires a vector argument .") }
};
if ivec::len[@ast::expr](args) != 1u {
if vec::len[@ast::expr](args) != 1u {
cx.span_fatal(sp, "malformed #ident_to_str call");
}

44
src/comp/syntax/ext/simplext.rs
View file

@ -1,7 +1,7 @@
use std;
import codemap::span;
import std::ivec;
import std::vec;
import std::option;
import std::map::hashmap;
import std::map::new_str_hash;
@ -33,7 +33,7 @@ import ast::mac_invoc;
export add_new_extension;
fn path_to_ident(pth: &path) -> option::t[ident] {
if ivec::len(pth.node.idents) == 1u && ivec::len(pth.node.types) == 0u {
if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u {
ret some(pth.node.idents.(0u));
}
ret none;
@ -103,10 +103,10 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
if res != none {
cx.span_fatal(m.span, "only one ellipsis allowed");
}
res = some({pre: ivec::slice(elts, 0u, idx - 1u),
res = some({pre: vec::slice(elts, 0u, idx - 1u),
rep: some(elts.(idx - 1u)),
post: ivec::slice(elts, idx + 1u,
ivec::len(elts))});
post: vec::slice(elts, idx + 1u,
vec::len(elts))});
}
_ { }
}
@ -286,7 +286,7 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
-> [@expr] {
alt elts_to_ell(cx, exprs) {
{pre: pre, rep: repeat_me_maybe, post: post} {
let res = ivec::map(recur, pre);
let res = vec::map(recur, pre);
alt repeat_me_maybe {
none. {}
some(repeat_me) {
@ -300,10 +300,10 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
seq(ms, _) {
alt repeat {
none. {
repeat = some({rep_count: ivec::len(*ms), name: fv});
repeat = some({rep_count: vec::len(*ms), name: fv});
}
some({rep_count: old_len, name: old_name}) {
let len = ivec::len(*ms);
let len = vec::len(*ms);
if old_len != len {
let msg = #fmt("'%s' occurs %u times, but ", fv,
len) + #fmt("'%s' occurs %u times",
@ -327,14 +327,14 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
while idx < rc {
*idx_path += ~[idx];
res += ~[recur(repeat_me)]; // whew!
ivec::pop(*idx_path);
vec::pop(*idx_path);
idx += 1u;
}
}
}
}
}
res += ivec::map(recur, post);
res += vec::map(recur, post);
ret res;
}
}
@ -356,7 +356,7 @@ fn transcribe_ident(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
fn transcribe_path(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
p: &path_, fld: ast_fold) -> path_ {
// Don't substitute into qualified names.
if ivec::len(p.types) > 0u || ivec::len(p.idents) != 1u { ret p; }
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
ret alt follow_for_trans(cx, b.find(p.idents.(0)), idx_path) {
some(match_ident(id)) {
{global: false, idents: ~[id.node], types: ~[]}
@ -375,7 +375,7 @@ fn transcribe_expr(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
ret alt e {
expr_path(p) {
// Don't substitute into qualified names.
if ivec::len(p.node.types) > 0u || ivec::len(p.node.idents) != 1u
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u
{
e
}
@ -452,14 +452,14 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
expr_vec(p_elts, _, _) {
alt elts_to_ell(cx, p_elts) {
{pre: pre, rep: some(repeat_me), post: post} {
p_t_s_r_length(cx, ivec::len(pre) + ivec::len(post),
p_t_s_r_length(cx, vec::len(pre) + vec::len(post),
true, s, b);
if(ivec::len(pre) > 0u) {
if(vec::len(pre) > 0u) {
p_t_s_r_actual_vector(cx, pre, true, s, b);
}
p_t_s_r_ellipses(cx, repeat_me, ivec::len(pre), s, b);
p_t_s_r_ellipses(cx, repeat_me, vec::len(pre), s, b);
if(ivec::len(post) > 0u) {
if(vec::len(post) > 0u) {
cx.span_unimpl(e.span,
"matching after `...` not yet supported");
}
@ -468,7 +468,7 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
if post != ~[] {
cx.bug("elts_to_ell provided an invalid result");
}
p_t_s_r_length(cx, ivec::len(pre), false, s, b);
p_t_s_r_length(cx, vec::len(pre), false, s, b);
p_t_s_r_actual_vector(cx, pre, false, s, b);
}
}
@ -534,7 +534,7 @@ fn p_t_s_r_path(cx: &ext_ctxt, p: &path, s: &selector, b: &binders) {
}
fn block_to_ident(blk: &blk_) -> option::t[ident] {
if ivec::len(blk.stmts) != 0u { ret none; }
if vec::len(blk.stmts) != 0u { ret none; }
ret alt blk.expr {
some(expr) {
alt expr.node { expr_path(pth) { path_to_ident(pth) } _ { none } }
@ -610,7 +610,7 @@ fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, offset: uint,
expr_vec(arg_elts, _, _) {
let elts = ~[];
let idx = offset;
while idx < ivec::len(arg_elts) {
while idx < vec::len(arg_elts) {
elts += ~[leaf(match_expr(arg_elts.(idx)))];
idx += 1u;
}
@ -637,7 +637,7 @@ fn p_t_s_r_length(cx: &ext_ctxt, len: uint, at_least: bool, s: selector,
match_expr(e) {
alt e.node {
expr_vec(arg_elts, _, _) {
let actual_len = ivec::len(arg_elts);
let actual_len = vec::len(arg_elts);
if (at_least && actual_len >= len) || actual_len == len {
some(leaf(match_exact))
} else { none }
@ -655,7 +655,7 @@ fn p_t_s_r_length(cx: &ext_ctxt, len: uint, at_least: bool, s: selector,
fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], repeat_after: bool,
s: &selector, b: &binders) {
let idx: uint = 0u;
while idx < ivec::len(elts) {
while idx < vec::len(elts) {
fn select(cx: &ext_ctxt, m: &matchable, idx: uint) -> match_result {
ret alt m {
match_expr(e) {
@ -689,7 +689,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
for arg: @expr in args {
alt arg.node {
expr_vec(elts, mut, seq_kind) {
if ivec::len(elts) != 2u {
if vec::len(elts) != 2u {
cx.span_fatal((*arg).span,
"extension clause must consist of [" +
"macro invocation, expansion body]");

68
src/comp/syntax/fold.rs
View file

@ -1,7 +1,7 @@
import syntax::codemap::span;
import ast::*;
import std::ivec;
import std::vec;
import std::option;
export ast_fold_precursor;
@ -111,7 +111,7 @@ fn fold_meta_item_(mi: &@meta_item, fld: ast_fold) -> @meta_item {
meta_word(id) { meta_word(fld.fold_ident(id)) }
meta_list(id, mis) {
let fold_meta_item = bind fold_meta_item_(_, fld);
meta_list(id, ivec::map(fold_meta_item, mis))
meta_list(id, vec::map(fold_meta_item, mis))
}
meta_name_value(id, s) {
meta_name_value(fld.fold_ident(id), s)
@ -154,10 +154,10 @@ fn noop_fold_crate(c: &crate_, fld: ast_fold) -> crate_ {
let fold_meta_item = bind fold_meta_item_(_, fld);
let fold_attribute = bind fold_attribute_(_, fold_meta_item);
ret {directives: ivec::map(fld.fold_crate_directive, c.directives),
ret {directives: vec::map(fld.fold_crate_directive, c.directives),
module: fld.fold_mod(c.module),
attrs: ivec::map(fold_attribute, c.attrs),
config: ivec::map(fold_meta_item, c.config)};
attrs: vec::map(fold_attribute, c.attrs),
config: vec::map(fold_meta_item, c.config)};
}
fn noop_fold_crate_directive(cd: &crate_directive_, fld: ast_fold) ->
@ -168,7 +168,7 @@ fn noop_fold_crate_directive(cd: &crate_directive_, fld: ast_fold) ->
}
cdir_dir_mod(id, fname, cds, attrs) {
cdir_dir_mod(fld.fold_ident(id), fname,
ivec::map(fld.fold_crate_directive, cds), attrs)
vec::map(fld.fold_crate_directive, cds), attrs)
}
cdir_view_item(vi) { cdir_view_item(fld.fold_view_item(vi)) }
cdir_syntax(_) { cd }
@ -187,19 +187,19 @@ fn noop_fold_native_item(ni: &@native_item, fld: ast_fold) -> @native_item {
let fold_attribute = bind fold_attribute_(_, fold_meta_item);
ret @{ident: fld.fold_ident(ni.ident),
attrs: ivec::map(fold_attribute, ni.attrs),
attrs: vec::map(fold_attribute, ni.attrs),
node:
alt ni.node {
native_item_ty. { native_item_ty }
native_item_fn(st, fdec, typms) {
native_item_fn(st,
{inputs: ivec::map(fold_arg, fdec.inputs),
{inputs: vec::map(fold_arg, fdec.inputs),
output: fld.fold_ty(fdec.output),
purity: fdec.purity,
il: fdec.il,
cf: fdec.cf,
constraints:
ivec::map(fld.fold_constr,
vec::map(fld.fold_constr,
fdec.constraints)}, typms)
}
},
@ -212,7 +212,7 @@ fn noop_fold_item(i: &@item, fld: ast_fold) -> @item {
let fold_attribute = bind fold_attribute_(_, fold_meta_item);
ret @{ident: fld.fold_ident(i.ident),
attrs: ivec::map(fold_attribute, i.attrs),
attrs: vec::map(fold_attribute, i.attrs),
id: i.id,
node: fld.fold_item_underscore(i.node),
span: i.span};
@ -234,11 +234,11 @@ fn noop_fold_item_underscore(i: &item_, fld: ast_fold) -> item_ {
item_native_mod(nm) { item_native_mod(fld.fold_native_mod(nm)) }
item_ty(t, typms) { item_ty(fld.fold_ty(t), typms) }
item_tag(variants, typms) {
item_tag(ivec::map(fld.fold_variant, variants), typms)
item_tag(vec::map(fld.fold_variant, variants), typms)
}
item_obj(o, typms, d) {
item_obj({fields: ivec::map(fold_obj_field, o.fields),
methods: ivec::map(fld.fold_method, o.methods)},
item_obj({fields: vec::map(fold_obj_field, o.fields),
methods: vec::map(fld.fold_method, o.methods)},
typms, d)
}
item_res(dtor, did, typms, cid) {
@ -253,7 +253,7 @@ fn noop_fold_method(m: &method_, fld: ast_fold) -> method_ {
fn noop_fold_block(b: &blk_, fld: ast_fold) -> blk_ {
ret {stmts: ivec::map(fld.fold_stmt, b.stmts),
ret {stmts: vec::map(fld.fold_stmt, b.stmts),
expr: option::map(fld.fold_expr, b.expr),
id: b.id};
}
@ -269,7 +269,7 @@ fn noop_fold_stmt(s: &stmt_, fld: ast_fold) -> stmt_ {
}
fn noop_fold_arm(a: &arm, fld: ast_fold) -> arm {
ret {pats: ivec::map(fld.fold_pat, a.pats),
ret {pats: vec::map(fld.fold_pat, a.pats),
body: fld.fold_block(a.body)};
}
@ -279,7 +279,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
pat_bind(ident) { pat_bind(fld.fold_ident(ident)) }
pat_lit(_) { p }
pat_tag(pth, pats) {
pat_tag(fld.fold_path(pth), ivec::map(fld.fold_pat, pats))
pat_tag(fld.fold_path(pth), vec::map(fld.fold_pat, pats))
}
pat_rec(fields, etc) {
let fs = ~[];
@ -289,7 +289,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
pat_rec(fs, etc)
}
pat_tup(elts) {
pat_tup(ivec::map(fld.fold_pat, elts))
pat_tup(vec::map(fld.fold_pat, elts))
}
pat_box(inner) { pat_box(fld.fold_pat(inner)) }
};
@ -297,7 +297,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
fn noop_fold_decl(d: &decl_, fld: ast_fold) -> decl_ {
ret alt d {
decl_local(ls) { decl_local(ivec::map(fld.fold_local, ls)) }
decl_local(ls) { decl_local(vec::map(fld.fold_local, ls)) }
decl_item(it) { decl_item(fld.fold_item(it)) }
}
}
@ -327,10 +327,10 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
alt ao.fields {
option::none. { ao.fields }
option::some(v) {
option::some(ivec::map(fold_anon_obj_field, v))
option::some(vec::map(fold_anon_obj_field, v))
}
},
methods: ivec::map(fld.fold_method, ao.methods),
methods: vec::map(fld.fold_method, ao.methods),
inner_obj: option::map(fld.fold_expr, ao.inner_obj)}
}
let fold_anon_obj = bind fold_anon_obj_(_, fld);
@ -343,11 +343,11 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
expr_vec(fld.map_exprs(fld.fold_expr, exprs), mut, seq_kind)
}
expr_rec(fields, maybe_expr) {
expr_rec(ivec::map(fold_field, fields),
expr_rec(vec::map(fold_field, fields),
option::map(fld.fold_expr, maybe_expr))
}
expr_tup(elts) {
expr_tup(ivec::map(fld.fold_expr, elts))
expr_tup(vec::map(fld.fold_expr, elts))
}
expr_call(f, args) {
expr_call(fld.fold_expr(f), fld.map_exprs(fld.fold_expr, args))
@ -355,7 +355,7 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
expr_self_method(id) { expr_self_method(fld.fold_ident(id)) }
expr_bind(f, args) {
let opt_map_se = bind option::map(fld.fold_expr, _);
expr_bind(fld.fold_expr(f), ivec::map(opt_map_se, args))
expr_bind(fld.fold_expr(f), vec::map(opt_map_se, args))
}
expr_spawn(spawn_dom, name, f, args) {
expr_spawn(spawn_dom, name, fld.fold_expr(f),
@ -390,7 +390,7 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
expr_do_while(fld.fold_block(blk), fld.fold_expr(expr))
}
expr_alt(expr, arms) {
expr_alt(fld.fold_expr(expr), ivec::map(fld.fold_arm, arms))
expr_alt(fld.fold_expr(expr), vec::map(fld.fold_arm, arms))
}
expr_fn(f) { expr_fn(fld.fold_fn(f)) }
expr_block(blk) { expr_block(fld.fold_block(blk)) }
@ -459,27 +459,27 @@ fn noop_fold_fn(f: &_fn, fld: ast_fold) -> _fn {
let fold_arg = bind fold_arg_(_, fld);
ret {decl:
{inputs: ivec::map(fold_arg, f.decl.inputs),
{inputs: vec::map(fold_arg, f.decl.inputs),
output: fld.fold_ty(f.decl.output),
purity: f.decl.purity,
il: f.decl.il,
cf: f.decl.cf,
constraints: ivec::map(fld.fold_constr, f.decl.constraints)},
constraints: vec::map(fld.fold_constr, f.decl.constraints)},
proto: f.proto,
body: fld.fold_block(f.body)};
}
// ...nor do modules
fn noop_fold_mod(m: &_mod, fld: ast_fold) -> _mod {
ret {view_items: ivec::map(fld.fold_view_item, m.view_items),
items: ivec::map(fld.fold_item, m.items)};
ret {view_items: vec::map(fld.fold_view_item, m.view_items),
items: vec::map(fld.fold_item, m.items)};
}
fn noop_fold_native_mod(nm: &native_mod, fld: ast_fold) -> native_mod {
ret {native_name: nm.native_name,
abi: nm.abi,
view_items: ivec::map(fld.fold_view_item, nm.view_items),
items: ivec::map(fld.fold_native_item, nm.items)}
view_items: vec::map(fld.fold_view_item, nm.view_items),
items: vec::map(fld.fold_native_item, nm.items)}
}
fn noop_fold_variant(v: &variant_, fld: ast_fold) -> variant_ {
@ -487,15 +487,15 @@ fn noop_fold_variant(v: &variant_, fld: ast_fold) -> variant_ {
ret {ty: fld.fold_ty(va.ty), id: va.id};
}
let fold_variant_arg = bind fold_variant_arg_(_, fld);
ret {name: v.name, args: ivec::map(fold_variant_arg, v.args), id: v.id};
ret {name: v.name, args: vec::map(fold_variant_arg, v.args), id: v.id};
}
fn noop_fold_ident(i: &ident, fld: ast_fold) -> ident { ret i; }
fn noop_fold_path(p: &path_, fld: ast_fold) -> path_ {
ret {global: p.global,
idents: ivec::map(fld.fold_ident, p.idents),
types: ivec::map(fld.fold_ty, p.types)};
idents: vec::map(fld.fold_ident, p.idents),
types: vec::map(fld.fold_ty, p.types)};
}
fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
@ -514,7 +514,7 @@ fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
/* temporarily eta-expand because of a compiler bug with using `fn[T]` as a
value */
fn noop_map_exprs(f: fn(&@expr) -> @expr , es: [@expr]) -> [@expr] {
ret ivec::map(f, es);
ret vec::map(f, es);
}
fn noop_id(i: node_id) -> node_id { ret i; }

4
src/comp/syntax/parse/lexer.rs
View file

@ -1,7 +1,7 @@
import std::io;
import std::int;
import std::ivec;
import std::vec;
import std::str;
import std::map;
import std::map::hashmap;
@ -669,7 +669,7 @@ fn read_block_comment(rdr: &reader, code_to_the_left: bool) -> cmnt {
}
let style = if code_to_the_left { trailing } else { isolated };
consume_non_eol_whitespace(rdr);
if !rdr.is_eof() && rdr.curr() != '\n' && ivec::len(lines) == 1u {
if !rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u {
style = mixed;
}
log "<<< block comment";

28
src/comp/syntax/parse/parser.rs
View file

@ -1,6 +1,6 @@
import std::io;
import std::ivec;
import std::vec;
import std::str;
import std::option;
import std::option::some;
@ -87,18 +87,18 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
fn peek() -> token::token { ret tok; }
fn bump() {
last_tok_span = tok_span;
if ivec::len(buffer) == 0u {
if vec::len(buffer) == 0u {
let next = lexer::next_token(rdr);
tok = next.tok;
tok_span = ast::mk_sp(next.chpos, rdr.get_chpos());
} else {
let next = ivec::pop(buffer);
let next = vec::pop(buffer);
tok = next.tok;
tok_span = next.span;
}
}
fn look_ahead(distance: uint) -> token::token {
while ivec::len(buffer) < distance {
while vec::len(buffer) < distance {
let next = lexer::next_token(rdr);
let sp = ast::mk_sp(next.chpos, rdr.get_chpos());
buffer = ~[{tok: next.tok, span: sp}] + buffer;
@ -523,7 +523,7 @@ fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
p.bump();
ts += ~[parse_ty(p, false)];
}
if ivec::len(ts) == 1u {
if vec::len(ts) == 1u {
t = ts.(0).node;
} else {
t = ast::ty_tup(ts);
@ -791,7 +791,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
}
hi = p.get_hi_pos();
expect(p, token::RPAREN);
if ivec::len(es) == 1u {
if vec::len(es) == 1u {
ret mk_expr(p, lo, hi, es.(0).node);
} else {
ret mk_expr(p, lo, hi, ast::expr_tup(es));
@ -1023,7 +1023,7 @@ fn parse_syntax_ext(p: &parser) -> @ast::expr {
fn parse_syntax_ext_naked(p: &parser, lo: uint) -> @ast::expr {
let pth = parse_path(p);
if ivec::len(pth.node.idents) == 0u {
if vec::len(pth.node.idents) == 0u {
p.fatal("expected a syntax expander name");
}
//temporary for a backwards-compatible cycle:
@ -1474,7 +1474,7 @@ fn parse_pat(p: &parser) -> @ast::pat {
p.bump();
fields += ~[parse_pat(p)];
}
if ivec::len(fields) == 1u { expect(p, token::COMMA); }
if vec::len(fields) == 1u { expect(p, token::COMMA); }
hi = p.get_hi_pos();
expect(p, token::RPAREN);
pat = ast::pat_tup(fields);
@ -1570,7 +1570,7 @@ fn parse_source_stmt(p: &parser) -> @ast::stmt {
let maybe_item = parse_item(p, item_attrs);
// If we have attributes then we should have an item
if ivec::len(item_attrs) > 0u {
if vec::len(item_attrs) > 0u {
alt maybe_item {
some(_) {/* fallthrough */ }
_ { ret p.fatal("expected item"); }
@ -1899,7 +1899,7 @@ fn parse_mod_items(p: &parser, term: token::token,
first_item_attrs: &[ast::attribute]) -> ast::_mod {
// Shouldn't be any view items since we've already parsed an item attr
let view_items =
if ivec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
if vec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
let items: [@ast::item] = ~[];
let initial_attrs = first_item_attrs;
while p.peek() != term {
@ -1982,7 +1982,7 @@ fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
-> ast::native_mod {
// Shouldn't be any view items since we've already parsed an item attr
let view_items =
if ivec::len(first_item_attrs) == 0u {
if vec::len(first_item_attrs) == 0u {
parse_native_view(p)
} else { ~[] };
let items: [@ast::native_item] = ~[];
@ -2287,7 +2287,7 @@ fn parse_rest_import_name(p: &parser, first: ast::ident,
if glob {
ret ast::view_item_import_glob(identifiers, p.get_id());
} else {
let len = ivec::len(identifiers);
let len = vec::len(identifiers);
ret ast::view_item_import(identifiers.(len - 1u), identifiers,
p.get_id());
}
@ -2412,7 +2412,7 @@ fn parse_crate_directive(p: &parser, first_outer_attr: &[ast::attribute]) ->
// Collect the next attributes
let outer_attrs = first_outer_attr + parse_outer_attributes(p);
// In a crate file outer attributes are only going to apply to mods
let expect_mod = ivec::len(outer_attrs) > 0u;
let expect_mod = vec::len(outer_attrs) > 0u;
let lo = p.get_lo_pos();
if expect_mod || is_word(p, "mod") {
@ -2467,7 +2467,7 @@ fn parse_crate_directives(p: &parser, term: token::token,
// This is pretty ugly. If we have an outer attribute then we can't accept
// seeing the terminator next, so if we do see it then fail the same way
// parse_crate_directive would
if ivec::len(first_outer_attr) > 0u && p.peek() == term {
if vec::len(first_outer_attr) > 0u && p.peek() == term {
expect_word(p, "mod");
}

18
src/comp/syntax/print/pp.rs
View file

@ -1,6 +1,6 @@
import std::io;
import std::ivec;
import std::vec;
import std::str;
@ -76,8 +76,8 @@ fn tok_str(t: token) -> str {
fn buf_str(toks: &[mutable token], szs: &[mutable int], left: uint,
right: uint, lim: uint) -> str {
let n = ivec::len(toks);
assert (n == ivec::len(szs));
let n = vec::len(toks);
assert (n == vec::len(szs));
let i = left;
let L = lim;
let s = "[";
@ -104,9 +104,9 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
let n: uint = 3u * linewidth;
log #fmt("mk_printer %u", linewidth);
let token: [mutable token] = ivec::init_elt_mut(EOF, n);
let size: [mutable int] = ivec::init_elt_mut(0, n);
let scan_stack: [mutable uint] = ivec::init_elt_mut(0u, n);
let token: [mutable token] = vec::init_elt_mut(EOF, n);
let size: [mutable int] = vec::init_elt_mut(0, n);
let scan_stack: [mutable uint] = vec::init_elt_mut(0u, n);
let print_stack: [print_stack_elt] = ~[];
ret printer(out, n, linewidth as int, // margin
linewidth as int, // space
@ -403,7 +403,7 @@ obj printer(out: io::writer,
pending_indentation += amount;
}
fn top() -> print_stack_elt {
let n = ivec::len(print_stack);
let n = vec::len(print_stack);
let top: print_stack_elt = {offset: 0, pbreak: broken(inconsistent)};
if n != 0u { top = print_stack.(n - 1u); }
ret top;
@ -432,8 +432,8 @@ obj printer(out: io::writer,
}
END. {
log "print END -> pop END";
assert (ivec::len(print_stack) != 0u);
ivec::pop(print_stack);
assert (vec::len(print_stack) != 0u);
vec::pop(print_stack);
}
BREAK(b) {
let top = self.top();

38
src/comp/syntax/print/pprust.rs
View file

@ -1,5 +1,5 @@
import std::ivec;
import std::vec;
import std::int;
import std::io;
import std::str;
@ -50,7 +50,7 @@ type ps =
fn ibox(s: &ps, u: uint) { s.boxes += ~[pp::inconsistent]; pp::ibox(s.s, u); }
fn end(s: &ps) { ivec::pop(s.boxes); pp::end(s.s); }
fn end(s: &ps) { vec::pop(s.boxes); pp::end(s.s); }
fn rust_printer(writer: io::writer) -> ps {
let boxes: [pp::breaks] = ~[];
@ -229,7 +229,7 @@ fn commasep[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ) {
fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ,
get_span: fn(&IN) -> codemap::span ) {
box(s, 0u, b);
let len = ivec::len[IN](elts);
let len = vec::len[IN](elts);
let i = 0u;
for elt: IN in elts {
maybe_print_comment(s, get_span(elt).hi);
@ -454,9 +454,9 @@ fn print_item(s: &ps, item: &@ast::item) {
}
ast::item_tag(variants, params) {
let newtype =
ivec::len(variants) == 1u &&
vec::len(variants) == 1u &&
str::eq(item.ident, variants.(0).node.name) &&
ivec::len(variants.(0).node.args) == 1u;
vec::len(variants.(0).node.args) == 1u;
if newtype {
ibox(s, indent_unit);
word_space(s, "tag");
@ -475,7 +475,7 @@ fn print_item(s: &ps, item: &@ast::item) {
space(s.s);
maybe_print_comment(s, v.span.lo);
word(s.s, v.node.name);
if ivec::len(v.node.args) > 0u {
if vec::len(v.node.args) > 0u {
popen(s);
fn print_variant_arg(s: &ps, arg: &ast::variant_arg) {
print_type(s, arg.ty);
@ -725,7 +725,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
}
if mut == ast::mut {
word(s.s, "mutable");
if ivec::len(exprs) > 0u { nbsp(s); }
if vec::len(exprs) > 0u { nbsp(s); }
}
commasep_exprs(s, inconsistent, exprs);
word(s.s, "]");
@ -745,7 +745,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
commasep_cmnt(s, consistent, fields, print_field, get_span);
alt wth {
some(expr) {
if ivec::len(fields) > 0u { space(s.s); }
if vec::len(fields) > 0u { space(s.s); }
ibox(s, indent_unit);
word_space(s, "with");
print_expr(s, expr);
@ -1130,7 +1130,7 @@ fn print_path(s: &ps, path: &ast::path) {
if first { first = false; } else { word(s.s, "::"); }
word(s.s, id);
}
if ivec::len(path.node.types) > 0u {
if vec::len(path.node.types) > 0u {
word(s.s, "[");
commasep(s, inconsistent, path.node.types, print_type);
word(s.s, "]");
@ -1147,7 +1147,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
ast::pat_lit(lit) { print_literal(s, lit); }
ast::pat_tag(path, args) {
print_path(s, path);
if ivec::len(args) > 0u {
if vec::len(args) > 0u {
popen(s);
commasep(s, inconsistent, args, print_pat);
pclose(s);
@ -1165,7 +1165,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
fn get_span(f: &ast::field_pat) -> codemap::span { ret f.pat.span; }
commasep_cmnt(s, consistent, fields, print_field, get_span);
if etc {
if ivec::len(fields) != 0u { word_space(s, ","); }
if vec::len(fields) != 0u { word_space(s, ","); }
word(s.s, "_");
}
word(s.s, "}");
@ -1243,7 +1243,7 @@ fn print_kind(s: &ps, kind: ast::kind) {
}
fn print_type_params(s: &ps, params: &[ast::ty_param]) {
if ivec::len(params) > 0u {
if vec::len(params) > 0u {
word(s.s, "[");
fn printParam(s: &ps, param: &ast::ty_param) {
print_kind(s, param.kind);
@ -1280,7 +1280,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
ast::view_item_use(id, mta, _) {
head(s, "use");
word(s.s, id);
if ivec::len(mta) > 0u {
if vec::len(mta) > 0u {
popen(s);
commasep(s, consistent, mta, print_meta_item);
pclose(s);
@ -1288,7 +1288,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
}
ast::view_item_import(id, ids, _) {
head(s, "import");
if !str::eq(id, ids.(ivec::len(ids) - 1u)) {
if !str::eq(id, ids.(vec::len(ids) - 1u)) {
word_space(s, id);
word_space(s, "=");
}
@ -1419,7 +1419,7 @@ fn print_remaining_comments(s: &ps) {
}
fn in_cbox(s: &ps) -> bool {
let len = ivec::len(s.boxes);
let len = vec::len(s.boxes);
if len == 0u { ret false; }
ret s.boxes.(len - 1u) == pp::consistent;
}
@ -1465,7 +1465,7 @@ fn lit_to_str(l: &@ast::lit) -> str { be to_str(l, print_literal); }
fn next_lit(s: &ps) -> option::t[lexer::lit] {
alt s.literals {
some(lits) {
if s.cur_lit < ivec::len(lits) {
if s.cur_lit < vec::len(lits) {
ret some(lits.(s.cur_lit));
} else { ret none[lexer::lit]; }
}
@ -1490,7 +1490,7 @@ fn maybe_print_comment(s: &ps, pos: uint) {
fn print_comment(s: &ps, cmnt: lexer::cmnt) {
alt cmnt.style {
lexer::mixed. {
assert (ivec::len(cmnt.lines) == 1u);
assert (vec::len(cmnt.lines) == 1u);
zerobreak(s.s);
word(s.s, cmnt.lines.(0));
zerobreak(s.s);
@ -1501,7 +1501,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
}
lexer::trailing. {
word(s.s, " ");
if ivec::len(cmnt.lines) == 1u {
if vec::len(cmnt.lines) == 1u {
word(s.s, cmnt.lines.(0));
hardbreak(s.s);
} else {
@ -1557,7 +1557,7 @@ fn to_str[T](t: &T, f: fn(&ps, &T) ) -> str {
fn next_comment(s: &ps) -> option::t[lexer::cmnt] {
alt s.comments {
some(cmnts) {
if s.cur_cmnt < ivec::len(cmnts) {
if s.cur_cmnt < vec::len(cmnts) {
ret some(cmnts.(s.cur_cmnt));
} else { ret none[lexer::cmnt]; }
}

2
src/comp/syntax/untyped_ast.rs
View file

@ -1,5 +1,5 @@
import std::ivec;
import std::ivec::map;
import std::vec::map;
import std::option;
import std::option::some;
import std::option::none;

6
src/comp/syntax/util/interner.rs
View file

@ -1,7 +1,7 @@
// An "interner" is a data structure that associates values with uint tags and
// allows bidirectional lookup; i.e. given a value, one can easily find the
// type, and vice versa.
import std::ivec;
import std::vec;
import std::map;
import std::map::hashmap;
import std::map::hashfn;
@ -25,7 +25,7 @@ fn intern[@T](itr: &interner[T], val: &T) -> uint {
alt itr.map.find(val) {
some(idx) { ret idx; }
none. {
let new_idx = ivec::len[T](itr.vect);
let new_idx = vec::len[T](itr.vect);
itr.map.insert(val, new_idx);
itr.vect += ~[val];
ret new_idx;
@ -35,5 +35,5 @@ fn intern[@T](itr: &interner[T], val: &T) -> uint {
fn get[T](itr: &interner[T], idx: uint) -> T { ret itr.vect.(idx); }
fn len[T](itr : &interner[T]) -> uint { ret ivec::len(itr.vect); }
fn len[T](itr : &interner[T]) -> uint { ret vec::len(itr.vect); }

2
src/comp/util/common.rs
View file

@ -154,7 +154,7 @@ fn call_kind_str(c: call_kind) -> str {
}
fn is_main_name(path: &[str]) -> bool {
str::eq(option::get(std::ivec::last(path)), "main")
str::eq(option::get(std::vec::last(path)), "main")
}
// FIXME mode this to std::float when editing the stdlib no longer

4
src/comp/util/ppaux.rs
View file

@ -1,4 +1,4 @@
import std::ivec;
import std::vec;
import std::str;
import std::int;
import std::option;
@ -112,7 +112,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
// The user should never see this if the cname is set properly!
s += "<tag#" + int::str(id.crate) + ":" + int::str(id.node) + ">";
if ivec::len[t](tps) > 0u {
if vec::len[t](tps) > 0u {
let strs: [str] = ~[];
for typ: t in tps { strs += ~[ty_to_str(cx, typ)]; }
s += "[" + str::connect(strs, ",") + "]";

6
src/fuzzer/ast_match.rs
View file

@ -1,10 +1,10 @@
use std;
import std::ivec;
import std::vec;
fn ivec_equal[T](v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
-> bool {
let Lv = ivec::len(v);
if Lv != ivec::len(u) { ret false; }
let Lv = vec::len(v);
if Lv != vec::len(u) { ret false; }
let i = 0u;
while i < Lv {
if !element_equality_test(v.(i), u.(i)) { ret false; }

8
src/fuzzer/fuzzer.rs
View file

@ -8,7 +8,7 @@ import std::getopts::opt_present;
import std::getopts::opt_str;
import std::io;
import std::io::stdout;
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::option;
@ -148,7 +148,7 @@ fn as_str(f: fn(io::writer) ) -> str {
fn check_variants_of_ast(crate: &ast::crate, codemap: &codemap::codemap, filename: &str) {
let exprs = steal_exprs(crate);
let exprsL = ivec::len(exprs);
let exprsL = vec::len(exprs);
if (exprsL < 100u) {
for each i: uint in under(uint::min(exprsL, 20u)) {
log_err "Replacing... " + pprust::expr_to_str(@exprs.(i));
@ -316,7 +316,7 @@ fn check_roundtrip_convergence(code: &str, maxIters: uint) {
}
fn check_convergence(files: &[str]) {
log_err #fmt("pp convergence tests: %u files", ivec::len(files));
log_err #fmt("pp convergence tests: %u files", vec::len(files));
for file in files {
if !file_is_confusing(file) {
let s = io::read_whole_file_str(file);
@ -346,7 +346,7 @@ fn check_variants(files: &[str]) {
}
fn main(args: [str]) {
if ivec::len(args) != 2u {
if vec::len(args) != 2u {
log_err #fmt("usage: %s <testdir>", args.(0));
ret;
}

10
src/lib/aio.rs
View file

@ -1,5 +1,5 @@
import task;
import ivec;
import vec;
import comm;
import comm::_chan;
@ -55,7 +55,7 @@ tag request {
type ctx = _chan[request];
fn ip_to_sbuf(ip: net::ip_addr) -> *u8 {
ivec::to_ptr(str::bytes(net::format_addr(ip)))
vec::to_ptr(str::bytes(net::format_addr(ip)))
}
fn connect_task(ip: net::ip_addr, portnum: int, evt: _chan[socket_event]) {
@ -78,8 +78,8 @@ fn new_client(client: client, evt: _chan[socket_event]) {
log "waiting for bytes";
let data: [u8] = reader.recv();
log "got some bytes";
log ivec::len[u8](data);
if (ivec::len[u8](data) == 0u) {
log vec::len[u8](data);
if (vec::len[u8](data) == 0u) {
log "got empty buffer, bailing";
break;
}
@ -145,7 +145,7 @@ fn request_task(c: _chan[ctx]) {
}
write(socket,v,status) {
rustrt::aio_writedata(socket,
ivec::to_ptr[u8](v), ivec::len[u8](v),
vec::to_ptr[u8](v), vec::len[u8](v),
status);
}
close_server(server,status) {

20
src/lib/bitv.rs
View file

@ -32,13 +32,13 @@ fn uint_bits() -> uint { ret 32u + (1u << 32u >> 27u); }
fn create(nbits: uint, init: bool) -> t {
let elt = if init { !0u } else { 0u };
let storage = ivec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
let storage = vec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
ret @{storage: storage, nbits: nbits};
}
fn process(op: &block(uint, uint) -> uint , v0: &t, v1: &t) -> bool {
let len = ivec::len(v1.storage);
assert (ivec::len(v0.storage) == len);
let len = vec::len(v1.storage);
assert (vec::len(v0.storage) == len);
assert (v0.nbits == v1.nbits);
let changed = false;
for each i: uint in uint::range(0u, len) {
@ -69,8 +69,8 @@ fn assign(v0: &t, v1: t) -> bool {
}
fn clone(v: t) -> t {
let storage = ivec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
let len = ivec::len(v.storage);
let storage = vec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
let len = vec::len(v.storage);
for each i: uint in uint::range(0u, len) { storage.(i) = v.storage.(i); }
ret @{storage: storage, nbits: v.nbits};
}
@ -88,7 +88,7 @@ fn equal(v0: &t, v1: &t) -> bool {
// FIXME: when we can break or return from inside an iterator loop,
// we can eliminate this painful while-loop
let len = ivec::len(v1.storage);
let len = vec::len(v1.storage);
let i = 0u;
while i < len {
if v0.storage.(i) != v1.storage.(i) { ret false; }
@ -98,7 +98,7 @@ fn equal(v0: &t, v1: &t) -> bool {
}
fn clear(v: &t) {
for each i: uint in uint::range(0u, ivec::len(v.storage)) {
for each i: uint in uint::range(0u, vec::len(v.storage)) {
v.storage.(i) = 0u;
}
}
@ -108,7 +108,7 @@ fn set_all(v: &t) {
}
fn invert(v: &t) {
for each i: uint in uint::range(0u, ivec::len(v.storage)) {
for each i: uint in uint::range(0u, vec::len(v.storage)) {
v.storage.(i) = !v.storage.(i);
}
}
@ -150,7 +150,7 @@ fn init_to_vec(v: t, i: uint) -> uint { ret if get(v, i) { 1u } else { 0u }; }
fn to_vec(v: &t) -> [uint] {
let sub = bind init_to_vec(v, _);
ret ivec::init_fn[uint](sub, v.nbits);
ret vec::init_fn[uint](sub, v.nbits);
}
fn to_str(v: &t) -> str {
@ -162,7 +162,7 @@ fn to_str(v: &t) -> str {
}
fn eq_ivec(v0: &t, v1: &[uint]) -> bool {
assert (v0.nbits == ivec::len[uint](v1));
assert (v0.nbits == vec::len[uint](v1));
let len = v0.nbits;
let i = 0u;
while i < len {

16
src/lib/deque.rs
View file

@ -28,7 +28,7 @@ fn create[@T]() -> t[T] {
fn grow[@T](nelts: uint, lo: uint, elts: &[mutable cell[T]]) ->
[mutable cell[T]] {
assert (nelts == ivec::len(elts));
assert (nelts == vec::len(elts));
let rv = ~[mutable];
let i = 0u;
@ -53,11 +53,11 @@ fn create[@T]() -> t[T] {
fn add_front(t: &T) {
let oldlo: uint = lo;
if lo == 0u {
lo = ivec::len[cell[T]](elts) - 1u;
lo = vec::len[cell[T]](elts) - 1u;
} else { lo -= 1u; }
if lo == hi {
elts = grow[T](nelts, oldlo, elts);
lo = ivec::len[cell[T]](elts) - 1u;
lo = vec::len[cell[T]](elts) - 1u;
hi = nelts;
}
elts.(lo) = option::some[T](t);
@ -70,7 +70,7 @@ fn create[@T]() -> t[T] {
hi = nelts;
}
elts.(hi) = option::some[T](t);
hi = (hi + 1u) % ivec::len[cell[T]](elts);
hi = (hi + 1u) % vec::len[cell[T]](elts);
nelts += 1u;
}
@ -81,13 +81,13 @@ fn create[@T]() -> t[T] {
fn pop_front() -> T {
let t: T = get[T](elts, lo);
elts.(lo) = option::none[T];
lo = (lo + 1u) % ivec::len[cell[T]](elts);
lo = (lo + 1u) % vec::len[cell[T]](elts);
nelts -= 1u;
ret t;
}
fn pop_back() -> T {
if hi == 0u {
hi = ivec::len[cell[T]](elts) - 1u;
hi = vec::len[cell[T]](elts) - 1u;
} else { hi -= 1u; }
let t: T = get[T](elts, hi);
elts.(hi) = option::none[T];
@ -97,12 +97,12 @@ fn create[@T]() -> t[T] {
fn peek_front() -> T { ret get[T](elts, lo); }
fn peek_back() -> T { ret get[T](elts, hi - 1u); }
fn get(i: int) -> T {
let idx: uint = (lo + (i as uint)) % ivec::len[cell[T]](elts);
let idx: uint = (lo + (i as uint)) % vec::len[cell[T]](elts);
ret get[T](elts, idx);
}
}
let v: [mutable cell[T]] =
ivec::init_elt_mut(option::none, initial_capacity);
vec::init_elt_mut(option::none, initial_capacity);
ret deque[T](0u, 0u, 0u, v);
}
// Local Variables:

6
src/lib/ebml.rs
View file

@ -40,7 +40,7 @@ fn vint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
}
fn new_doc(data: &@[u8]) -> doc {
ret {data: data, start: 0u, end: ivec::len[u8](*data)};
ret {data: data, start: 0u, end: vec::len[u8](*data)};
}
fn doc_at(data: &@[u8], start: uint) -> doc {
@ -96,7 +96,7 @@ iter tagged_docs(d: doc, tg: uint) -> doc {
}
}
fn doc_data(d: doc) -> [u8] { ret ivec::slice[u8](*d.data, d.start, d.end); }
fn doc_data(d: doc) -> [u8] { ret vec::slice[u8](*d.data, d.start, d.end); }
fn be_uint_from_bytes(data: &@[u8], start: uint, size: uint) -> uint {
let sz = size;
@ -167,7 +167,7 @@ fn start_tag(w: &writer, tag_id: uint) {
}
fn end_tag(w: &writer) {
let last_size_pos = ivec::pop[uint](w.size_positions);
let last_size_pos = vec::pop[uint](w.size_positions);
let cur_pos = w.writer.tell();
w.writer.seek(last_size_pos as int, io::seek_set);
write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u);

2
src/lib/extfmt.rs
View file

@ -372,7 +372,7 @@ mod rt {
// FIXME: This might be useful in str: but needs to be utf8 safe first
fn str_init_elt(c: char, n_elts: uint) -> str {
let svec = ivec::init_elt[u8](c as u8, n_elts);
let svec = vec::init_elt[u8](c as u8, n_elts);
ret str::unsafe_from_bytes(svec);
}

18
src/lib/getopts.rs
View file

@ -77,7 +77,7 @@ fn name_str(nm: name) -> str {
fn find_opt(opts: &[opt], nm: name) -> option::t[uint] {
let i = 0u;
let l = ivec::len[opt](opts);
let l = vec::len[opt](opts);
while i < l { if opts.(i).name == nm { ret some[uint](i); } i += 1u; }
ret none[uint];
}
@ -107,11 +107,11 @@ fn fail_str(f: fail_) -> str {
tag result { success(match); failure(fail_); }
fn getopts(args: &[str], opts: &[opt]) -> result {
let n_opts = ivec::len[opt](opts);
let n_opts = vec::len[opt](opts);
fn f(x: uint) -> [optval] { ret ~[]; }
let vals = ivec::init_fn_mut[[optval]](f, n_opts);
let vals = vec::init_fn_mut[[optval]](f, n_opts);
let free: [str] = ~[];
let l = ivec::len[str](args);
let l = vec::len[str](args);
let i = 0u;
while i < l {
let cur = args.(i);
@ -163,7 +163,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
maybe. {
if !option::is_none[str](i_arg) {
vals.(optid) += ~[val(option::get(i_arg))];
} else if (name_pos < ivec::len[name](names) ||
} else if (name_pos < vec::len[name](names) ||
i + 1u == l || is_arg(args.(i + 1u))) {
vals.(optid) += ~[given];
} else { i += 1u; vals.(optid) += ~[val(args.(i))]; }
@ -182,7 +182,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
}
i = 0u;
while i < n_opts {
let n = ivec::len[optval](vals.(i));
let n = vec::len[optval](vals.(i));
let occ = opts.(i).occur;
if occ == req {
if n == 0u {
@ -209,7 +209,7 @@ fn opt_vals(m: &match, nm: str) -> [optval] {
fn opt_val(m: &match, nm: str) -> optval { ret opt_vals(m, nm).(0); }
fn opt_present(m: &match, nm: str) -> bool {
ret ivec::len[optval](opt_vals(m, nm)) > 0u;
ret vec::len[optval](opt_vals(m, nm)) > 0u;
}
fn opt_str(m: &match, nm: str) -> str {
@ -226,7 +226,7 @@ fn opt_strs(m: &match, nm: str) -> [str] {
fn opt_maybe_str(m: &match, nm: str) -> option::t[str] {
let vals = opt_vals(m, nm);
if ivec::len[optval](vals) == 0u { ret none[str]; }
if vec::len[optval](vals) == 0u { ret none[str]; }
ret alt vals.(0) { val(s) { some[str](s) } _ { none[str] } };
}
@ -236,7 +236,7 @@ fn opt_maybe_str(m: &match, nm: str) -> option::t[str] {
/// present and an argument was provided.
fn opt_default(m: &match, nm: str, def: str) -> option::t[str] {
let vals = opt_vals(m, nm);
if ivec::len[optval](vals) == 0u { ret none[str]; }
if vec::len[optval](vals) == 0u { ret none[str]; }
ret alt vals.(0) { val(s) { some[str](s) } _ { some[str](def) } }
}
// Local Variables:

36
src/lib/io.rs
View file

@ -62,9 +62,9 @@ resource FILE_res(f: os::libc::FILE) {
obj FILE_buf_reader(f: os::libc::FILE, res: option::t[@FILE_res]) {
fn read(len: uint) -> [u8] {
let buf = ~[];
ivec::reserve[u8](buf, len);
let read = os::libc::fread(ivec::to_ptr[u8](buf), 1u, len, f);
ivec::unsafe::set_len[u8](buf, read);
vec::reserve[u8](buf, len);
let read = os::libc::fread(vec::to_ptr[u8](buf), 1u, len, f);
vec::unsafe::set_len[u8](buf, read);
ret buf;
}
fn read_byte() -> int { ret os::libc::fgetc(f); }
@ -196,24 +196,24 @@ type byte_buf = @{buf: [u8], mutable pos: uint};
obj byte_buf_reader(bbuf: byte_buf) {
fn read(len: uint) -> [u8] {
let rest = ivec::len[u8](bbuf.buf) - bbuf.pos;
let rest = vec::len[u8](bbuf.buf) - bbuf.pos;
let to_read = len;
if rest < to_read { to_read = rest; }
let range = ivec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
let range = vec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
bbuf.pos += to_read;
ret range;
}
fn read_byte() -> int {
if bbuf.pos == ivec::len[u8](bbuf.buf) { ret -1; }
if bbuf.pos == vec::len[u8](bbuf.buf) { ret -1; }
let b = bbuf.buf.(bbuf.pos);
bbuf.pos += 1u;
ret b as int;
}
fn unread_byte(byte: int) { log_err "TODO: unread_byte"; fail; }
fn eof() -> bool { ret bbuf.pos == ivec::len[u8](bbuf.buf); }
fn eof() -> bool { ret bbuf.pos == vec::len[u8](bbuf.buf); }
fn seek(offset: int, whence: seek_style) {
let pos = bbuf.pos;
let len = ivec::len[u8](bbuf.buf);
let len = vec::len[u8](bbuf.buf);
bbuf.pos = seek_in_buf(offset, pos, len, whence);
}
fn tell() -> uint { ret bbuf.pos; }
@ -245,8 +245,8 @@ type buf_writer =
obj FILE_writer(f: os::libc::FILE, res: option::t[@FILE_res]) {
fn write(v: &[u8]) {
let len = ivec::len[u8](v);
let vbuf = ivec::to_ptr[u8](v);
let len = vec::len[u8](v);
let vbuf = vec::to_ptr[u8](v);
let nout = os::libc::fwrite(vbuf, len, 1u, f);
if nout < 1u { log_err "error dumping buffer"; }
}
@ -264,11 +264,11 @@ resource fd_res(fd: int) {
obj fd_buf_writer(fd: int, res: option::t[@fd_res]) {
fn write(v: &[u8]) {
let len = ivec::len[u8](v);
let len = vec::len[u8](v);
let count = 0u;
let vbuf;
while count < len {
vbuf = ptr::offset(ivec::to_ptr[u8](v), count);
vbuf = ptr::offset(vec::to_ptr[u8](v), count);
let nout = os::libc::write(fd, vbuf, len);
if nout < 0 {
log_err "error dumping buffer";
@ -401,18 +401,18 @@ obj byte_buf_writer(buf: mutable_byte_buf) {
fn write(v: &[u8]) {
// Fast path.
if buf.pos == ivec::len(buf.buf) {
if buf.pos == vec::len(buf.buf) {
for b: u8 in v { buf.buf += ~[mutable b]; }
buf.pos += ivec::len[u8](v);
buf.pos += vec::len[u8](v);
ret;
}
// FIXME: Optimize: These should be unique pointers.
let vlen = ivec::len[u8](v);
let vlen = vec::len[u8](v);
let vpos = 0u;
while vpos < vlen {
let b = v.(vpos);
if buf.pos == ivec::len(buf.buf) {
if buf.pos == vec::len(buf.buf) {
buf.buf += ~[mutable b];
} else { buf.buf.(buf.pos) = b; }
buf.pos += 1u;
@ -421,7 +421,7 @@ obj byte_buf_writer(buf: mutable_byte_buf) {
}
fn seek(offset: int, whence: seek_style) {
let pos = buf.pos;
let len = ivec::len(buf.buf);
let len = vec::len(buf.buf);
buf.pos = seek_in_buf(offset, pos, len, whence);
}
fn tell() -> uint { ret buf.pos; }
@ -431,7 +431,7 @@ fn string_writer() -> str_writer {
// FIXME: yikes, this is bad. Needs fixing of mutable syntax.
let b: [mutable u8] = ~[mutable 0u8];
ivec::pop(b);
vec::pop(b);
let buf: mutable_byte_buf = @{mutable buf: b, mutable pos: 0u};
obj str_writer_wrap(wr: writer, buf: mutable_byte_buf) {
fn get_writer() -> writer { ret wr; }

2
src/lib/list.rs
View file

@ -9,7 +9,7 @@ fn from_vec[@T](v: &[T]) -> list[T] {
// a reverse vector iterator. Unfortunately generic iterators seem not to
// work yet.
for item: T in ivec::reversed(v) { l = cons[T](item, @l); }
for item: T in vec::reversed(v) { l = cons[T](item, @l); }
ret l;
}

2
src/lib/map.rs
View file

@ -27,7 +27,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
let load_factor: util::rational = {num: 3, den: 4};
tag bucket[@K, @V] { nil; deleted; some(K, V); }
fn make_buckets[@K, @V](nbkts: uint) -> [mutable (bucket[K, V])] {
ret ivec::init_elt_mut[bucket[K, V]](nil[K, V], nbkts);
ret vec::init_elt_mut[bucket[K, V]](nil[K, V], nbkts);
}
// Derive two hash functions from the one given by taking the upper
// half and lower half of the uint bits. Our bucket probing

6
src/lib/net.rs
View file

@ -1,5 +1,5 @@
import str;
import ivec;
import vec;
import uint;
tag ip_addr {
@ -20,8 +20,8 @@ fn format_addr(ip : ip_addr) -> str {
}
fn parse_addr(ip : str) -> ip_addr {
let parts = ivec::map(uint::from_str, str::split(ip, ".".(0)));
if ivec::len(parts) != 4u { fail "Too many dots in IP address"; }
let parts = vec::map(uint::from_str, str::split(ip, ".".(0)));
if vec::len(parts) != 4u { fail "Too many dots in IP address"; }
for i in parts { if i > 255u { fail "Invalid IP Address part."; } }
ipv4(parts.(0) as u8,
parts.(1) as u8,

2
src/lib/posix_fs.rs
View file

@ -24,7 +24,7 @@ fn list_dir(path: str) -> [str] {
os::libc::closedir(dir);
ret result;
}
ivec::push[str](result, rustrt::rust_dirent_filename(ent));
vec::push[str](result, rustrt::rust_dirent_filename(ent));
}
os::libc::closedir(dir);
ret result;

2
src/lib/run_program.rs
View file

@ -25,7 +25,7 @@ fn spawn_process(prog: str, args: &[str], in_fd: int, out_fd: int,
// pointer to its buffer
let argv = arg_vec(prog, args);
let pid = rustrt::rust_run_program(
ivec::to_ptr(argv), in_fd, out_fd, err_fd);
vec::to_ptr(argv), in_fd, out_fd, err_fd);
ret pid;
}

14
src/lib/sha1.rs
View file

@ -82,8 +82,8 @@ fn mk_sha1() -> sha1 {
fn process_msg_block(st: &sha1state) {
// FIXME: Make precondition
assert (ivec::len(st.h) == digest_buf_len);
assert (ivec::len(st.work_buf) == work_buf_len);
assert (vec::len(st.h) == digest_buf_len);
assert (vec::len(st.work_buf) == work_buf_len);
let t: int; // Loop counter
let w = st.work_buf;
@ -187,7 +187,7 @@ fn mk_sha1() -> sha1 {
fn pad_msg(st: &sha1state) {
// FIXME: Should be a precondition
assert (ivec::len(st.msg_block) == msg_block_len);
assert (vec::len(st.msg_block) == msg_block_len);
/*
* Check to see if the current message block is too small to hold
* the initial padding bits and length. If so, we will pad the
@ -226,7 +226,7 @@ fn mk_sha1() -> sha1 {
fn reset() {
// FIXME: Should be typestate precondition
assert (ivec::len(st.h) == digest_buf_len);
assert (vec::len(st.h) == digest_buf_len);
st.len_low = 0u32;
st.len_high = 0u32;
st.msg_block_idx = 0u;
@ -248,13 +248,13 @@ fn mk_sha1() -> sha1 {
}
}
let st =
{h: ivec::init_elt_mut[u32](0u32, digest_buf_len),
{h: vec::init_elt_mut[u32](0u32, digest_buf_len),
mutable len_low: 0u32,
mutable len_high: 0u32,
msg_block: ivec::init_elt_mut[u8](0u8, msg_block_len),
msg_block: vec::init_elt_mut[u8](0u8, msg_block_len),
mutable msg_block_idx: 0u,
mutable computed: false,
work_buf: ivec::init_elt_mut[u32](0u32, work_buf_len)};
work_buf: vec::init_elt_mut[u32](0u32, work_buf_len)};
let sh = sha1(st);
sh.reset();
ret sh;

8
src/lib/smallintmap.rs
View file

@ -15,11 +15,11 @@ fn mk[@T]() -> smallintmap[T] {
}
fn insert[@T](m: &smallintmap[T], key: uint, val: &T) {
ivec::grow_set[option::t[T]](m.v, key, none[T], some[T](val));
vec::grow_set[option::t[T]](m.v, key, none[T], some[T](val));
}
fn find[@T](m: &smallintmap[T], key: uint) -> option::t[T] {
if key < ivec::len[option::t[T]](m.v) { ret m.v.(key); }
if key < vec::len[option::t[T]](m.v) { ret m.v.(key); }
ret none[T];
}
@ -35,10 +35,10 @@ fn contains_key[@T](m: &smallintmap[T], key: uint) -> bool {
}
fn truncate[@T](m: &smallintmap[T], len: uint) {
m.v = ivec::slice_mut[option::t[T]](m.v, 0u, len);
m.v = vec::slice_mut[option::t[T]](m.v, 0u, len);
}
fn max_key[T](m: &smallintmap[T]) -> uint {
ret ivec::len[option::t[T]](m.v);
ret vec::len[option::t[T]](m.v);
}

4
src/lib/sort.rs
View file

@ -1,6 +1,6 @@
import ivec::len;
import ivec::slice;
import vec::len;
import vec::slice;
export merge_sort;
export quick_sort;

2
src/lib/std.rc
View file

@ -14,7 +14,7 @@ mod int;
mod uint;
mod u8;
mod u64;
mod ivec;
mod vec;
mod str;
// General io and system-services modules.

14
src/lib/str.rs
View file

@ -132,7 +132,7 @@ const tag_six_b: uint = 252u;
fn is_utf8(v: &[u8]) -> bool {
let i = 0u;
let total = ivec::len[u8](v);
let total = vec::len[u8](v);
while i < total {
let chsize = utf8_char_width(v.(i));
if chsize == 0u { ret false; }
@ -185,7 +185,7 @@ fn buf(s: &str) -> sbuf { ret rustrt::str_buf(s); }
fn bytes(s: str) -> [u8] {
let sbuffer = buf(s);
let ptr = unsafe::reinterpret_cast(sbuffer);
ret ivec::unsafe::from_buf(ptr, byte_len(s));
ret vec::unsafe::from_buf(ptr, byte_len(s));
}
fn unsafe_from_bytes(v: &[mutable? u8]) -> str {
@ -496,13 +496,13 @@ fn replace(s: str, from: str, to: str) : is_not_empty(from) -> str {
// FIXME: Also not efficient
fn char_slice(s: &str, begin: uint, end: uint) -> str {
from_chars(ivec::slice(to_chars(s), begin, end))
from_chars(vec::slice(to_chars(s), begin, end))
}
fn trim_left(s: &str) -> str {
fn count_whities(s: &[char]) -> uint {
let i = 0u;
while i < ivec::len(s) {
while i < vec::len(s) {
if !char::is_whitespace(s.(i)) {
break;
}
@ -512,12 +512,12 @@ fn trim_left(s: &str) -> str {
}
let chars = to_chars(s);
let whities = count_whities(chars);
ret from_chars(ivec::slice(chars, whities, ivec::len(chars)));
ret from_chars(vec::slice(chars, whities, vec::len(chars)));
}
fn trim_right(s: &str) -> str {
fn count_whities(s: &[char]) -> uint {
let i = ivec::len(s);
let i = vec::len(s);
while 0u < i {
if !char::is_whitespace(s.(i - 1u)) {
break;
@ -528,7 +528,7 @@ fn trim_right(s: &str) -> str {
}
let chars = to_chars(s);
let whities = count_whities(chars);
ret from_chars(ivec::slice(chars, 0u, whities));
ret from_chars(vec::slice(chars, 0u, whities));
}
fn trim(s: &str) -> str {

24
src/lib/test.rs
View file

@ -50,7 +50,7 @@ type test_desc = {name: test_name, fn: test_fn, ignore: bool};
// The default console test runner. It accepts the command line
// arguments and a vector of test_descs (generated at compile time).
fn test_main_ivec(args: &[str], tests: &[test_desc]) {
check (ivec::is_not_empty(args));
check (vec::is_not_empty(args));
let opts =
alt parse_opts(args) {
either::left(o) { o }
@ -60,7 +60,7 @@ fn test_main_ivec(args: &[str], tests: &[test_desc]) {
}
fn test_main(args: &vec[str], tests: &[test_desc]) {
test_main_ivec(ivec::from_vec(args), tests);
test_main_ivec(vec::from_vec(args), tests);
}
type test_opts = {filter: option::t[str], run_ignored: bool};
@ -68,11 +68,11 @@ type test_opts = {filter: option::t[str], run_ignored: bool};
type opt_res = either::t[test_opts, str];
// Parses command line arguments into test options
fn parse_opts(args: &[str]) : ivec::is_not_empty(args) -> opt_res {
fn parse_opts(args: &[str]) : vec::is_not_empty(args) -> opt_res {
// FIXME (#649): Shouldn't have to check here
check (ivec::is_not_empty(args));
let args_ = ivec::tail(args);
check (vec::is_not_empty(args));
let args_ = vec::tail(args);
let opts = ~[getopts::optflag("ignored")];
let match =
alt getopts::getopts(args_, opts) {
@ -81,7 +81,7 @@ fn parse_opts(args: &[str]) : ivec::is_not_empty(args) -> opt_res {
};
let filter =
if ivec::len(match.free) > 0u {
if vec::len(match.free) > 0u {
option::some(match.free.(0))
} else { option::none };
@ -121,7 +121,7 @@ fn run_tests_console_(opts: &test_opts, tests: &[test_desc],
fn callback(event: testevent, st: test_state) {
alt event {
te_filtered(filtered_tests) {
st.total = ivec::len(filtered_tests);
st.total = vec::len(filtered_tests);
st.out.write_line(#fmt("\nrunning %u tests", st.total));
}
te_wait(test) {
@ -230,13 +230,13 @@ fn run_tests(opts: &test_opts, tests: &[test_desc],
// result of a particular test for an unusually long amount of time.
let concurrency = get_concurrency();
log #fmt("using %u test tasks", concurrency);
let total = ivec::len(filtered_tests);
let total = vec::len(filtered_tests);
let run_idx = 0u;
let wait_idx = 0u;
let futures = ~[];
while wait_idx < total {
while ivec::len(futures) < concurrency && run_idx < total {
while vec::len(futures) < concurrency && run_idx < total {
futures += ~[run_test(filtered_tests.(run_idx), to_task)];
run_idx += 1u;
}
@ -245,7 +245,7 @@ fn run_tests(opts: &test_opts, tests: &[test_desc],
callback(te_wait(future.test));
let result = future.wait();
callback(te_result(future.test, result));
futures = ivec::slice(futures, 1u, ivec::len(futures));
futures = vec::slice(futures, 1u, vec::len(futures));
wait_idx += 1u;
}
}
@ -275,7 +275,7 @@ fn filter_tests(opts: &test_opts, tests: &[test_desc]) -> [test_desc] {
}(_, filter_str);
ivec::filter_map(filter, filtered)
vec::filter_map(filter, filtered)
};
// Maybe pull out the ignored test and unignore them
@ -293,7 +293,7 @@ fn filter_tests(opts: &test_opts, tests: &[test_desc]) -> [test_desc] {
};
ivec::filter_map(filter, filtered)
vec::filter_map(filter, filtered)
};
// Sort the tests alphabetically

8
src/lib/ufind.rs
View file

@ -13,7 +13,7 @@ type ufind = {mutable nodes: [mutable node]};
fn make() -> ufind { ret {mutable nodes: ~[mutable]}; }
fn make_set(ufnd: &ufind) -> uint {
let idx = ivec::len(ufnd.nodes);
let idx = vec::len(ufnd.nodes);
ufnd.nodes += ~[mutable none[uint]];
ret idx;
}
@ -40,13 +40,13 @@ fn union(ufnd: &ufind, m: uint, n: uint) {
} else if (m_root > n_root) { ufnd.nodes.(m_root) = some[uint](n_root); }
}
fn set_count(ufnd: &ufind) -> uint { ret ivec::len[node](ufnd.nodes); }
fn set_count(ufnd: &ufind) -> uint { ret vec::len[node](ufnd.nodes); }
// Removes all sets with IDs greater than or equal to the given value.
fn prune(ufnd: &ufind, n: uint) {
// TODO: Use "slice" once we get rid of "mutable?"
let len = ivec::len[node](ufnd.nodes);
while len != n { ivec::pop[node](ufnd.nodes); len -= 1u; }
let len = vec::len[node](ufnd.nodes);
while len != n { vec::pop[node](ufnd.nodes); len -= 1u; }
}

4
src/lib/uint.rs
View file

@ -43,8 +43,8 @@ fn next_power_of_two(n: uint) -> uint {
}
fn parse_buf(buf: &[u8], radix: uint) -> uint {
if ivec::len[u8](buf) == 0u { log_err "parse_buf(): buf is empty"; fail; }
let i = ivec::len[u8](buf) - 1u;
if vec::len[u8](buf) == 0u { log_err "parse_buf(): buf is empty"; fail; }
let i = vec::len[u8](buf) - 1u;
let power = 1u;
let n = 0u;
while true {

0
src/lib/ivec.rs → src/lib/vec.rs
View file

8
src/test/bench/shootout-fannkuchredux.rs
View file

@ -1,15 +1,15 @@
// Based on Isaac Gouy's fannkuchredux.csharp
use std;
import std::int;
import std::ivec;
import std::vec;
fn fannkuch(n: int) -> int {
fn perm1init(i: uint) -> int { ret i as int; }
let perm1init_ = perm1init; // Rustboot workaround
let perm = ivec::init_elt_mut(0, n as uint);
let perm1 = ivec::init_fn_mut(perm1init_, n as uint);
let count = ivec::init_elt_mut(0, n as uint);
let perm = vec::init_elt_mut(0, n as uint);
let perm1 = vec::init_fn_mut(perm1init_, n as uint);
let count = vec::init_elt_mut(0, n as uint);
let f = 0;
let i = 0;
let k = 0;

4
src/test/bench/shootout-fasta.rs
View file

@ -6,7 +6,7 @@
* http://shootout.alioth.debian.org/
*/
use std;
import std::ivec;
import std::vec;
import std::str;
import std::uint;
import std::int;
@ -40,7 +40,7 @@ fn select_random(r: u32, genelist: &[aminoacids]) -> char {
} else { be bisect(v, mid, hi, target); }
} else { ret v.(hi).ch; }
}
ret bisect(genelist, 0u, ivec::len[aminoacids](genelist) - 1u, r);
ret bisect(genelist, 0u, vec::len[aminoacids](genelist) - 1u, r);
}
fn make_random_fasta(id: str, desc: str, genelist: &[aminoacids], n: int) {

6
src/test/bench/shootout-pfib.rs
View file

@ -11,7 +11,7 @@
use std;
import std::ivec;
import std::vec;
import std::uint;
import std::time;
import std::str;
@ -52,7 +52,7 @@ type config = {stress: bool};
fn parse_opts(argv: [str]) -> config {
let opts = ~[getopts::optflag("stress")];
let opt_args = ivec::slice(argv, 1u, ivec::len(argv));
let opt_args = vec::slice(argv, 1u, vec::len(argv));
alt getopts::getopts(opt_args, opts) {
@ -80,7 +80,7 @@ fn stress(num_tasks: int) {
}
fn main(argv: [str]) {
if ivec::len(argv) == 1u {
if vec::len(argv) == 1u {
assert (fib(8) == 21);
log fib(8);
} else {

4
src/test/bench/task-perf-spawnalot.rs
View file

@ -1,5 +1,5 @@
use std;
import std::ivec;
import std::vec;
import std::task;
import std::uint;
import std::str;
@ -16,7 +16,7 @@ fn g() {}
fn main(args: [str]) {
let n = if ivec::len(args) < 2u {
let n = if vec::len(args) < 2u {
10u
} else {
uint::parse_buf(str::bytes(args.(1)), 10u)

8
src/test/bench/task-perf-word-count.rs
View file

@ -15,7 +15,7 @@ import std::option::some;
import std::option::none;
import std::str;
import std::map;
import std::ivec;
import std::vec;
import std::io;
import std::time;
@ -158,7 +158,7 @@ mod map_reduce {
let tasks = start_mappers(ctrl.mk_chan(), inputs);
let num_mappers = ivec::len(inputs) as int;
let num_mappers = vec::len(inputs) as int;
while num_mappers > 0 {
alt ctrl.recv() {
@ -199,7 +199,7 @@ mod map_reduce {
}
fn main(argv: [str]) {
if ivec::len(argv) < 2u {
if vec::len(argv) < 2u {
let out = io::stdout();
out.write_line(#fmt("Usage: %s <filename> ...", argv.(0)));
@ -216,7 +216,7 @@ fn main(argv: [str]) {
let start = time::precise_time_ns();
map_reduce::map_reduce(ivec::slice(argv, 1u, ivec::len(argv)));
map_reduce::map_reduce(vec::slice(argv, 1u, vec::len(argv)));
let stop = time::precise_time_ns();
let elapsed = stop - start;

2
src/test/compile-fail/alias-mismatch.rs
View file

@ -1,6 +1,6 @@
// error-pattern:expected argument mode
use std;
import std::ivec::map;
import std::vec::map;
fn main() {
fn f(i: uint) -> bool { true }

2
src/test/compile-fail/bad-module.rs
View file

@ -1,4 +1,4 @@
// error-pattern: unresolved import: ivec
import ivec;
fn main() { let foo = ivec::len([]); }
fn main() { let foo = vec::len([]); }

2
src/test/compile-fail/cross-crate-glob-collision.rs
View file

@ -3,7 +3,7 @@
use std;
// expecting swap to be defined in vec
import std::ivec::*;
import std::vec::*;
import alternate_supplier::*;
mod alternate_supplier {

8
src/test/compiletest/compiletest.rs
View file

@ -3,7 +3,7 @@ import std::getopts;
import std::test;
import std::fs;
import std::str;
import std::ivec;
import std::vec;
import std::task;
import std::task::task_id;
@ -38,8 +38,8 @@ fn parse_config(args: &[str]) -> config {
getopts::optflag("ignored"), getopts::optopt("runtool"),
getopts::optopt("rustcflags"), getopts::optflag("verbose")];
check (ivec::is_not_empty(args));
let args_ = ivec::tail(args);
check (vec::is_not_empty(args));
let args_ = vec::tail(args);
let match =
alt getopts::getopts(args_, opts) {
getopts::success(m) { m }
@ -55,7 +55,7 @@ fn parse_config(args: &[str]) -> config {
mode: str_mode(getopts::opt_str(match, "mode")),
run_ignored: getopts::opt_present(match, "ignored"),
filter:
if ivec::len(match.free) > 0u {
if vec::len(match.free) > 0u {
option::some(match.free.(0))
} else { option::none },
runtool: getopts::opt_maybe_str(match, "runtool"),

6
src/test/compiletest/procsrv.rs
View file

@ -9,7 +9,7 @@ import std::task;
import std::task::task_id;
import std::generic_os::setenv;
import std::generic_os::getenv;
import std::ivec;
import std::vec;
import std::os;
import std::run;
import std::io;
@ -186,7 +186,7 @@ fn export_lib_path(path: &str) { setenv(util::lib_path_env_var(), path); }
fn clone_ivecstr(v: &[str]) -> [[u8]] {
let r = ~[];
for t: str in ivec::slice(v, 0u, ivec::len(v)) {
for t: str in vec::slice(v, 0u, vec::len(v)) {
r += ~[str::bytes(t)];
}
ret r;
@ -194,7 +194,7 @@ fn clone_ivecstr(v: &[str]) -> [[u8]] {
fn clone_ivecu8str(v: &[[u8]]) -> [str] {
let r = ~[];
for t in ivec::slice(v, 0u, ivec::len(v)) {
for t in vec::slice(v, 0u, vec::len(v)) {
r += ~[str::unsafe_from_bytes(t)];
}
ret r;

22
src/test/compiletest/runtest.rs
View file

@ -3,7 +3,7 @@ import std::str;
import std::option;
import std::fs;
import std::os;
import std::ivec;
import std::vec;
import std::test;
import common::mode_run_pass;
@ -117,10 +117,10 @@ fn run_pretty_test(cx: &cx, props: &test_props, testfile: &str) {
io::read_whole_file_str(filepath)
}
option::none. {
srcs.(ivec::len(srcs) - 2u)
srcs.(vec::len(srcs) - 2u)
}
};
let actual = srcs.(ivec::len(srcs) - 1u);
let actual = srcs.(vec::len(srcs) - 1u);
if option::is_some(props.pp_exact) {
// Now we have to care about line endings
@ -186,7 +186,7 @@ actual:\n\
fn check_error_patterns(props: &test_props, testfile: &str,
procres: &procres) {
if ivec::is_empty(props.error_patterns) {
if vec::is_empty(props.error_patterns) {
fatal("no error pattern specified in " + testfile);
}
@ -196,7 +196,7 @@ fn check_error_patterns(props: &test_props, testfile: &str,
if str::find(line, next_err_pat) > 0 {
log #fmt("found error pattern %s", next_err_pat);
next_err_idx += 1u;
if next_err_idx == ivec::len(props.error_patterns) {
if next_err_idx == vec::len(props.error_patterns) {
log "found all error patterns";
ret;
}
@ -205,9 +205,9 @@ fn check_error_patterns(props: &test_props, testfile: &str,
}
let missing_patterns =
ivec::slice(props.error_patterns, next_err_idx,
ivec::len(props.error_patterns));
if ivec::len(missing_patterns) == 1u {
vec::slice(props.error_patterns, next_err_idx,
vec::len(props.error_patterns));
if vec::len(missing_patterns) == 1u {
fatal_procres(#fmt("error pattern '%s' not found!",
missing_patterns.(0)), procres);
} else {
@ -268,7 +268,7 @@ fn make_run_args(config: &config,
};
let args = toolargs + ~[make_exe_name(config, testfile)];
ret {prog: args.(0), args: ivec::slice(args, 1u, ivec::len(args))};
ret {prog: args.(0), args: vec::slice(args, 1u, vec::len(args))};
}
fn split_maybe_args(argstr: &option::t[str]) -> [str] {
@ -288,7 +288,7 @@ fn split_maybe_args(argstr: &option::t[str]) -> [str] {
}
ret true;
}
ivec::filter_map(flt, v)
vec::filter_map(flt, v)
}
alt argstr {
@ -356,7 +356,7 @@ fn output_base_name(config: &config, testfile: &str) -> str {
let filename =
{
let parts = str::split(fs::basename(testfile), '.' as u8);
parts = ivec::slice(parts, 0u, ivec::len(parts) - 1u);
parts = vec::slice(parts, 0u, vec::len(parts) - 1u);
str::connect(parts, ".")
};
#fmt("%s%s.%s", base, filename, config.stage_id)

8
src/test/run-pass/block-vec-map2.rs
View file

@ -1,10 +1,10 @@
use std;
import std::ivec;
import std::vec;
fn main() {
let v = std::ivec::map2({|&i, &b| if b { -i } else { i }},
~[1, 2, 3, 4, 5],
~[true, false, false, true, true]);
let v = std::vec::map2({|&i, &b| if b { -i } else { i }},
~[1, 2, 3, 4, 5],
~[true, false, false, true, true]);
log_err v;
assert v == ~[-1, 2, 3, -4, -5];
}

4
src/test/run-pass/hashmap-memory.rs
View file

@ -10,7 +10,7 @@ import option = std::option::t;
import std::option::some;
import std::option::none;
import std::str;
import std::ivec;
import std::vec;
import std::map;
import std::task;
import std::comm::_chan;
@ -73,7 +73,7 @@ mod map_reduce {
start_mappers(ctrl.mk_chan(), inputs);
let num_mappers = ivec::len(inputs) as int;
let num_mappers = vec::len(inputs) as int;
while num_mappers > 0 {
alt ctrl.recv() {

2
src/test/run-pass/import-glob-crate.rs
View file

@ -1,6 +1,6 @@
use std;
import std::ivec::*;
import std::vec::*;
fn main() {
let v = init_elt(0, 0u);

8
src/test/run-pass/issue-687.rs
View file

@ -1,5 +1,5 @@
use std;
import std::ivec;
import std::vec;
import std::task;
import std::comm;
import std::comm::_chan;
@ -22,12 +22,12 @@ fn packager(cb: _chan[_chan[[u8]]], msg: _chan[msg]) {
log "waiting for bytes";
let data = p.recv();
log "got bytes";
if ivec::len(data) == 0u {
if vec::len(data) == 0u {
log "got empty bytes, quitting";
break;
}
log "sending non-empty buffer of length";
log ivec::len(data);
log vec::len(data);
send(msg, received(data));
log "sent non-empty buffer";
}
@ -51,7 +51,7 @@ fn main() {
closed. { log "Got close message"; break; }
received(data) {
log "Got data. Length is:";
log ivec::len[u8](data);
log vec::len[u8](data);
}
}
}

4
src/test/run-pass/mod-view-items.rs
View file

@ -6,8 +6,8 @@
mod m {
use std;
import std::ivec;
fn f() -> [int] { ivec::init_elt(0, 1u) }
import std::vec;
fn f() -> [int] { vec::init_elt(0, 1u) }
}
fn main() { let x = m::f(); }

2
src/test/run-pass/mutable-alias-vec.rs
View file

@ -10,7 +10,7 @@ fn main() {
grow(v);
grow(v);
grow(v);
let len = std::ivec::len[int](v);
let len = std::vec::len[int](v);
log len;
assert (len == 3 as uint);
}

4
src/test/run-pass/utf8_chars.rs
View file

@ -1,6 +1,6 @@
use std;
import std::str;
import std::ivec;
import std::vec;
fn main() {
// Chars of 1, 2, 3, and 4 bytes
@ -9,7 +9,7 @@ fn main() {
assert (str::byte_len(s) == 10u);
assert (str::char_len(s) == 4u);
assert (ivec::len[char](str::to_chars(s)) == 4u);
assert (vec::len[char](str::to_chars(s)) == 4u);
assert (str::eq(str::from_chars(str::to_chars(s)), s));
assert (str::char_at(s, 0u) == 'e');
assert (str::char_at(s, 1u) == 'é');

6
src/test/run-pass/vec-append.rs
View file

@ -3,7 +3,7 @@
// -*- rust -*-
use std;
import std::str;
import std::ivec;
import std::vec;
// FIXME: import std::dbg::const_refcount. Currently
// cross-crate const references don't work.
@ -57,9 +57,9 @@ fn slow_growth2_helper(s: str) { // ref up: s
assert (str::refcount(s) == const_refcount);
assert (str::refcount(mumble) == const_refcount);
log v.(0);
log ivec::len[str](v);
log vec::len[str](v);
assert (str::eq(v.(0), mumble));
assert (ivec::len[str](v) == 1u);
assert (vec::len[str](v) == 1u);
} // ref down: mumble, s,
log str::refcount(s);

6
src/test/run-pass/vec-self-append.rs
View file

@ -3,7 +3,7 @@
// xfail-stage3
use std;
import std::ivec;
import std::vec;
fn main() {
// Make sure we properly handle repeated self-appends.
@ -11,8 +11,8 @@ fn main() {
let i = 20;
let expected_len = 1u;
while i > 0 {
log_err ivec::len(a);
assert (ivec::len(a) == expected_len);
log_err vec::len(a);
assert (vec::len(a) == expected_len);
a += a;
i -= 1;
expected_len *= 2u;

4
src/test/stdtest/bitv.rs
View file

@ -1,6 +1,6 @@
use std;
import std::ivec;
import std::vec;
import std::bitv;
#[test]
@ -8,7 +8,7 @@ fn test_0_elements() {
let act;
let exp;
act = bitv::create(0u, false);
exp = ivec::init_elt[uint](0u, 0u);
exp = vec::init_elt[uint](0u, 0u);
// FIXME: why can't I write vec[uint]()?
assert (bitv::eq_ivec(act, exp));

2
src/test/stdtest/either.rs
View file

@ -1,6 +1,6 @@
use std;
import std::either::*;
import std::ivec::len;
import std::vec::len;
#[test]
fn test_either_left() {

2
src/test/stdtest/getopts.rs
View file

@ -1,6 +1,6 @@
use std;
import std::ivec;
import std::vec;
import std::option;
import opt = std::getopts;

6
src/test/stdtest/qsort.rs
View file

@ -2,11 +2,11 @@
use std;
import std::sort;
import std::ivec;
import std::vec;
import std::int;
fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
let len = std::ivec::len[int](v1);
let len = std::vec::len[int](v1);
fn ltequal(a: &int, b: &int) -> bool { ret a <= b; }
let f = ltequal;
std::sort::quick_sort[int](f, v1);
@ -49,7 +49,7 @@ fn test_simple() {
fn lteq(a: &int, b: &int) -> bool { int::le(a, b) }
sort::quick_sort(lteq, names);
let pairs = ivec::zip(expected, ivec::from_mut(names));
let pairs = vec::zip(expected, vec::from_mut(names));
for (a, b) in pairs {
log #fmt("%d %d", a, b);
assert (a == b);

2
src/test/stdtest/qsort3.rs
View file

@ -2,7 +2,7 @@
use std;
fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
let len = std::ivec::len[int](v1);
let len = std::vec::len[int](v1);
fn lt(a: &int, b: &int) -> bool { ret a < b; }
fn equal(a: &int, b: &int) -> bool { ret a == b; }
let f1 = lt;

2
src/test/stdtest/run.rs
View file

@ -4,7 +4,7 @@ import std::os;
import std::io;
import std::option;
import std::str;
import std::ivec;
import std::vec;
// Regression test for memory leaks
#[cfg(target_os = "linux")]

6
src/test/stdtest/sha1.rs
View file

@ -4,7 +4,7 @@
use std;
import std::sha1;
import std::ivec;
import std::vec;
import std::str;
#[test]
@ -61,8 +61,8 @@ fn test() {
0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
let tests = fips_180_1_tests + wikipedia_tests;
fn check_vec_eq(v0: &[u8], v1: &[u8]) {
assert (ivec::len[u8](v0) == ivec::len[u8](v1));
let len = ivec::len[u8](v0);
assert (vec::len[u8](v0) == vec::len[u8](v1));
let len = vec::len[u8](v0);
let i = 0u;
while i < len {
let a = v0.(i);

2
src/test/stdtest/sort.rs
View file

@ -2,7 +2,7 @@
use std;
fn check_sort(v1: &[int], v2: &[int]) {
let len = std::ivec::len[int](v1);
let len = std::vec::len[int](v1);
fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
let f = lteq;
let v3 = std::sort::merge_sort[int](f, v1);

2
src/test/stdtest/stdtest.rc
View file

@ -9,7 +9,7 @@ mod fs;
mod getopts;
mod int;
mod io;
mod ivec;
mod vec;
mod list;
mod map;
mod net;

10
src/test/stdtest/test.rs
View file

@ -2,7 +2,7 @@ import std::test;
import std::str;
import std::option;
import std::either;
import std::ivec;
import std::vec;
#[test]
fn do_not_run_ignored_tests() {
@ -27,7 +27,7 @@ fn ignored_tests_result_in_ignored() {
#[test]
fn first_free_arg_should_be_a_filter() {
let args = ~["progname", "filter"];
check (ivec::is_not_empty(args));
check (vec::is_not_empty(args));
let opts = alt test::parse_opts(args) { either::left(o) { o } };
assert (str::eq("filter", option::get(opts.filter)));
}
@ -35,7 +35,7 @@ fn first_free_arg_should_be_a_filter() {
#[test]
fn parse_ignored_flag() {
let args = ~["progname", "filter", "--ignored"];
check (ivec::is_not_empty(args));
check (vec::is_not_empty(args));
let opts = alt test::parse_opts(args) { either::left(o) { o } };
assert (opts.run_ignored);
}
@ -51,7 +51,7 @@ fn filter_for_ignored_option() {
{name: "2", fn: fn () { }, ignore: false}];
let filtered = test::filter_tests(opts, tests);
assert (ivec::len(filtered) == 1u);
assert (vec::len(filtered) == 1u);
assert (filtered.(0).name == "1");
assert (filtered.(0).ignore == false);
}
@ -86,7 +86,7 @@ fn sort_tests() {
"test::ignored_tests_result_in_ignored", "test::parse_ignored_flag",
"test::sort_tests"];
let pairs = ivec::zip(expected, filtered);
let pairs = vec::zip(expected, filtered);
for (a, b) in pairs {

Some files were not shown because too many files have changed in this diff Show more