bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Finally rename std::_xxx to std::xxx

Browse source 
Except for _task, which is still a keyword.
This commit is contained in:
Marijn Haverbeke 2011-05-17 20:41:41 +02:00
parent 6067050656
commit 09d8ef8d51
87 changed files with 1224 additions and 1224 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,7 +1,7 @@
import driver::session; import driver::session;
import lib::llvm::llvm; import lib::llvm::llvm;
import middle::trans; import middle::trans;
import std::_str; import std::str;
import std::fs; import std::fs;
import lib::llvm::llvm::ModuleRef; import lib::llvm::llvm::ModuleRef;
@ -25,7 +25,7 @@ fn llvm_err(session::session sess, str msg) {
if ((buf as uint) == 0u) { if ((buf as uint) == 0u) {
sess.err(msg); sess.err(msg);
} else { } else {
sess.err(msg + ": " + _str::str_from_cstr(buf)); sess.err(msg + ": " + str::str_from_cstr(buf));
} }
fail; fail;
} }
@ -33,7 +33,7 @@ fn llvm_err(session::session sess, str msg) {
fn link_intrinsics(session::session sess, ModuleRef llmod) { fn link_intrinsics(session::session sess, ModuleRef llmod) {
auto path = fs::connect(sess.get_opts().sysroot, "intrinsics.bc"); auto path = fs::connect(sess.get_opts().sysroot, "intrinsics.bc");
auto membuf = auto membuf =
llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(_str::buf(path)); llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(str::buf(path));
if ((membuf as uint) == 0u) { if ((membuf as uint) == 0u) {
llvm_err(sess, "installation problem: couldn't open intrinstics.bc"); llvm_err(sess, "installation problem: couldn't open intrinstics.bc");
fail; fail;
@ -69,12 +69,12 @@ mod write {
// Decides what to call an intermediate file, given the name of the output // Decides what to call an intermediate file, given the name of the output
// and the extension to use. // and the extension to use.
fn mk_intermediate_name(str output_path, str extension) -> str { fn mk_intermediate_name(str output_path, str extension) -> str {
auto dot_pos = _str::index(output_path, '.' as u8); auto dot_pos = str::index(output_path, '.' as u8);
auto stem; auto stem;
if (dot_pos < 0) { if (dot_pos < 0) {
stem = output_path; stem = output_path;
} else { } else {
stem = _str::substr(output_path, 0u, dot_pos as uint); stem = str::substr(output_path, 0u, dot_pos as uint);
} }
ret stem + "." + extension; ret stem + "." + extension;
} }
@ -105,12 +105,12 @@ mod write {
auto filename = mk_intermediate_name(output, auto filename = mk_intermediate_name(output,
"no-opt.bc"); "no-opt.bc");
llvm::LLVMWriteBitcodeToFile(llmod, llvm::LLVMWriteBitcodeToFile(llmod,
_str::buf(filename)); str::buf(filename));
} }
} }
case (_) { case (_) {
auto filename = mk_intermediate_name(output, "bc"); auto filename = mk_intermediate_name(output, "bc");
llvm::LLVMWriteBitcodeToFile(llmod, _str::buf(filename)); llvm::LLVMWriteBitcodeToFile(llmod, str::buf(filename));
} }
} }
} }
@ -161,14 +161,14 @@ mod write {
// Always output the bitcode file with --save-temps // Always output the bitcode file with --save-temps
auto filename = mk_intermediate_name(output, "opt.bc"); auto filename = mk_intermediate_name(output, "opt.bc");
llvm::LLVMRunPassManager(pm.llpm, llmod); llvm::LLVMRunPassManager(pm.llpm, llmod);
llvm::LLVMWriteBitcodeToFile(llmod, _str::buf(output)); llvm::LLVMWriteBitcodeToFile(llmod, str::buf(output));
pm = mk_pass_manager(); pm = mk_pass_manager();
// Save the assembly file if -S is used // Save the assembly file if -S is used
if (opts.output_type == output_type_assembly) { if (opts.output_type == output_type_assembly) {
llvm::LLVMRustWriteOutputFile(pm.llpm, llmod, llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
_str::buf(x86::get_target_triple()), str::buf(x86::get_target_triple()),
_str::buf(output), LLVMAssemblyFile); str::buf(output), LLVMAssemblyFile);
} }
// Save the object file for -c or --save-temps alone // Save the object file for -c or --save-temps alone
@ -176,16 +176,16 @@ mod write {
if ((opts.output_type == output_type_object) || if ((opts.output_type == output_type_object) ||
(opts.output_type == output_type_exe)) { (opts.output_type == output_type_exe)) {
llvm::LLVMRustWriteOutputFile(pm.llpm, llmod, llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
_str::buf(x86::get_target_triple()), str::buf(x86::get_target_triple()),
_str::buf(output), LLVMObjectFile); str::buf(output), LLVMObjectFile);
} }
} else { } else {
// If we aren't saving temps then just output the file // If we aren't saving temps then just output the file
// type corresponding to the '-c' or '-S' flag used // type corresponding to the '-c' or '-S' flag used
llvm::LLVMRustWriteOutputFile(pm.llpm, llmod, llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
_str::buf(x86::get_target_triple()), str::buf(x86::get_target_triple()),
_str::buf(output), str::buf(output),
FileType); FileType);
} }
@ -201,7 +201,7 @@ mod write {
// flag, then output it here // flag, then output it here
llvm::LLVMRunPassManager(pm.llpm, llmod); llvm::LLVMRunPassManager(pm.llpm, llmod);
llvm::LLVMWriteBitcodeToFile(llmod, _str::buf(output)); llvm::LLVMWriteBitcodeToFile(llmod, str::buf(output));
llvm::LLVMDisposeModule(llmod); llvm::LLVMDisposeModule(llmod);
if (opts.time_llvm_passes) { if (opts.time_llvm_passes) {

34
src/comp/back/x86.rs
View file

@ -1,7 +1,7 @@
import lib::llvm::llvm; import lib::llvm::llvm;
import lib::llvm::llvm::ModuleRef; import lib::llvm::llvm::ModuleRef;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::os::target_os; import std::os::target_os;
import util::common::istr; import util::common::istr;
@ -241,7 +241,7 @@ fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
} }
auto m = ["movl " + src_off + "(%ebp),%eax", auto m = ["movl " + src_off + "(%ebp),%eax",
"movl %eax," + dst_off + "(%esp)"]; "movl %eax," + dst_off + "(%esp)"];
ret _str::connect(m, "\n\t"); ret str::connect(m, "\n\t");
} }
auto carg = bind copy_arg(pass_task, _); auto carg = bind copy_arg(pass_task, _);
@ -259,7 +259,7 @@ fn native_glue(int n_args, abi::native_glue_type ngt) -> vec[str] {
+ ["subl $" + wstr(n_args) + ", %esp # esp -= args", + ["subl $" + wstr(n_args) + ", %esp # esp -= args",
"andl $~0xf, %esp # align esp down"] "andl $~0xf, %esp # align esp down"]
+ _vec::init_fn[str](carg, (n_args) as uint) + vec::init_fn[str](carg, (n_args) as uint)
+ ["movl %edx, %edi # save task from edx to edi", + ["movl %edx, %edi # save task from edx to edi",
"call *%ecx # call *%ecx", "call *%ecx # call *%ecx",
@ -278,7 +278,7 @@ fn decl_glue(int align, str prefix, str name, vec[str] insns) -> str {
ret "\t.globl " + sym + "\n" + ret "\t.globl " + sym + "\n" +
"\t.balign " + istr(align) + "\n" + "\t.balign " + istr(align) + "\n" +
sym + ":\n" + sym + ":\n" +
"\t" + _str::connect(insns, "\n\t"); "\t" + str::connect(insns, "\n\t");
} }
@ -291,8 +291,8 @@ fn decl_native_glue(int align, str prefix, abi::native_glue_type ngt, uint n)
} }
fn get_symbol_prefix() -> str { fn get_symbol_prefix() -> str {
if (_str::eq(target_os(), "macos") || if (str::eq(target_os(), "macos") ||
_str::eq(target_os(), "win32")) { str::eq(target_os(), "win32")) {
ret "_"; ret "_";
} else { } else {
ret ""; ret "";
@ -313,44 +313,44 @@ fn get_module_asm() -> str {
abi::yield_glue_name(), abi::yield_glue_name(),
rust_yield_glue())] rust_yield_glue())]
+ _vec::init_fn[str](bind decl_native_glue(align, prefix, + vec::init_fn[str](bind decl_native_glue(align, prefix,
abi::ngt_rust, _), (abi::n_native_glues + 1) as uint) abi::ngt_rust, _), (abi::n_native_glues + 1) as uint)
+ _vec::init_fn[str](bind decl_native_glue(align, prefix, + vec::init_fn[str](bind decl_native_glue(align, prefix,
abi::ngt_pure_rust, _), (abi::n_native_glues + 1) as uint) abi::ngt_pure_rust, _), (abi::n_native_glues + 1) as uint)
+ _vec::init_fn[str](bind decl_native_glue(align, prefix, + vec::init_fn[str](bind decl_native_glue(align, prefix,
abi::ngt_cdecl, _), (abi::n_native_glues + 1) as uint); abi::ngt_cdecl, _), (abi::n_native_glues + 1) as uint);
ret _str::connect(glues, "\n\n"); ret str::connect(glues, "\n\n");
} }
fn get_meta_sect_name() -> str { fn get_meta_sect_name() -> str {
if (_str::eq(target_os(), "macos")) { if (str::eq(target_os(), "macos")) {
ret "__DATA,__note.rustc"; ret "__DATA,__note.rustc";
} }
if (_str::eq(target_os(), "win32")) { if (str::eq(target_os(), "win32")) {
ret ".note.rustc"; ret ".note.rustc";
} }
ret ".note.rustc"; ret ".note.rustc";
} }
fn get_data_layout() -> str { fn get_data_layout() -> str {
if (_str::eq(target_os(), "macos")) { if (str::eq(target_os(), "macos")) {
ret "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64" + ret "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64" +
"-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" + "-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" +
"-n8:16:32"; "-n8:16:32";
} }
if (_str::eq(target_os(), "win32")) { if (str::eq(target_os(), "win32")) {
ret "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32"; ret "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32";
} }
ret "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32"; ret "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32";
} }
fn get_target_triple() -> str { fn get_target_triple() -> str {
if (_str::eq(target_os(), "macos")) { if (str::eq(target_os(), "macos")) {
ret "i686-apple-darwin"; ret "i686-apple-darwin";
} }
if (_str::eq(target_os(), "win32")) { if (str::eq(target_os(), "win32")) {
ret "i686-pc-mingw32"; ret "i686-pc-mingw32";
} }
ret "i686-unknown-linux-gnu"; ret "i686-unknown-linux-gnu";

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

@ -19,8 +19,8 @@ import std::map::mk_hashmap;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::io; import std::io;
import std::run; import std::run;
@ -59,9 +59,9 @@ fn default_environment(session::session sess,
fn parse_input(session::session sess, fn parse_input(session::session sess,
parser::parser p, parser::parser p,
str input) -> @ast::crate { str input) -> @ast::crate {
if (_str::ends_with(input, ".rc")) { if (str::ends_with(input, ".rc")) {
ret parser::parse_crate_from_crate_file(p); ret parser::parse_crate_from_crate_file(p);
} else if (_str::ends_with(input, ".rs")) { } else if (str::ends_with(input, ".rs")) {
ret parser::parse_crate_from_source_file(p); ret parser::parse_crate_from_source_file(p);
} }
sess.err("unknown input file type: " + input); sess.err("unknown input file type: " + input);
@ -130,7 +130,7 @@ fn pretty_print_input(session::session sess,
fn version(str argv0) { fn version(str argv0) {
auto vers = "unknown version"; auto vers = "unknown version";
auto env_vers = #env("CFG_VERSION"); auto env_vers = #env("CFG_VERSION");
if (_str::byte_len(env_vers) != 0u) { if (str::byte_len(env_vers) != 0u) {
vers = env_vers; vers = env_vers;
} }
io::stdout().write_str(#fmt("%s %s\n", argv0, vers)); io::stdout().write_str(#fmt("%s %s\n", argv0, vers));
@ -166,25 +166,25 @@ options:
} }
fn get_os(str triple) -> session::os { fn get_os(str triple) -> session::os {
if (_str::find(triple, "win32") >= 0 || if (str::find(triple, "win32") >= 0 ||
_str::find(triple, "mingw32") >= 0 ) { str::find(triple, "mingw32") >= 0 ) {
ret session::os_win32; ret session::os_win32;
} else if (_str::find(triple, "darwin") >= 0) { ret session::os_macos; } } else if (str::find(triple, "darwin") >= 0) { ret session::os_macos; }
else if (_str::find(triple, "linux") >= 0) { ret session::os_linux; } else if (str::find(triple, "linux") >= 0) { ret session::os_linux; }
else { log_err "Unknown operating system!"; fail; } else { log_err "Unknown operating system!"; fail; }
} }
fn get_arch(str triple) -> session::arch { fn get_arch(str triple) -> session::arch {
if (_str::find(triple, "i386") >= 0 || if (str::find(triple, "i386") >= 0 ||
_str::find(triple, "i486") >= 0 || str::find(triple, "i486") >= 0 ||
_str::find(triple, "i586") >= 0 || str::find(triple, "i586") >= 0 ||
_str::find(triple, "i686") >= 0 || str::find(triple, "i686") >= 0 ||
_str::find(triple, "i786") >= 0 ) { str::find(triple, "i786") >= 0 ) {
ret session::arch_x86; ret session::arch_x86;
} else if (_str::find(triple, "x86_64") >= 0) { } else if (str::find(triple, "x86_64") >= 0) {
ret session::arch_x64; ret session::arch_x64;
} else if (_str::find(triple, "arm") >= 0 || } else if (str::find(triple, "arm") >= 0 ||
_str::find(triple, "xscale") >= 0 ) { str::find(triple, "xscale") >= 0 ) {
ret session::arch_arm; ret session::arch_arm;
} }
else { else {
@ -195,14 +195,14 @@ fn get_arch(str triple) -> session::arch {
fn get_default_sysroot(str binary) -> str { fn get_default_sysroot(str binary) -> str {
auto dirname = fs::dirname(binary); auto dirname = fs::dirname(binary);
if (_str::eq(dirname, binary)) { ret "."; } if (str::eq(dirname, binary)) { ret "."; }
ret dirname; ret dirname;
} }
fn main(vec[str] args) { fn main(vec[str] args) {
let str triple = let str triple =
std::_str::rustrt::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple()); std::str::rustrt::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple());
let @session::config target_cfg = let @session::config target_cfg =
@rec(os = get_os(triple), @rec(os = get_os(triple),
@ -221,7 +221,7 @@ fn main(vec[str] args) {
optflag("stats"), optflag("stats"),
optflag("time-passes"), optflag("time-llvm-passes"), optflag("time-passes"), optflag("time-llvm-passes"),
optflag("no-typestate"), optflag("noverify")]; optflag("no-typestate"), optflag("noverify")];
auto binary = _vec::shift[str](args); auto binary = vec::shift[str](args);
auto match; auto match;
alt (getopts::getopts(args, opts)) { alt (getopts::getopts(args, opts)) {
case (getopts::failure(?f)) { case (getopts::failure(?f)) {
@ -298,7 +298,7 @@ fn main(vec[str] args) {
session::session(target_crate_num, target_cfg, sopts, session::session(target_crate_num, target_cfg, sopts,
crate_cache, md, front::codemap::new_codemap()); crate_cache, md, front::codemap::new_codemap());
auto n_inputs = _vec::len[str](match.free); auto n_inputs = vec::len[str](match.free);
if (glue) { if (glue) {
if (n_inputs > 0u) { if (n_inputs > 0u) {
@ -325,8 +325,8 @@ fn main(vec[str] args) {
} else { } else {
alt (output_file) { alt (output_file) {
case (none[str]) { case (none[str]) {
let vec[str] parts = _str::split(ifile, '.' as u8); let vec[str] parts = str::split(ifile, '.' as u8);
_vec::pop[str](parts); vec::pop[str](parts);
saved_out_filename = parts.(0); saved_out_filename = parts.(0);
alt (output_type) { alt (output_type) {
case (link::output_type_none) { parts += ["pp"]; } case (link::output_type_none) { parts += ["pp"]; }
@ -337,7 +337,7 @@ fn main(vec[str] args) {
case (link::output_type_object) { parts += ["o"]; } case (link::output_type_object) { parts += ["o"]; }
case (link::output_type_exe) { parts += ["o"]; } case (link::output_type_exe) { parts += ["o"]; }
} }
auto ofile = _str::connect(parts, "."); auto ofile = str::connect(parts, ".");
compile_input(sess, env, ifile, ofile); compile_input(sess, env, ifile, ofile);
} }
case (some[str](?ofile)) { case (some[str](?ofile)) {

2
src/comp/driver/session.rs
View file

@ -2,7 +2,7 @@ import front::ast;
import front::codemap; import front::codemap;
import util::common::span; import util::common::span;
import util::common::ty_mach; import util::common::ty_mach;
import std::_uint; import std::uint;
import std::term; import std::term;
import std::io; import std::io;
import std::map; import std::map;

6
src/comp/front/ast.rs
View file

@ -1,7 +1,7 @@
import std::map::hashmap; import std::map::hashmap;
import std::option; import std::option;
import std::_str; import std::str;
import std::_vec; import std::vec;
import util::common::span; import util::common::span;
import util::common::spanned; import util::common::spanned;
import util::common::ty_mach; import util::common::ty_mach;
@ -454,7 +454,7 @@ fn is_exported(ident i, _mod m) -> bool {
for (@ast::view_item vi in m.view_items) { for (@ast::view_item vi in m.view_items) {
alt (vi.node) { alt (vi.node) {
case (ast::view_item_export(?id)) { case (ast::view_item_export(?id)) {
if (_str::eq(i, id)) { if (str::eq(i, id)) {
ret true; ret true;
} }
count += 1; count += 1;

8
src/comp/front/codemap.rs
View file

@ -1,4 +1,4 @@
import std::_vec; import std::vec;
/* A codemap is a thing that maps uints to file/line/column positions /* A codemap is a thing that maps uints to file/line/column positions
* in a crate. This to make it possible to represent the positions * in a crate. This to make it possible to represent the positions
@ -24,18 +24,18 @@ fn new_filemap(str filename, uint start_pos) -> filemap {
} }
fn next_line(filemap file, uint pos) { fn next_line(filemap file, uint pos) {
_vec::push[uint](file.lines, pos); vec::push[uint](file.lines, pos);
} }
fn lookup_pos(codemap map, uint pos) -> loc { fn lookup_pos(codemap map, uint pos) -> loc {
auto a = 0u; auto b = _vec::len[filemap](map.files); auto a = 0u; auto b = vec::len[filemap](map.files);
while (b - a > 1u) { while (b - a > 1u) {
auto m = (a + b) / 2u; auto m = (a + b) / 2u;
if (map.files.(m).start_pos > pos) { b = m; } if (map.files.(m).start_pos > pos) { b = m; }
else { a = m; } else { a = m; }
} }
auto f = map.files.(a); auto f = map.files.(a);
a = 0u; b = _vec::len[uint](f.lines); a = 0u; b = vec::len[uint](f.lines);
while (b - a > 1u) { while (b - a > 1u) {
auto m = (a + b) / 2u; auto m = (a + b) / 2u;
if (f.lines.(m) > pos) { b = m; } if (f.lines.(m) > pos) { b = m; }

58
src/comp/front/creader.rs
View file

@ -14,9 +14,9 @@ import back::x86;
import util::common; import util::common;
import util::common::span; import util::common::span;
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
import std::ebml; import std::ebml;
import std::fs; import std::fs;
import std::io; import std::io;
@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
auto name = ""; auto name = "";
while (peek(st) as char != '=') { while (peek(st) as char != '=') {
name += _str::unsafe_from_byte(next(st)); name += str::unsafe_from_byte(next(st));
} }
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
fields += [rec(ident=name, mt=parse_mt(st, sd))]; fields += [rec(ident=name, mt=parse_mt(st, sd))];
@ -155,7 +155,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
} }
auto name = ""; auto name = "";
while (peek(st) as char != '[') { while (peek(st) as char != '[') {
name += _str::unsafe_from_byte(next(st)); name += str::unsafe_from_byte(next(st));
} }
auto func = parse_ty_fn(st, sd); auto func = parse_ty_fn(st, sd);
methods += [rec(proto=proto, methods += [rec(proto=proto,
@ -205,7 +205,7 @@ fn parse_mt(@pstate st, str_def sd) -> ty::mt {
fn parse_def(@pstate st, str_def sd) -> ast::def_id { fn parse_def(@pstate st, str_def sd) -> ast::def_id {
auto def = ""; auto def = "";
while (peek(st) as char != '|') { while (peek(st) as char != '|') {
def += _str::unsafe_from_byte(next(st)); def += str::unsafe_from_byte(next(st));
} }
st.pos = st.pos + 1u; st.pos = st.pos + 1u;
ret sd(def); ret sd(def);
@ -260,7 +260,7 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) {
fn parse_def_id(vec[u8] buf) -> ast::def_id { fn parse_def_id(vec[u8] buf) -> ast::def_id {
auto colon_idx = 0u; auto colon_idx = 0u;
auto len = _vec::len[u8](buf); auto len = vec::len[u8](buf);
while (colon_idx < len && buf.(colon_idx) != (':' as u8)) { while (colon_idx < len && buf.(colon_idx) != (':' as u8)) {
colon_idx += 1u; colon_idx += 1u;
} }
@ -269,10 +269,10 @@ fn parse_def_id(vec[u8] buf) -> ast::def_id {
fail; fail;
} }
auto crate_part = _vec::slice[u8](buf, 0u, colon_idx); auto crate_part = vec::slice[u8](buf, 0u, colon_idx);
auto def_part = _vec::slice[u8](buf, colon_idx + 1u, len); auto def_part = vec::slice[u8](buf, colon_idx + 1u, len);
auto crate_num = _uint::parse_buf(crate_part, 10u) as int; auto crate_num = uint::parse_buf(crate_part, 10u) as int;
auto def_num = _uint::parse_buf(def_part, 10u) as int; auto def_num = uint::parse_buf(def_part, 10u) as int;
ret tup(crate_num, def_num); ret tup(crate_num, def_num);
} }
@ -289,8 +289,8 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
auto belt = metadata::tag_index_buckets_bucket_elt; auto belt = metadata::tag_index_buckets_bucket_elt;
for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) { for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u); auto pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
if (eq_fn(_vec::slice[u8](elt.data, elt.start+4u, elt.end))) { if (eq_fn(vec::slice[u8](elt.data, elt.start+4u, elt.end))) {
_vec::push(result, ebml::doc_at(d.data, pos)); vec::push(result, ebml::doc_at(d.data, pos));
} }
} }
ret result; ret result;
@ -300,16 +300,16 @@ fn lookup_hash(&ebml::doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
// definition the path refers to. // definition the path refers to.
fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] { fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] {
fn eq_item(vec[u8] data, str s) -> bool { fn eq_item(vec[u8] data, str s) -> bool {
ret _str::eq(_str::unsafe_from_bytes(data), s); ret str::eq(str::unsafe_from_bytes(data), s);
} }
auto s = _str::connect(path, "::"); auto s = str::connect(path, "::");
auto md = ebml::new_doc(data); auto md = ebml::new_doc(data);
auto paths = ebml::get_doc(md, metadata::tag_paths); auto paths = ebml::get_doc(md, metadata::tag_paths);
auto eqer = bind eq_item(_, s); auto eqer = bind eq_item(_, s);
let vec[ast::def_id] result = []; let vec[ast::def_id] result = [];
for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) { for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) {
auto did_doc = ebml::get_doc(doc, metadata::tag_def_id); auto did_doc = ebml::get_doc(doc, metadata::tag_def_id);
_vec::push(result, parse_def_id(ebml::doc_data(did_doc))); vec::push(result, parse_def_id(ebml::doc_data(did_doc)));
} }
ret result; ret result;
} }
@ -320,7 +320,7 @@ fn maybe_find_item(int item_id, &ebml::doc items) -> option::t[ebml::doc] {
} }
auto eqer = bind eq_item(_, item_id); auto eqer = bind eq_item(_, item_id);
auto found = lookup_hash(items, eqer, metadata::hash_def_num(item_id)); auto found = lookup_hash(items, eqer, metadata::hash_def_num(item_id));
if (_vec::len(found) == 0u) { if (vec::len(found) == 0u) {
ret option::none[ebml::doc]; ret option::none[ebml::doc];
} else { } else {
ret option::some[ebml::doc](found.(0)); ret option::some[ebml::doc](found.(0));
@ -345,7 +345,7 @@ fn item_kind(&ebml::doc item) -> u8 {
fn item_symbol(&ebml::doc item) -> str { fn item_symbol(&ebml::doc item) -> str {
auto sym = ebml::get_doc(item, metadata::tag_items_data_item_symbol); auto sym = ebml::get_doc(item, metadata::tag_items_data_item_symbol);
ret _str::unsafe_from_bytes(ebml::doc_data(sym)); ret str::unsafe_from_bytes(ebml::doc_data(sym));
} }
fn variant_tag_id(&ebml::doc d) -> ast::def_id { fn variant_tag_id(&ebml::doc d) -> ast::def_id {
@ -359,13 +359,13 @@ fn item_type(&ebml::doc item, int this_cnum, ty::ctxt tcx) -> ty::t {
// that, in turn, links against another crate. We need a mapping // that, in turn, links against another crate. We need a mapping
// from crate ID to crate "meta" attributes as part of the crate // from crate ID to crate "meta" attributes as part of the crate
// metadata: // metadata:
auto buf = _str::bytes(s); auto buf = str::bytes(s);
auto external_def_id = parse_def_id(buf); auto external_def_id = parse_def_id(buf);
ret tup(this_cnum, external_def_id._1); ret tup(this_cnum, external_def_id._1);
} }
auto tp = ebml::get_doc(item, metadata::tag_items_data_item_type); auto tp = ebml::get_doc(item, metadata::tag_items_data_item_type);
auto s = _str::unsafe_from_bytes(ebml::doc_data(tp)); auto s = str::unsafe_from_bytes(ebml::doc_data(tp));
ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start, ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
bind parse_external_def_id(this_cnum, _), tcx); bind parse_external_def_id(this_cnum, _), tcx);
} }
@ -384,25 +384,25 @@ fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
auto v = metadata::tag_items_data_item_variant; auto v = metadata::tag_items_data_item_variant;
for each (ebml::doc p in ebml::tagged_docs(item, v)) { for each (ebml::doc p in ebml::tagged_docs(item, v)) {
auto ext = parse_def_id(ebml::doc_data(p)); auto ext = parse_def_id(ebml::doc_data(p));
_vec::push[ast::def_id](ids, tup(this_cnum, ext._1)); vec::push[ast::def_id](ids, tup(this_cnum, ext._1));
} }
ret ids; ret ids;
} }
fn get_metadata_section(str filename) -> option::t[vec[u8]] { fn get_metadata_section(str filename) -> option::t[vec[u8]] {
auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile
(_str::buf(filename)); (str::buf(filename));
if (mb as int == 0) {ret option::none[vec[u8]];} if (mb as int == 0) {ret option::none[vec[u8]];}
auto of = mk_object_file(mb); auto of = mk_object_file(mb);
auto si = mk_section_iter(of.llof); auto si = mk_section_iter(of.llof);
while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) { while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
auto name_buf = llvm::LLVMGetSectionName(si.llsi); auto name_buf = llvm::LLVMGetSectionName(si.llsi);
auto name = _str::str_from_cstr(name_buf); auto name = str::str_from_cstr(name_buf);
if (_str::eq(name, x86::get_meta_sect_name())) { if (str::eq(name, x86::get_meta_sect_name())) {
auto cbuf = llvm::LLVMGetSectionContents(si.llsi); auto cbuf = llvm::LLVMGetSectionContents(si.llsi);
auto csz = llvm::LLVMGetSectionSize(si.llsi); auto csz = llvm::LLVMGetSectionSize(si.llsi);
auto cvbuf = cbuf as _vec::vbuf; auto cvbuf = cbuf as vec::vbuf;
ret option::some[vec[u8]](_vec::vec_from_vbuf[u8](cvbuf, csz)); ret option::some[vec[u8]](vec::vec_from_vbuf[u8](cvbuf, csz));
} }
llvm::LLVMMoveToNextSection(si.llsi); llvm::LLVMMoveToNextSection(si.llsi);
} }
@ -481,7 +481,7 @@ fn lookup_defs(session::session sess, int cnum, vec[ast::ident] path)
-> vec[ast::def] { -> vec[ast::def] {
auto data = sess.get_external_crate(cnum).data; auto data = sess.get_external_crate(cnum).data;
ret _vec::map(bind lookup_def(cnum, data, _), ret vec::map(bind lookup_def(cnum, data, _),
resolve_path(path, data)); resolve_path(path, data));
} }
@ -580,8 +580,8 @@ fn list_file_metadata(str path, io::writer out) {
fn read_path(&ebml::doc d) -> tup(str, uint) { fn read_path(&ebml::doc d) -> tup(str, uint) {
auto desc = ebml::doc_data(d); auto desc = ebml::doc_data(d);
auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u); auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u);
auto pathbytes = _vec::slice[u8](desc, 4u, _vec::len[u8](desc)); auto pathbytes = vec::slice[u8](desc, 4u, vec::len[u8](desc));
auto path = _str::unsafe_from_bytes(pathbytes); auto path = str::unsafe_from_bytes(pathbytes);
ret tup(path, pos); ret tup(path, pos);
} }

18
src/comp/front/eval.rs
View file

@ -1,5 +1,5 @@
import std::_vec; import std::vec;
import std::_str; import std::str;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
@ -92,7 +92,7 @@ fn val_as_str(val v) -> str {
fn lookup(session::session sess, env e, span sp, ident i) -> val { fn lookup(session::session sess, env e, span sp, ident i) -> val {
for (tup(ident, val) pair in e) { for (tup(ident, val) pair in e) {
if (_str::eq(i, pair._0)) { if (str::eq(i, pair._0)) {
ret pair._1; ret pair._1;
} }
} }
@ -115,8 +115,8 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
fn eval_expr(ctx cx, env e, @ast::expr x) -> val { fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
alt (x.node) { alt (x.node) {
case (ast::expr_path(?pth, _)) { case (ast::expr_path(?pth, _)) {
if (_vec::len[ident](pth.node.idents) == 1u && if (vec::len[ident](pth.node.idents) == 1u &&
_vec::len[@ast::ty](pth.node.types) == 0u) { vec::len[@ast::ty](pth.node.types) == 0u) {
ret lookup(cx.sess, e, x.span, pth.node.idents.(0)); ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
} }
cx.sess.span_err(x.span, "evaluating structured path-name"); cx.sess.span_err(x.span, "evaluating structured path-name");
@ -225,7 +225,7 @@ fn val_eq(session::session sess, span sp, val av, val bv) -> bool {
ret val_as_int(av) == val_as_int(bv); ret val_as_int(av) == val_as_int(bv);
} }
if (val_is_str(av) && val_is_str(bv)) { if (val_is_str(av) && val_is_str(bv)) {
ret _str::eq(val_as_str(av), ret str::eq(val_as_str(av),
val_as_str(bv)); val_as_str(bv));
} }
sess.span_err(sp, "bad types in comparison"); sess.span_err(sp, "bad types in comparison");
@ -394,7 +394,7 @@ fn eval_crate_directive(ctx cx,
cx.next_ann = p0.next_ann_num(); cx.next_ann = p0.next_ann_num();
auto im = ast::item_mod(id, m0, next_id); auto im = ast::item_mod(id, m0, next_id);
auto i = @spanned(cdir.span.lo, cdir.span.hi, im); auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
_vec::push[@ast::item](items, i); vec::push[@ast::item](items, i);
} }
case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) { case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
@ -411,11 +411,11 @@ fn eval_crate_directive(ctx cx,
auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path); auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
auto im = ast::item_mod(id, m0, cx.p.next_def_id()); auto im = ast::item_mod(id, m0, cx.p.next_def_id());
auto i = @spanned(cdir.span.lo, cdir.span.hi, im); auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
_vec::push[@ast::item](items, i); vec::push[@ast::item](items, i);
} }
case (ast::cdir_view_item(?vi)) { case (ast::cdir_view_item(?vi)) {
_vec::push[@ast::view_item](view_items, vi); vec::push[@ast::view_item](view_items, vi);
} }
case (ast::cdir_meta(?mi)) { case (ast::cdir_meta(?mi)) {

6
src/comp/front/extenv.rs
View file

@ -6,8 +6,8 @@
import util::common; import util::common;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::option; import std::option;
import std::generic_os; import std::generic_os;
@ -19,7 +19,7 @@ fn expand_syntax_ext(parser::parser p,
vec[@ast::expr] args, vec[@ast::expr] args,
option::t[str] body) -> @ast::expr { option::t[str] body) -> @ast::expr {
if (_vec::len[@ast::expr](args) != 1u) { if (vec::len[@ast::expr](args) != 1u) {
p.err("malformed #env call"); p.err("malformed #env call");
} }

24
src/comp/front/extfmt.rs
View file

@ -7,8 +7,8 @@
import front::parser::parser; import front::parser::parser;
import util::common; import util::common;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::option; import std::option;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
@ -50,7 +50,7 @@ fn expand_syntax_ext(parser p,
vec[@ast::expr] args, vec[@ast::expr] args,
option::t[str] body) -> @ast::expr { option::t[str] body) -> @ast::expr {
if (_vec::len[@ast::expr](args) == 0u) { if (vec::len[@ast::expr](args) == 0u) {
// FIXME: Handle error correctly. // FIXME: Handle error correctly.
log_err "malformed #fmt call"; log_err "malformed #fmt call";
fail; fail;
@ -62,8 +62,8 @@ fn expand_syntax_ext(parser p,
// log fmt; // log fmt;
auto pieces = parse_fmt_string(fmt); auto pieces = parse_fmt_string(fmt);
auto args_len = _vec::len[@ast::expr](args); auto args_len = vec::len[@ast::expr](args);
auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u); auto fmt_args = vec::slice[@ast::expr](args, 1u, args_len - 1u);
ret pieces_to_expr(p, pieces, args); ret pieces_to_expr(p, pieces, args);
} }
@ -203,7 +203,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
// FIXME: 0-length vectors can't have their type inferred // FIXME: 0-length vectors can't have their type inferred
// through the rec that these flags are a member of, so // through the rec that these flags are a member of, so
// this is a hack placeholder flag // this is a hack placeholder flag
if (_vec::len[@ast::expr](flagexprs) == 0u) { if (vec::len[@ast::expr](flagexprs) == 0u) {
flagexprs += [make_rt_path_expr(p, sp, "flag_none")]; flagexprs += [make_rt_path_expr(p, sp, "flag_none")];
} }
@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn log_conv(conv c) { fn log_conv(conv c) {
alt (c.param) { alt (c.param) {
case (some[int](?p)) { case (some[int](?p)) {
log "param: " + std::_int::to_str(p, 10u); log "param: " + std::int::to_str(p, 10u);
} }
case (_) { case (_) {
log "param: none"; log "param: none";
@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
} }
alt (c.width) { alt (c.width) {
case (count_is(?i)) { case (count_is(?i)) {
log "width: count is " + std::_int::to_str(i, 10u); log "width: count is " + std::int::to_str(i, 10u);
} }
case (count_is_param(?i)) { case (count_is_param(?i)) {
log "width: count is param " + std::_int::to_str(i, 10u); log "width: count is param " + std::int::to_str(i, 10u);
} }
case (count_is_next_param) { case (count_is_next_param) {
log "width: count is next param"; log "width: count is next param";
@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
} }
alt (c.precision) { alt (c.precision) {
case (count_is(?i)) { case (count_is(?i)) {
log "prec: count is " + std::_int::to_str(i, 10u); log "prec: count is " + std::int::to_str(i, 10u);
} }
case (count_is_param(?i)) { case (count_is_param(?i)) {
log "prec: count is param " + std::_int::to_str(i, 10u); log "prec: count is param " + std::int::to_str(i, 10u);
} }
case (count_is_next_param) { case (count_is_next_param) {
log "prec: count is next param"; log "prec: count is next param";
@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr); tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr);
} }
case (piece_conv(?conv)) { case (piece_conv(?conv)) {
if (n >= _vec::len[@ast::expr](args)) { if (n >= vec::len[@ast::expr](args)) {
log_err "too many conversions in #fmt string"; log_err "too many conversions in #fmt string";
fail; fail;
} }

60
src/comp/front/lexer.rs
View file

@ -1,7 +1,7 @@
import std::io; import std::io;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::_int; import std::int;
import std::map; import std::map;
import std::map::hashmap; import std::map::hashmap;
import std::option; import std::option;
@ -54,13 +54,13 @@ fn new_reader(session sess, io::reader rdr,
} }
fn next() -> char { fn next() -> char {
if (pos < len) {ret _str::char_at(file, pos);} if (pos < len) {ret str::char_at(file, pos);}
else {ret -1 as char;} else {ret -1 as char;}
} }
fn init() { fn init() {
if (pos < len) { if (pos < len) {
auto next = _str::char_range_at(file, pos); auto next = str::char_range_at(file, pos);
pos = next._1; pos = next._1;
ch = next._0; ch = next._0;
} }
@ -72,7 +72,7 @@ fn new_reader(session sess, io::reader rdr,
if (ch == '\n') { if (ch == '\n') {
codemap::next_line(fm, chpos); codemap::next_line(fm, chpos);
} }
auto next = _str::char_range_at(file, pos); auto next = str::char_range_at(file, pos);
pos = next._1; pos = next._1;
ch = next._0; ch = next._0;
} else { } else {
@ -90,9 +90,9 @@ fn new_reader(session sess, io::reader rdr,
sess.span_err(rec(lo=chpos, hi=chpos), m); sess.span_err(rec(lo=chpos, hi=chpos), m);
} }
} }
auto file = _str::unsafe_from_bytes(rdr.read_whole_stream()); auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = []; let vec[str] strs = [];
auto rd = reader(sess, file, _str::byte_len(file), 0u, -1 as char, auto rd = reader(sess, file, str::byte_len(file), 0u, -1 as char,
filemap.start_pos, filemap.start_pos, filemap.start_pos, filemap.start_pos,
strs, filemap, itr); strs, filemap, itr);
rd.init(); rd.init();
@ -228,15 +228,15 @@ fn scan_exponent(reader rdr) -> option::t[str] {
auto res = ""; auto res = "";
if (c == 'e' || c == 'E') { if (c == 'e' || c == 'E') {
res += _str::from_bytes([c as u8]); res += str::from_bytes([c as u8]);
rdr.bump(); rdr.bump();
c = rdr.curr(); c = rdr.curr();
if (c == '-' || c == '+') { if (c == '-' || c == '+') {
res += _str::from_bytes([c as u8]); res += str::from_bytes([c as u8]);
rdr.bump(); rdr.bump();
} }
auto exponent = scan_dec_digits(rdr); auto exponent = scan_dec_digits(rdr);
if (_str::byte_len(exponent) > 0u) { if (str::byte_len(exponent) > 0u) {
ret(some(res + exponent)); ret(some(res + exponent));
} }
else { else {
@ -256,7 +256,7 @@ fn scan_dec_digits(reader rdr) -> str {
while (is_dec_digit (c) || c == '_') { while (is_dec_digit (c) || c == '_') {
if (c != '_') { if (c != '_') {
res += _str::from_bytes([c as u8]); res += str::from_bytes([c as u8]);
} }
rdr.bump(); rdr.bump();
c = rdr.curr(); c = rdr.curr();
@ -458,12 +458,12 @@ fn next_token(reader rdr) -> token::token {
if (is_alpha(c) || c == '_') { if (is_alpha(c) || c == '_') {
while (is_alnum(c) || c == '_') { while (is_alnum(c) || c == '_') {
_str::push_char(accum_str, c); str::push_char(accum_str, c);
rdr.bump(); rdr.bump();
c = rdr.curr(); c = rdr.curr();
} }
if (_str::eq(accum_str, "_")) { if (str::eq(accum_str, "_")) {
ret token::UNDERSCORE; ret token::UNDERSCORE;
} }
@ -621,37 +621,37 @@ fn next_token(reader rdr) -> token::token {
alt (rdr.next()) { alt (rdr.next()) {
case ('n') { case ('n') {
rdr.bump(); rdr.bump();
_str::push_byte(accum_str, '\n' as u8); str::push_byte(accum_str, '\n' as u8);
} }
case ('r') { case ('r') {
rdr.bump(); rdr.bump();
_str::push_byte(accum_str, '\r' as u8); str::push_byte(accum_str, '\r' as u8);
} }
case ('t') { case ('t') {
rdr.bump(); rdr.bump();
_str::push_byte(accum_str, '\t' as u8); str::push_byte(accum_str, '\t' as u8);
} }
case ('\\') { case ('\\') {
rdr.bump(); rdr.bump();
_str::push_byte(accum_str, '\\' as u8); str::push_byte(accum_str, '\\' as u8);
} }
case ('"') { case ('"') {
rdr.bump(); rdr.bump();
_str::push_byte(accum_str, '"' as u8); str::push_byte(accum_str, '"' as u8);
} }
case ('x') { case ('x') {
_str::push_char(accum_str, str::push_char(accum_str,
scan_numeric_escape(rdr)); scan_numeric_escape(rdr));
} }
case ('u') { case ('u') {
_str::push_char(accum_str, str::push_char(accum_str,
scan_numeric_escape(rdr)); scan_numeric_escape(rdr));
} }
case ('U') { case ('U') {
_str::push_char(accum_str, str::push_char(accum_str,
scan_numeric_escape(rdr)); scan_numeric_escape(rdr));
} }
@ -663,7 +663,7 @@ fn next_token(reader rdr) -> token::token {
} }
} }
case (_) { case (_) {
_str::push_char(accum_str, rdr.curr()); str::push_char(accum_str, rdr.curr());
} }
} }
rdr.bump(); rdr.bump();
@ -754,7 +754,7 @@ fn read_line_comment(reader rdr) -> cmnt {
while (rdr.curr() == ' ') {rdr.bump();} while (rdr.curr() == ' ') {rdr.bump();}
auto val = ""; auto val = "";
while (rdr.curr() != '\n' && !rdr.is_eof()) { while (rdr.curr() != '\n' && !rdr.is_eof()) {
_str::push_char(val, rdr.curr()); str::push_char(val, rdr.curr());
rdr.bump(); rdr.bump();
} }
ret rec(val=cmnt_line(val), ret rec(val=cmnt_line(val),
@ -771,7 +771,7 @@ fn read_block_comment(reader rdr) -> cmnt {
auto level = 1; auto level = 1;
while (true) { while (true) {
if (rdr.curr() == '\n') { if (rdr.curr() == '\n') {
_vec::push[str](lines, val); vec::push[str](lines, val);
val = ""; val = "";
consume_whitespace(rdr); consume_whitespace(rdr);
} else { } else {
@ -779,13 +779,13 @@ fn read_block_comment(reader rdr) -> cmnt {
level -= 1; level -= 1;
if (level == 0) { if (level == 0) {
rdr.bump(); rdr.bump(); rdr.bump(); rdr.bump();
_vec::push[str](lines, val); vec::push[str](lines, val);
break; break;
} }
} else if (rdr.curr() == '/' && rdr.next() == '*') { } else if (rdr.curr() == '/' && rdr.next() == '*') {
level += 1; level += 1;
} }
_str::push_char(val, rdr.curr()); str::push_char(val, rdr.curr());
rdr.bump(); rdr.bump();
} }
if (rdr.is_eof()) { if (rdr.is_eof()) {
@ -800,16 +800,16 @@ fn read_block_comment(reader rdr) -> cmnt {
fn gather_comments(session sess, str path) -> vec[cmnt] { fn gather_comments(session sess, str path) -> vec[cmnt] {
auto srdr = io::file_reader(path); auto srdr = io::file_reader(path);
auto itr = @interner::mk_interner[str](_str::hash, _str::eq); auto itr = @interner::mk_interner[str](str::hash, str::eq);
auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr); auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
let vec[cmnt] comments = []; let vec[cmnt] comments = [];
while (!rdr.is_eof()) { while (!rdr.is_eof()) {
while (true) { while (true) {
consume_whitespace(rdr); consume_whitespace(rdr);
if (rdr.curr() == '/' && rdr.next() == '/') { if (rdr.curr() == '/' && rdr.next() == '/') {
_vec::push[cmnt](comments, read_line_comment(rdr)); vec::push[cmnt](comments, read_line_comment(rdr));
} else if (rdr.curr() == '/' && rdr.next() == '*') { } else if (rdr.curr() == '/' && rdr.next() == '*') {
_vec::push[cmnt](comments, read_block_comment(rdr)); vec::push[cmnt](comments, read_block_comment(rdr));
} else { break; } } else { break; }
} }
next_token(rdr); next_token(rdr);

62
src/comp/front/parser.rs
View file

@ -1,6 +1,6 @@
import std::io; import std::io;
import std::_vec; import std::vec;
import std::_str; import std::str;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
@ -156,13 +156,13 @@ fn new_parser(session::session sess,
} }
} }
auto ftype = SOURCE_FILE; auto ftype = SOURCE_FILE;
if (_str::ends_with(path, ".rc")) { if (str::ends_with(path, ".rc")) {
ftype = CRATE_FILE; ftype = CRATE_FILE;
} }
auto srdr = io::file_reader(path); auto srdr = io::file_reader(path);
auto filemap = codemap::new_filemap(path, pos); auto filemap = codemap::new_filemap(path, pos);
_vec::push[codemap::filemap](sess.get_codemap().files, filemap); vec::push[codemap::filemap](sess.get_codemap().files, filemap);
auto itr = @interner::mk_interner[str](_str::hash, _str::eq); auto itr = @interner::mk_interner[str](str::hash, str::eq);
auto rdr = lexer::new_reader(sess, srdr, filemap, itr); auto rdr = lexer::new_reader(sess, srdr, filemap, itr);
// Make sure npos points at first actual token: // Make sure npos points at first actual token:
lexer::consume_any_whitespace(rdr); lexer::consume_any_whitespace(rdr);
@ -278,14 +278,14 @@ fn parse_str_lit_or_env_ident(parser p) -> ast::ident {
fn is_word(&parser p, &str word) -> bool { fn is_word(&parser p, &str word) -> bool {
ret alt (p.peek()) { ret alt (p.peek()) {
case (token::IDENT(?sid, false)) { _str::eq(word, p.get_str(sid)) } case (token::IDENT(?sid, false)) { str::eq(word, p.get_str(sid)) }
case (_) { false } case (_) { false }
}; };
} }
fn eat_word(&parser p, &str word) -> bool { fn eat_word(&parser p, &str word) -> bool {
alt (p.peek()) { alt (p.peek()) {
case (token::IDENT(?sid, false)) { case (token::IDENT(?sid, false)) {
if (_str::eq(word, p.get_str(sid))) { if (str::eq(word, p.get_str(sid))) {
p.bump(); p.bump();
ret true; ret true;
} else { ret false; } } else { ret false; }
@ -433,7 +433,7 @@ fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
while (true) { while (true) {
auto constr = parse_ty_constr(p); auto constr = parse_ty_constr(p);
hi = constr.span.hi; hi = constr.span.hi;
_vec::push[@ast::constr](constrs, constr); vec::push[@ast::constr](constrs, constr);
if (p.peek() == token::COMMA) { if (p.peek() == token::COMMA) {
p.bump(); p.bump();
} else { } else {
@ -818,7 +818,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
if (eat_word(p, "with")) { if (eat_word(p, "with")) {
with_obj = some[ast::ident](parse_ident(p)); with_obj = some[ast::ident](parse_ident(p));
} else { } else {
_vec::push[@ast::method](meths, vec::push[@ast::method](meths,
parse_method(p)); parse_method(p));
} }
} }
@ -1004,16 +1004,16 @@ fn expand_syntax_ext(parser p, ast::span sp,
&ast::path path, vec[@ast::expr] args, &ast::path path, vec[@ast::expr] args,
option::t[str] body) -> ast::expr_ { option::t[str] body) -> ast::expr_ {
assert (_vec::len[ast::ident](path.node.idents) > 0u); assert (vec::len[ast::ident](path.node.idents) > 0u);
auto extname = path.node.idents.(0); auto extname = path.node.idents.(0);
if (_str::eq(extname, "fmt")) { if (str::eq(extname, "fmt")) {
auto expanded = extfmt::expand_syntax_ext(p, args, body); auto expanded = extfmt::expand_syntax_ext(p, args, body);
auto newexpr = ast::expr_ext(path, args, body, auto newexpr = ast::expr_ext(path, args, body,
expanded, expanded,
p.get_ann()); p.get_ann());
ret newexpr; ret newexpr;
} else if (_str::eq(extname, "env")) { } else if (str::eq(extname, "env")) {
auto expanded = extenv::expand_syntax_ext(p, sp, args, body); auto expanded = extenv::expand_syntax_ext(p, sp, args, body);
auto newexpr = ast::expr_ext(path, args, body, auto newexpr = ast::expr_ext(path, args, body,
expanded, expanded,
@ -1833,7 +1833,7 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
if (eat_word(p, "drop")) { if (eat_word(p, "drop")) {
dtor = some[@ast::method](parse_dtor(p)); dtor = some[@ast::method](parse_dtor(p));
} else { } else {
_vec::push[@ast::method](meths, vec::push[@ast::method](meths,
parse_method(p)); parse_method(p));
} }
} }
@ -1953,12 +1953,12 @@ fn parse_item_native_mod(parser p) -> @ast::item {
auto abi = ast::native_abi_cdecl; auto abi = ast::native_abi_cdecl;
if (!is_word(p, "mod")) { if (!is_word(p, "mod")) {
auto t = parse_str_lit_or_env_ident(p); auto t = parse_str_lit_or_env_ident(p);
if (_str::eq(t, "cdecl")) { if (str::eq(t, "cdecl")) {
} else if (_str::eq(t, "rust")) { } else if (str::eq(t, "rust")) {
abi = ast::native_abi_rust; abi = ast::native_abi_rust;
} else if (_str::eq(t, "llvm")) { } else if (str::eq(t, "llvm")) {
abi = ast::native_abi_llvm; abi = ast::native_abi_llvm;
} else if (_str::eq(t, "rust-intrinsic")) { } else if (str::eq(t, "rust-intrinsic")) {
abi = ast::native_abi_rust_intrinsic; abi = ast::native_abi_rust_intrinsic;
} else { } else {
p.err("unsupported abi: " + t); p.err("unsupported abi: " + t);
@ -2079,16 +2079,16 @@ fn peeking_at_item(parser p) -> bool {
alt (p.peek()) { alt (p.peek()) {
case (token::IDENT(?sid, false)) { case (token::IDENT(?sid, false)) {
auto st = p.get_str(sid); auto st = p.get_str(sid);
ret _str::eq(st, "state") || ret str::eq(st, "state") ||
_str::eq(st, "gc") || str::eq(st, "gc") ||
_str::eq(st, "const") || str::eq(st, "const") ||
_str::eq(st, "fn") || str::eq(st, "fn") ||
_str::eq(st, "pred") || str::eq(st, "pred") ||
_str::eq(st, "iter") || str::eq(st, "iter") ||
_str::eq(st, "mod") || str::eq(st, "mod") ||
_str::eq(st, "type") || str::eq(st, "type") ||
_str::eq(st, "tag") || str::eq(st, "tag") ||
_str::eq(st, "obj"); str::eq(st, "obj");
} }
case (_) { ret false; } case (_) { ret false; }
} }
@ -2193,7 +2193,7 @@ fn parse_rest_import_name(parser p, ast::ident first,
defined_id = i; defined_id = i;
} }
case (_) { case (_) {
auto len = _vec::len[ast::ident](identifiers); auto len = vec::len[ast::ident](identifiers);
defined_id = identifiers.(len - 1u); defined_id = identifiers.(len - 1u);
} }
} }
@ -2262,8 +2262,8 @@ fn is_view_item(&parser p) -> bool {
alt (p.peek()) { alt (p.peek()) {
case (token::IDENT(?sid, false)) { case (token::IDENT(?sid, false)) {
auto st = p.get_str(sid); auto st = p.get_str(sid);
ret _str::eq(st, "use") || _str::eq(st, "import") || ret str::eq(st, "use") || str::eq(st, "import") ||
_str::eq(st, "export"); str::eq(st, "export");
} }
case (_) { ret false; } case (_) { ret false; }
} }
@ -2389,7 +2389,7 @@ fn parse_crate_directives(parser p, token::token term)
while (p.peek() != term) { while (p.peek() != term) {
auto cdir = @parse_crate_directive(p); auto cdir = @parse_crate_directive(p);
_vec::push[@ast::crate_directive](cdirs, cdir); vec::push[@ast::crate_directive](cdirs, cdir);
} }
ret cdirs; ret cdirs;

18
src/comp/front/token.rs
View file

@ -2,9 +2,9 @@ import util::common::ty_mach;
import util::common::ty_mach_to_str; import util::common::ty_mach_to_str;
import util::common::new_str_hash; import util::common::new_str_hash;
import util::interner; import util::interner;
import std::_int; import std::int;
import std::_uint; import std::uint;
import std::_str; import std::str;
type str_num = uint; type str_num = uint;
@ -133,10 +133,10 @@ fn to_str(lexer::reader r, token t) -> str {
case (POUND) { ret "#"; } case (POUND) { ret "#"; }
/* Literals */ /* Literals */
case (LIT_INT(?i)) { ret _int::to_str(i, 10u); } case (LIT_INT(?i)) { ret int::to_str(i, 10u); }
case (LIT_UINT(?u)) { ret _uint::to_str(u, 10u); } case (LIT_UINT(?u)) { ret uint::to_str(u, 10u); }
case (LIT_MACH_INT(?tm, ?i)) { case (LIT_MACH_INT(?tm, ?i)) {
ret _int::to_str(i, 10u) ret int::to_str(i, 10u)
+ "_" + ty_mach_to_str(tm); + "_" + ty_mach_to_str(tm);
} }
case (LIT_MACH_FLOAT(?tm, ?s)) { case (LIT_MACH_FLOAT(?tm, ?s)) {
@ -152,8 +152,8 @@ fn to_str(lexer::reader r, token t) -> str {
case (LIT_CHAR(?c)) { case (LIT_CHAR(?c)) {
// FIXME: escape. // FIXME: escape.
auto tmp = "'"; auto tmp = "'";
_str::push_char(tmp, c); str::push_char(tmp, c);
_str::push_byte(tmp, '\'' as u8); str::push_byte(tmp, '\'' as u8);
ret tmp; ret tmp;
} }
@ -163,7 +163,7 @@ fn to_str(lexer::reader r, token t) -> str {
/* Name components */ /* Name components */
case (IDENT(?s, _)) { ret interner::get[str](*r.get_interner(), s); } case (IDENT(?s, _)) { ret interner::get[str](*r.get_interner(), s); }
case (IDX(?i)) { ret "_" + _int::to_str(i, 10u); } case (IDX(?i)) { ret "_" + int::to_str(i, 10u); }
case (UNDERSCORE) { ret "_"; } case (UNDERSCORE) { ret "_"; }
case (BRACEQUOTE(_)) { ret "<bracequote>"; } case (BRACEQUOTE(_)) { ret "<bracequote>"; }

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

@ -1,7 +1,7 @@
import std::_vec; import std::vec;
import std::_str; import std::str;
import std::_str::rustrt::sbuf; import std::str::rustrt::sbuf;
import std::_vec::rustrt::vbuf; import std::vec::rustrt::vbuf;
import llvm::ModuleRef; import llvm::ModuleRef;
import llvm::ContextRef; import llvm::ContextRef;
@ -908,8 +908,8 @@ obj builder(BuilderRef B, @mutable bool terminated) {
assert (!*terminated); assert (!*terminated);
*terminated = true; *terminated = true;
ret llvm::LLVMBuildAggregateRet(B, ret llvm::LLVMBuildAggregateRet(B,
_vec::buf[ValueRef](RetVals), vec::buf[ValueRef](RetVals),
_vec::len[ValueRef](RetVals)); vec::len[ValueRef](RetVals));
} }
fn Br(BasicBlockRef Dest) -> ValueRef { fn Br(BasicBlockRef Dest) -> ValueRef {
@ -944,10 +944,10 @@ obj builder(BuilderRef B, @mutable bool terminated) {
assert (!*terminated); assert (!*terminated);
*terminated = true; *terminated = true;
ret llvm::LLVMBuildInvoke(B, Fn, ret llvm::LLVMBuildInvoke(B, Fn,
_vec::buf[ValueRef](Args), vec::buf[ValueRef](Args),
_vec::len[ValueRef](Args), vec::len[ValueRef](Args),
Then, Catch, Then, Catch,
_str::buf("")); str::buf(""));
} }
fn Unwind() -> ValueRef { fn Unwind() -> ValueRef {
@ -965,176 +965,176 @@ obj builder(BuilderRef B, @mutable bool terminated) {
/* Arithmetic */ /* Arithmetic */
fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildAdd(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildAdd(B, LHS, RHS, str::buf(""));
} }
fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNSWAdd(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNSWAdd(B, LHS, RHS, str::buf(""));
} }
fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNUWAdd(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNUWAdd(B, LHS, RHS, str::buf(""));
} }
fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFAdd(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFAdd(B, LHS, RHS, str::buf(""));
} }
fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSub(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildSub(B, LHS, RHS, str::buf(""));
} }
fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNSWSub(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNSWSub(B, LHS, RHS, str::buf(""));
} }
fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNUWSub(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNUWSub(B, LHS, RHS, str::buf(""));
} }
fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef { fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFSub(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFSub(B, LHS, RHS, str::buf(""));
} }
fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildMul(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildMul(B, LHS, RHS, str::buf(""));
} }
fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNSWMul(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNSWMul(B, LHS, RHS, str::buf(""));
} }
fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef { fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNUWMul(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildNUWMul(B, LHS, RHS, str::buf(""));
} }
fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef { fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFMul(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFMul(B, LHS, RHS, str::buf(""));
} }
fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildUDiv(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildUDiv(B, LHS, RHS, str::buf(""));
} }
fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSDiv(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildSDiv(B, LHS, RHS, str::buf(""));
} }
fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildExactSDiv(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildExactSDiv(B, LHS, RHS, str::buf(""));
} }
fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFDiv(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFDiv(B, LHS, RHS, str::buf(""));
} }
fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef { fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildURem(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildURem(B, LHS, RHS, str::buf(""));
} }
fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef { fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSRem(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildSRem(B, LHS, RHS, str::buf(""));
} }
fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef { fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFRem(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFRem(B, LHS, RHS, str::buf(""));
} }
fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildShl(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildShl(B, LHS, RHS, str::buf(""));
} }
fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef { fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildLShr(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildLShr(B, LHS, RHS, str::buf(""));
} }
fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef { fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildAShr(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildAShr(B, LHS, RHS, str::buf(""));
} }
fn And(ValueRef LHS, ValueRef RHS) -> ValueRef { fn And(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildAnd(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildAnd(B, LHS, RHS, str::buf(""));
} }
fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildOr(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildOr(B, LHS, RHS, str::buf(""));
} }
fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef { fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildXor(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildXor(B, LHS, RHS, str::buf(""));
} }
fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef { fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildBinOp(B, Op, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildBinOp(B, Op, LHS, RHS, str::buf(""));
} }
fn Neg(ValueRef V) -> ValueRef { fn Neg(ValueRef V) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNeg(B, V, _str::buf("")); ret llvm::LLVMBuildNeg(B, V, str::buf(""));
} }
fn NSWNeg(ValueRef V) -> ValueRef { fn NSWNeg(ValueRef V) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNSWNeg(B, V, _str::buf("")); ret llvm::LLVMBuildNSWNeg(B, V, str::buf(""));
} }
fn NUWNeg(ValueRef V) -> ValueRef { fn NUWNeg(ValueRef V) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNUWNeg(B, V, _str::buf("")); ret llvm::LLVMBuildNUWNeg(B, V, str::buf(""));
} }
fn FNeg(ValueRef V) -> ValueRef { fn FNeg(ValueRef V) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFNeg(B, V, _str::buf("")); ret llvm::LLVMBuildFNeg(B, V, str::buf(""));
} }
fn Not(ValueRef V) -> ValueRef { fn Not(ValueRef V) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildNot(B, V, _str::buf("")); ret llvm::LLVMBuildNot(B, V, str::buf(""));
} }
/* Memory */ /* Memory */
fn Malloc(TypeRef Ty) -> ValueRef { fn Malloc(TypeRef Ty) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildMalloc(B, Ty, _str::buf("")); ret llvm::LLVMBuildMalloc(B, Ty, str::buf(""));
} }
fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef { fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildArrayMalloc(B, Ty, Val, _str::buf("")); ret llvm::LLVMBuildArrayMalloc(B, Ty, Val, str::buf(""));
} }
fn Alloca(TypeRef Ty) -> ValueRef { fn Alloca(TypeRef Ty) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildAlloca(B, Ty, _str::buf("")); ret llvm::LLVMBuildAlloca(B, Ty, str::buf(""));
} }
fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef { fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildArrayAlloca(B, Ty, Val, _str::buf("")); ret llvm::LLVMBuildArrayAlloca(B, Ty, Val, str::buf(""));
} }
fn Free(ValueRef PointerVal) -> ValueRef { fn Free(ValueRef PointerVal) -> ValueRef {
@ -1144,7 +1144,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
fn Load(ValueRef PointerVal) -> ValueRef { fn Load(ValueRef PointerVal) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildLoad(B, PointerVal, _str::buf("")); ret llvm::LLVMBuildLoad(B, PointerVal, str::buf(""));
} }
fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef { fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef {
@ -1155,140 +1155,140 @@ obj builder(BuilderRef B, @mutable bool terminated) {
fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildGEP(B, Pointer, ret llvm::LLVMBuildGEP(B, Pointer,
_vec::buf[ValueRef](Indices), vec::buf[ValueRef](Indices),
_vec::len[ValueRef](Indices), vec::len[ValueRef](Indices),
_str::buf("")); str::buf(""));
} }
fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildInBoundsGEP(B, Pointer, ret llvm::LLVMBuildInBoundsGEP(B, Pointer,
_vec::buf[ValueRef](Indices), vec::buf[ValueRef](Indices),
_vec::len[ValueRef](Indices), vec::len[ValueRef](Indices),
_str::buf("")); str::buf(""));
} }
fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef { fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildStructGEP(B, Pointer, Idx, _str::buf("")); ret llvm::LLVMBuildStructGEP(B, Pointer, Idx, str::buf(""));
} }
fn GlobalString(sbuf _Str) -> ValueRef { fn GlobalString(sbuf _Str) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildGlobalString(B, _Str, _str::buf("")); ret llvm::LLVMBuildGlobalString(B, _Str, str::buf(""));
} }
fn GlobalStringPtr(sbuf _Str) -> ValueRef { fn GlobalStringPtr(sbuf _Str) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildGlobalStringPtr(B, _Str, _str::buf("")); ret llvm::LLVMBuildGlobalStringPtr(B, _Str, str::buf(""));
} }
/* Casts */ /* Casts */
fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef { fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildTrunc(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildTrunc(B, Val, DestTy, str::buf(""));
} }
fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef { fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildZExt(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildZExt(B, Val, DestTy, str::buf(""));
} }
fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef { fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSExt(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildSExt(B, Val, DestTy, str::buf(""));
} }
fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef { fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFPToUI(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildFPToUI(B, Val, DestTy, str::buf(""));
} }
fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef { fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFPToSI(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildFPToSI(B, Val, DestTy, str::buf(""));
} }
fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef { fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildUIToFP(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildUIToFP(B, Val, DestTy, str::buf(""));
} }
fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef { fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSIToFP(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildSIToFP(B, Val, DestTy, str::buf(""));
} }
fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef { fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFPTrunc(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildFPTrunc(B, Val, DestTy, str::buf(""));
} }
fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef { fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFPExt(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildFPExt(B, Val, DestTy, str::buf(""));
} }
fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef { fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildPtrToInt(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildPtrToInt(B, Val, DestTy, str::buf(""));
} }
fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef { fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildIntToPtr(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildIntToPtr(B, Val, DestTy, str::buf(""));
} }
fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildBitCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildBitCast(B, Val, DestTy, str::buf(""));
} }
fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, str::buf(""));
} }
fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, str::buf(""));
} }
fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, str::buf(""));
} }
fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef { fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildCast(B, Op, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildCast(B, Op, Val, DestTy, str::buf(""));
} }
fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildPointerCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildPointerCast(B, Val, DestTy, str::buf(""));
} }
fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildIntCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildIntCast(B, Val, DestTy, str::buf(""));
} }
fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef { fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFPCast(B, Val, DestTy, _str::buf("")); ret llvm::LLVMBuildFPCast(B, Val, DestTy, str::buf(""));
} }
/* Comparisons */ /* Comparisons */
fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef { fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildICmp(B, Op, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildICmp(B, Op, LHS, RHS, str::buf(""));
} }
fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef { fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildFCmp(B, Op, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildFCmp(B, Op, LHS, RHS, str::buf(""));
} }
@ -1296,95 +1296,95 @@ obj builder(BuilderRef B, @mutable bool terminated) {
fn Phi(TypeRef Ty, vec[ValueRef] vals, fn Phi(TypeRef Ty, vec[ValueRef] vals,
vec[BasicBlockRef] bbs) -> ValueRef { vec[BasicBlockRef] bbs) -> ValueRef {
assert (!*terminated); assert (!*terminated);
auto phi = llvm::LLVMBuildPhi(B, Ty, _str::buf("")); auto phi = llvm::LLVMBuildPhi(B, Ty, str::buf(""));
assert (_vec::len[ValueRef](vals) == _vec::len[BasicBlockRef](bbs)); assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, llvm::LLVMAddIncoming(phi,
_vec::buf[ValueRef](vals), vec::buf[ValueRef](vals),
_vec::buf[BasicBlockRef](bbs), vec::buf[BasicBlockRef](bbs),
_vec::len[ValueRef](vals)); vec::len[ValueRef](vals));
ret phi; ret phi;
} }
fn AddIncomingToPhi(ValueRef phi, fn AddIncomingToPhi(ValueRef phi,
vec[ValueRef] vals, vec[ValueRef] vals,
vec[BasicBlockRef] bbs) { vec[BasicBlockRef] bbs) {
assert (_vec::len[ValueRef](vals) == _vec::len[BasicBlockRef](bbs)); assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
llvm::LLVMAddIncoming(phi, llvm::LLVMAddIncoming(phi,
_vec::buf[ValueRef](vals), vec::buf[ValueRef](vals),
_vec::buf[BasicBlockRef](bbs), vec::buf[BasicBlockRef](bbs),
_vec::len[ValueRef](vals)); vec::len[ValueRef](vals));
} }
fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildCall(B, Fn, ret llvm::LLVMBuildCall(B, Fn,
_vec::buf[ValueRef](Args), vec::buf[ValueRef](Args),
_vec::len[ValueRef](Args), vec::len[ValueRef](Args),
_str::buf("")); str::buf(""));
} }
fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
assert (!*terminated); assert (!*terminated);
auto v = llvm::LLVMBuildCall(B, Fn, auto v = llvm::LLVMBuildCall(B, Fn,
_vec::buf[ValueRef](Args), vec::buf[ValueRef](Args),
_vec::len[ValueRef](Args), vec::len[ValueRef](Args),
_str::buf("")); str::buf(""));
llvm::LLVMSetInstructionCallConv(v, LLVMFastCallConv); llvm::LLVMSetInstructionCallConv(v, LLVMFastCallConv);
ret v; ret v;
} }
fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef { fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildSelect(B, If, Then, Else, _str::buf("")); ret llvm::LLVMBuildSelect(B, If, Then, Else, str::buf(""));
} }
fn VAArg(ValueRef list, TypeRef Ty) -> ValueRef { fn VAArg(ValueRef list, TypeRef Ty) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildVAArg(B, list, Ty, _str::buf("")); ret llvm::LLVMBuildVAArg(B, list, Ty, str::buf(""));
} }
fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef { fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildExtractElement(B, VecVal, Index, _str::buf("")); ret llvm::LLVMBuildExtractElement(B, VecVal, Index, str::buf(""));
} }
fn InsertElement(ValueRef VecVal, ValueRef EltVal, fn InsertElement(ValueRef VecVal, ValueRef EltVal,
ValueRef Index) -> ValueRef { ValueRef Index) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index, ret llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index,
_str::buf("")); str::buf(""));
} }
fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef { fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, _str::buf("")); ret llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, str::buf(""));
} }
fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef { fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildExtractValue(B, AggVal, Index, _str::buf("")); ret llvm::LLVMBuildExtractValue(B, AggVal, Index, str::buf(""));
} }
fn InsertValue(ValueRef AggVal, ValueRef EltVal, fn InsertValue(ValueRef AggVal, ValueRef EltVal,
uint Index) -> ValueRef { uint Index) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index, ret llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index,
_str::buf("")); str::buf(""));
} }
fn IsNull(ValueRef Val) -> ValueRef { fn IsNull(ValueRef Val) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildIsNull(B, Val, _str::buf("")); ret llvm::LLVMBuildIsNull(B, Val, str::buf(""));
} }
fn IsNotNull(ValueRef Val) -> ValueRef { fn IsNotNull(ValueRef Val) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildIsNotNull(B, Val, _str::buf("")); ret llvm::LLVMBuildIsNotNull(B, Val, str::buf(""));
} }
fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef { fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef {
assert (!*terminated); assert (!*terminated);
ret llvm::LLVMBuildPtrDiff(B, LHS, RHS, _str::buf("")); ret llvm::LLVMBuildPtrDiff(B, LHS, RHS, str::buf(""));
} }
fn Trap() -> ValueRef { fn Trap() -> ValueRef {
@ -1393,13 +1393,13 @@ obj builder(BuilderRef B, @mutable bool terminated) {
let ValueRef FN = llvm::LLVMGetBasicBlockParent(BB); let ValueRef FN = llvm::LLVMGetBasicBlockParent(BB);
let ModuleRef M = llvm::LLVMGetGlobalParent(FN); let ModuleRef M = llvm::LLVMGetGlobalParent(FN);
let ValueRef T = llvm::LLVMGetNamedFunction(M, let ValueRef T = llvm::LLVMGetNamedFunction(M,
_str::buf("llvm.trap")); str::buf("llvm.trap"));
assert (T as int != 0); assert (T as int != 0);
let vec[ValueRef] Args = []; let vec[ValueRef] Args = [];
ret llvm::LLVMBuildCall(B, T, ret llvm::LLVMBuildCall(B, T,
_vec::buf[ValueRef](Args), vec::buf[ValueRef](Args),
_vec::len[ValueRef](Args), vec::len[ValueRef](Args),
_str::buf("")); str::buf(""));
} }
drop { drop {
@ -1520,8 +1520,8 @@ fn type_to_str_inner(type_names names,
let TypeRef out_ty = llvm::LLVMGetReturnType(ty); let TypeRef out_ty = llvm::LLVMGetReturnType(ty);
let uint n_args = llvm::LLVMCountParamTypes(ty); let uint n_args = llvm::LLVMCountParamTypes(ty);
let vec[TypeRef] args = let vec[TypeRef] args =
_vec::init_elt[TypeRef](0 as TypeRef, n_args); vec::init_elt[TypeRef](0 as TypeRef, n_args);
llvm::LLVMGetParamTypes(ty, _vec::buf[TypeRef](args)); llvm::LLVMGetParamTypes(ty, vec::buf[TypeRef](args));
s += tys_str(names, outer, args); s += tys_str(names, outer, args);
s += ") -> "; s += ") -> ";
s += type_to_str_inner(names, outer, out_ty); s += type_to_str_inner(names, outer, out_ty);
@ -1532,8 +1532,8 @@ fn type_to_str_inner(type_names names,
let str s = "{"; let str s = "{";
let uint n_elts = llvm::LLVMCountStructElementTypes(ty); let uint n_elts = llvm::LLVMCountStructElementTypes(ty);
let vec[TypeRef] elts = let vec[TypeRef] elts =
_vec::init_elt[TypeRef](0 as TypeRef, n_elts); vec::init_elt[TypeRef](0 as TypeRef, n_elts);
llvm::LLVMGetStructElementTypes(ty, _vec::buf[TypeRef](elts)); llvm::LLVMGetStructElementTypes(ty, vec::buf[TypeRef](elts));
s += tys_str(names, outer, elts); s += tys_str(names, outer, elts);
s += "}"; s += "}";
ret s; ret s;
@ -1546,7 +1546,7 @@ fn type_to_str_inner(type_names names,
for (TypeRef tout in outer0) { for (TypeRef tout in outer0) {
i += 1u; i += 1u;
if (tout as int == ty as int) { if (tout as int == ty as int) {
let uint n = _vec::len[TypeRef](outer0) - i; let uint n = vec::len[TypeRef](outer0) - i;
ret "*\\" + util::common::istr(n as int); ret "*\\" + util::common::istr(n as int);
} }
} }
@ -1573,7 +1573,7 @@ obj target_data_dtor(TargetDataRef TD) {
type target_data = rec(TargetDataRef lltd, target_data_dtor dtor); type target_data = rec(TargetDataRef lltd, target_data_dtor dtor);
fn mk_target_data(str string_rep) -> target_data { fn mk_target_data(str string_rep) -> target_data {
auto lltd = llvm::LLVMCreateTargetData(_str::buf(string_rep)); auto lltd = llvm::LLVMCreateTargetData(str::buf(string_rep));
ret rec(lltd=lltd, dtor=target_data_dtor(lltd)); ret rec(lltd=lltd, dtor=target_data_dtor(lltd));
} }

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

@ -33,8 +33,8 @@ import front::ast::ann;
import front::ast::mt; import front::ast::mt;
import front::ast::purity; import front::ast::purity;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
type ast_fold[ENV] = type ast_fold[ENV] =
@rec @rec
@ -362,7 +362,7 @@ type ast_fold[ENV] =
fn fold_path[ENV](&ENV env, &ast_fold[ENV] fld, &path p) -> path { fn fold_path[ENV](&ENV env, &ast_fold[ENV] fld, &path p) -> path {
let vec[@ast::ty] tys_ = []; let vec[@ast::ty] tys_ = [];
for (@ast::ty t in p.node.types) { for (@ast::ty t in p.node.types) {
_vec::push[@ast::ty](tys_, fold_ty(env, fld, t)); vec::push[@ast::ty](tys_, fold_ty(env, fld, t));
} }
let ast::path_ p_ = rec(idents=p.node.idents, types=tys_); let ast::path_ p_ = rec(idents=p.node.idents, types=tys_);
ret fld.fold_path(env, p.span, p_); ret fld.fold_path(env, p.span, p_);
@ -404,7 +404,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
let vec[mt] elts_ = []; let vec[mt] elts_ = [];
for (mt elt in elts) { for (mt elt in elts) {
auto ty_ = fold_ty(env, fld, elt.ty); auto ty_ = fold_ty(env, fld, elt.ty);
_vec::push[mt](elts_, rec(ty=ty_, mut=elt.mut)); vec::push[mt](elts_, rec(ty=ty_, mut=elt.mut));
} }
ret fld.fold_ty_tup(env_, t.span, elts_); ret fld.fold_ty_tup(env_, t.span, elts_);
} }
@ -413,7 +413,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
let vec[ast::ty_field] flds_ = []; let vec[ast::ty_field] flds_ = [];
for (ast::ty_field f in flds) { for (ast::ty_field f in flds) {
auto ty_ = fold_ty(env, fld, f.mt.ty); auto ty_ = fold_ty(env, fld, f.mt.ty);
_vec::push[ast::ty_field] vec::push[ast::ty_field]
(flds_, rec(mt=rec(ty=ty_, mut=f.mt.mut) with f)); (flds_, rec(mt=rec(ty=ty_, mut=f.mt.mut) with f));
} }
ret fld.fold_ty_rec(env_, t.span, flds_); ret fld.fold_ty_rec(env_, t.span, flds_);
@ -426,7 +426,7 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
m.inputs, m.output); m.inputs, m.output);
alt (tfn.node) { alt (tfn.node) {
case (ast::ty_fn(?p, ?ins, ?out)) { case (ast::ty_fn(?p, ?ins, ?out)) {
_vec::push[ast::ty_method] vec::push[ast::ty_method]
(meths_, rec(proto=p, inputs=ins, (meths_, rec(proto=p, inputs=ins,
output=out with m)); output=out with m));
} }
@ -541,7 +541,7 @@ fn fold_exprs[ENV](&ENV env, &ast_fold[ENV] fld,
&vec[@expr] es) -> vec[@expr] { &vec[@expr] es) -> vec[@expr] {
let vec[@expr] exprs = []; let vec[@expr] exprs = [];
for (@expr e in es) { for (@expr e in es) {
_vec::push[@expr](exprs, fold_expr(env, fld, e)); vec::push[@expr](exprs, fold_expr(env, fld, e));
} }
ret exprs; ret exprs;
} }
@ -893,7 +893,7 @@ fn fold_block[ENV](&ENV env, &ast_fold[ENV] fld, &block blk) -> block {
let vec[@ast::stmt] stmts = []; let vec[@ast::stmt] stmts = [];
for (@ast::stmt s in blk.node.stmts) { for (@ast::stmt s in blk.node.stmts) {
auto new_stmt = fold_stmt[ENV](env_, fld, s); auto new_stmt = fold_stmt[ENV](env_, fld, s);
_vec::push[@ast::stmt](stmts, new_stmt); vec::push[@ast::stmt](stmts, new_stmt);
} }
auto expr = none[@ast::expr]; auto expr = none[@ast::expr];
@ -980,7 +980,7 @@ fn fold_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::_obj ob) -> ast::_obj {
m.node.ann), m.node.ann),
span=m.span); span=m.span);
let ENV _env = fld.update_env_for_item(env, i); let ENV _env = fld.update_env_for_item(env, i);
_vec::push[@ast::method](meths, fold_method(_env, fld, m)); vec::push[@ast::method](meths, fold_method(_env, fld, m));
} }
ret fld.fold_obj(env, fields, meths, dtor); ret fld.fold_obj(env, fields, meths, dtor);
} }
@ -1023,7 +1023,7 @@ fn fold_anon_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast::anon_obj ob)
m.node.ann), m.node.ann),
span=m.span); span=m.span);
let ENV _env = fld.update_env_for_item(env, i); let ENV _env = fld.update_env_for_item(env, i);
_vec::push[@ast::method](meths, fold_method(_env, fld, m)); vec::push[@ast::method](meths, fold_method(_env, fld, m));
} }
ret fld.fold_anon_obj(env, fields, meths, with_obj); ret fld.fold_anon_obj(env, fields, meths, with_obj);
} }
@ -1124,12 +1124,12 @@ fn fold_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast::_mod m) -> ast::_mod {
for (@view_item vi in m.view_items) { for (@view_item vi in m.view_items) {
auto new_vi = fold_view_item[ENV](e, fld, vi); auto new_vi = fold_view_item[ENV](e, fld, vi);
_vec::push[@view_item](view_items, new_vi); vec::push[@view_item](view_items, new_vi);
} }
for (@item i in m.items) { for (@item i in m.items) {
auto new_item = fold_item[ENV](e, fld, i); auto new_item = fold_item[ENV](e, fld, i);
_vec::push[@item](items, new_item); vec::push[@item](items, new_item);
} }
ret fld.fold_mod(e, rec(view_items=view_items, items=items)); ret fld.fold_mod(e, rec(view_items=view_items, items=items));
@ -1162,12 +1162,12 @@ fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld,
for (@view_item vi in m.view_items) { for (@view_item vi in m.view_items) {
auto new_vi = fold_view_item[ENV](e, fld, vi); auto new_vi = fold_view_item[ENV](e, fld, vi);
_vec::push[@view_item](view_items, new_vi); vec::push[@view_item](view_items, new_vi);
} }
for (@native_item i in m.items) { for (@native_item i in m.items) {
auto new_item = fold_native_item[ENV](e, fld, i); auto new_item = fold_native_item[ENV](e, fld, i);
_vec::push[@native_item](items, new_item); vec::push[@native_item](items, new_item);
} }
ret fld.fold_native_mod(e, rec(native_name=m.native_name, ret fld.fold_native_mod(e, rec(native_name=m.native_name,

38
src/comp/middle/metadata.rs
View file

@ -1,6 +1,6 @@
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
import std::map::hashmap; import std::map::hashmap;
import std::ebml; import std::ebml;
import std::io; import std::io;
@ -120,8 +120,8 @@ mod Encode {
if (abbrev_len < len) { if (abbrev_len < len) {
// I.e. it's actually an abbreviation. // I.e. it's actually an abbreviation.
auto s = ("#" auto s = ("#"
+ _uint::to_str(pos, 16u) + ":" + uint::to_str(pos, 16u) + ":"
+ _uint::to_str(len, 16u) + "#"); + uint::to_str(len, 16u) + "#");
auto a = rec(pos=pos, len=len, s=s); auto a = rec(pos=pos, len=len, s=s);
abbrevs.insert(t, a); abbrevs.insert(t, a);
} }
@ -265,7 +265,7 @@ mod Encode {
// Returns a Plain Old LLVM String: // Returns a Plain Old LLVM String:
fn C_postr(&str s) -> ValueRef { fn C_postr(&str s) -> ValueRef {
ret llvm::LLVMConstString(_str::buf(s), _str::byte_len(s), False); ret llvm::LLVMConstString(str::buf(s), str::byte_len(s), False);
} }
@ -273,13 +273,13 @@ fn C_postr(&str s) -> ValueRef {
fn encode_name(&ebml::writer ebml_w, &str name) { fn encode_name(&ebml::writer ebml_w, &str name) {
ebml::start_tag(ebml_w, tag_paths_data_name); ebml::start_tag(ebml_w, tag_paths_data_name);
ebml_w.writer.write(_str::bytes(name)); ebml_w.writer.write(str::bytes(name));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
fn encode_def_id(&ebml::writer ebml_w, &ast::def_id id) { fn encode_def_id(&ebml::writer ebml_w, &ast::def_id id) {
ebml::start_tag(ebml_w, tag_def_id); ebml::start_tag(ebml_w, tag_def_id);
ebml_w.writer.write(_str::bytes(def_to_str(id))); ebml_w.writer.write(str::bytes(def_to_str(id)));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
@ -301,7 +301,7 @@ fn add_to_index(&ebml::writer ebml_w,
&mutable vec[tup(str, uint)] index, &mutable vec[tup(str, uint)] index,
&str name) { &str name) {
auto full_path = path + [name]; auto full_path = path + [name];
index += [tup(_str::connect(full_path, "::"), ebml_w.writer.tell())]; index += [tup(str::connect(full_path, "::"), ebml_w.writer.tell())];
} }
fn encode_native_module_item_paths(&ebml::writer ebml_w, fn encode_native_module_item_paths(&ebml::writer ebml_w,
@ -424,13 +424,13 @@ fn def_to_str(&ast::def_id did) -> str {
fn encode_type_param_count(&ebml::writer ebml_w, &vec[ast::ty_param] tps) { fn encode_type_param_count(&ebml::writer ebml_w, &vec[ast::ty_param] tps) {
ebml::start_tag(ebml_w, tag_items_data_item_ty_param_count); ebml::start_tag(ebml_w, tag_items_data_item_ty_param_count);
ebml::write_vint(ebml_w.writer, _vec::len[ast::ty_param](tps)); ebml::write_vint(ebml_w.writer, vec::len[ast::ty_param](tps));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
fn encode_variant_id(&ebml::writer ebml_w, &ast::def_id vid) { fn encode_variant_id(&ebml::writer ebml_w, &ast::def_id vid) {
ebml::start_tag(ebml_w, tag_items_data_item_variant); ebml::start_tag(ebml_w, tag_items_data_item_variant);
ebml_w.writer.write(_str::bytes(def_to_str(vid))); ebml_w.writer.write(str::bytes(def_to_str(vid)));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
@ -447,20 +447,20 @@ fn encode_type(&@trans::crate_ctxt cx, &ebml::writer ebml_w, &ty::t typ) {
fn encode_symbol(&@trans::crate_ctxt cx, &ebml::writer ebml_w, fn encode_symbol(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
&ast::def_id did) { &ast::def_id did) {
ebml::start_tag(ebml_w, tag_items_data_item_symbol); ebml::start_tag(ebml_w, tag_items_data_item_symbol);
ebml_w.writer.write(_str::bytes(cx.item_symbols.get(did))); ebml_w.writer.write(str::bytes(cx.item_symbols.get(did)));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
fn encode_discriminant(&@trans::crate_ctxt cx, &ebml::writer ebml_w, fn encode_discriminant(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
&ast::def_id did) { &ast::def_id did) {
ebml::start_tag(ebml_w, tag_items_data_item_symbol); ebml::start_tag(ebml_w, tag_items_data_item_symbol);
ebml_w.writer.write(_str::bytes(cx.discrim_symbols.get(did))); ebml_w.writer.write(str::bytes(cx.discrim_symbols.get(did)));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
fn encode_tag_id(&ebml::writer ebml_w, &ast::def_id id) { fn encode_tag_id(&ebml::writer ebml_w, &ast::def_id id) {
ebml::start_tag(ebml_w, tag_items_data_item_tag_id); ebml::start_tag(ebml_w, tag_items_data_item_tag_id);
ebml_w.writer.write(_str::bytes(def_to_str(id))); ebml_w.writer.write(str::bytes(def_to_str(id)));
ebml::end_tag(ebml_w); ebml::end_tag(ebml_w);
} }
@ -478,7 +478,7 @@ fn encode_tag_variant_info(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
encode_kind(ebml_w, 'v' as u8); encode_kind(ebml_w, 'v' as u8);
encode_tag_id(ebml_w, did); encode_tag_id(ebml_w, did);
encode_type(cx, ebml_w, trans::node_ann_type(cx, variant.node.ann)); encode_type(cx, ebml_w, trans::node_ann_type(cx, variant.node.ann));
if (_vec::len[ast::variant_arg](variant.node.args) > 0u) { if (vec::len[ast::variant_arg](variant.node.args) > 0u) {
encode_symbol(cx, ebml_w, variant.node.id); encode_symbol(cx, ebml_w, variant.node.id);
} }
encode_discriminant(cx, ebml_w, variant.node.id); encode_discriminant(cx, ebml_w, variant.node.id);
@ -611,7 +611,7 @@ fn hash_def_num(&int def_num) -> uint {
fn hash_path(&str s) -> uint { fn hash_path(&str s) -> uint {
auto h = 5381u; auto h = 5381u;
for (u8 ch in _str::bytes(s)) { for (u8 ch in str::bytes(s)) {
h = ((h << 5u) + h) ^ (ch as uint); h = ((h << 5u) + h) ^ (ch as uint);
} }
ret h; ret h;
@ -620,7 +620,7 @@ fn hash_path(&str s) -> uint {
fn create_index[T](&vec[tup(T, uint)] index, fn(&T) -> uint hash_fn) fn create_index[T](&vec[tup(T, uint)] index, fn(&T) -> uint hash_fn)
-> vec[vec[tup(T, uint)]] { -> vec[vec[tup(T, uint)]] {
let vec[vec[tup(T, uint)]] buckets = []; let vec[vec[tup(T, uint)]] buckets = [];
for each (uint i in _uint::range(0u, 256u)) { for each (uint i in uint::range(0u, 256u)) {
let vec[tup(T, uint)] bucket = []; let vec[tup(T, uint)] bucket = [];
buckets += [bucket]; buckets += [bucket];
} }
@ -712,9 +712,9 @@ fn write_metadata(&@trans::crate_ctxt cx, &@ast::crate crate) {
auto llconst = trans::C_struct([llmeta]); auto llconst = trans::C_struct([llmeta]);
auto llglobal = llvm::LLVMAddGlobal(cx.llmod, trans::val_ty(llconst), auto llglobal = llvm::LLVMAddGlobal(cx.llmod, trans::val_ty(llconst),
_str::buf("rust_metadata")); str::buf("rust_metadata"));
llvm::LLVMSetInitializer(llglobal, llconst); llvm::LLVMSetInitializer(llglobal, llconst);
llvm::LLVMSetSection(llglobal, _str::buf(x86::get_meta_sect_name())); llvm::LLVMSetSection(llglobal, str::buf(x86::get_meta_sect_name()));
} }
// //

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

@ -18,8 +18,8 @@ import std::list::cons;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import std::_str; import std::str;
import std::_vec; import std::vec;
// Resolving happens in two passes. The first pass collects defids of all // Resolving happens in two passes. The first pass collects defids of all
// (internal) imports and modules, so that they can be looked up when needed, // (internal) imports and modules, so that they can be looked up when needed,
@ -52,7 +52,7 @@ tag import_state {
type ext_hash = hashmap[tup(def_id,str,namespace),def]; type ext_hash = hashmap[tup(def_id,str,namespace),def];
fn new_ext_hash() -> ext_hash { fn new_ext_hash() -> ext_hash {
fn hash(&tup(def_id,str,namespace) v) -> uint { fn hash(&tup(def_id,str,namespace) v) -> uint {
ret _str::hash(v._1) + util::common::hash_def(v._0) + (alt (v._2) { ret str::hash(v._1) + util::common::hash_def(v._0) + (alt (v._2) {
case (ns_value) { 1u } case (ns_value) { 1u }
case (ns_type) { 2u } case (ns_type) { 2u }
case (ns_module) { 3u } case (ns_module) { 3u }
@ -61,7 +61,7 @@ fn new_ext_hash() -> ext_hash {
fn eq(&tup(def_id,str,namespace) v1, fn eq(&tup(def_id,str,namespace) v1,
&tup(def_id,str,namespace) v2) -> bool { &tup(def_id,str,namespace) v2) -> bool {
ret util::common::def_eq(v1._0, v2._0) && ret util::common::def_eq(v1._0, v2._0) &&
_str::eq(v1._1, v2._1) && str::eq(v1._1, v2._1) &&
v1._2 == v2._2; v1._2 == v2._2;
} }
ret std::map::mk_hashmap[tup(def_id,str,namespace),def](hash, eq); ret std::map::mk_hashmap[tup(def_id,str,namespace),def](hash, eq);
@ -223,7 +223,7 @@ fn resolve_names(&@env e, &ast::crate c) {
} }
case (_) { case (_) {
e.sess.span_err(p.span, "not a tag variant: " + e.sess.span_err(p.span, "not a tag variant: " +
_str::connect(p.node.idents, "::")); str::connect(p.node.idents, "::"));
fail; fail;
} }
} }
@ -321,7 +321,7 @@ fn resolve_import(&env e, &@ast::view_item it, &list[scope] sc) {
} }
e.imports.insert(defid._1, resolving(it.span)); e.imports.insert(defid._1, resolving(it.span));
auto n_idents = _vec::len(ids); auto n_idents = vec::len(ids);
auto end_id = ids.(n_idents - 1u); auto end_id = ids.(n_idents - 1u);
if (n_idents == 1u) { if (n_idents == 1u) {
@ -377,7 +377,7 @@ fn unresolved(&env e, &span sp, &ident id, &str kind) {
fn lookup_path_strict(&env e, &list[scope] sc, &span sp, vec[ident] idents, fn lookup_path_strict(&env e, &list[scope] sc, &span sp, vec[ident] idents,
namespace ns) -> def { namespace ns) -> def {
auto n_idents = _vec::len(idents); auto n_idents = vec::len(idents);
auto headns = if (n_idents == 1u) { ns } else { ns_module }; auto headns = if (n_idents == 1u) { ns } else { ns_module };
auto dcur = lookup_in_scope_strict(e, sc, sp, idents.(0), headns); auto dcur = lookup_in_scope_strict(e, sc, sp, idents.(0), headns);
auto i = 1u; auto i = 1u;
@ -477,7 +477,7 @@ fn lookup_in_scope(&env e, list[scope] sc, &span sp, &ident id, namespace ns)
if (ns == ns_value) { if (ns == ns_value) {
alt (d.node) { alt (d.node) {
case (ast::decl_local(?local)) { case (ast::decl_local(?local)) {
if (_str::eq(local.ident, id)) { if (str::eq(local.ident, id)) {
ret some(ast::def_local(local.id)); ret some(ast::def_local(local.id));
} }
} }
@ -529,7 +529,7 @@ fn lookup_in_ty_params(&ident id, &vec[ast::ty_param] ty_params)
-> option::t[def] { -> option::t[def] {
auto i = 0u; auto i = 0u;
for (ast::ty_param tp in ty_params) { for (ast::ty_param tp in ty_params) {
if (_str::eq(tp, id)) { if (str::eq(tp, id)) {
ret some(ast::def_ty_arg(i)); ret some(ast::def_ty_arg(i));
} }
i += 1u; i += 1u;
@ -540,7 +540,7 @@ fn lookup_in_ty_params(&ident id, &vec[ast::ty_param] ty_params)
fn lookup_in_pat(&ident id, &ast::pat pat) -> option::t[def] { fn lookup_in_pat(&ident id, &ast::pat pat) -> option::t[def] {
alt (pat.node) { alt (pat.node) {
case (ast::pat_bind(?name, ?defid, _)) { case (ast::pat_bind(?name, ?defid, _)) {
if (_str::eq(name, id)) { ret some(ast::def_binding(defid)); } if (str::eq(name, id)) { ret some(ast::def_binding(defid)); }
} }
case (ast::pat_wild(_)) {} case (ast::pat_wild(_)) {}
case (ast::pat_lit(_, _)) {} case (ast::pat_lit(_, _)) {}
@ -560,7 +560,7 @@ fn lookup_in_fn(&ident id, &ast::fn_decl decl, &vec[ast::ty_param] ty_params,
alt (ns) { alt (ns) {
case (ns_value) { case (ns_value) {
for (ast::arg a in decl.inputs) { for (ast::arg a in decl.inputs) {
if (_str::eq(a.ident, id)) { if (str::eq(a.ident, id)) {
ret some(ast::def_arg(a.id)); ret some(ast::def_arg(a.id));
} }
} }
@ -578,7 +578,7 @@ fn lookup_in_obj(&ident id, &ast::_obj ob, &vec[ast::ty_param] ty_params,
alt (ns) { alt (ns) {
case (ns_value) { case (ns_value) {
for (ast::obj_field f in ob.fields) { for (ast::obj_field f in ob.fields) {
if (_str::eq(f.ident, id)) { if (str::eq(f.ident, id)) {
ret some(ast::def_obj_field(f.id)); ret some(ast::def_obj_field(f.id));
} }
} }
@ -598,7 +598,7 @@ fn lookup_in_block(&ident id, &ast::block_ b, namespace ns)
case (ast::stmt_decl(?d,_)) { case (ast::stmt_decl(?d,_)) {
alt (d.node) { alt (d.node) {
case (ast::decl_local(?loc)) { case (ast::decl_local(?loc)) {
if (ns == ns_value && _str::eq(id, loc.ident)) { if (ns == ns_value && str::eq(id, loc.ident)) {
ret some(ast::def_local(loc.id)); ret some(ast::def_local(loc.id));
} }
} }
@ -607,12 +607,12 @@ fn lookup_in_block(&ident id, &ast::block_ b, namespace ns)
case (ast::item_tag(?name, ?variants, _, case (ast::item_tag(?name, ?variants, _,
?defid, _)) { ?defid, _)) {
if (ns == ns_type) { if (ns == ns_type) {
if (_str::eq(name, id)) { if (str::eq(name, id)) {
ret some(ast::def_ty(defid)); ret some(ast::def_ty(defid));
} }
} else if (ns == ns_value) { } else if (ns == ns_value) {
for (ast::variant v in variants) { for (ast::variant v in variants) {
if (_str::eq(v.node.name, id)) { if (str::eq(v.node.name, id)) {
ret some(ast::def_variant( ret some(ast::def_variant(
defid, v.node.id)); defid, v.node.id));
} }
@ -620,7 +620,7 @@ fn lookup_in_block(&ident id, &ast::block_ b, namespace ns)
} }
} }
case (_) { case (_) {
if (_str::eq(ast::item_ident(it), id)) { if (str::eq(ast::item_ident(it), id)) {
auto found = found_def_item(it, ns); auto found = found_def_item(it, ns);
if (!option::is_none(found)) {ret found;} if (!option::is_none(found)) {ret found;}
} }

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

@ -1,9 +1,9 @@
import std::_int; import std::int;
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
import std::_str::rustrt::sbuf; import std::str::rustrt::sbuf;
import std::_vec::rustrt::vbuf; import std::vec::rustrt::vbuf;
import std::map; import std::map;
import std::map::hashmap; import std::map::hashmap;
import std::option; import std::option;
@ -197,7 +197,7 @@ fn extend_path(@local_ctxt cx, &str name) -> @local_ctxt {
} }
fn path_name(&vec[str] path) -> str { fn path_name(&vec[str] path) -> str {
ret _str::connect(path, sep()); ret str::connect(path, sep());
} }
@ -215,7 +215,7 @@ fn get_type_sha1(&@crate_ctxt ccx, &ty::t t) -> str {
abbrevs=metadata::ac_no_abbrevs); abbrevs=metadata::ac_no_abbrevs);
ccx.sha.input_str(metadata::Encode::ty_str(cx, t)); ccx.sha.input_str(metadata::Encode::ty_str(cx, t));
hash = _str::substr(ccx.sha.result_str(), 0u, 16u); hash = str::substr(ccx.sha.result_str(), 0u, 16u);
ccx.type_sha1s.insert(t, hash); ccx.type_sha1s.insert(t, hash);
} }
} }
@ -335,8 +335,8 @@ fn T_size_t() -> TypeRef {
fn T_fn(vec[TypeRef] inputs, TypeRef output) -> TypeRef { fn T_fn(vec[TypeRef] inputs, TypeRef output) -> TypeRef {
ret llvm::LLVMFunctionType(output, ret llvm::LLVMFunctionType(output,
_vec::buf[TypeRef](inputs), vec::buf[TypeRef](inputs),
_vec::len[TypeRef](inputs), vec::len[TypeRef](inputs),
False); False);
} }
@ -350,8 +350,8 @@ fn T_ptr(TypeRef t) -> TypeRef {
} }
fn T_struct(&vec[TypeRef] elts) -> TypeRef { fn T_struct(&vec[TypeRef] elts) -> TypeRef {
ret llvm::LLVMStructType(_vec::buf[TypeRef](elts), ret llvm::LLVMStructType(vec::buf[TypeRef](elts),
_vec::len[TypeRef](elts), vec::len[TypeRef](elts),
False); False);
} }
@ -381,9 +381,9 @@ fn T_task(&type_names tn) -> TypeRef {
fn T_tydesc_field(&type_names tn, int field) -> TypeRef { fn T_tydesc_field(&type_names tn, int field) -> TypeRef {
// Bit of a kludge: pick the fn typeref out of the tydesc.. // Bit of a kludge: pick the fn typeref out of the tydesc..
let vec[TypeRef] tydesc_elts = let vec[TypeRef] tydesc_elts =
_vec::init_elt[TypeRef](T_nil(), abi::n_tydesc_fields as uint); vec::init_elt[TypeRef](T_nil(), abi::n_tydesc_fields as uint);
llvm::LLVMGetStructElementTypes(T_tydesc(tn), llvm::LLVMGetStructElementTypes(T_tydesc(tn),
_vec::buf[TypeRef](tydesc_elts)); vec::buf[TypeRef](tydesc_elts));
auto t = llvm::LLVMGetElementType(tydesc_elts.(field)); auto t = llvm::LLVMGetElementType(tydesc_elts.(field));
ret t; ret t;
} }
@ -401,7 +401,7 @@ fn T_glue_fn(&type_names tn) -> TypeRef {
fn T_dtor(&@crate_ctxt ccx, TypeRef llself_ty) -> TypeRef { fn T_dtor(&@crate_ctxt ccx, TypeRef llself_ty) -> TypeRef {
ret type_of_fn_full(ccx, ast::proto_fn, some[TypeRef](llself_ty), ret type_of_fn_full(ccx, ast::proto_fn, some[TypeRef](llself_ty),
_vec::empty[ty::arg](), ty::mk_nil(ccx.tcx), 0u); vec::empty[ty::arg](), ty::mk_nil(ccx.tcx), 0u);
} }
fn T_cmp_glue_fn(&type_names tn) -> TypeRef { fn T_cmp_glue_fn(&type_names tn) -> TypeRef {
@ -565,7 +565,7 @@ fn T_opaque_closure_ptr(&type_names tn) -> TypeRef {
} }
fn T_tag(&type_names tn, uint size) -> TypeRef { fn T_tag(&type_names tn, uint size) -> TypeRef {
auto s = "tag_" + _uint::to_str(size, 10u); auto s = "tag_" + uint::to_str(size, 10u);
if (tn.name_has_type(s)) { if (tn.name_has_type(s)) {
ret tn.get_type(s); ret tn.get_type(s);
} }
@ -596,7 +596,7 @@ fn T_opaque_tag_ptr(&type_names tn) -> TypeRef {
} }
fn T_captured_tydescs(&type_names tn, uint n) -> TypeRef { fn T_captured_tydescs(&type_names tn, uint n) -> TypeRef {
ret T_struct(_vec::init_elt[TypeRef](T_ptr(T_tydesc(tn)), n)); ret T_struct(vec::init_elt[TypeRef](T_ptr(T_tydesc(tn)), n));
} }
fn T_obj_ptr(&type_names tn, uint n_captured_tydescs) -> TypeRef { fn T_obj_ptr(&type_names tn, uint n_captured_tydescs) -> TypeRef {
@ -857,7 +857,7 @@ fn type_of_inner(&@crate_ctxt cx, &ty::t t) -> TypeRef {
assert (llty as int != 0); assert (llty as int != 0);
if (cx.sess.get_opts().save_temps) { if (cx.sess.get_opts().save_temps) {
llvm::LLVMAddTypeName(cx.llmod, llvm::LLVMAddTypeName(cx.llmod,
_str::buf(ty::ty_to_short_str(cx.tcx, t)), str::buf(ty::ty_to_short_str(cx.tcx, t)),
llty); llty);
} }
cx.lltypes.insert(t, llty); cx.lltypes.insert(t, llty);
@ -919,7 +919,7 @@ fn sanitize(&str s) -> str {
c != (' ' as u8) && c != ('\t' as u8) && c != (' ' as u8) && c != ('\t' as u8) &&
c != (';' as u8)) { c != (';' as u8)) {
auto v = [c]; auto v = [c];
result += _str::from_bytes(v); result += str::from_bytes(v);
} }
} }
} }
@ -944,11 +944,11 @@ fn C_integral(TypeRef t, uint u, Bool sign_extend) -> ValueRef {
} }
fn C_float(&str s) -> ValueRef { fn C_float(&str s) -> ValueRef {
ret llvm::LLVMConstRealOfString(T_float(), _str::buf(s)); ret llvm::LLVMConstRealOfString(T_float(), str::buf(s));
} }
fn C_floating(&str s, TypeRef t) -> ValueRef { fn C_floating(&str s, TypeRef t) -> ValueRef {
ret llvm::LLVMConstRealOfString(t, _str::buf(s)); ret llvm::LLVMConstRealOfString(t, str::buf(s));
} }
fn C_nil() -> ValueRef { fn C_nil() -> ValueRef {
@ -975,9 +975,9 @@ fn C_u8(uint i) -> ValueRef {
// This is a 'c-like' raw string, which differs from // This is a 'c-like' raw string, which differs from
// our boxed-and-length-annotated strings. // our boxed-and-length-annotated strings.
fn C_cstr(&@crate_ctxt cx, &str s) -> ValueRef { fn C_cstr(&@crate_ctxt cx, &str s) -> ValueRef {
auto sc = llvm::LLVMConstString(_str::buf(s), _str::byte_len(s), False); auto sc = llvm::LLVMConstString(str::buf(s), str::byte_len(s), False);
auto g = llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), auto g = llvm::LLVMAddGlobal(cx.llmod, val_ty(sc),
_str::buf(cx.names.next("str"))); str::buf(cx.names.next("str")));
llvm::LLVMSetInitializer(g, sc); llvm::LLVMSetInitializer(g, sc);
llvm::LLVMSetGlobalConstant(g, True); llvm::LLVMSetGlobalConstant(g, True);
llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage
@ -987,15 +987,15 @@ fn C_cstr(&@crate_ctxt cx, &str s) -> ValueRef {
// A rust boxed-and-length-annotated string. // A rust boxed-and-length-annotated string.
fn C_str(&@crate_ctxt cx, &str s) -> ValueRef { fn C_str(&@crate_ctxt cx, &str s) -> ValueRef {
auto len = _str::byte_len(s); auto len = str::byte_len(s);
auto box = C_struct([C_int(abi::const_refcount as int), auto box = C_struct([C_int(abi::const_refcount as int),
C_int(len + 1u as int), // 'alloc' C_int(len + 1u as int), // 'alloc'
C_int(len + 1u as int), // 'fill' C_int(len + 1u as int), // 'fill'
C_int(0), // 'pad' C_int(0), // 'pad'
llvm::LLVMConstString(_str::buf(s), llvm::LLVMConstString(str::buf(s),
len, False)]); len, False)]);
auto g = llvm::LLVMAddGlobal(cx.llmod, val_ty(box), auto g = llvm::LLVMAddGlobal(cx.llmod, val_ty(box),
_str::buf(cx.names.next("str"))); str::buf(cx.names.next("str")));
llvm::LLVMSetInitializer(g, box); llvm::LLVMSetInitializer(g, box);
llvm::LLVMSetGlobalConstant(g, True); llvm::LLVMSetGlobalConstant(g, True);
llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage
@ -1010,24 +1010,24 @@ fn C_zero_byte_arr(uint size) -> ValueRef {
elts += [C_u8(0u)]; elts += [C_u8(0u)];
i += 1u; i += 1u;
} }
ret llvm::LLVMConstArray(T_i8(), _vec::buf[ValueRef](elts), ret llvm::LLVMConstArray(T_i8(), vec::buf[ValueRef](elts),
_vec::len[ValueRef](elts)); vec::len[ValueRef](elts));
} }
fn C_struct(&vec[ValueRef] elts) -> ValueRef { fn C_struct(&vec[ValueRef] elts) -> ValueRef {
ret llvm::LLVMConstStruct(_vec::buf[ValueRef](elts), ret llvm::LLVMConstStruct(vec::buf[ValueRef](elts),
_vec::len[ValueRef](elts), vec::len[ValueRef](elts),
False); False);
} }
fn C_array(TypeRef ty, &vec[ValueRef] elts) -> ValueRef { fn C_array(TypeRef ty, &vec[ValueRef] elts) -> ValueRef {
ret llvm::LLVMConstArray(ty, _vec::buf[ValueRef](elts), ret llvm::LLVMConstArray(ty, vec::buf[ValueRef](elts),
_vec::len[ValueRef](elts)); vec::len[ValueRef](elts));
} }
fn decl_fn(ModuleRef llmod, &str name, uint cc, TypeRef llty) -> ValueRef { fn decl_fn(ModuleRef llmod, &str name, uint cc, TypeRef llty) -> ValueRef {
let ValueRef llfn = let ValueRef llfn =
llvm::LLVMAddFunction(llmod, _str::buf(name), llty); llvm::LLVMAddFunction(llmod, str::buf(name), llty);
llvm::LLVMSetFunctionCallConv(llfn, cc); llvm::LLVMSetFunctionCallConv(llfn, cc);
ret llfn; ret llfn;
} }
@ -1075,7 +1075,7 @@ fn decl_native_glue(ModuleRef llmod, &type_names tn,
args += [T_int()]; // taskptr, will not be passed args += [T_int()]; // taskptr, will not be passed
} }
args += _vec::init_elt[TypeRef](T_int(), n as uint); args += vec::init_elt[TypeRef](T_int(), n as uint);
ret decl_fastcall_fn(llmod, s, T_fn(args, T_int())); ret decl_fastcall_fn(llmod, s, T_fn(args, T_int()));
} }
@ -1096,7 +1096,7 @@ fn get_extern_const(&hashmap[str, ValueRef] externs,
if (externs.contains_key(name)) { if (externs.contains_key(name)) {
ret externs.get(name); ret externs.get(name);
} }
auto c = llvm::LLVMAddGlobal(llmod, ty, _str::buf(name)); auto c = llvm::LLVMAddGlobal(llmod, ty, str::buf(name));
externs.insert(name, c); externs.insert(name, c);
ret c; ret c;
} }
@ -1104,7 +1104,7 @@ fn get_extern_const(&hashmap[str, ValueRef] externs,
fn get_simple_extern_fn(&hashmap[str, ValueRef] externs, fn get_simple_extern_fn(&hashmap[str, ValueRef] externs,
ModuleRef llmod, &str name, ModuleRef llmod, &str name,
int n_args) -> ValueRef { int n_args) -> ValueRef {
auto inputs = _vec::init_elt[TypeRef](T_int(), n_args as uint); auto inputs = vec::init_elt[TypeRef](T_int(), n_args as uint);
auto output = T_int(); auto output = T_int();
auto t = T_fn(inputs, output); auto t = T_fn(inputs, output);
ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t); ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t);
@ -1114,7 +1114,7 @@ fn trans_native_call(&builder b, @glue_fns glues, ValueRef lltaskptr,
&hashmap[str, ValueRef] externs, &hashmap[str, ValueRef] externs,
&type_names tn, ModuleRef llmod, &str name, &type_names tn, ModuleRef llmod, &str name,
bool pass_task, &vec[ValueRef] args) -> ValueRef { bool pass_task, &vec[ValueRef] args) -> ValueRef {
let int n = (_vec::len[ValueRef](args) as int); let int n = (vec::len[ValueRef](args) as int);
let ValueRef llnative = get_simple_extern_fn(externs, llmod, name, n); let ValueRef llnative = get_simple_extern_fn(externs, llmod, name, n);
llnative = llvm::LLVMConstPointerCast(llnative, T_int()); llnative = llvm::LLVMConstPointerCast(llnative, T_int());
@ -1445,7 +1445,7 @@ fn GEP_tup_like(&@block_ctxt cx, &ty::t t,
fn split_type(&@crate_ctxt ccx, &ty::t t, &vec[int] ixs, uint n) fn split_type(&@crate_ctxt ccx, &ty::t t, &vec[int] ixs, uint n)
-> rec(vec[ty::t] prefix, ty::t target) { -> rec(vec[ty::t] prefix, ty::t target) {
let uint len = _vec::len[int](ixs); let uint len = vec::len[int](ixs);
// We don't support 0-index or 1-index GEPs: The former is nonsense // 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 // and the latter would only be meaningful if we supported non-0
@ -1467,7 +1467,7 @@ fn GEP_tup_like(&@block_ctxt cx, &ty::t t,
let vec[ty::t] prefix = []; let vec[ty::t] prefix = [];
let int i = 0; let int i = 0;
while (i < ix) { while (i < ix) {
_vec::push[ty::t](prefix, vec::push[ty::t](prefix,
ty::get_element_type(ccx.tcx, t, i as uint)); ty::get_element_type(ccx.tcx, t, i as uint));
i += 1 ; i += 1 ;
} }
@ -1696,8 +1696,8 @@ fn get_derived_tydesc(&@block_ctxt cx, &ty::t t, bool escapes,
let uint n_params = ty::count_ty_params(bcx.fcx.lcx.ccx.tcx, t); let uint n_params = ty::count_ty_params(bcx.fcx.lcx.ccx.tcx, t);
auto tys = linearize_ty_params(bcx, t); auto tys = linearize_ty_params(bcx, t);
assert (n_params == _vec::len[uint](tys._0)); assert (n_params == vec::len[uint](tys._0));
assert (n_params == _vec::len[ValueRef](tys._1)); assert (n_params == vec::len[ValueRef](tys._1));
auto root_ti = get_static_tydesc(bcx, t, tys._0); auto root_ti = get_static_tydesc(bcx, t, tys._0);
static_ti = some[@tydesc_info](root_ti); static_ti = some[@tydesc_info](root_ti);
@ -1833,7 +1833,7 @@ fn declare_tydesc(&@local_ctxt cx, &ty::t t,
} }
auto gvar = llvm::LLVMAddGlobal(ccx.llmod, T_tydesc(ccx.tn), auto gvar = llvm::LLVMAddGlobal(ccx.llmod, T_tydesc(ccx.tn),
_str::buf(name)); str::buf(name));
auto info = @rec(ty = t, auto info = @rec(ty = t,
tydesc = gvar, tydesc = gvar,
@ -1892,23 +1892,23 @@ fn make_generic_glue(&@local_ctxt cx,
llty = T_ptr(type_of(cx.ccx, t)); llty = T_ptr(type_of(cx.ccx, t));
} }
auto ty_param_count = _vec::len[uint](ty_params); auto ty_param_count = vec::len[uint](ty_params);
auto lltyparams = llvm::LLVMGetParam(llfn, 3u); auto lltyparams = llvm::LLVMGetParam(llfn, 3u);
auto copy_args_bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); auto copy_args_bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
auto lltydescs = _vec::empty_mut[ValueRef](); auto lltydescs = vec::empty_mut[ValueRef]();
auto p = 0u; auto p = 0u;
while (p < ty_param_count) { while (p < ty_param_count) {
auto llparam = copy_args_bcx.build.GEP(lltyparams, auto llparam = copy_args_bcx.build.GEP(lltyparams,
[C_int(p as int)]); [C_int(p as int)]);
llparam = copy_args_bcx.build.Load(llparam); llparam = copy_args_bcx.build.Load(llparam);
_vec::grow_set[ValueRef](lltydescs, ty_params.(p), 0 as ValueRef, vec::grow_set[ValueRef](lltydescs, ty_params.(p), 0 as ValueRef,
llparam); llparam);
p += 1u; p += 1u;
} }
fcx.lltydescs = _vec::freeze[ValueRef](lltydescs); fcx.lltydescs = vec::freeze[ValueRef](lltydescs);
auto bcx = new_top_block_ctxt(fcx); auto bcx = new_top_block_ctxt(fcx);
auto lltop = bcx.llbb; auto lltop = bcx.llbb;
@ -2248,7 +2248,7 @@ fn decr_refcnt_and_if_zero(&@block_ctxt cx,
fn maybe_name_value(&@crate_ctxt cx, ValueRef v, &str s) { fn maybe_name_value(&@crate_ctxt cx, ValueRef v, &str s) {
if (cx.sess.get_opts().save_temps) { if (cx.sess.get_opts().save_temps) {
llvm::LLVMSetValueName(v, _str::buf(s)); llvm::LLVMSetValueName(v, str::buf(s));
} }
} }
@ -2527,7 +2527,7 @@ fn tag_variants(&@crate_ctxt cx, &ast::def_id id) -> vec[variant_info] {
for (ast::variant variant in variants) { for (ast::variant variant in variants) {
auto ctor_ty = node_ann_type(cx, variant.node.ann); auto ctor_ty = node_ann_type(cx, variant.node.ann);
let vec[ty::t] arg_tys = []; let vec[ty::t] arg_tys = [];
if (_vec::len[ast::variant_arg](variant.node.args) > 0u) { if (vec::len[ast::variant_arg](variant.node.args) > 0u) {
for (ty::arg a in ty::ty_fn_args(cx.tcx, ctor_ty)) { for (ty::arg a in ty::ty_fn_args(cx.tcx, ctor_ty)) {
arg_tys += [a.ty]; arg_tys += [a.ty];
} }
@ -2548,7 +2548,7 @@ fn tag_variant_with_id(&@crate_ctxt cx,
auto variants = tag_variants(cx, tag_id); auto variants = tag_variants(cx, tag_id);
auto i = 0u; auto i = 0u;
while (i < _vec::len[variant_info](variants)) { while (i < vec::len[variant_info](variants)) {
auto variant = variants.(i); auto variant = variants.(i);
if (common::def_eq(variant.id, variant_id)) { if (common::def_eq(variant.id, variant_id)) {
ret variant; ret variant;
@ -2644,7 +2644,7 @@ fn iter_structural_ty_full(&@block_ctxt cx,
} }
case (ty::ty_tag(?tid, ?tps)) { case (ty::ty_tag(?tid, ?tps)) {
auto variants = tag_variants(cx.fcx.lcx.ccx, tid); auto variants = tag_variants(cx.fcx.lcx.ccx, tid);
auto n_variants = _vec::len[variant_info](variants); auto n_variants = vec::len[variant_info](variants);
// Cast the tags to types we can GEP into. // Cast the tags to types we can GEP into.
auto lltagty = T_opaque_tag_ptr(cx.fcx.lcx.ccx.tn); auto lltagty = T_opaque_tag_ptr(cx.fcx.lcx.ccx.tn);
@ -2681,10 +2681,10 @@ fn iter_structural_ty_full(&@block_ctxt cx,
for (variant_info variant in variants) { for (variant_info variant in variants) {
auto variant_cx = new_sub_block_ctxt(bcx, auto variant_cx = new_sub_block_ctxt(bcx,
"tag-iter-variant-" + "tag-iter-variant-" +
_uint::to_str(i, 10u)); uint::to_str(i, 10u));
llvm::LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb); llvm::LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb);
if (_vec::len[ty::t](variant.args) > 0u) { if (vec::len[ty::t](variant.args) > 0u) {
// N-ary variant. // N-ary variant.
auto fn_ty = variant.ctor_ty; auto fn_ty = variant.ctor_ty;
alt (ty::struct(bcx.fcx.lcx.ccx.tcx, fn_ty)) { alt (ty::struct(bcx.fcx.lcx.ccx.tcx, fn_ty)) {
@ -3670,12 +3670,12 @@ fn join_results(&@block_ctxt parent_cx,
} }
} }
alt (_vec::len[result](live)) { alt (vec::len[result](live)) {
case (0u) { case (0u) {
// No incoming edges are live, so we're in dead-code-land. // No incoming edges are live, so we're in dead-code-land.
// Arbitrarily pick the first dead edge, since the caller // Arbitrarily pick the first dead edge, since the caller
// is just going to propagate it outward. // is just going to propagate it outward.
assert (_vec::len[result](ins) >= 1u); assert (vec::len[result](ins) >= 1u);
ret ins.(0); ret ins.(0);
} }
@ -3806,10 +3806,10 @@ fn collect_upvars(&@block_ctxt cx, &ast::block bloc,
case (ast::expr_path(?path, ?ann)) { case (ast::expr_path(?path, ?ann)) {
alt (e.def_map.get(ast::ann_tag(ann))) { alt (e.def_map.get(ast::ann_tag(ann))) {
case (ast::def_arg(?did)) { case (ast::def_arg(?did)) {
_vec::push[ast::def_id](e.refs, did); vec::push[ast::def_id](e.refs, did);
} }
case (ast::def_local(?did)) { case (ast::def_local(?did)) {
_vec::push[ast::def_id](e.refs, did); vec::push[ast::def_id](e.refs, did);
} }
case (_) {} case (_) {}
} }
@ -3892,7 +3892,7 @@ fn trans_for_each(&@block_ctxt cx,
} }
auto upvars = collect_upvars(cx, body, decl_id); auto upvars = collect_upvars(cx, body, decl_id);
auto upvar_count = _vec::len[ast::def_id](upvars); auto upvar_count = vec::len[ast::def_id](upvars);
auto llbindingsptr; auto llbindingsptr;
if (upvar_count > 0u) { if (upvar_count > 0u) {
@ -3931,7 +3931,7 @@ fn trans_for_each(&@block_ctxt cx,
} }
// Create an environment and populate it with the bindings. // Create an environment and populate it with the bindings.
auto tydesc_count = _vec::len[ValueRef](cx.fcx.lltydescs); auto tydesc_count = vec::len[ValueRef](cx.fcx.lltydescs);
auto llenvptrty = T_closure_ptr(lcx.ccx.tn, T_ptr(T_nil()), auto llenvptrty = T_closure_ptr(lcx.ccx.tn, T_ptr(T_nil()),
val_ty(llbindingsptr), tydesc_count); val_ty(llbindingsptr), tydesc_count);
auto llenvptr = alloca(cx, llvm::LLVMGetElementType(llenvptrty)); auto llenvptr = alloca(cx, llvm::LLVMGetElementType(llenvptrty));
@ -4149,7 +4149,7 @@ fn trans_pat_match(&@block_ctxt cx, &@ast::pat pat, ValueRef llval,
auto ty_params = ty::ann_to_type_params(cx.fcx.lcx.ccx.node_types, auto ty_params = ty::ann_to_type_params(cx.fcx.lcx.ccx.node_types,
ann); ann);
if (_vec::len[@ast::pat](subpats) > 0u) { if (vec::len[@ast::pat](subpats) > 0u) {
auto llblobptr = matched_cx.build.GEP(lltagptr, auto llblobptr = matched_cx.build.GEP(lltagptr,
[C_int(0), C_int(1)]); [C_int(0), C_int(1)]);
auto i = 0; auto i = 0;
@ -4201,7 +4201,7 @@ fn trans_pat_binding(&@block_ctxt cx, &@ast::pat pat,
} }
} }
case (ast::pat_tag(_, ?subpats, ?ann)) { case (ast::pat_tag(_, ?subpats, ?ann)) {
if (_vec::len[@ast::pat](subpats) == 0u) { ret res(cx, llval); } if (vec::len[@ast::pat](subpats) == 0u) { ret res(cx, llval); }
// Get the appropriate variant for this tag. // Get the appropriate variant for this tag.
auto vdef = ast::variant_def_ids auto vdef = ast::variant_def_ids
@ -4326,7 +4326,7 @@ fn lval_generic_fn(&@block_ctxt cx,
auto tys = ty::ann_to_type_params(cx.fcx.lcx.ccx.node_types, ann); auto tys = ty::ann_to_type_params(cx.fcx.lcx.ccx.node_types, ann);
auto monoty = ty::ann_to_type(cx.fcx.lcx.ccx.node_types, ann); auto monoty = ty::ann_to_type(cx.fcx.lcx.ccx.node_types, ann);
if (_vec::len[ty::t](tys) != 0u) { if (vec::len[ty::t](tys) != 0u) {
auto bcx = lv.res.bcx; auto bcx = lv.res.bcx;
let vec[ValueRef] tydescs = []; let vec[ValueRef] tydescs = [];
let vec[option::t[@tydesc_info]] tis = []; let vec[option::t[@tydesc_info]] tis = [];
@ -4336,7 +4336,7 @@ fn lval_generic_fn(&@block_ctxt cx,
auto td = get_tydesc(bcx, t, true, ti); auto td = get_tydesc(bcx, t, true, ti);
tis += [ti]; tis += [ti];
bcx = td.bcx; bcx = td.bcx;
_vec::push[ValueRef](tydescs, td.val); vec::push[ValueRef](tydescs, td.val);
} }
auto gen = rec( item_type = tpt._1, auto gen = rec( item_type = tpt._1,
static_tis = tis, static_tis = tis,
@ -4356,7 +4356,7 @@ fn lookup_discriminant(&@local_ctxt lcx, &ast::def_id tid, &ast::def_id vid)
assert (lcx.ccx.sess.get_targ_crate_num() != vid._0); assert (lcx.ccx.sess.get_targ_crate_num() != vid._0);
auto sym = creader::get_symbol(lcx.ccx.sess, vid); auto sym = creader::get_symbol(lcx.ccx.sess, vid);
auto gvar = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), auto gvar = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(),
_str::buf(sym)); str::buf(sym));
llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMExternalLinkage llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMExternalLinkage
as llvm::Linkage); as llvm::Linkage);
llvm::LLVMSetGlobalConstant(gvar, True); llvm::LLVMSetGlobalConstant(gvar, True);
@ -4818,7 +4818,7 @@ fn trans_bind(&@block_ctxt cx, &@ast::expr f,
case (none[@ast::expr]) { case (none[@ast::expr]) {
} }
case (some[@ast::expr](?e)) { case (some[@ast::expr](?e)) {
_vec::push[@ast::expr](bound, e); vec::push[@ast::expr](bound, e);
} }
} }
} }
@ -4838,9 +4838,9 @@ fn trans_bind(&@block_ctxt cx, &@ast::expr f,
lltydescs = ginfo.tydescs; lltydescs = ginfo.tydescs;
} }
} }
auto ty_param_count = _vec::len[ValueRef](lltydescs); auto ty_param_count = vec::len[ValueRef](lltydescs);
if (_vec::len[@ast::expr](bound) == 0u && ty_param_count == 0u) { if (vec::len[@ast::expr](bound) == 0u && ty_param_count == 0u) {
// Trivial 'binding': just return the static pair-ptr. // Trivial 'binding': just return the static pair-ptr.
ret f_res.res; ret f_res.res;
} else { } else {
@ -4856,8 +4856,8 @@ fn trans_bind(&@block_ctxt cx, &@ast::expr f,
auto arg = trans_expr(bcx, e); auto arg = trans_expr(bcx, e);
bcx = arg.bcx; bcx = arg.bcx;
_vec::push[ValueRef](bound_vals, arg.val); vec::push[ValueRef](bound_vals, arg.val);
_vec::push[ty::t](bound_tys, vec::push[ty::t](bound_tys,
ty::expr_ty(cx.fcx.lcx.ccx.tcx, ty::expr_ty(cx.fcx.lcx.ccx.tcx,
cx.fcx.lcx.ccx.node_types, e)); cx.fcx.lcx.ccx.node_types, e));
@ -4874,7 +4874,7 @@ fn trans_bind(&@block_ctxt cx, &@ast::expr f,
let ty::t tydesc_ty = ty::mk_type(cx.fcx.lcx.ccx.tcx); let ty::t tydesc_ty = ty::mk_type(cx.fcx.lcx.ccx.tcx);
let vec[ty::t] captured_tys = let vec[ty::t] captured_tys =
_vec::init_elt[ty::t](tydesc_ty, ty_param_count); vec::init_elt[ty::t](tydesc_ty, ty_param_count);
let vec[ty::t] closure_tys = let vec[ty::t] closure_tys =
[tydesc_ty, [tydesc_ty,
@ -5297,7 +5297,7 @@ fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args,
auto bcx = cx; auto bcx = cx;
auto unit_sz = size_of(bcx, unit_ty); auto unit_sz = size_of(bcx, unit_ty);
bcx = unit_sz.bcx; bcx = unit_sz.bcx;
auto data_sz = bcx.build.Mul(C_int(_vec::len[@ast::expr](args) as int), auto data_sz = bcx.build.Mul(C_int(vec::len[@ast::expr](args) as int),
unit_sz.val); unit_sz.val);
// FIXME: pass tydesc properly. // FIXME: pass tydesc properly.
@ -5315,8 +5315,8 @@ fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args,
auto pseudo_tup_ty = auto pseudo_tup_ty =
ty::mk_imm_tup(cx.fcx.lcx.ccx.tcx, ty::mk_imm_tup(cx.fcx.lcx.ccx.tcx,
_vec::init_elt[ty::t](unit_ty, vec::init_elt[ty::t](unit_ty,
_vec::len[@ast::expr](args))); vec::len[@ast::expr](args)));
let int i = 0; let int i = 0;
for (@ast::expr e in args) { for (@ast::expr e in args) {
@ -5393,7 +5393,7 @@ fn trans_rec(&@block_ctxt cx, &vec[ast::field] fields,
auto src_res = res(bcx, C_nil()); auto src_res = res(bcx, C_nil());
for (ast::field f in fields) { for (ast::field f in fields) {
if (_str::eq(f.ident, tf.ident)) { if (str::eq(f.ident, tf.ident)) {
expr_provided = true; expr_provided = true;
src_res = trans_expr(bcx, f.expr); src_res = trans_expr(bcx, f.expr);
} }
@ -5626,13 +5626,13 @@ fn load_if_immediate(&@block_ctxt cx, ValueRef v, &ty::t t) -> ValueRef {
fn trans_log(int lvl, &@block_ctxt cx, &@ast::expr e) -> result { fn trans_log(int lvl, &@block_ctxt cx, &@ast::expr e) -> result {
auto lcx = cx.fcx.lcx; auto lcx = cx.fcx.lcx;
auto modname = _str::connect(lcx.module_path, "::"); auto modname = str::connect(lcx.module_path, "::");
auto global; auto global;
if (lcx.ccx.module_data.contains_key(modname)) { if (lcx.ccx.module_data.contains_key(modname)) {
global = lcx.ccx.module_data.get(modname); global = lcx.ccx.module_data.get(modname);
} else { } else {
global = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), global = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(),
_str::buf("_rust_mod_log_" + modname)); str::buf("_rust_mod_log_" + modname));
llvm::LLVMSetGlobalConstant(global, False); llvm::LLVMSetGlobalConstant(global, False);
llvm::LLVMSetInitializer(global, C_null(T_int())); llvm::LLVMSetInitializer(global, C_null(T_int()));
llvm::LLVMSetLinkage(global, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(global, lib::llvm::LLVMInternalLinkage
@ -6067,9 +6067,9 @@ fn new_block_ctxt(&@fn_ctxt cx, &block_parent parent,
block_kind kind, block_kind kind,
&str name) -> @block_ctxt { &str name) -> @block_ctxt {
let vec[cleanup] cleanups = []; let vec[cleanup] cleanups = [];
auto s = _str::buf(""); auto s = str::buf("");
if (cx.lcx.ccx.sess.get_opts().save_temps) { if (cx.lcx.ccx.sess.get_opts().save_temps) {
s = _str::buf(cx.lcx.ccx.names.next(name)); s = str::buf(cx.lcx.ccx.names.next(name));
} }
let BasicBlockRef llbb = llvm::LLVMAppendBasicBlock(cx.llfn, s); let BasicBlockRef llbb = llvm::LLVMAppendBasicBlock(cx.llfn, s);
ret @rec(llbb=llbb, ret @rec(llbb=llbb,
@ -6114,10 +6114,10 @@ fn trans_block_cleanups(&@block_ctxt cx,
auto bcx = cx; auto bcx = cx;
if (cleanup_cx.kind == NON_SCOPE_BLOCK) { if (cleanup_cx.kind == NON_SCOPE_BLOCK) {
assert (_vec::len[cleanup](cleanup_cx.cleanups) == 0u); assert (vec::len[cleanup](cleanup_cx.cleanups) == 0u);
} }
auto i = _vec::len[cleanup](cleanup_cx.cleanups); auto i = vec::len[cleanup](cleanup_cx.cleanups);
while (i > 0u) { while (i > 0u) {
i -= 1u; i -= 1u;
auto c = cleanup_cx.cleanups.(i); auto c = cleanup_cx.cleanups.(i);
@ -6282,9 +6282,9 @@ fn new_local_ctxt(&@crate_ctxt ccx) -> @local_ctxt {
// tydescs. // tydescs.
fn mk_standard_basic_blocks(ValueRef llfn) -> fn mk_standard_basic_blocks(ValueRef llfn) ->
tup(BasicBlockRef, BasicBlockRef, BasicBlockRef) { tup(BasicBlockRef, BasicBlockRef, BasicBlockRef) {
ret tup(llvm::LLVMAppendBasicBlock(llfn, _str::buf("allocas")), ret tup(llvm::LLVMAppendBasicBlock(llfn, str::buf("allocas")),
llvm::LLVMAppendBasicBlock(llfn, _str::buf("copy_args")), llvm::LLVMAppendBasicBlock(llfn, str::buf("copy_args")),
llvm::LLVMAppendBasicBlock(llfn, _str::buf("derived_tydescs"))); llvm::LLVMAppendBasicBlock(llfn, str::buf("derived_tydescs")));
} }
// NB: must keep 4 fns in sync: // NB: must keep 4 fns in sync:
@ -6324,7 +6324,7 @@ fn new_fn_ctxt(@local_ctxt cx,
llobjfields=llobjfields, llobjfields=llobjfields,
lllocals=lllocals, lllocals=lllocals,
llupvars=llupvars, llupvars=llupvars,
mutable lltydescs=_vec::empty[ValueRef](), mutable lltydescs=vec::empty[ValueRef](),
derived_tydescs=derived_tydescs, derived_tydescs=derived_tydescs,
lcx=cx); lcx=cx);
} }
@ -6478,7 +6478,7 @@ fn populate_fn_ctxt_from_llself(@fn_ctxt fcx, self_vt llself) {
// its magic. // its magic.
auto fields_tup_ty = ty::mk_imm_tup(fcx.lcx.ccx.tcx, field_tys); auto fields_tup_ty = ty::mk_imm_tup(fcx.lcx.ccx.tcx, field_tys);
auto n_typarams = _vec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams); auto n_typarams = vec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams);
let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams); let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams);
auto box_cell = auto box_cell =
@ -6595,7 +6595,7 @@ fn trans_vtbl(@local_ctxt cx,
let vec[ValueRef] methods = [dtor]; let vec[ValueRef] methods = [dtor];
fn meth_lteq(&@ast::method a, &@ast::method b) -> bool { fn meth_lteq(&@ast::method a, &@ast::method b) -> bool {
ret _str::lteq(a.node.ident, b.node.ident); ret str::lteq(a.node.ident, b.node.ident);
} }
auto meths = std::sort::merge_sort[@ast::method](bind meth_lteq(_,_), auto meths = std::sort::merge_sort[@ast::method](bind meth_lteq(_,_),
@ -6609,7 +6609,7 @@ fn trans_vtbl(@local_ctxt cx,
llfnty = type_of_fn_full(cx.ccx, proto, llfnty = type_of_fn_full(cx.ccx, proto,
some[TypeRef](llself_ty), some[TypeRef](llself_ty),
inputs, output, inputs, output,
_vec::len[ast::ty_param](ty_params)); vec::len[ast::ty_param](ty_params));
} }
} }
@ -6628,7 +6628,7 @@ fn trans_vtbl(@local_ctxt cx,
auto vtbl = C_struct(methods); auto vtbl = C_struct(methods);
auto vtbl_name = mangle_name_by_seq(cx.ccx, cx.path, "vtbl"); auto vtbl_name = mangle_name_by_seq(cx.ccx, cx.path, "vtbl");
auto gvar = llvm::LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl), auto gvar = llvm::LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl),
_str::buf(vtbl_name)); str::buf(vtbl_name));
llvm::LLVMSetInitializer(gvar, vtbl); llvm::LLVMSetInitializer(gvar, vtbl);
llvm::LLVMSetGlobalConstant(gvar, True); llvm::LLVMSetGlobalConstant(gvar, True);
llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMInternalLinkage
@ -6696,22 +6696,22 @@ fn trans_obj(@local_ctxt cx, &ast::_obj ob, ast::def_id oid,
// FIXME we should probably also allocate a box for empty objs that have a // FIXME we should probably also allocate a box for empty objs that have a
// dtor, since otherwise they are never dropped, and the dtor never runs // dtor, since otherwise they are never dropped, and the dtor never runs
if (_vec::len[ast::ty_param](ty_params) == 0u && if (vec::len[ast::ty_param](ty_params) == 0u &&
_vec::len[ty::arg](arg_tys) == 0u) { vec::len[ty::arg](arg_tys) == 0u) {
// Store null into pair, if no args or typarams. // Store null into pair, if no args or typarams.
bcx.build.Store(C_null(llbox_ty), pair_box); bcx.build.Store(C_null(llbox_ty), pair_box);
} else { } else {
// Malloc a box for the body and copy args in. // Malloc a box for the body and copy args in.
let vec[ty::t] obj_fields = []; let vec[ty::t] obj_fields = [];
for (ty::arg a in arg_tys) { for (ty::arg a in arg_tys) {
_vec::push[ty::t](obj_fields, a.ty); vec::push[ty::t](obj_fields, a.ty);
} }
// Synthesize an obj body type. // Synthesize an obj body type.
auto tydesc_ty = ty::mk_type(ccx.tcx); auto tydesc_ty = ty::mk_type(ccx.tcx);
let vec[ty::t] tps = []; let vec[ty::t] tps = [];
for (ast::ty_param tp in ty_params) { for (ast::ty_param tp in ty_params) {
_vec::push[ty::t](tps, tydesc_ty); vec::push[ty::t](tps, tydesc_ty);
} }
let ty::t typarams_ty = ty::mk_imm_tup(ccx.tcx, tps); let ty::t typarams_ty = ty::mk_imm_tup(ccx.tcx, tps);
@ -6797,7 +6797,7 @@ fn trans_obj(@local_ctxt cx, &ast::_obj ob, ast::def_id oid,
fn trans_tag_variant(@local_ctxt cx, ast::def_id tag_id, fn trans_tag_variant(@local_ctxt cx, ast::def_id tag_id,
&ast::variant variant, int index, &ast::variant variant, int index,
&vec[ast::ty_param] ty_params) { &vec[ast::ty_param] ty_params) {
if (_vec::len[ast::variant_arg](variant.node.args) == 0u) { if (vec::len[ast::variant_arg](variant.node.args) == 0u) {
ret; // nullary constructors are just constants ret; // nullary constructors are just constants
} }
@ -6807,7 +6807,7 @@ fn trans_tag_variant(@local_ctxt cx, ast::def_id tag_id,
for (ast::variant_arg varg in variant.node.args) { for (ast::variant_arg varg in variant.node.args) {
fn_args += [rec(mode=ast::alias, fn_args += [rec(mode=ast::alias,
ty=varg.ty, ty=varg.ty,
ident="arg" + _uint::to_str(i, 10u), ident="arg" + uint::to_str(i, 10u),
id=varg.id)]; id=varg.id)];
} }
@ -6949,7 +6949,7 @@ fn get_pair_fn_ty(TypeRef llpairty) -> TypeRef {
// Bit of a kludge: pick the fn typeref out of the pair. // Bit of a kludge: pick the fn typeref out of the pair.
let vec[TypeRef] pair_tys = [T_nil(), T_nil()]; let vec[TypeRef] pair_tys = [T_nil(), T_nil()];
llvm::LLVMGetStructElementTypes(llpairty, llvm::LLVMGetStructElementTypes(llpairty,
_vec::buf[TypeRef](pair_tys)); vec::buf[TypeRef](pair_tys));
ret llvm::LLVMGetElementType(pair_tys.(0)); ret llvm::LLVMGetElementType(pair_tys.(0));
} }
@ -6965,7 +6965,7 @@ fn decl_fn_and_pair(&@crate_ctxt ccx,
alt (ty::struct(ccx.tcx, node_ann_type(ccx, ann))) { alt (ty::struct(ccx.tcx, node_ann_type(ccx, ann))) {
case (ty::ty_fn(?proto, ?inputs, ?output)) { case (ty::ty_fn(?proto, ?inputs, ?output)) {
llfty = type_of_fn(ccx, proto, inputs, output, llfty = type_of_fn(ccx, proto, inputs, output,
_vec::len[ast::ty_param](ty_params)); vec::len[ast::ty_param](ty_params));
llpairty = T_fn_pair(ccx.tn, llfty); llpairty = T_fn_pair(ccx.tn, llfty);
} }
case (_) { case (_) {
@ -6987,7 +6987,7 @@ fn decl_fn_and_pair(&@crate_ctxt ccx,
fn register_fn_pair(&@crate_ctxt cx, str ps, TypeRef llpairty, ValueRef llfn, fn register_fn_pair(&@crate_ctxt cx, str ps, TypeRef llpairty, ValueRef llfn,
ast::def_id id) { ast::def_id id) {
let ValueRef gvar = llvm::LLVMAddGlobal(cx.llmod, llpairty, let ValueRef gvar = llvm::LLVMAddGlobal(cx.llmod, llpairty,
_str::buf(ps)); str::buf(ps));
auto pair = C_struct([llfn, auto pair = C_struct([llfn,
C_null(T_opaque_closure_ptr(cx.tn))]); C_null(T_opaque_closure_ptr(cx.tn))]);
@ -7013,7 +7013,7 @@ fn native_fn_ty_param_count(&@crate_ctxt cx, &ast::def_id id) -> uint {
fail; fail;
} }
case (ast::native_item_fn(_, _, _, ?tps, _, _)) { case (ast::native_item_fn(_, _, _, ?tps, _, _)) {
count = _vec::len[ast::ty_param](tps); count = vec::len[ast::ty_param](tps);
} }
} }
ret count; ret count;
@ -7101,7 +7101,7 @@ fn decl_native_fn_and_pair(&@crate_ctxt ccx,
if (pass_task) { call_args += [lltaskptr]; } if (pass_task) { call_args += [lltaskptr]; }
auto arg_n = 3u; auto arg_n = 3u;
for each (uint i in _uint::range(0u, num_ty_param)) { for each (uint i in uint::range(0u, num_ty_param)) {
auto llarg = llvm::LLVMGetParam(fcx.llfn, arg_n); auto llarg = llvm::LLVMGetParam(fcx.llfn, arg_n);
fcx.lltydescs += [llarg]; fcx.lltydescs += [llarg];
assert (llarg as int != 0); assert (llarg as int != 0);
@ -7232,13 +7232,13 @@ fn new_walk_ctxt() -> @walk_ctxt {
fn enter_item(@walk_ctxt cx, &@ast::item item) { fn enter_item(@walk_ctxt cx, &@ast::item item) {
alt (item.node) { alt (item.node) {
case (ast::item_fn(?name, _, _, _, _)) { case (ast::item_fn(?name, _, _, _, _)) {
_vec::push[str](cx.path, name); vec::push[str](cx.path, name);
} }
case (ast::item_obj(?name, _, _, _, _)) { case (ast::item_obj(?name, _, _, _, _)) {
_vec::push[str](cx.path, name); vec::push[str](cx.path, name);
} }
case (ast::item_mod(?name, _, _)) { case (ast::item_mod(?name, _, _)) {
_vec::push[str](cx.path, name); vec::push[str](cx.path, name);
} }
case (_) { } case (_) { }
} }
@ -7247,13 +7247,13 @@ fn enter_item(@walk_ctxt cx, &@ast::item item) {
fn leave_item(@walk_ctxt cx, &@ast::item item) { fn leave_item(@walk_ctxt cx, &@ast::item item) {
alt (item.node) { alt (item.node) {
case (ast::item_fn(_, _, _, _, _)) { case (ast::item_fn(_, _, _, _, _)) {
_vec::pop[str](cx.path); vec::pop[str](cx.path);
} }
case (ast::item_obj(_, _, _, _, _)) { case (ast::item_obj(_, _, _, _, _)) {
_vec::pop[str](cx.path); vec::pop[str](cx.path);
} }
case (ast::item_mod(_, _, _)) { case (ast::item_mod(_, _, _)) {
_vec::pop[str](cx.path); vec::pop[str](cx.path);
} }
case (_) { } case (_) { }
} }
@ -7281,7 +7281,7 @@ fn collect_item_1(&@crate_ctxt ccx, @walk_ctxt wcx, &@ast::item i) {
case (ast::item_const(?name, _, _, ?cid, ?ann)) { case (ast::item_const(?name, _, _, ?cid, ?ann)) {
auto typ = node_ann_type(ccx, ann); auto typ = node_ann_type(ccx, ann);
auto g = llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, typ), auto g = llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, typ),
_str::buf(ccx.names.next(name))); str::buf(ccx.names.next(name)));
llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage
as llvm::Linkage); as llvm::Linkage);
ccx.items.insert(cid, i); ccx.items.insert(cid, i);
@ -7345,7 +7345,7 @@ fn collect_tag_ctor(&@crate_ctxt ccx, @walk_ctxt wcx, &@ast::item i) {
alt (i.node) { alt (i.node) {
case (ast::item_tag(_, ?variants, ?tps, _, _)) { case (ast::item_tag(_, ?variants, ?tps, _, _)) {
for (ast::variant variant in variants) { for (ast::variant variant in variants) {
if (_vec::len[ast::variant_arg](variant.node.args) != 0u) { if (vec::len[ast::variant_arg](variant.node.args) != 0u) {
decl_fn_and_pair(ccx, wcx.path + [variant.node.name], decl_fn_and_pair(ccx, wcx.path + [variant.node.name],
"tag", tps, variant.node.ann, "tag", tps, variant.node.ann,
variant.node.id); variant.node.id);
@ -7373,7 +7373,7 @@ fn trans_constant(&@crate_ctxt ccx, @walk_ctxt wcx, &@ast::item it) {
alt (it.node) { alt (it.node) {
case (ast::item_tag(?ident, ?variants, _, ?tag_id, _)) { case (ast::item_tag(?ident, ?variants, _, ?tag_id, _)) {
auto i = 0u; auto i = 0u;
auto n_variants = _vec::len[ast::variant](variants); auto n_variants = vec::len[ast::variant](variants);
while (i < n_variants) { while (i < n_variants) {
auto variant = variants.(i); auto variant = variants.(i);
@ -7383,7 +7383,7 @@ fn trans_constant(&@crate_ctxt ccx, @walk_ctxt wcx, &@ast::item it) {
#fmt("_rust_tag_discrim_%s_%u", #fmt("_rust_tag_discrim_%s_%u",
ident, i)); ident, i));
auto discrim_gvar = llvm::LLVMAddGlobal(ccx.llmod, T_int(), auto discrim_gvar = llvm::LLVMAddGlobal(ccx.llmod, T_int(),
_str::buf(s)); str::buf(s));
llvm::LLVMSetInitializer(discrim_gvar, discrim_val); llvm::LLVMSetInitializer(discrim_gvar, discrim_val);
llvm::LLVMSetGlobalConstant(discrim_gvar, True); llvm::LLVMSetGlobalConstant(discrim_gvar, True);
@ -7443,7 +7443,7 @@ fn trans_exit_task_glue(@glue_fns glues,
auto llfn = glues.exit_task_glue; auto llfn = glues.exit_task_glue;
auto entrybb = llvm::LLVMAppendBasicBlock(llfn, _str::buf("entry")); auto entrybb = llvm::LLVMAppendBasicBlock(llfn, str::buf("entry"));
auto build = new_builder(entrybb); auto build = new_builder(entrybb);
let ValueRef arg1 = llvm::LLVMGetParam(llfn, 0u); let ValueRef arg1 = llvm::LLVMGetParam(llfn, 0u);
@ -7465,9 +7465,9 @@ fn trans_exit_task_glue(@glue_fns glues,
} }
fn create_typedefs(&@crate_ctxt cx) { fn create_typedefs(&@crate_ctxt cx) {
llvm::LLVMAddTypeName(cx.llmod, _str::buf("crate"), T_crate(cx.tn)); llvm::LLVMAddTypeName(cx.llmod, str::buf("crate"), T_crate(cx.tn));
llvm::LLVMAddTypeName(cx.llmod, _str::buf("task"), T_task(cx.tn)); llvm::LLVMAddTypeName(cx.llmod, str::buf("task"), T_task(cx.tn));
llvm::LLVMAddTypeName(cx.llmod, _str::buf("tydesc"), T_tydesc(cx.tn)); llvm::LLVMAddTypeName(cx.llmod, str::buf("tydesc"), T_tydesc(cx.tn));
} }
fn create_crate_constant(ValueRef crate_ptr, @glue_fns glues) { fn create_crate_constant(ValueRef crate_ptr, @glue_fns glues) {
@ -7509,7 +7509,7 @@ fn find_main_fn(&@crate_ctxt cx) -> ValueRef {
let ValueRef v = C_nil(); let ValueRef v = C_nil();
let uint n = 0u; let uint n = 0u;
for each (@tup(ast::def_id, str) i in cx.item_symbols.items()) { for each (@tup(ast::def_id, str) i in cx.item_symbols.items()) {
if (_str::ends_with(i._1, e)) { if (str::ends_with(i._1, e)) {
n += 1u; n += 1u;
v = cx.item_ids.get(i._0); v = cx.item_ids.get(i._0);
} }
@ -7533,7 +7533,7 @@ fn trans_main_fn(@local_ctxt cx, ValueRef llcrate, ValueRef crate_map) {
auto T_rust_start_args = [T_int(), T_int(), T_int(), T_int(), T_int()]; auto T_rust_start_args = [T_int(), T_int(), T_int(), T_int(), T_int()];
auto main_name; auto main_name;
if (_str::eq(std::os::target_os(), "win32")) { if (str::eq(std::os::target_os(), "win32")) {
main_name = "WinMain@16"; main_name = "WinMain@16";
} else { } else {
main_name = "main"; main_name = "main";
@ -7558,7 +7558,7 @@ fn trans_main_fn(@local_ctxt cx, ValueRef llcrate, ValueRef crate_map) {
// //
let BasicBlockRef llbb = let BasicBlockRef llbb =
llvm::LLVMAppendBasicBlock(llmain, _str::buf("")); llvm::LLVMAppendBasicBlock(llmain, str::buf(""));
auto b = new_builder(llbb); auto b = new_builder(llbb);
auto start_args = [p2i(llrust_main), p2i(llcrate), llargc, llargv, auto start_args = [p2i(llrust_main), p2i(llcrate), llargc, llargv,
@ -7629,7 +7629,7 @@ fn decl_no_op_type_glue(ModuleRef llmod, type_names tn) -> ValueRef {
} }
fn make_no_op_type_glue(ValueRef fun) { fn make_no_op_type_glue(ValueRef fun) {
auto bb_name = _str::buf("_rust_no_op_type_glue_bb"); auto bb_name = str::buf("_rust_no_op_type_glue_bb");
auto llbb = llvm::LLVMAppendBasicBlock(fun, bb_name); auto llbb = llvm::LLVMAppendBasicBlock(fun, bb_name);
new_builder(llbb).RetVoid(); new_builder(llbb).RetVoid();
} }
@ -7733,7 +7733,7 @@ fn trans_vec_append_glue(@local_ctxt cx) {
llobjfields=new_def_hash[ValueRef](), llobjfields=new_def_hash[ValueRef](),
lllocals=new_def_hash[ValueRef](), lllocals=new_def_hash[ValueRef](),
llupvars=new_def_hash[ValueRef](), llupvars=new_def_hash[ValueRef](),
mutable lltydescs=_vec::empty[ValueRef](), mutable lltydescs=vec::empty[ValueRef](),
derived_tydescs=derived_tydescs, derived_tydescs=derived_tydescs,
lcx=cx); lcx=cx);
@ -7857,13 +7857,13 @@ fn make_glues(ModuleRef llmod, &type_names tn) -> @glue_fns {
T_void())), T_void())),
native_glues_rust = native_glues_rust =
_vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn, vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn,
abi::ngt_rust, _), abi::n_native_glues + 1 as uint), abi::ngt_rust, _), abi::n_native_glues + 1 as uint),
native_glues_pure_rust = native_glues_pure_rust =
_vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn, vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn,
abi::ngt_pure_rust, _), abi::n_native_glues + 1 as uint), abi::ngt_pure_rust, _), abi::n_native_glues + 1 as uint),
native_glues_cdecl = native_glues_cdecl =
_vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn, vec::init_fn[ValueRef](bind decl_native_glue(llmod, tn,
abi::ngt_cdecl, _), abi::n_native_glues + 1 as uint), abi::ngt_cdecl, _), abi::n_native_glues + 1 as uint),
no_op_type_glue = decl_no_op_type_glue(llmod, tn), no_op_type_glue = decl_no_op_type_glue(llmod, tn),
vec_append_glue = make_vec_append_glue(llmod, tn)); vec_append_glue = make_vec_append_glue(llmod, tn));
@ -7873,19 +7873,19 @@ fn make_common_glue(&session::session sess, &str output) {
// FIXME: part of this is repetitive and is probably a good idea // FIXME: part of this is repetitive and is probably a good idea
// to autogen it. // to autogen it.
auto llmod = auto llmod =
llvm::LLVMModuleCreateWithNameInContext(_str::buf("rust_out"), llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"),
llvm::LLVMGetGlobalContext()); llvm::LLVMGetGlobalContext());
llvm::LLVMSetDataLayout(llmod, _str::buf(x86::get_data_layout())); llvm::LLVMSetDataLayout(llmod, str::buf(x86::get_data_layout()));
llvm::LLVMSetTarget(llmod, _str::buf(x86::get_target_triple())); llvm::LLVMSetTarget(llmod, str::buf(x86::get_target_triple()));
auto td = mk_target_data(x86::get_data_layout()); auto td = mk_target_data(x86::get_data_layout());
auto tn = mk_type_names(); auto tn = mk_type_names();
let ValueRef crate_ptr = let ValueRef crate_ptr =
llvm::LLVMAddGlobal(llmod, T_crate(tn), _str::buf("rust_crate")); llvm::LLVMAddGlobal(llmod, T_crate(tn), str::buf("rust_crate"));
auto intrinsics = declare_intrinsics(llmod); auto intrinsics = declare_intrinsics(llmod);
llvm::LLVMSetModuleInlineAsm(llmod, _str::buf(x86::get_module_asm())); llvm::LLVMSetModuleInlineAsm(llmod, str::buf(x86::get_module_asm()));
auto glues = make_glues(llmod, tn); auto glues = make_glues(llmod, tn);
create_crate_constant(crate_ptr, glues); create_crate_constant(crate_ptr, glues);
@ -7900,23 +7900,23 @@ fn create_module_map(&@crate_ctxt ccx) -> ValueRef {
auto elttype = T_struct([T_int(), T_int()]); auto elttype = T_struct([T_int(), T_int()]);
auto maptype = T_array(elttype, ccx.module_data.size() + 1u); auto maptype = T_array(elttype, ccx.module_data.size() + 1u);
auto map = llvm::LLVMAddGlobal(ccx.llmod, maptype, auto map = llvm::LLVMAddGlobal(ccx.llmod, maptype,
_str::buf("_rust_mod_map")); str::buf("_rust_mod_map"));
llvm::LLVMSetLinkage(map, lib::llvm::LLVMInternalLinkage llvm::LLVMSetLinkage(map, lib::llvm::LLVMInternalLinkage
as llvm::Linkage); as llvm::Linkage);
let vec[ValueRef] elts = []; let vec[ValueRef] elts = [];
for each (@tup(str, ValueRef) item in ccx.module_data.items()) { for each (@tup(str, ValueRef) item in ccx.module_data.items()) {
auto elt = C_struct([p2i(C_cstr(ccx, item._0)), p2i(item._1)]); auto elt = C_struct([p2i(C_cstr(ccx, item._0)), p2i(item._1)]);
_vec::push[ValueRef](elts, elt); vec::push[ValueRef](elts, elt);
} }
auto term = C_struct([C_int(0), C_int(0)]); auto term = C_struct([C_int(0), C_int(0)]);
_vec::push[ValueRef](elts, term); vec::push[ValueRef](elts, term);
llvm::LLVMSetInitializer(map, C_array(elttype, elts)); llvm::LLVMSetInitializer(map, C_array(elttype, elts));
ret map; ret map;
} }
fn crate_name(&@crate_ctxt ccx, &str deflt) -> str { fn crate_name(&@crate_ctxt ccx, &str deflt) -> str {
for (@ast::meta_item item in ccx.sess.get_metadata()) { for (@ast::meta_item item in ccx.sess.get_metadata()) {
if (_str::eq(item.node.name, "name")) { if (str::eq(item.node.name, "name")) {
ret item.node.value; ret item.node.value;
} }
} }
@ -7930,15 +7930,15 @@ fn create_crate_map(&@crate_ctxt ccx) -> ValueRef {
while (ccx.sess.has_external_crate(i)) { while (ccx.sess.has_external_crate(i)) {
auto name = ccx.sess.get_external_crate(i).name; auto name = ccx.sess.get_external_crate(i).name;
auto cr = llvm::LLVMAddGlobal(ccx.llmod, T_int(), auto cr = llvm::LLVMAddGlobal(ccx.llmod, T_int(),
_str::buf("_rust_crate_map_" + name)); str::buf("_rust_crate_map_" + name));
_vec::push[ValueRef](subcrates, p2i(cr)); vec::push[ValueRef](subcrates, p2i(cr));
i += 1; i += 1;
} }
_vec::push[ValueRef](subcrates, C_int(0)); vec::push[ValueRef](subcrates, C_int(0));
auto sym_name = "_rust_crate_map_" + crate_name(ccx, "__none__"); auto sym_name = "_rust_crate_map_" + crate_name(ccx, "__none__");
auto arrtype = T_array(T_int(), _vec::len[ValueRef](subcrates)); auto arrtype = T_array(T_int(), vec::len[ValueRef](subcrates));
auto maptype = T_struct([T_int(), arrtype]); auto maptype = T_struct([T_int(), arrtype]);
auto map = llvm::LLVMAddGlobal(ccx.llmod, maptype, _str::buf(sym_name)); auto map = llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf(sym_name));
llvm::LLVMSetLinkage(map, lib::llvm::LLVMExternalLinkage llvm::LLVMSetLinkage(map, lib::llvm::LLVMExternalLinkage
as llvm::Linkage); as llvm::Linkage);
llvm::LLVMSetInitializer(map, C_struct([p2i(create_module_map(ccx)), llvm::LLVMSetInitializer(map, C_struct([p2i(create_module_map(ccx)),
@ -7951,15 +7951,15 @@ fn trans_crate(&session::session sess, &@ast::crate crate, &ty::ctxt tcx,
&str output) &str output)
-> ModuleRef { -> ModuleRef {
auto llmod = auto llmod =
llvm::LLVMModuleCreateWithNameInContext(_str::buf("rust_out"), llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"),
llvm::LLVMGetGlobalContext()); llvm::LLVMGetGlobalContext());
llvm::LLVMSetDataLayout(llmod, _str::buf(x86::get_data_layout())); llvm::LLVMSetDataLayout(llmod, str::buf(x86::get_data_layout()));
llvm::LLVMSetTarget(llmod, _str::buf(x86::get_target_triple())); llvm::LLVMSetTarget(llmod, str::buf(x86::get_target_triple()));
auto td = mk_target_data(x86::get_data_layout()); auto td = mk_target_data(x86::get_data_layout());
auto tn = mk_type_names(); auto tn = mk_type_names();
let ValueRef crate_ptr = let ValueRef crate_ptr =
llvm::LLVMAddGlobal(llmod, T_crate(tn), _str::buf("rust_crate")); llvm::LLVMAddGlobal(llmod, T_crate(tn), str::buf("rust_crate"));
auto intrinsics = declare_intrinsics(llmod); auto intrinsics = declare_intrinsics(llmod);

2
src/comp/middle/tstate/ann.rs
View file

@ -1,5 +1,5 @@
import front::ast::ident; import front::ast::ident;
import std::_vec; import std::vec;
import std::bitv; import std::bitv;
/* /*

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

@ -1,4 +1,4 @@
import std::_vec; import std::vec;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
@ -131,7 +131,7 @@ fn annotate_exprs(&fn_info_map fm, &vec[@expr] es) -> vec[@expr] {
ret annotate_expr(fm, e); ret annotate_expr(fm, e);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[@expr, @expr](f, es); ret vec::map[@expr, @expr](f, es);
} }
fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] { fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
fn one(fn_info_map fm, &elt e) -> elt { fn one(fn_info_map fm, &elt e) -> elt {
@ -139,7 +139,7 @@ fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
expr=annotate_expr(fm, e.expr)); expr=annotate_expr(fm, e.expr));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[elt, elt](f, es); ret vec::map[elt, elt](f, es);
} }
fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] { fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
fn one(fn_info_map fm, &field f) -> field { fn one(fn_info_map fm, &field f) -> field {
@ -148,7 +148,7 @@ fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
expr=annotate_expr(fm, f.expr)); expr=annotate_expr(fm, f.expr));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[field, field](f, fs); ret vec::map[field, field](f, fs);
} }
fn annotate_option_exp(&fn_info_map fm, &option::t[@expr] o) fn annotate_option_exp(&fn_info_map fm, &option::t[@expr] o)
-> option::t[@expr] { -> option::t[@expr] {
@ -164,7 +164,7 @@ fn annotate_option_exprs(&fn_info_map fm, &vec[option::t[@expr]] es)
ret annotate_option_exp(fm, o); ret annotate_option_exp(fm, o);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[option::t[@expr], option::t[@expr]](f, es); ret vec::map[option::t[@expr], option::t[@expr]](f, es);
} }
fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl { fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
auto d1 = d.node; auto d1 = d.node;
@ -194,7 +194,7 @@ fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] {
block=annotate_block(fm, a.block)); block=annotate_block(fm, a.block));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[arm, arm](f, alts); ret vec::map[arm, arm](f, alts);
} }
fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr { fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
@ -345,7 +345,7 @@ fn annotate_block(&fn_info_map fm, &block b) -> block {
for (@stmt s in b.node.stmts) { for (@stmt s in b.node.stmts) {
auto new_s = annotate_stmt(fm, s); auto new_s = annotate_stmt(fm, s);
_vec::push[@stmt](new_stmts, new_s); vec::push[@stmt](new_stmts, new_s);
} }
fn ann_e(fn_info_map fm, &@expr e) -> @expr { fn ann_e(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e); ret annotate_expr(fm, e);
@ -367,7 +367,7 @@ fn annotate_mod(&fn_info_map fm, &_mod m) -> _mod {
for (@item i in m.items) { for (@item i in m.items) {
auto new_i = annotate_item(fm, i); auto new_i = annotate_item(fm, i);
_vec::push[@item](new_items, new_i); vec::push[@item](new_items, new_i);
} }
ret rec(items=new_items with m); ret rec(items=new_items with m);
} }
@ -387,7 +387,7 @@ fn annotate_obj(&fn_info_map fm, &_obj o) -> _obj {
ret annotate_method(fm, m); ret annotate_method(fm, m);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
auto new_methods = _vec::map[@method, @method](f, o.methods); auto new_methods = vec::map[@method, @method](f, o.methods);
auto new_dtor = option::map[@method, @method](f, o.dtor); auto new_dtor = option::map[@method, @method](f, o.dtor);
ret rec(methods=new_methods, dtor=new_dtor with o); ret rec(methods=new_methods, dtor=new_dtor with o);
} }
@ -479,7 +479,7 @@ fn annotate_module(&fn_info_map fm, &_mod module) -> _mod {
for (@item i in module.items) { for (@item i in module.items) {
auto new_item = annotate_item(fm, i); auto new_item = annotate_item(fm, i);
_vec::push[@item](new_items, new_item); vec::push[@item](new_items, new_item);
} }
ret rec(items = new_items with module); ret rec(items = new_items with module);

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

@ -1,6 +1,6 @@
import std::bitv; import std::bitv;
import std::_vec::len; import std::vec::len;
import std::_vec::pop; import std::vec::pop;
import std::option; import std::option;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;

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

@ -1,7 +1,7 @@
import std::bitv; import std::bitv;
import std::_vec; import std::vec;
import std::_vec::len; import std::vec::len;
import std::_vec::slice; import std::vec::slice;
import front::ast; import front::ast;
import front::ast::def_id; import front::ast::def_id;
@ -74,7 +74,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond {
/* works on either postconds or preconds /* works on either postconds or preconds
should probably rethink the whole type synonym situation */ should probably rethink the whole type synonym situation */
fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec::len[postcond](rest); auto sz = vec::len[postcond](rest);
if (sz > 0u) { if (sz > 0u) {
auto other = rest.(0); auto other = rest.(0);
@ -96,7 +96,7 @@ fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond {
/* Gee, maybe we could use foldl or something */ /* Gee, maybe we could use foldl or something */
fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec::len[postcond](rest); auto sz = vec::len[postcond](rest);
if (sz > 0u) { if (sz > 0u) {
auto other = rest.(0); auto other = rest.(0);

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

@ -31,12 +31,12 @@ import tstate::ann::prestate;
import tstate::ann::implies; import tstate::ann::implies;
import tstate::ann::ann_precond; import tstate::ann::ann_precond;
import tstate::ann::ann_prestate; import tstate::ann::ann_prestate;
import std::_vec::map; import std::vec::map;
import std::_vec; import std::vec;
import std::_vec::slice; import std::vec::slice;
import std::_vec::unzip; import std::vec::unzip;
import std::_vec::plus_option; import std::vec::plus_option;
import std::_vec::cat_options; import std::vec::cat_options;
import std::option; import std::option;
import std::option::t; import std::option::t;
@ -123,7 +123,7 @@ fn check_states_against_conditions(&fn_ctxt fcx, &_fn f, &ann a) -> () {
auto do_one = bind do_one_(fcx, _, post, nv); auto do_one = bind do_one_(fcx, _, post, nv);
_vec::map[@stmt, ()](do_one, f.body.node.stmts); vec::map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_ctxt fcx, &@expr e, @poststate post) -> () { fn do_inner_(fn_ctxt fcx, &@expr e, @poststate post) -> () {
check_states_expr(fcx, e); check_states_expr(fcx, e);
*post = expr_poststate(e); *post = expr_poststate(e);
@ -187,7 +187,7 @@ fn check_obj_state(&crate_ctxt ccx, &vec[obj_field] fields,
ret check_method_states(ccx, m); ret check_method_states(ccx, m);
} }
auto f = bind one(ccx,_); auto f = bind one(ccx,_);
_vec::map[@method, ()](f, methods); vec::map[@method, ()](f, methods);
option::map[@method, ()](f, dtor); option::map[@method, ()](f, dtor);
ret rec(fields=fields, methods=methods, dtor=dtor); ret rec(fields=fields, methods=methods, dtor=dtor);
} }

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

@ -1,5 +1,5 @@
import std::_vec; import std::vec;
import std::_vec::plus_option; import std::vec::plus_option;
import front::ast; import front::ast;
import front::ast::crate; import front::ast::crate;
@ -39,12 +39,12 @@ fn var_is_local(def_id v, fn_info m) -> bool {
fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@local loc) fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@local loc)
-> @decl { -> @decl {
log("collect_local: pushing " + loc.ident); log("collect_local: pushing " + loc.ident);
_vec::push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id)); vec::push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id));
ret @respan(sp, decl_local(loc)); ret @respan(sp, decl_local(loc));
} }
fn find_locals(_fn f) -> @vec[tup(ident,def_id)] { fn find_locals(_fn f) -> @vec[tup(ident,def_id)] {
auto res = @_vec::alloc[tup(ident,def_id)](0u); auto res = @vec::alloc[tup(ident,def_id)](0u);
auto fld = new_identity_fold[@vec[tup(ident, def_id)]](); auto fld = new_identity_fold[@vec[tup(ident, def_id)]]();
fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld); fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld);
@ -72,7 +72,7 @@ fn mk_fn_info(_fn f, def_id f_id, ident f_name) -> fn_info {
just collect locally declared vars */ just collect locally declared vars */
let @vec[tup(ident,def_id)] locals = find_locals(f); let @vec[tup(ident,def_id)] locals = find_locals(f);
// log (uistr(_vec::len[tup(ident, def_id)](locals)) + " locals"); // log (uistr(vec::len[tup(ident, def_id)](locals)) + " locals");
for (tup(ident,def_id) p in *locals) { for (tup(ident,def_id) p in *locals) {
next = add_var(p._1, p._0, next, res); next = add_var(p._1, p._0, next, res);
} }
@ -98,7 +98,7 @@ fn mk_fn_info_item_fn(&crate_ctxt ccx, &span sp, &ident i, &_fn f,
fn mk_fn_info_item_obj(&crate_ctxt ccx, &span sp, &ident i, &_obj o, fn mk_fn_info_item_obj(&crate_ctxt ccx, &span sp, &ident i, &_obj o,
&vec[ty_param] ty_params, &vec[ty_param] ty_params,
&obj_def_ids odid, &ann a) -> @item { &obj_def_ids odid, &ann a) -> @item {
auto all_methods = _vec::clone[@method](o.methods); auto all_methods = vec::clone[@method](o.methods);
plus_option[@method](all_methods, o.dtor); plus_option[@method](all_methods, o.dtor);
auto f_inf; auto f_inf;
for (@method m in all_methods) { for (@method m in all_methods) {

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

@ -1,5 +1,5 @@
import std::_vec; import std::vec;
import std::_vec::plus_option; import std::vec::plus_option;
import std::option; import std::option;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
@ -180,7 +180,7 @@ fn find_pre_post_obj(&crate_ctxt ccx, _obj o) -> () {
find_pre_post_fn(fcx, m.node.meth); find_pre_post_fn(fcx, m.node.meth);
} }
auto f = bind do_a_method(ccx,_); auto f = bind do_a_method(ccx,_);
_vec::map[@method, ()](f, o.methods); vec::map[@method, ()](f, o.methods);
option::map[@method, ()](f, o.dtor); option::map[@method, ()](f, o.dtor);
} }
@ -233,19 +233,19 @@ fn find_pre_post_exprs(&fn_ctxt fcx, &vec[@expr] args, ann a) {
} }
auto f = bind do_one(fcx, _); auto f = bind do_one(fcx, _);
_vec::map[@expr, ()](f, args); vec::map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post { fn get_pp(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(e);
} }
auto g = get_pp; auto g = get_pp;
auto pps = _vec::map[@expr, pre_and_post](g, args); auto pps = vec::map[@expr, pre_and_post](g, args);
auto h = get_post; auto h = get_post;
set_pre_and_post(a, set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing, pps), rec(precondition=seq_preconds(enclosing, pps),
postcondition=union_postconds postcondition=union_postconds
(nv, (_vec::map[pre_and_post, postcond](h, pps))))); (nv, (vec::map[pre_and_post, postcond](h, pps)))));
} }
fn find_pre_post_loop(&fn_ctxt fcx, &@decl d, &@expr index, fn find_pre_post_loop(&fn_ctxt fcx, &@decl d, &@expr index,
@ -292,13 +292,13 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) -> () {
alt (e.node) { alt (e.node) {
case (expr_call(?operator, ?operands, ?a)) { case (expr_call(?operator, ?operands, ?a)) {
auto args = _vec::clone[@expr](operands); auto args = vec::clone[@expr](operands);
_vec::push[@expr](args, operator); vec::push[@expr](args, operator);
find_pre_post_exprs(fcx, args, a); find_pre_post_exprs(fcx, args, a);
} }
case (expr_spawn(_, _, ?operator, ?operands, ?a)) { case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
auto args = _vec::clone[@expr](operands); auto args = vec::clone[@expr](operands);
_vec::push[@expr](args, operator); vec::push[@expr](args, operator);
find_pre_post_exprs(fcx, args, a); find_pre_post_exprs(fcx, args, a);
} }
case (expr_vec(?args, _, ?a)) { case (expr_vec(?args, _, ?a)) {
@ -352,7 +352,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) -> () {
} }
case (expr_rec(?fields,?maybe_base,?a)) { case (expr_rec(?fields,?maybe_base,?a)) {
auto es = field_exprs(fields); auto es = field_exprs(fields);
_vec::plus_option[@expr](es, maybe_base); vec::plus_option[@expr](es, maybe_base);
find_pre_post_exprs(fcx, es, a); find_pre_post_exprs(fcx, es, a);
} }
case (expr_assign(?lhs, ?rhs, ?a)) { case (expr_assign(?lhs, ?rhs, ?a)) {
@ -505,7 +505,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) -> () {
ret block_pp(an_alt.block); ret block_pp(an_alt.block);
} }
auto f = bind do_an_alt(fcx, _); auto f = bind do_an_alt(fcx, _);
auto alt_pps = _vec::map[arm, pre_and_post](f, alts); auto alt_pps = vec::map[arm, pre_and_post](f, alts);
fn combine_pp(pre_and_post antec, fn combine_pp(pre_and_post antec,
fn_info enclosing, &pre_and_post pp, fn_info enclosing, &pre_and_post pp,
&pre_and_post next) -> pre_and_post { &pre_and_post next) -> pre_and_post {
@ -519,7 +519,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) -> () {
postcondition=false_postcond(num_local_vars)); postcondition=false_postcond(num_local_vars));
auto g = bind combine_pp(antec_pp, fcx.enclosing, _, _); auto g = bind combine_pp(antec_pp, fcx.enclosing, _, _);
auto alts_overall_pp = _vec::foldl[pre_and_post, pre_and_post] auto alts_overall_pp = vec::foldl[pre_and_post, pre_and_post]
(g, e_pp, alt_pps); (g, e_pp, alt_pps);
set_pre_and_post(a, alts_overall_pp); set_pre_and_post(a, alts_overall_pp);
@ -545,8 +545,8 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) -> () {
set_pre_and_post(a, expr_pp(p)); set_pre_and_post(a, expr_pp(p));
} }
case(expr_bind(?operator, ?maybe_args, ?a)) { case(expr_bind(?operator, ?maybe_args, ?a)) {
auto args = _vec::cat_options[@expr](maybe_args); auto args = vec::cat_options[@expr](maybe_args);
_vec::push[@expr](args, operator); /* ??? order of eval? */ vec::push[@expr](args, operator); /* ??? order of eval? */
find_pre_post_exprs(fcx, args, a); find_pre_post_exprs(fcx, args, a);
} }
case (expr_break(?a)) { case (expr_break(?a)) {
@ -643,7 +643,7 @@ fn find_pre_post_block(&fn_ctxt fcx, block b) -> () {
} }
auto do_one = bind do_one_(fcx, _); auto do_one = bind do_one_(fcx, _);
_vec::map[@stmt, ()](do_one, b.node.stmts); vec::map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(fn_ctxt fcx, &@expr e) -> () { fn do_inner_(fn_ctxt fcx, &@expr e) -> () {
find_pre_post_expr(fcx, e); find_pre_post_expr(fcx, e);
} }
@ -656,7 +656,7 @@ fn find_pre_post_block(&fn_ctxt fcx, block b) -> () {
ret stmt_pp(*s); ret stmt_pp(*s);
} }
auto f = get_pp_stmt; auto f = get_pp_stmt;
pps += _vec::map[@stmt, pre_and_post](f, b.node.stmts); pps += vec::map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post { fn get_pp_expr(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(e);
} }
@ -666,10 +666,10 @@ fn find_pre_post_block(&fn_ctxt fcx, block b) -> () {
auto block_precond = seq_preconds(fcx.enclosing, pps); auto block_precond = seq_preconds(fcx.enclosing, pps);
auto h = get_post; auto h = get_post;
auto postconds = _vec::map[pre_and_post, postcond](h, pps); auto postconds = vec::map[pre_and_post, postcond](h, pps);
/* A block may be empty, so this next line ensures that the postconds /* A block may be empty, so this next line ensures that the postconds
vector is non-empty. */ vector is non-empty. */
_vec::push[postcond](postconds, block_precond); vec::push[postcond](postconds, block_precond);
auto block_postcond = empty_poststate(nv); auto block_postcond = empty_poststate(nv);
/* conservative approximation */ /* conservative approximation */
if (! has_nonlocal_exits(b)) { if (! has_nonlocal_exits(b)) {

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

@ -1,7 +1,7 @@
import std::bitv; import std::bitv;
import std::_vec; import std::vec;
import std::_vec::plus_option; import std::vec::plus_option;
import std::_vec::cat_options; import std::vec::cat_options;
import std::option; import std::option;
import std::option::get; import std::option::get;
import std::option::is_none; import std::option::is_none;
@ -538,7 +538,7 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
changed = find_pre_post_state_expr(fcx, pres, e) || changed; changed = find_pre_post_state_expr(fcx, pres, e) || changed;
auto e_post = expr_poststate(e); auto e_post = expr_poststate(e);
auto a_post; auto a_post;
if (_vec::len[arm](alts) > 0u) { if (vec::len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars); a_post = false_postcond(num_local_vars);
for (arm an_alt in alts) { for (arm an_alt in alts) {
changed = find_pre_post_state_block(fcx, e_post, changed = find_pre_post_state_block(fcx, e_post,
@ -766,8 +766,8 @@ fn find_pre_post_state_obj(crate_ctxt ccx, _obj o) -> bool {
m.node.meth); m.node.meth);
} }
auto f = bind do_a_method(ccx,_); auto f = bind do_a_method(ccx,_);
auto flags = _vec::map[@method, bool](f, o.methods); auto flags = vec::map[@method, bool](f, o.methods);
auto changed = _vec::or(flags); auto changed = vec::or(flags);
changed = changed || maybe[@method, bool](false, f, o.dtor); changed = changed || maybe[@method, bool](false, f, o.dtor);
ret changed; ret changed;
} }

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

@ -1,6 +1,6 @@
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
import std::box; import std::box;
import std::ufind; import std::ufind;
import std::map; import std::map;
@ -194,7 +194,7 @@ fn mk_type_store() -> @type_store {
intern(ts, ty_type, none[str]); intern(ts, ty_type, none[str]);
intern(ts, ty_bot, none[str]); intern(ts, ty_bot, none[str]);
assert _vec::len(ts.vect) == idx_first_others; assert vec::len(ts.vect) == idx_first_others;
ret ts; ret ts;
} }
@ -479,11 +479,11 @@ fn cname(&ctxt cx, &t typ) -> option::t[str] {
// Stringification // Stringification
fn path_to_str(&ast::path pth) -> str { fn path_to_str(&ast::path pth) -> str {
auto result = _str::connect(pth.node.idents, "::"); auto result = str::connect(pth.node.idents, "::");
if (_vec::len[@ast::ty](pth.node.types) > 0u) { if (vec::len[@ast::ty](pth.node.types) > 0u) {
auto f = pretty::pprust::ty_to_str; auto f = pretty::pprust::ty_to_str;
result += "["; result += "[";
result += _str::connect(_vec::map(f, pth.node.types), ","); result += str::connect(vec::map(f, pth.node.types), ",");
result += "]"; result += "]";
} }
ret result; ret result;
@ -527,7 +527,7 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
} }
s += "("; s += "(";
s += _str::connect(_vec::map[arg,str](f, inputs), ", "); s += str::connect(vec::map[arg,str](f, inputs), ", ");
s += ")"; s += ")";
if (struct(cx, output) != ty_nil) { if (struct(cx, output) != ty_nil) {
@ -585,24 +585,24 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
case (ty_tup(?elems)) { case (ty_tup(?elems)) {
auto f = bind mt_to_str(cx, _); auto f = bind mt_to_str(cx, _);
auto strs = _vec::map[mt,str](f, elems); auto strs = vec::map[mt,str](f, elems);
s += "tup(" + _str::connect(strs, ",") + ")"; s += "tup(" + str::connect(strs, ",") + ")";
} }
case (ty_rec(?elems)) { case (ty_rec(?elems)) {
auto f = bind field_to_str(cx, _); auto f = bind field_to_str(cx, _);
auto strs = _vec::map[field,str](f, elems); auto strs = vec::map[field,str](f, elems);
s += "rec(" + _str::connect(strs, ",") + ")"; s += "rec(" + str::connect(strs, ",") + ")";
} }
case (ty_tag(?id, ?tps)) { case (ty_tag(?id, ?tps)) {
// The user should never see this if the cname is set properly! // The user should never see this if the cname is set properly!
s += "<tag#" + util::common::istr(id._0) + ":" + s += "<tag#" + util::common::istr(id._0) + ":" +
util::common::istr(id._1) + ">"; util::common::istr(id._1) + ">";
if (_vec::len[t](tps) > 0u) { if (vec::len[t](tps) > 0u) {
auto f = bind ty_to_str(cx, _); auto f = bind ty_to_str(cx, _);
auto strs = _vec::map[t,str](f, tps); auto strs = vec::map[t,str](f, tps);
s += "[" + _str::connect(strs, ",") + "]"; s += "[" + str::connect(strs, ",") + "]";
} }
} }
@ -617,8 +617,8 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
case (ty_obj(?meths)) { case (ty_obj(?meths)) {
auto f = bind method_to_str(cx, _); auto f = bind method_to_str(cx, _);
auto m = _vec::map[method,str](f, meths); auto m = vec::map[method,str](f, meths);
s += "obj {\n\t" + _str::connect(m, "\n\t") + "\n}"; s += "obj {\n\t" + str::connect(m, "\n\t") + "\n}";
} }
case (ty_var(?v)) { case (ty_var(?v)) {
@ -631,11 +631,11 @@ fn ty_to_str(ctxt cx, &t typ) -> str {
} }
case (ty_param(?id)) { case (ty_param(?id)) {
s += "'" + _str::unsafe_from_bytes([('a' as u8) + (id as u8)]); s += "'" + str::unsafe_from_bytes([('a' as u8) + (id as u8)]);
} }
case (ty_bound_param(?id)) { case (ty_bound_param(?id)) {
s += "''" + _str::unsafe_from_bytes([('a' as u8) + s += "''" + str::unsafe_from_bytes([('a' as u8) +
(id as u8)]); (id as u8)]);
} }
@ -652,7 +652,7 @@ fn ty_to_short_str(ctxt cx, t typ) -> str {
auto f = def_to_str; auto f = def_to_str;
auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata::ac_no_abbrevs); auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata::ac_no_abbrevs);
auto s = metadata::Encode::ty_str(ecx, typ); auto s = metadata::Encode::ty_str(ecx, typ);
if (_str::byte_len(s) >= 32u) { s = _str::substr(s, 0u, 32u); } if (str::byte_len(s) >= 32u) { s = str::substr(s, 0u, 32u); }
ret s; ret s;
} }
@ -955,14 +955,14 @@ fn type_has_dynamic_size(&ctxt cx, &t ty) -> bool {
alt (struct(cx, ty)) { alt (struct(cx, ty)) {
case (ty_tup(?mts)) { case (ty_tup(?mts)) {
auto i = 0u; auto i = 0u;
while (i < _vec::len[mt](mts)) { while (i < vec::len[mt](mts)) {
if (type_has_dynamic_size(cx, mts.(i).ty)) { ret true; } if (type_has_dynamic_size(cx, mts.(i).ty)) { ret true; }
i += 1u; i += 1u;
} }
} }
case (ty_rec(?fields)) { case (ty_rec(?fields)) {
auto i = 0u; auto i = 0u;
while (i < _vec::len[field](fields)) { while (i < vec::len[field](fields)) {
if (type_has_dynamic_size(cx, fields.(i).mt.ty)) { if (type_has_dynamic_size(cx, fields.(i).mt.ty)) {
ret true; ret true;
} }
@ -971,7 +971,7 @@ fn type_has_dynamic_size(&ctxt cx, &t ty) -> bool {
} }
case (ty_tag(_, ?subtys)) { case (ty_tag(_, ?subtys)) {
auto i = 0u; auto i = 0u;
while (i < _vec::len[t](subtys)) { while (i < vec::len[t](subtys)) {
if (type_has_dynamic_size(cx, subtys.(i))) { ret true; } if (type_has_dynamic_size(cx, subtys.(i))) { ret true; }
i += 1u; i += 1u;
} }
@ -1139,7 +1139,7 @@ fn hash_type_structure(&sty st) -> uint {
case (ty_obj(?methods)) { case (ty_obj(?methods)) {
auto h = 27u; auto h = 27u;
for (method m in methods) { for (method m in methods) {
h += h << 5u + _str::hash(m.ident); h += h << 5u + str::hash(m.ident);
} }
ret h; ret h;
} }
@ -1157,7 +1157,7 @@ fn hash_type_info(&sty st, &option::t[str] cname_opt) -> uint {
auto h = hash_type_structure(st); auto h = hash_type_structure(st);
alt (cname_opt) { alt (cname_opt) {
case (none[str]) { /* no-op */ } case (none[str]) { /* no-op */ }
case (some[str](?s)) { h += h << 5u + _str::hash(s); } case (some[str](?s)) { h += h << 5u + str::hash(s); }
} }
ret h; ret h;
} }
@ -1178,8 +1178,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
&vec[arg] args_b, &t rty_b) -> bool { &vec[arg] args_b, &t rty_b) -> bool {
if (!eq_ty(rty_a, rty_b)) { ret false; } if (!eq_ty(rty_a, rty_b)) { ret false; }
auto len = _vec::len[arg](args_a); auto len = vec::len[arg](args_a);
if (len != _vec::len[arg](args_b)) { ret false; } if (len != vec::len[arg](args_b)) { ret false; }
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
@ -1257,8 +1257,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_tag(?id_b, ?tys_b)) { case (ty_tag(?id_b, ?tys_b)) {
if (!equal_def(id_a, id_b)) { ret false; } if (!equal_def(id_a, id_b)) { ret false; }
auto len = _vec::len[t](tys_a); auto len = vec::len[t](tys_a);
if (len != _vec::len[t](tys_b)) { ret false; } if (len != vec::len[t](tys_b)) { ret false; }
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
if (!eq_ty(tys_a.(i), tys_b.(i))) { ret false; } if (!eq_ty(tys_a.(i), tys_b.(i))) { ret false; }
@ -1302,8 +1302,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_tup(?mts_a)) { case (ty_tup(?mts_a)) {
alt (b) { alt (b) {
case (ty_tup(?mts_b)) { case (ty_tup(?mts_b)) {
auto len = _vec::len[mt](mts_a); auto len = vec::len[mt](mts_a);
if (len != _vec::len[mt](mts_b)) { ret false; } if (len != vec::len[mt](mts_b)) { ret false; }
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
if (!equal_mt(mts_a.(i), mts_b.(i))) { ret false; } if (!equal_mt(mts_a.(i), mts_b.(i))) { ret false; }
@ -1317,12 +1317,12 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_rec(?flds_a)) { case (ty_rec(?flds_a)) {
alt (b) { alt (b) {
case (ty_rec(?flds_b)) { case (ty_rec(?flds_b)) {
auto len = _vec::len[field](flds_a); auto len = vec::len[field](flds_a);
if (len != _vec::len[field](flds_b)) { ret false; } if (len != vec::len[field](flds_b)) { ret false; }
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
auto fld_a = flds_a.(i); auto fld_b = flds_b.(i); auto fld_a = flds_a.(i); auto fld_b = flds_b.(i);
if (!_str::eq(fld_a.ident, fld_b.ident) || if (!str::eq(fld_a.ident, fld_b.ident) ||
!equal_mt(fld_a.mt, fld_b.mt)) { !equal_mt(fld_a.mt, fld_b.mt)) {
ret false; ret false;
} }
@ -1354,13 +1354,13 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
case (ty_obj(?methods_a)) { case (ty_obj(?methods_a)) {
alt (b) { alt (b) {
case (ty_obj(?methods_b)) { case (ty_obj(?methods_b)) {
auto len = _vec::len[method](methods_a); auto len = vec::len[method](methods_a);
if (len != _vec::len[method](methods_b)) { ret false; } if (len != vec::len[method](methods_b)) { ret false; }
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
auto m_a = methods_a.(i); auto m_b = methods_b.(i); auto m_a = methods_a.(i); auto m_b = methods_b.(i);
if (m_a.proto != m_b.proto || if (m_a.proto != m_b.proto ||
!_str::eq(m_a.ident, m_b.ident) || !str::eq(m_a.ident, m_b.ident) ||
!equal_fn(m_a.inputs, m_a.output, !equal_fn(m_a.inputs, m_a.output,
m_b.inputs, m_b.output)) { m_b.inputs, m_b.output)) {
ret false; ret false;
@ -1432,7 +1432,7 @@ fn eq_raw_ty(&raw_t a, &raw_t b) -> bool {
case (some[str](?s_a)) { case (some[str](?s_a)) {
alt (b.cname) { alt (b.cname) {
case (some[str](?s_b)) { case (some[str](?s_b)) {
if (!_str::eq(s_a, s_b)) { ret false; } if (!str::eq(s_a, s_b)) { ret false; }
} }
case (_) { ret false; } case (_) { ret false; }
} }
@ -1534,7 +1534,7 @@ fn count_ty_params(ctxt cx, t ty) -> uint {
let @mutable vec[uint] param_indices = @mutable v; let @mutable vec[uint] param_indices = @mutable v;
auto f = bind counter(cx, param_indices, _); auto f = bind counter(cx, param_indices, _);
walk_ty(cx, f, ty); walk_ty(cx, f, ty);
ret _vec::len[uint](*param_indices); ret vec::len[uint](*param_indices);
} }
fn type_contains_vars(&ctxt cx, &t typ) -> bool { fn type_contains_vars(&ctxt cx, &t typ) -> bool {
@ -1605,7 +1605,7 @@ fn native_item_ty(&node_type_table ntt, &@ast::native_item it)
auto result_ty; auto result_ty;
alt (it.node) { alt (it.node) {
case (ast::native_item_fn(_, _, _, ?tps, _, ?ann)) { case (ast::native_item_fn(_, _, _, ?tps, _, ?ann)) {
ty_param_count = _vec::len[ast::ty_param](tps); ty_param_count = vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
} }
@ -1621,22 +1621,22 @@ fn item_ty(&node_type_table ntt, &@ast::item it) -> ty_param_count_and_ty {
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
case (ast::item_fn(_, _, ?tps, _, ?ann)) { case (ast::item_fn(_, _, ?tps, _, ?ann)) {
ty_param_count = _vec::len[ast::ty_param](tps); ty_param_count = vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
case (ast::item_mod(_, _, _)) { case (ast::item_mod(_, _, _)) {
fail; // modules are typeless fail; // modules are typeless
} }
case (ast::item_ty(_, _, ?tps, _, ?ann)) { case (ast::item_ty(_, _, ?tps, _, ?ann)) {
ty_param_count = _vec::len[ast::ty_param](tps); ty_param_count = vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
case (ast::item_tag(_, _, ?tps, ?did, ?ann)) { case (ast::item_tag(_, _, ?tps, ?did, ?ann)) {
ty_param_count = _vec::len[ast::ty_param](tps); ty_param_count = vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
case (ast::item_obj(_, _, ?tps, _, ?ann)) { case (ast::item_obj(_, _, ?tps, _, ?ann)) {
ty_param_count = _vec::len[ast::ty_param](tps); ty_param_count = vec::len[ast::ty_param](tps);
result_ty = ann_to_type(ntt, ann); result_ty = ann_to_type(ntt, ann);
} }
} }
@ -1781,7 +1781,7 @@ fn field_num(&session::session sess, &span sp,
accum += (c as uint) - ('0' as uint); accum += (c as uint) - ('0' as uint);
} else { } else {
auto s = ""; auto s = "";
s += _str::unsafe_from_byte(c); s += str::unsafe_from_byte(c);
sess.span_err(sp, sess.span_err(sp,
"bad numeric field on tuple: " "bad numeric field on tuple: "
+ " non-digit character: " + " non-digit character: "
@ -1797,7 +1797,7 @@ fn field_idx(&session::session sess, &span sp,
&ast::ident id, &vec[field] fields) -> uint { &ast::ident id, &vec[field] fields) -> uint {
let uint i = 0u; let uint i = 0u;
for (field f in fields) { for (field f in fields) {
if (_str::eq(f.ident, id)) { if (str::eq(f.ident, id)) {
ret i; ret i;
} }
i += 1u; i += 1u;
@ -1810,7 +1810,7 @@ fn method_idx(&session::session sess, &span sp,
&ast::ident id, &vec[method] meths) -> uint { &ast::ident id, &vec[method] meths) -> uint {
let uint i = 0u; let uint i = 0u;
for (method m in meths) { for (method m in meths) {
if (_str::eq(m.ident, id)) { if (str::eq(m.ident, id)) {
ret i; ret i;
} }
i += 1u; i += 1u;
@ -1821,7 +1821,7 @@ fn method_idx(&session::session sess, &span sp,
fn sort_methods(&vec[method] meths) -> vec[method] { fn sort_methods(&vec[method] meths) -> vec[method] {
fn method_lteq(&method a, &method b) -> bool { fn method_lteq(&method a, &method b) -> bool {
ret _str::lteq(a.ident, b.ident); ret str::lteq(a.ident, b.ident);
} }
ret std::sort::merge_sort[method](bind method_lteq(_,_), meths); ret std::sort::merge_sort[method](bind method_lteq(_,_), meths);
@ -1896,8 +1896,8 @@ mod unify {
&vec[arg] expected_inputs, &t expected_output, &vec[arg] expected_inputs, &t expected_output,
&vec[arg] actual_inputs, &t actual_output) &vec[arg] actual_inputs, &t actual_output)
-> fn_common_res { -> fn_common_res {
auto expected_len = _vec::len[arg](expected_inputs); auto expected_len = vec::len[arg](expected_inputs);
auto actual_len = _vec::len[arg](actual_inputs); auto actual_len = vec::len[arg](actual_inputs);
if (expected_len != actual_len) { if (expected_len != actual_len) {
ret fn_common_res_err(ures_err(terr_arg_count, ret fn_common_res_err(ures_err(terr_arg_count,
expected, actual)); expected, actual));
@ -2012,8 +2012,8 @@ mod unify {
&vec[method] actual_meths) -> result { &vec[method] actual_meths) -> result {
let vec[method] result_meths = []; let vec[method] result_meths = [];
let uint i = 0u; let uint i = 0u;
let uint expected_len = _vec::len[method](expected_meths); let uint expected_len = vec::len[method](expected_meths);
let uint actual_len = _vec::len[method](actual_meths); let uint actual_len = vec::len[method](actual_meths);
if (expected_len != actual_len) { if (expected_len != actual_len) {
ret ures_err(terr_meth_count, expected, actual); ret ures_err(terr_meth_count, expected, actual);
@ -2022,7 +2022,7 @@ mod unify {
while (i < expected_len) { while (i < expected_len) {
auto e_meth = expected_meths.(i); auto e_meth = expected_meths.(i);
auto a_meth = actual_meths.(i); auto a_meth = actual_meths.(i);
if (! _str::eq(e_meth.ident, a_meth.ident)) { if (! str::eq(e_meth.ident, a_meth.ident)) {
ret ures_err(terr_obj_meths(e_meth.ident, a_meth.ident), ret ures_err(terr_obj_meths(e_meth.ident, a_meth.ident),
expected, actual); expected, actual);
} }
@ -2086,7 +2086,7 @@ mod unify {
case (_) { case (_) {
// Just bind the type variable to the expected type. // Just bind the type variable to the expected type.
auto vlen = _vec::len[vec[t]](cx.types); auto vlen = vec::len[vec[t]](cx.types);
if (actual_n < vlen) { if (actual_n < vlen) {
cx.types.(actual_n) += [expected]; cx.types.(actual_n) += [expected];
} else { } else {
@ -2154,7 +2154,7 @@ mod unify {
// ty::ty_tup case // ty::ty_tup case
let vec[t] result_tps = []; let vec[t] result_tps = [];
auto i = 0u; auto i = 0u;
auto expected_len = _vec::len[t](expected_tps); auto expected_len = vec::len[t](expected_tps);
while (i < expected_len) { while (i < expected_len) {
auto expected_tp = expected_tps.(i); auto expected_tp = expected_tps.(i);
auto actual_tp = actual_tps.(i); auto actual_tp = actual_tps.(i);
@ -2165,7 +2165,7 @@ mod unify {
alt (result) { alt (result) {
case (ures_ok(?rty)) { case (ures_ok(?rty)) {
_vec::push[t](result_tps, rty); vec::push[t](result_tps, rty);
} }
case (_) { case (_) {
ret result; ret result;
@ -2294,8 +2294,8 @@ mod unify {
case (ty::ty_tup(?expected_elems)) { case (ty::ty_tup(?expected_elems)) {
alt (struct(cx.tcx, actual)) { alt (struct(cx.tcx, actual)) {
case (ty::ty_tup(?actual_elems)) { case (ty::ty_tup(?actual_elems)) {
auto expected_len = _vec::len[ty::mt](expected_elems); auto expected_len = vec::len[ty::mt](expected_elems);
auto actual_len = _vec::len[ty::mt](actual_elems); auto actual_len = vec::len[ty::mt](actual_elems);
if (expected_len != actual_len) { if (expected_len != actual_len) {
auto err = terr_tuple_size(expected_len, auto err = terr_tuple_size(expected_len,
actual_len); actual_len);
@ -2348,8 +2348,8 @@ mod unify {
case (ty::ty_rec(?expected_fields)) { case (ty::ty_rec(?expected_fields)) {
alt (struct(cx.tcx, actual)) { alt (struct(cx.tcx, actual)) {
case (ty::ty_rec(?actual_fields)) { case (ty::ty_rec(?actual_fields)) {
auto expected_len = _vec::len[field](expected_fields); auto expected_len = vec::len[field](expected_fields);
auto actual_len = _vec::len[field](actual_fields); auto actual_len = vec::len[field](actual_fields);
if (expected_len != actual_len) { if (expected_len != actual_len) {
auto err = terr_record_size(expected_len, auto err = terr_record_size(expected_len,
actual_len); actual_len);
@ -2374,7 +2374,7 @@ mod unify {
case (some[ast::mutability](?m)) { mut = m; } case (some[ast::mutability](?m)) { mut = m; }
} }
if (!_str::eq(expected_field.ident, if (!str::eq(expected_field.ident,
actual_field.ident)) { actual_field.ident)) {
auto err = auto err =
terr_record_fields(expected_field.ident, terr_record_fields(expected_field.ident,
@ -2388,7 +2388,7 @@ mod unify {
alt (result) { alt (result) {
case (ures_ok(?rty)) { case (ures_ok(?rty)) {
auto mt = rec(ty=rty, mut=mut); auto mt = rec(ty=rty, mut=mut);
_vec::push[field] vec::push[field]
(result_fields, (result_fields,
rec(mt=mt with expected_field)); rec(mt=mt with expected_field));
} }
@ -2455,7 +2455,7 @@ mod unify {
case (ty::ty_var(?expected_id)) { case (ty::ty_var(?expected_id)) {
// Add a binding. // Add a binding.
auto expected_n = get_or_create_set(cx, expected_id); auto expected_n = get_or_create_set(cx, expected_id);
auto vlen = _vec::len[vec[t]](cx.types); auto vlen = vec::len[vec[t]](cx.types);
if (expected_n < vlen) { if (expected_n < vlen) {
cx.types.(expected_n) += [actual]; cx.types.(expected_n) += [actual];
} else { } else {
@ -2519,7 +2519,7 @@ mod unify {
fn unify_sets(&@ctxt cx) -> vec[t] { fn unify_sets(&@ctxt cx) -> vec[t] {
let vec[t] throwaway = []; let vec[t] throwaway = [];
let vec[mutable vec[t]] set_types = [mutable throwaway]; let vec[mutable vec[t]] set_types = [mutable throwaway];
_vec::pop[vec[t]](set_types); // FIXME: botch vec::pop[vec[t]](set_types); // FIXME: botch
for (ufind::node node in cx.sets.nodes) { for (ufind::node node in cx.sets.nodes) {
let vec[t] v = []; let vec[t] v = [];
@ -2527,7 +2527,7 @@ mod unify {
} }
auto i = 0u; auto i = 0u;
while (i < _vec::len[vec[t]](set_types)) { while (i < vec::len[vec[t]](set_types)) {
auto root = ufind::find(cx.sets, i); auto root = ufind::find(cx.sets, i);
set_types.(root) += cx.types.(i); set_types.(root) += cx.types.(i);
i += 1u; i += 1u;
@ -2535,7 +2535,7 @@ mod unify {
let vec[t] result = []; let vec[t] result = [];
for (vec[t] types in set_types) { for (vec[t] types in set_types) {
if (_vec::len[t](types) > 1u) { if (vec::len[t](types) > 1u) {
log_err "unification of > 1 types in a type set is " + log_err "unification of > 1 types in a type set is " +
"unimplemented"; "unimplemented";
fail; fail;
@ -2552,7 +2552,7 @@ mod unify {
&ty_ctxt tcx) -> result { &ty_ctxt tcx) -> result {
let vec[t] throwaway = []; let vec[t] throwaway = [];
let vec[mutable vec[t]] types = [mutable throwaway]; let vec[mutable vec[t]] types = [mutable throwaway];
_vec::pop[vec[t]](types); // FIXME: botch vec::pop[vec[t]](types); // FIXME: botch
auto cx = @rec(sets=ufind::make(), auto cx = @rec(sets=ufind::make(),
var_ids=common::new_int_hash[uint](), var_ids=common::new_int_hash[uint](),
@ -2565,7 +2565,7 @@ mod unify {
case (ures_ok(?typ)) { case (ures_ok(?typ)) {
// Fast path: if there are no local variables, don't perform // Fast path: if there are no local variables, don't perform
// substitutions. // substitutions.
if (_vec::len(cx.sets.nodes) == 0u) { if (vec::len(cx.sets.nodes) == 0u) {
ret ures_ok(typ); ret ures_ok(typ);
} }
@ -2591,16 +2591,16 @@ fn type_err_to_str(&ty::type_err err) -> str {
ret "vectors differ in mutability"; ret "vectors differ in mutability";
} }
case (terr_tuple_size(?e_sz, ?a_sz)) { case (terr_tuple_size(?e_sz, ?a_sz)) {
ret "expected a tuple with " + _uint::to_str(e_sz, 10u) + ret "expected a tuple with " + uint::to_str(e_sz, 10u) +
" elements but found one with " + _uint::to_str(a_sz, 10u) + " elements but found one with " + uint::to_str(a_sz, 10u) +
" elements"; " elements";
} }
case (terr_tuple_mutability) { case (terr_tuple_mutability) {
ret "tuple elements differ in mutability"; ret "tuple elements differ in mutability";
} }
case (terr_record_size(?e_sz, ?a_sz)) { case (terr_record_size(?e_sz, ?a_sz)) {
ret "expected a record with " + _uint::to_str(e_sz, 10u) + ret "expected a record with " + uint::to_str(e_sz, 10u) +
" fields but found one with " + _uint::to_str(a_sz, 10u) + " fields but found one with " + uint::to_str(a_sz, 10u) +
" fields"; " fields";
} }
case (terr_record_mutability) { case (terr_record_mutability) {

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

@ -37,9 +37,9 @@ import middle::ty::ty_nil;
import middle::ty::unify::ures_ok; import middle::ty::unify::ures_ok;
import middle::ty::unify::ures_err; import middle::ty::unify::ures_err;
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
import std::map; import std::map;
import std::map::hashmap; import std::map::hashmap;
import std::option; import std::option;
@ -97,12 +97,12 @@ fn substitute_ty_params(&@crate_ctxt ccx,
} }
} }
auto supplied_len = _vec::len[ty::t](supplied); auto supplied_len = vec::len[ty::t](supplied);
if (ty_param_count != supplied_len) { if (ty_param_count != supplied_len) {
ccx.sess.span_err(sp, "expected " + ccx.sess.span_err(sp, "expected " +
_uint::to_str(ty_param_count, 10u) + uint::to_str(ty_param_count, 10u) +
" type parameter(s) but found " + " type parameter(s) but found " +
_uint::to_str(supplied_len, 10u) + " parameter(s)"); uint::to_str(supplied_len, 10u) + " parameter(s)");
fail; fail;
} }
@ -187,7 +187,7 @@ fn instantiate_path(&@fn_ctxt fcx, &ast::path pth, &ty_param_count_and_ty tpt,
auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1); auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1);
auto ty_substs_opt; auto ty_substs_opt;
auto ty_substs_len = _vec::len[@ast::ty](pth.node.types); auto ty_substs_len = vec::len[@ast::ty](pth.node.types);
if (ty_substs_len > 0u) { if (ty_substs_len > 0u) {
let vec[ty::t] ty_substs = []; let vec[ty::t] ty_substs = [];
auto i = 0u; auto i = 0u;
@ -298,7 +298,7 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
case (ast::ty_tup(?fields)) { case (ast::ty_tup(?fields)) {
let vec[ty::mt] flds = []; let vec[ty::mt] flds = [];
for (ast::mt field in fields) { for (ast::mt field in fields) {
_vec::push[ty::mt](flds, ast_mt_to_mt(tcx, getter, field)); vec::push[ty::mt](flds, ast_mt_to_mt(tcx, getter, field));
} }
typ = ty::mk_tup(tcx, flds); typ = ty::mk_tup(tcx, flds);
} }
@ -306,14 +306,14 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
let vec[field] flds = []; let vec[field] flds = [];
for (ast::ty_field f in fields) { for (ast::ty_field f in fields) {
auto tm = ast_mt_to_mt(tcx, getter, f.mt); auto tm = ast_mt_to_mt(tcx, getter, f.mt);
_vec::push[field](flds, rec(ident=f.ident, mt=tm)); vec::push[field](flds, rec(ident=f.ident, mt=tm));
} }
typ = ty::mk_rec(tcx, flds); typ = ty::mk_rec(tcx, flds);
} }
case (ast::ty_fn(?proto, ?inputs, ?output)) { case (ast::ty_fn(?proto, ?inputs, ?output)) {
auto f = bind ast_arg_to_arg(tcx, getter, _); auto f = bind ast_arg_to_arg(tcx, getter, _);
auto i = _vec::map[ast::ty_arg, arg](f, inputs); auto i = vec::map[ast::ty_arg, arg](f, inputs);
auto out_ty = ast_ty_to_ty(tcx, getter, output); auto out_ty = ast_ty_to_ty(tcx, getter, output);
typ = ty::mk_fn(tcx, proto, i, out_ty); typ = ty::mk_fn(tcx, proto, i, out_ty);
} }
@ -341,9 +341,9 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t {
let vec[ty::method] tmeths = []; let vec[ty::method] tmeths = [];
auto f = bind ast_arg_to_arg(tcx, getter, _); auto f = bind ast_arg_to_arg(tcx, getter, _);
for (ast::ty_method m in meths) { for (ast::ty_method m in meths) {
auto ins = _vec::map[ast::ty_arg, arg](f, m.inputs); auto ins = vec::map[ast::ty_arg, arg](f, m.inputs);
auto out = ast_ty_to_ty(tcx, getter, m.output); auto out = ast_ty_to_ty(tcx, getter, m.output);
_vec::push[ty::method](tmeths, vec::push[ty::method](tmeths,
rec(proto=m.proto, rec(proto=m.proto,
ident=m.ident, ident=m.ident,
inputs=ins, inputs=ins,
@ -377,7 +377,7 @@ fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast::ty ast_ty) -> ty::t {
// Writes a type parameter count and type pair into the node type table. // Writes a type parameter count and type pair into the node type table.
fn write_type(&node_type_table ntt, uint node_id, fn write_type(&node_type_table ntt, uint node_id,
&ty_param_substs_opt_and_ty tpot) { &ty_param_substs_opt_and_ty tpot) {
_vec::grow_set[option::t[ty::ty_param_substs_opt_and_ty]] vec::grow_set[option::t[ty::ty_param_substs_opt_and_ty]]
(*ntt, (*ntt,
node_id, node_id,
none[ty_param_substs_opt_and_ty], none[ty_param_substs_opt_and_ty],
@ -425,10 +425,10 @@ mod collect {
ast::proto proto, ast::proto proto,
&vec[ast::ty_param] ty_params, &vec[ast::ty_param] ty_params,
&ast::def_id def_id) -> ty::ty_param_count_and_ty { &ast::def_id def_id) -> ty::ty_param_count_and_ty {
auto input_tys = _vec::map[ast::arg,arg](ty_of_arg, decl.inputs); auto input_tys = vec::map[ast::arg,arg](ty_of_arg, decl.inputs);
auto output_ty = convert(decl.output); auto output_ty = convert(decl.output);
auto t_fn = ty::mk_fn(cx.tcx, proto, input_tys, output_ty); auto t_fn = ty::mk_fn(cx.tcx, proto, input_tys, output_ty);
auto ty_param_count = _vec::len[ast::ty_param](ty_params); auto ty_param_count = vec::len[ast::ty_param](ty_params);
auto tpt = tup(ty_param_count, t_fn); auto tpt = tup(ty_param_count, t_fn);
cx.type_cache.insert(def_id, tpt); cx.type_cache.insert(def_id, tpt);
ret tpt; ret tpt;
@ -441,10 +441,10 @@ mod collect {
ast::native_abi abi, ast::native_abi abi,
&vec[ast::ty_param] ty_params, &vec[ast::ty_param] ty_params,
&ast::def_id def_id) -> ty::ty_param_count_and_ty{ &ast::def_id def_id) -> ty::ty_param_count_and_ty{
auto input_tys = _vec::map[ast::arg,arg](ty_of_arg, decl.inputs); auto input_tys = vec::map[ast::arg,arg](ty_of_arg, decl.inputs);
auto output_ty = convert(decl.output); auto output_ty = convert(decl.output);
auto t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty); auto t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty);
auto ty_param_count = _vec::len[ast::ty_param](ty_params); auto ty_param_count = vec::len[ast::ty_param](ty_params);
auto tpt = tup(ty_param_count, t_fn); auto tpt = tup(ty_param_count, t_fn);
cx.type_cache.insert(def_id, tpt); cx.type_cache.insert(def_id, tpt);
ret tpt; ret tpt;
@ -479,7 +479,7 @@ mod collect {
auto get = bind getter(cx, _); auto get = bind getter(cx, _);
auto convert = bind ast_ty_to_ty(cx.tcx, get, _); auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
auto f = bind ty_of_arg(cx, _); auto f = bind ty_of_arg(cx, _);
auto inputs = _vec::map[ast::arg,arg](f, m.node.meth.decl.inputs); auto inputs = vec::map[ast::arg,arg](f, m.node.meth.decl.inputs);
auto output = convert(m.node.meth.decl.output); auto output = convert(m.node.meth.decl.output);
ret rec(proto=m.node.meth.proto, ident=m.node.ident, ret rec(proto=m.node.meth.proto, ident=m.node.ident,
inputs=inputs, output=output); inputs=inputs, output=output);
@ -492,7 +492,7 @@ mod collect {
auto methods = get_obj_method_types(cx, obj_info); auto methods = get_obj_method_types(cx, obj_info);
auto t_obj = ty::mk_obj(cx.tcx, ty::sort_methods(methods)); auto t_obj = ty::mk_obj(cx.tcx, ty::sort_methods(methods));
t_obj = ty::rename(cx.tcx, t_obj, id); t_obj = ty::rename(cx.tcx, t_obj, id);
auto ty_param_count = _vec::len[ast::ty_param](ty_params); auto ty_param_count = vec::len[ast::ty_param](ty_params);
ret tup(ty_param_count, t_obj); ret tup(ty_param_count, t_obj);
} }
@ -508,7 +508,7 @@ mod collect {
for (ast::obj_field f in obj_info.fields) { for (ast::obj_field f in obj_info.fields) {
auto g = bind getter(cx, _); auto g = bind getter(cx, _);
auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty); auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
_vec::push[arg](t_inputs, rec(mode=ty::mo_alias, ty=t_field)); vec::push[arg](t_inputs, rec(mode=ty::mo_alias, ty=t_field));
} }
auto t_fn = ty::mk_fn(cx.tcx, ast::proto_fn, t_inputs, t_obj._1); auto t_fn = ty::mk_fn(cx.tcx, ast::proto_fn, t_inputs, t_obj._1);
@ -555,7 +555,7 @@ mod collect {
// Tell ast_ty_to_ty() that we want to perform a recursive // Tell ast_ty_to_ty() that we want to perform a recursive
// call to resolve any named types. // call to resolve any named types.
auto typ = convert(t); auto typ = convert(t);
auto ty_param_count = _vec::len[ast::ty_param](tps); auto ty_param_count = vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, typ); auto tpt = tup(ty_param_count, typ);
cx.type_cache.insert(def_id, tpt); cx.type_cache.insert(def_id, tpt);
ret tpt; ret tpt;
@ -573,7 +573,7 @@ mod collect {
auto t = ty::mk_tag(cx.tcx, def_id, subtys); auto t = ty::mk_tag(cx.tcx, def_id, subtys);
auto ty_param_count = _vec::len[ast::ty_param](tps); auto ty_param_count = vec::len[ast::ty_param](tps);
auto tpt = tup(ty_param_count, t); auto tpt = tup(ty_param_count, t);
cx.type_cache.insert(def_id, tpt); cx.type_cache.insert(def_id, tpt);
ret tpt; ret tpt;
@ -625,13 +625,13 @@ mod collect {
i += 1u; i += 1u;
} }
auto ty_param_count = _vec::len[ast::ty_param](ty_params); auto ty_param_count = vec::len[ast::ty_param](ty_params);
for (ast::variant variant in variants) { for (ast::variant variant in variants) {
// Nullary tag constructors get turned into constants; n-ary tag // Nullary tag constructors get turned into constants; n-ary tag
// constructors get turned into functions. // constructors get turned into functions.
auto result_ty; auto result_ty;
if (_vec::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); result_ty = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
} else { } else {
// As above, tell ast_ty_to_ty() that trans_ty_item_to_ty() // As above, tell ast_ty_to_ty() that trans_ty_item_to_ty()
@ -662,7 +662,7 @@ mod collect {
} }
fn get_obj_method_types(&@ctxt cx, &ast::_obj object) -> vec[method] { fn get_obj_method_types(&@ctxt cx, &ast::_obj object) -> vec[method] {
ret _vec::map[@ast::method,method](bind ty_of_method(cx, _), ret vec::map[@ast::method,method](bind ty_of_method(cx, _),
object.methods); object.methods);
} }
@ -726,7 +726,7 @@ mod collect {
// ty_of_obj().) // ty_of_obj().)
auto method_types = get_obj_method_types(cx, object); auto method_types = get_obj_method_types(cx, object);
auto i = 0u; auto i = 0u;
while (i < _vec::len[@ast::method](object.methods)) { while (i < vec::len[@ast::method](object.methods)) {
write_type_only(cx.node_types, write_type_only(cx.node_types,
ast::ann_tag(object.methods.(i).node.ann), ast::ann_tag(object.methods.(i).node.ann),
ty::method_ty_to_fn_ty(cx.tcx, ty::method_ty_to_fn_ty(cx.tcx,
@ -736,11 +736,11 @@ mod collect {
// Write in the types of the object fields. // Write in the types of the object fields.
// //
// FIXME: We want to use _uint::range() here, but that causes // FIXME: We want to use uint::range() here, but that causes
// an assertion in trans. // an assertion in trans.
auto args = ty::ty_fn_args(cx.tcx, tpt._1); auto args = ty::ty_fn_args(cx.tcx, tpt._1);
i = 0u; i = 0u;
while (i < _vec::len[ty::arg](args)) { while (i < vec::len[ty::arg](args)) {
auto fld = object.fields.(i); auto fld = object.fields.(i);
write_type_only(cx.node_types, ast::ann_tag(fld.ann), write_type_only(cx.node_types, ast::ann_tag(fld.ann),
args.(i).ty); args.(i).ty);
@ -840,7 +840,7 @@ mod unify {
// FIXME: horrid botch // FIXME: horrid botch
let vec[mutable ty::t] param_substs = let vec[mutable ty::t] param_substs =
[mutable ty::mk_nil(fcx.ccx.tcx)]; [mutable ty::mk_nil(fcx.ccx.tcx)];
_vec::pop(param_substs); vec::pop(param_substs);
ret with_params(fcx, expected, actual, param_substs); ret with_params(fcx, expected, actual, param_substs);
} }
@ -999,7 +999,7 @@ mod Demand {
let vec[mutable ty::t] ty_param_substs = let vec[mutable ty::t] ty_param_substs =
[mutable ty::mk_nil(fcx.ccx.tcx)]; [mutable ty::mk_nil(fcx.ccx.tcx)];
_vec::pop(ty_param_substs); // FIXME: horrid botch vec::pop(ty_param_substs); // FIXME: horrid botch
for (ty::t ty_param_subst in ty_param_substs_0) { for (ty::t ty_param_subst in ty_param_substs_0) {
ty_param_substs += [mutable ty_param_subst]; ty_param_substs += [mutable ty_param_subst];
} }
@ -1042,7 +1042,7 @@ fn are_compatible(&@fn_ctxt fcx, &ty::t expected, &ty::t actual) -> bool {
// Returns the types of the arguments to a tag variant. // Returns the types of the arguments to a tag variant.
fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid, fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid,
&vec[ty::t] tag_ty_params) -> vec[ty::t] { &vec[ty::t] tag_ty_params) -> vec[ty::t] {
auto ty_param_count = _vec::len[ty::t](tag_ty_params); auto ty_param_count = vec::len[ty::t](tag_ty_params);
let vec[ty::t] result = []; let vec[ty::t] result = [];
@ -1137,7 +1137,7 @@ mod Pushdown {
pat.span, pat.span,
t1, t2); t1, t2);
_vec::push(tparams, res); vec::push(tparams, res);
j += 1u; j += 1u;
} }
@ -1247,7 +1247,7 @@ mod Pushdown {
case (none[@ast::expr]) { case (none[@ast::expr]) {
auto i = 0u; auto i = 0u;
for (ast::field field_0 in fields_0) { for (ast::field field_0 in fields_0) {
assert (_str::eq(field_0.ident, assert (str::eq(field_0.ident,
field_mts.(i).ident)); field_mts.(i).ident));
auto e_1 = auto e_1 =
pushdown_expr(fcx, pushdown_expr(fcx,
@ -1269,7 +1269,7 @@ mod Pushdown {
for (ast::field field_0 in fields_0) { for (ast::field field_0 in fields_0) {
for (ty::field ft in field_mts) { for (ty::field ft in field_mts) {
if (_str::eq(field_0.ident, if (str::eq(field_0.ident,
ft.ident)) { ft.ident)) {
auto e_1 = auto e_1 =
pushdown_expr(fcx, ft.mt.ty, pushdown_expr(fcx, ft.mt.ty,
@ -1713,7 +1713,7 @@ fn check_pat(&@fn_ctxt fcx, &@ast::pat pat) {
(fcx.ccx.tcx.def_map.get(ast::ann_tag(old_ann))); (fcx.ccx.tcx.def_map.get(ast::ann_tag(old_ann)));
auto t = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx, auto t = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
fcx.ccx.type_cache, vdef._1)._1; fcx.ccx.type_cache, vdef._1)._1;
auto len = _vec::len[ast::ident](p.node.idents); auto len = vec::len[ast::ident](p.node.idents);
auto last_id = p.node.idents.(len - 1u); auto last_id = p.node.idents.(len - 1u);
auto tpt = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx, auto tpt = ty::lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx,
@ -1724,14 +1724,14 @@ fn check_pat(&@fn_ctxt fcx, &@ast::pat pat) {
alt (struct(fcx.ccx.tcx, t)) { alt (struct(fcx.ccx.tcx, t)) {
// N-ary variants have function types. // N-ary variants have function types.
case (ty::ty_fn(_, ?args, ?tag_ty)) { case (ty::ty_fn(_, ?args, ?tag_ty)) {
auto arg_len = _vec::len[arg](args); auto arg_len = vec::len[arg](args);
auto subpats_len = _vec::len[@ast::pat](subpats); auto subpats_len = vec::len[@ast::pat](subpats);
if (arg_len != subpats_len) { if (arg_len != subpats_len) {
// TODO: pluralize properly // TODO: pluralize properly
auto err_msg = "tag type " + last_id + " has " + auto err_msg = "tag type " + last_id + " has " +
_uint::to_str(subpats_len, 10u) + uint::to_str(subpats_len, 10u) +
" field(s), but this pattern has " + " field(s), but this pattern has " +
_uint::to_str(arg_len, 10u) + uint::to_str(arg_len, 10u) +
" field(s)"; " field(s)";
fcx.ccx.sess.span_err(pat.span, err_msg); fcx.ccx.sess.span_err(pat.span, err_msg);
@ -1748,13 +1748,13 @@ fn check_pat(&@fn_ctxt fcx, &@ast::pat pat) {
// Nullary variants have tag types. // Nullary variants have tag types.
case (ty::ty_tag(?tid, _)) { case (ty::ty_tag(?tid, _)) {
auto subpats_len = _vec::len[@ast::pat](subpats); auto subpats_len = vec::len[@ast::pat](subpats);
if (subpats_len > 0u) { if (subpats_len > 0u) {
// TODO: pluralize properly // TODO: pluralize properly
auto err_msg = "tag type " + last_id + auto err_msg = "tag type " + last_id +
" has no field(s)," + " has no field(s)," +
" but this pattern has " + " but this pattern has " +
_uint::to_str(subpats_len, 10u) + uint::to_str(subpats_len, 10u) +
" field(s)"; " field(s)";
fcx.ccx.sess.span_err(pat.span, err_msg); fcx.ccx.sess.span_err(pat.span, err_msg);
@ -1855,13 +1855,13 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto arg_ty = rec(mode=mo_either, auto arg_ty = rec(mode=mo_either,
ty=expr_ty(fcx.ccx.tcx, ty=expr_ty(fcx.ccx.tcx,
fcx.ccx.node_types, a_0)); fcx.ccx.node_types, a_0));
_vec::push[arg](arg_tys_0, arg_ty); vec::push[arg](arg_tys_0, arg_ty);
} }
case (none[@ast::expr]) { case (none[@ast::expr]) {
args_0 += [none[@ast::expr]]; args_0 += [none[@ast::expr]];
auto typ = next_ty_var(fcx.ccx); auto typ = next_ty_var(fcx.ccx);
_vec::push[arg](arg_tys_0, rec(mode=mo_either, ty=typ)); vec::push[arg](arg_tys_0, rec(mode=mo_either, ty=typ));
} }
} }
} }
@ -2028,7 +2028,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
// The definition doesn't take type parameters. If the programmer // The definition doesn't take type parameters. If the programmer
// supplied some, that's an error. // supplied some, that's an error.
if (_vec::len[@ast::ty](pth.node.types) > 0u) { if (vec::len[@ast::ty](pth.node.types) > 0u) {
fcx.ccx.sess.span_err(expr.span, "this kind of value does " + fcx.ccx.sess.span_err(expr.span, "this kind of value does " +
"not take type parameters"); "not take type parameters");
fail; fail;
@ -2471,7 +2471,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
// For each blank argument, add the type of that argument // For each blank argument, add the type of that argument
// to the resulting function type. // to the resulting function type.
auto i = 0u; auto i = 0u;
while (i < _vec::len[option::t[@ast::expr]](args)) { while (i < vec::len[option::t[@ast::expr]](args)) {
alt (args.(i)) { alt (args.(i)) {
case (some[@ast::expr](_)) { /* no-op */ } case (some[@ast::expr](_)) { /* no-op */ }
case (none[@ast::expr]) { case (none[@ast::expr]) {
@ -2623,7 +2623,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
let vec[@ast::expr] args_1 = []; let vec[@ast::expr] args_1 = [];
let ty::t t; let ty::t t;
if (_vec::len[@ast::expr](args) == 0u) { if (vec::len[@ast::expr](args) == 0u) {
t = next_ty_var(fcx.ccx); t = next_ty_var(fcx.ccx);
} else { } else {
auto expr_1 = check_expr(fcx, args.(0)); auto expr_1 = check_expr(fcx, args.(0));
@ -2635,7 +2635,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types, auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
expr_1); expr_1);
Demand::simple(fcx, expr.span, t, expr_t); Demand::simple(fcx, expr.span, t, expr_t);
_vec::push[@ast::expr](args_1,expr_1); vec::push[@ast::expr](args_1,expr_1);
} }
auto typ = ty::mk_vec(fcx.ccx.tcx, rec(ty=t, mut=mut)); auto typ = ty::mk_vec(fcx.ccx.tcx, rec(ty=t, mut=mut));
@ -2653,7 +2653,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto expr_1 = check_expr(fcx, e.expr); auto expr_1 = check_expr(fcx, e.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types, auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
expr_1); expr_1);
_vec::push[ast::elt](elts_1, rec(expr=expr_1 with e)); vec::push[ast::elt](elts_1, rec(expr=expr_1 with e));
elts_mt += [rec(ty=expr_t, mut=e.mut)]; elts_mt += [rec(ty=expr_t, mut=e.mut)];
} }
@ -2681,10 +2681,10 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
auto expr_1 = check_expr(fcx, f.expr); auto expr_1 = check_expr(fcx, f.expr);
auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types, auto expr_t = expr_ty(fcx.ccx.tcx, fcx.ccx.node_types,
expr_1); expr_1);
_vec::push[ast::field](fields_1, rec(expr=expr_1 with f)); vec::push[ast::field](fields_1, rec(expr=expr_1 with f));
auto expr_mt = rec(ty=expr_t, mut=f.mut); auto expr_mt = rec(ty=expr_t, mut=f.mut);
_vec::push[field](fields_t, rec(ident=f.ident, mt=expr_mt)); vec::push[field](fields_t, rec(ident=f.ident, mt=expr_mt));
} }
auto ann; auto ann;
@ -2721,7 +2721,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
for (ty::field f in fields_t) { for (ty::field f in fields_t) {
auto found = false; auto found = false;
for (ty::field bf in base_fields) { for (ty::field bf in base_fields) {
if (_str::eq(f.ident, bf.ident)) { if (str::eq(f.ident, bf.ident)) {
Demand::simple(fcx, expr.span, f.mt.ty, Demand::simple(fcx, expr.span, f.mt.ty,
bf.mt.ty); bf.mt.ty);
found = true; found = true;
@ -2749,7 +2749,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
case (ty::ty_tup(?args)) { case (ty::ty_tup(?args)) {
let uint ix = ty::field_num(fcx.ccx.sess, let uint ix = ty::field_num(fcx.ccx.sess,
expr.span, field); expr.span, field);
if (ix >= _vec::len[ty::mt](args)) { if (ix >= vec::len[ty::mt](args)) {
fcx.ccx.sess.span_err(expr.span, fcx.ccx.sess.span_err(expr.span,
"bad index on tuple"); "bad index on tuple");
} }
@ -2765,7 +2765,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
case (ty::ty_rec(?fields)) { case (ty::ty_rec(?fields)) {
let uint ix = ty::field_idx(fcx.ccx.sess, let uint ix = ty::field_idx(fcx.ccx.sess,
expr.span, field, fields); expr.span, field, fields);
if (ix >= _vec::len[typeck::field](fields)) { if (ix >= vec::len[typeck::field](fields)) {
fcx.ccx.sess.span_err(expr.span, fcx.ccx.sess.span_err(expr.span,
"bad index on record"); "bad index on record");
} }
@ -2781,7 +2781,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) -> @ast::expr {
case (ty::ty_obj(?methods)) { case (ty::ty_obj(?methods)) {
let uint ix = ty::method_idx(fcx.ccx.sess, let uint ix = ty::method_idx(fcx.ccx.sess,
expr.span, field, methods); expr.span, field, methods);
if (ix >= _vec::len[typeck::method](methods)) { if (ix >= vec::len[typeck::method](methods)) {
fcx.ccx.sess.span_err(expr.span, fcx.ccx.sess.span_err(expr.span,
"bad index on obj"); "bad index on obj");
} }
@ -2998,7 +2998,7 @@ fn check_stmt(&@fn_ctxt fcx, &@ast::stmt stmt) -> @ast::stmt {
fn check_block(&@fn_ctxt fcx, &ast::block block) -> ast::block { fn check_block(&@fn_ctxt fcx, &ast::block block) -> ast::block {
let vec[@ast::stmt] stmts = []; let vec[@ast::stmt] stmts = [];
for (@ast::stmt s in block.node.stmts) { for (@ast::stmt s in block.node.stmts) {
_vec::push[@ast::stmt](stmts, check_stmt(fcx, s)); vec::push[@ast::stmt](stmts, check_stmt(fcx, s));
} }
auto expr = none[@ast::expr]; auto expr = none[@ast::expr];
@ -3125,7 +3125,7 @@ fn hash_unify_cache_entry(&unify_cache_entry uce) -> uint {
h += h << 5u + ty::hash_ty(uce._1); h += h << 5u + ty::hash_ty(uce._1);
auto i = 0u; auto i = 0u;
auto tys_len = _vec::len(uce._2); auto tys_len = vec::len(uce._2);
while (i < tys_len) { while (i < tys_len) {
h += h << 5u + ty::hash_ty(uce._2.(i)); h += h << 5u + ty::hash_ty(uce._2.(i));
i += 1u; i += 1u;
@ -3138,8 +3138,8 @@ fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool {
if (!ty::eq_ty(a._0, b._0) || !ty::eq_ty(a._1, b._1)) { ret false; } if (!ty::eq_ty(a._0, b._0) || !ty::eq_ty(a._1, b._1)) { ret false; }
auto i = 0u; auto i = 0u;
auto tys_len = _vec::len(a._2); auto tys_len = vec::len(a._2);
if (_vec::len(b._2) != tys_len) { ret false; } if (vec::len(b._2) != tys_len) { ret false; }
while (i < tys_len) { while (i < tys_len) {
if (!ty::eq_ty(a._2.(i), b._2.(i))) { ret false; } if (!ty::eq_ty(a._2.(i), b._2.(i))) { ret false; }

94
src/comp/middle/typestate_check.rs
View file

@ -154,15 +154,15 @@ import pretty::pp::mkstate;
import std::io::stdout; import std::io::stdout;
import std::io::str_writer; import std::io::str_writer;
import std::io::string_writer; import std::io::string_writer;
import std::_vec::map; import std::vec::map;
import std::_vec; import std::vec;
import std::_vec::len; import std::vec::len;
import std::_vec::pop; import std::vec::pop;
import std::_vec::push; import std::vec::push;
import std::_vec::slice; import std::vec::slice;
import std::_vec::unzip; import std::vec::unzip;
import std::_vec::plus_option; import std::vec::plus_option;
import std::_vec::cat_options; import std::vec::cat_options;
import std::option; import std::option;
import std::option::t; import std::option::t;
import std::option::some; import std::option::some;
@ -178,7 +178,7 @@ import std::list::cons;
import std::list::nil; import std::list::nil;
import std::list::foldl; import std::list::foldl;
import std::list::find; import std::list::find;
import std::_uint; import std::uint;
import std::bitv; import std::bitv;
import std::util::fst; import std::util::fst;
import std::util::snd; import std::util::snd;
@ -310,12 +310,12 @@ fn num_locals(fn_info m) -> uint {
fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast::local loc) fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast::local loc)
-> @decl { -> @decl {
log("collect_local: pushing " + loc.ident); log("collect_local: pushing " + loc.ident);
_vec::push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id)); vec::push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id));
ret @respan(sp, decl_local(loc)); ret @respan(sp, decl_local(loc));
} }
fn find_locals(_fn f) -> @vec[tup(ident,def_id)] { fn find_locals(_fn f) -> @vec[tup(ident,def_id)] {
auto res = @_vec::alloc[tup(ident,def_id)](0u); auto res = @vec::alloc[tup(ident,def_id)](0u);
auto fld = fold::new_identity_fold[@vec[tup(ident, def_id)]](); auto fld = fold::new_identity_fold[@vec[tup(ident, def_id)]]();
fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld); fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld);
@ -341,7 +341,7 @@ fn mk_fn_info(_fn f) -> fn_info {
just collect locally declared vars */ just collect locally declared vars */
let @vec[tup(ident,def_id)] locals = find_locals(f); let @vec[tup(ident,def_id)] locals = find_locals(f);
log(uistr(_vec::len[tup(ident, def_id)](*locals)) + " locals"); log(uistr(vec::len[tup(ident, def_id)](*locals)) + " locals");
for (tup(ident,def_id) p in *locals) { for (tup(ident,def_id) p in *locals) {
next = add_var(p._1, p._0, next, res); next = add_var(p._1, p._0, next, res);
} }
@ -363,7 +363,7 @@ fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast::_fn f,
fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast::_obj o, fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast::_obj o,
&vec[ast::ty_param] ty_params, &vec[ast::ty_param] ty_params,
&ast::obj_def_ids odid, &ann a) -> @item { &ast::obj_def_ids odid, &ann a) -> @item {
auto all_methods = _vec::clone[@method](o.methods); auto all_methods = vec::clone[@method](o.methods);
plus_option[@method](all_methods, o.dtor); plus_option[@method](all_methods, o.dtor);
for (@method m in all_methods) { for (@method m in all_methods) {
fi.insert(m.node.id, mk_fn_info(m.node.meth)); fi.insert(m.node.id, mk_fn_info(m.node.meth));
@ -651,7 +651,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond {
/* works on either postconds or preconds /* works on either postconds or preconds
should probably rethink the whole type synonym situation */ should probably rethink the whole type synonym situation */
fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec::len[postcond](rest); auto sz = vec::len[postcond](rest);
if (sz > 0u) { if (sz > 0u) {
auto other = rest.(0); auto other = rest.(0);
@ -673,7 +673,7 @@ fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond {
/* Gee, maybe we could use foldl or something */ /* Gee, maybe we could use foldl or something */
fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
auto sz = _vec::len[postcond](rest); auto sz = vec::len[postcond](rest);
if (sz > 0u) { if (sz > 0u) {
auto other = rest.(0); auto other = rest.(0);
@ -719,7 +719,7 @@ fn find_pre_post_obj(&def_map dm, &fn_info_map fm, _obj o) -> () {
find_pre_post_fn(dm, fm, fm.get(m.node.id), m.node.meth); find_pre_post_fn(dm, fm, fm.get(m.node.id), m.node.meth);
} }
auto f = bind do_a_method(dm, fm, _); auto f = bind do_a_method(dm, fm, _);
_vec::map[@method, ()](f, o.methods); vec::map[@method, ()](f, o.methods);
option::map[@method, ()](f, o.dtor); option::map[@method, ()](f, o.dtor);
} }
@ -729,8 +729,8 @@ fn find_pre_post_state_obj(&def_map dm, &fn_info_map fm, _obj o) -> bool {
ret find_pre_post_state_fn(dm, fm, fm.get(m.node.id), m.node.meth); ret find_pre_post_state_fn(dm, fm, fm.get(m.node.id), m.node.meth);
} }
auto f = bind do_a_method(dm, fm, _); auto f = bind do_a_method(dm, fm, _);
auto flags = _vec::map[@method, bool](f, o.methods); auto flags = vec::map[@method, bool](f, o.methods);
auto changed = _vec::or(flags); auto changed = vec::or(flags);
changed = changed || maybe[@method, bool](false, f, o.dtor); changed = changed || maybe[@method, bool](false, f, o.dtor);
ret changed; ret changed;
} }
@ -777,19 +777,19 @@ fn find_pre_post_exprs(&def_map dm, &fn_info_map fm, &fn_info enclosing,
} }
auto f = bind do_one(dm, fm, enclosing, _); auto f = bind do_one(dm, fm, enclosing, _);
_vec::map[@expr, ()](f, args); vec::map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post { fn get_pp(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(e);
} }
auto g = get_pp; auto g = get_pp;
auto pps = _vec::map[@expr, pre_and_post](g, args); auto pps = vec::map[@expr, pre_and_post](g, args);
auto h = get_post; auto h = get_post;
set_pre_and_post(a, set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing, pps), rec(precondition=seq_preconds(enclosing, pps),
postcondition=union_postconds postcondition=union_postconds
(nv, (_vec::map[pre_and_post, postcond](h, pps))))); (nv, (vec::map[pre_and_post, postcond](h, pps)))));
} }
fn find_pre_post_loop(&def_map dm, &fn_info_map fm, &fn_info enclosing, fn find_pre_post_loop(&def_map dm, &fn_info_map fm, &fn_info enclosing,
@ -816,13 +816,13 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
alt (e.node) { alt (e.node) {
case (expr_call(?operator, ?operands, ?a)) { case (expr_call(?operator, ?operands, ?a)) {
auto args = _vec::clone[@expr](operands); auto args = vec::clone[@expr](operands);
_vec::push[@expr](args, operator); vec::push[@expr](args, operator);
find_pre_post_exprs(dm, fm, enclosing, args, a); find_pre_post_exprs(dm, fm, enclosing, args, a);
} }
case (expr_spawn(_, _, ?operator, ?operands, ?a)) { case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
auto args = _vec::clone[@expr](operands); auto args = vec::clone[@expr](operands);
_vec::push[@expr](args, operator); vec::push[@expr](args, operator);
find_pre_post_exprs(dm, fm, enclosing, args, a); find_pre_post_exprs(dm, fm, enclosing, args, a);
} }
case (expr_vec(?args, _, ?a)) { case (expr_vec(?args, _, ?a)) {
@ -875,7 +875,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
} }
case (expr_rec(?fields,?maybe_base,?a)) { case (expr_rec(?fields,?maybe_base,?a)) {
auto es = field_exprs(fields); auto es = field_exprs(fields);
_vec::plus_option[@expr](es, maybe_base); vec::plus_option[@expr](es, maybe_base);
find_pre_post_exprs(dm, fm, enclosing, es, a); find_pre_post_exprs(dm, fm, enclosing, es, a);
} }
case (expr_assign(?lhs, ?rhs, ?a)) { case (expr_assign(?lhs, ?rhs, ?a)) {
@ -1048,7 +1048,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
ret block_pp(an_alt.block); ret block_pp(an_alt.block);
} }
auto f = bind do_an_alt(dm, fm, enclosing, _); auto f = bind do_an_alt(dm, fm, enclosing, _);
auto alt_pps = _vec::map[arm, pre_and_post](f, alts); auto alt_pps = vec::map[arm, pre_and_post](f, alts);
fn combine_pp(pre_and_post antec, fn combine_pp(pre_and_post antec,
fn_info enclosing, &pre_and_post pp, fn_info enclosing, &pre_and_post pp,
&pre_and_post next) -> pre_and_post { &pre_and_post next) -> pre_and_post {
@ -1062,7 +1062,7 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
postcondition=false_postcond(num_local_vars)); postcondition=false_postcond(num_local_vars));
auto g = bind combine_pp(antec_pp, enclosing, _, _); auto g = bind combine_pp(antec_pp, enclosing, _, _);
auto alts_overall_pp = _vec::foldl[pre_and_post, pre_and_post] auto alts_overall_pp = vec::foldl[pre_and_post, pre_and_post]
(g, e_pp, alt_pps); (g, e_pp, alt_pps);
set_pre_and_post(a, alts_overall_pp); set_pre_and_post(a, alts_overall_pp);
@ -1088,8 +1088,8 @@ fn find_pre_post_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
set_pre_and_post(a, expr_pp(p)); set_pre_and_post(a, expr_pp(p));
} }
case(expr_bind(?operator, ?maybe_args, ?a)) { case(expr_bind(?operator, ?maybe_args, ?a)) {
auto args = _vec::cat_options[@expr](maybe_args); auto args = vec::cat_options[@expr](maybe_args);
_vec::push[@expr](args, operator); /* ??? order of eval? */ vec::push[@expr](args, operator); /* ??? order of eval? */
find_pre_post_exprs(dm, fm, enclosing, args, a); find_pre_post_exprs(dm, fm, enclosing, args, a);
} }
case (expr_break(?a)) { case (expr_break(?a)) {
@ -1207,7 +1207,7 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
} }
auto do_one = bind do_one_(dm, fm, enclosing, _); auto do_one = bind do_one_(dm, fm, enclosing, _);
_vec::map[@stmt, ()](do_one, b.node.stmts); vec::map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(def_map dm, fn_info_map fm, fn_info i, &@expr e) -> () { fn do_inner_(def_map dm, fn_info_map fm, fn_info i, &@expr e) -> () {
find_pre_post_expr(dm, fm, i, e); find_pre_post_expr(dm, fm, i, e);
} }
@ -1220,7 +1220,7 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
ret stmt_pp(*s); ret stmt_pp(*s);
} }
auto f = get_pp_stmt; auto f = get_pp_stmt;
pps += _vec::map[@stmt, pre_and_post](f, b.node.stmts); pps += vec::map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post { fn get_pp_expr(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(e);
} }
@ -1230,10 +1230,10 @@ fn find_pre_post_block(&def_map dm, &fn_info_map fm, &fn_info enclosing,
auto block_precond = seq_preconds(enclosing, pps); auto block_precond = seq_preconds(enclosing, pps);
auto h = get_post; auto h = get_post;
auto postconds = _vec::map[pre_and_post, postcond](h, pps); auto postconds = vec::map[pre_and_post, postcond](h, pps);
/* A block may be empty, so this next line ensures that the postconds /* A block may be empty, so this next line ensures that the postconds
vector is non-empty. */ vector is non-empty. */
_vec::push[postcond](postconds, block_precond); vec::push[postcond](postconds, block_precond);
auto block_postcond = empty_poststate(nv); auto block_postcond = empty_poststate(nv);
/* conservative approximation */ /* conservative approximation */
if (! has_nonlocal_exits(b)) { if (! has_nonlocal_exits(b)) {
@ -1708,7 +1708,7 @@ fn find_pre_post_state_expr(&def_map dm, &fn_info_map fm, &fn_info enclosing,
|| changed; || changed;
auto e_post = expr_poststate(e); auto e_post = expr_poststate(e);
auto a_post; auto a_post;
if (_vec::len[arm](alts) > 0u) { if (vec::len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars); a_post = false_postcond(num_local_vars);
for (arm an_alt in alts) { for (arm an_alt in alts) {
changed = find_pre_post_state_block(dm, fm, enclosing, e_post, changed = find_pre_post_state_block(dm, fm, enclosing, e_post,
@ -1987,7 +1987,7 @@ fn check_states_against_conditions(fn_info enclosing, &ast::_fn f) -> () {
} }
auto do_one = bind do_one_(enclosing, _); auto do_one = bind do_one_(enclosing, _);
_vec::map[@stmt, ()](do_one, f.body.node.stmts); vec::map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_info i, &@expr e) -> () { fn do_inner_(fn_info i, &@expr e) -> () {
check_states_expr(i, e); check_states_expr(i, e);
} }
@ -2034,7 +2034,7 @@ fn check_obj_state(def_map dm, &fn_info_map f_info_map,
ret check_method_states(dm, fm, m); ret check_method_states(dm, fm, m);
} }
auto f = bind one(dm, f_info_map,_); auto f = bind one(dm, f_info_map,_);
_vec::map[@method, ()](f, methods); vec::map[@method, ()](f, methods);
option::map[@method, ()](f, dtor); option::map[@method, ()](f, dtor);
ret rec(fields=fields, methods=methods, dtor=dtor); ret rec(fields=fields, methods=methods, dtor=dtor);
} }
@ -2125,7 +2125,7 @@ fn annotate_exprs(&fn_info_map fm, &vec[@expr] es) -> vec[@expr] {
ret annotate_expr(fm, e); ret annotate_expr(fm, e);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[@expr, @expr](f, es); ret vec::map[@expr, @expr](f, es);
} }
fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] { fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
fn one(fn_info_map fm, &elt e) -> elt { fn one(fn_info_map fm, &elt e) -> elt {
@ -2133,7 +2133,7 @@ fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] {
expr=annotate_expr(fm, e.expr)); expr=annotate_expr(fm, e.expr));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[elt, elt](f, es); ret vec::map[elt, elt](f, es);
} }
fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] { fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
fn one(fn_info_map fm, &field f) -> field { fn one(fn_info_map fm, &field f) -> field {
@ -2142,7 +2142,7 @@ fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] {
expr=annotate_expr(fm, f.expr)); expr=annotate_expr(fm, f.expr));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[field, field](f, fs); ret vec::map[field, field](f, fs);
} }
fn annotate_option_exp(&fn_info_map fm, &option::t[@expr] o) fn annotate_option_exp(&fn_info_map fm, &option::t[@expr] o)
-> option::t[@expr] { -> option::t[@expr] {
@ -2158,7 +2158,7 @@ fn annotate_option_exprs(&fn_info_map fm, &vec[option::t[@expr]] es)
ret annotate_option_exp(fm, o); ret annotate_option_exp(fm, o);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[option::t[@expr], option::t[@expr]](f, es); ret vec::map[option::t[@expr], option::t[@expr]](f, es);
} }
fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl { fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl {
auto d1 = d.node; auto d1 = d.node;
@ -2188,7 +2188,7 @@ fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] {
block=annotate_block(fm, a.block)); block=annotate_block(fm, a.block));
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
ret _vec::map[arm, arm](f, alts); ret vec::map[arm, arm](f, alts);
} }
fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr { fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
@ -2339,7 +2339,7 @@ fn annotate_block(&fn_info_map fm, &block b) -> block {
for (@stmt s in b.node.stmts) { for (@stmt s in b.node.stmts) {
auto new_s = annotate_stmt(fm, s); auto new_s = annotate_stmt(fm, s);
_vec::push[@stmt](new_stmts, new_s); vec::push[@stmt](new_stmts, new_s);
} }
fn ann_e(fn_info_map fm, &@expr e) -> @expr { fn ann_e(fn_info_map fm, &@expr e) -> @expr {
ret annotate_expr(fm, e); ret annotate_expr(fm, e);
@ -2361,7 +2361,7 @@ fn annotate_mod(&fn_info_map fm, &ast::_mod m) -> ast::_mod {
for (@item i in m.items) { for (@item i in m.items) {
auto new_i = annotate_item(fm, i); auto new_i = annotate_item(fm, i);
_vec::push[@item](new_items, new_i); vec::push[@item](new_items, new_i);
} }
ret rec(items=new_items with m); ret rec(items=new_items with m);
} }
@ -2381,7 +2381,7 @@ fn annotate_obj(&fn_info_map fm, &ast::_obj o) -> ast::_obj {
ret annotate_method(fm, m); ret annotate_method(fm, m);
} }
auto f = bind one(fm,_); auto f = bind one(fm,_);
auto new_methods = _vec::map[@method, @method](f, o.methods); auto new_methods = vec::map[@method, @method](f, o.methods);
auto new_dtor = option::map[@method, @method](f, o.dtor); auto new_dtor = option::map[@method, @method](f, o.dtor);
ret rec(methods=new_methods, dtor=new_dtor with o); ret rec(methods=new_methods, dtor=new_dtor with o);
} }
@ -2474,7 +2474,7 @@ fn annotate_module(&fn_info_map fm, &ast::_mod module) -> ast::_mod {
for (@item i in module.items) { for (@item i in module.items) {
auto new_item = annotate_item(fm, i); auto new_item = annotate_item(fm, i);
_vec::push[@item](new_items, new_item); vec::push[@item](new_items, new_item);
} }
ret rec(items = new_items with module); ret rec(items = new_items with module);

30
src/comp/pretty/pp.rs
View file

@ -1,6 +1,6 @@
import std::io; import std::io;
import std::_vec; import std::vec;
import std::_str; import std::str;
tag boxtype {box_h; box_v; box_hv; box_align;} tag boxtype {box_h; box_v; box_hv; box_align;}
tag contexttype {cx_h; cx_v;} tag contexttype {cx_h; cx_v;}
@ -57,12 +57,12 @@ fn write_spaces(ps p, uint i) {
fn push_context(ps p, contexttype tp, uint indent) { fn push_context(ps p, contexttype tp, uint indent) {
before_print(p, false); before_print(p, false);
_vec::push[context](p.context, rec(tp=tp, indent=indent)); vec::push[context](p.context, rec(tp=tp, indent=indent));
p.start_of_box = true; p.start_of_box = true;
} }
fn pop_context(ps p) { fn pop_context(ps p) {
_vec::pop[context](p.context); vec::pop[context](p.context);
} }
fn add_token(ps p, token tok) { fn add_token(ps p, token tok) {
@ -89,7 +89,7 @@ fn buffer_token(ps p, token tok) {
} else { } else {
alt (tok) { alt (tok) {
case (open(?tp,_)) { case (open(?tp,_)) {
_vec::push[boxtype](p.scandepth, tp); vec::push[boxtype](p.scandepth, tp);
if (p.scanning == scan_h) { if (p.scanning == scan_h) {
if (tp == box_h) { if (tp == box_h) {
check_potential_brk(p); check_potential_brk(p);
@ -97,14 +97,14 @@ fn buffer_token(ps p, token tok) {
} }
} }
case (close) { case (close) {
_vec::pop[boxtype](p.scandepth); vec::pop[boxtype](p.scandepth);
if (_vec::len[boxtype](p.scandepth) == 0u) { if (vec::len[boxtype](p.scandepth) == 0u) {
finish_scan(p, true); finish_scan(p, true);
} }
} }
case (brk(_)) { case (brk(_)) {
if (p.scanning == scan_h) { if (p.scanning == scan_h) {
if (p.scandepth.(_vec::len[boxtype](p.scandepth)-1u) == box_v) { if (p.scandepth.(vec::len[boxtype](p.scandepth)-1u) == box_v) {
finish_scan(p, true); finish_scan(p, true);
} }
} }
@ -123,7 +123,7 @@ fn check_potential_brk(ps p) {
fn finish_scan(ps p, bool fits) { fn finish_scan(ps p, bool fits) {
auto buf = p.buffered; auto buf = p.buffered;
auto front = _vec::shift[token](buf); auto front = vec::shift[token](buf);
auto chosen_tp = cx_h; auto chosen_tp = cx_h;
if (!fits) {chosen_tp = cx_v;} if (!fits) {chosen_tp = cx_v;}
alt (front) { alt (front) {
@ -154,10 +154,10 @@ fn start_scan(ps p, token tok, scantype tp) {
} }
fn cur_context(ps p) -> context { fn cur_context(ps p) -> context {
ret p.context.(_vec::len[context](p.context)-1u); ret p.context.(vec::len[context](p.context)-1u);
} }
fn base_indent(ps p) -> uint { fn base_indent(ps p) -> uint {
auto i = _vec::len[context](p.context); auto i = vec::len[context](p.context);
while (i > 0u) { while (i > 0u) {
i -= 1u; i -= 1u;
auto cx = p.context.(i); auto cx = p.context.(i);
@ -191,7 +191,7 @@ fn do_token(ps p, token tok) {
line_break(p); line_break(p);
} }
case (word(?w)) { case (word(?w)) {
auto len = _str::char_len(w); auto len = str::char_len(w);
if (len + p.col + p.spaces > p.width && !start_of_box && if (len + p.col + p.spaces > p.width && !start_of_box &&
!p.start_of_line) { !p.start_of_line) {
line_break(p); line_break(p);
@ -203,7 +203,7 @@ fn do_token(ps p, token tok) {
case (cword(?w)) { case (cword(?w)) {
before_print(p, true); before_print(p, true);
p.out.write_str(w); p.out.write_str(w);
p.col += _str::char_len(w); p.col += str::char_len(w);
} }
case (open(?tp, ?indent)) { case (open(?tp, ?indent)) {
if (tp == box_v) { if (tp == box_v) {
@ -248,8 +248,8 @@ fn token_size(token tok) -> uint {
alt (tok) { alt (tok) {
case (brk(?sz)) {ret sz;} case (brk(?sz)) {ret sz;}
case (hardbrk) {ret 0xFFFFFFu;} case (hardbrk) {ret 0xFFFFFFu;}
case (word(?w)) {ret _str::char_len(w);} case (word(?w)) {ret str::char_len(w);}
case (cword(?w)) {ret _str::char_len(w);} case (cword(?w)) {ret str::char_len(w);}
case (open(_, _)) {ret 0u;} case (open(_, _)) {ret 0u;}
case (close) {ret 0u;} case (close) {ret 0u;}
} }

32
src/comp/pretty/pprust.rs
View file

@ -1,5 +1,5 @@
import std::_vec; import std::vec;
import std::_str; import std::str;
import std::io; import std::io;
import std::option; import std::option;
import driver::session::session; import driver::session::session;
@ -92,7 +92,7 @@ fn commasep[IN](ps s, vec[IN] elts, fn(ps, &IN) op) {
} }
fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op, fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
fn(&IN) -> common::span get_span) { fn(&IN) -> common::span get_span) {
auto len = _vec::len[IN](elts); auto len = vec::len[IN](elts);
auto i = 0u; auto i = 0u;
for (IN elt in elts) { for (IN elt in elts) {
op(s, elt); op(s, elt);
@ -162,7 +162,7 @@ fn print_type(ps s, &@ast::ty ty) {
fn get_span(&ast::ty_field f) -> common::span { fn get_span(&ast::ty_field f) -> common::span {
// Try to reconstruct the span for this field // Try to reconstruct the span for this field
auto sp = f.mt.ty.span; auto sp = f.mt.ty.span;
auto hi = sp.hi + _str::char_len(f.ident) + 1u; auto hi = sp.hi + str::char_len(f.ident) + 1u;
ret rec(hi=hi with sp); ret rec(hi=hi with sp);
} }
auto f = print_field; auto f = print_field;
@ -272,7 +272,7 @@ fn print_item(ps s, @ast::item item) {
for (ast::variant v in variants) { for (ast::variant v in variants) {
maybe_print_comment(s, v.span.lo); maybe_print_comment(s, v.span.lo);
wrd(s.s, v.node.name); wrd(s.s, v.node.name);
if (_vec::len[ast::variant_arg](v.node.args) > 0u) { if (vec::len[ast::variant_arg](v.node.args) > 0u) {
popen(s); popen(s);
fn print_variant_arg(ps s, &ast::variant_arg arg) { fn print_variant_arg(ps s, &ast::variant_arg arg) {
print_type(s, arg.ty); print_type(s, arg.ty);
@ -360,7 +360,7 @@ fn print_literal(ps s, @ast::lit lit) {
alt (lit.node) { alt (lit.node) {
case (ast::lit_str(?st)) {print_string(s, st);} case (ast::lit_str(?st)) {print_string(s, st);}
case (ast::lit_char(?ch)) { case (ast::lit_char(?ch)) {
wrd(s.s, "'" + escape_str(_str::from_bytes([ch as u8]), '\'') wrd(s.s, "'" + escape_str(str::from_bytes([ch as u8]), '\'')
+ "'"); + "'");
} }
case (ast::lit_int(?val)) { case (ast::lit_int(?val)) {
@ -436,7 +436,7 @@ fn print_expr(ps s, &@ast::expr expr) {
commasep_cmnt[ast::field](s, fields, f, gs); commasep_cmnt[ast::field](s, fields, f, gs);
alt (wth) { alt (wth) {
case (option::some[@ast::expr](?expr)) { case (option::some[@ast::expr](?expr)) {
if (_vec::len[ast::field](fields) > 0u) {space(s.s);} if (vec::len[ast::field](fields) > 0u) {space(s.s);}
hbox(s); hbox(s);
wrd1(s, "with"); wrd1(s, "with");
print_expr(s, expr); print_expr(s, expr);
@ -673,7 +673,7 @@ fn print_expr(ps s, &@ast::expr expr) {
case (ast::expr_ext(?path, ?args, ?body, _, _)) { case (ast::expr_ext(?path, ?args, ?body, _, _)) {
wrd(s.s, "#"); wrd(s.s, "#");
print_path(s, path); print_path(s, path);
if (_vec::len[@ast::expr](args) > 0u) { if (vec::len[@ast::expr](args) > 0u) {
popen(s); popen(s);
commasep_exprs(s, args); commasep_exprs(s, args);
pclose(s); pclose(s);
@ -761,7 +761,7 @@ fn print_path(ps s, ast::path path) {
else {wrd(s.s, "::");} else {wrd(s.s, "::");}
wrd(s.s, id); wrd(s.s, id);
} }
if (_vec::len[@ast::ty](path.node.types) > 0u) { if (vec::len[@ast::ty](path.node.types) > 0u) {
wrd(s.s, "["); wrd(s.s, "[");
auto f = print_type; auto f = print_type;
commasep[@ast::ty](s, path.node.types, f); commasep[@ast::ty](s, path.node.types, f);
@ -777,7 +777,7 @@ fn print_pat(ps s, &@ast::pat pat) {
case (ast::pat_lit(?lit,_)) {print_literal(s, lit);} case (ast::pat_lit(?lit,_)) {print_literal(s, lit);}
case (ast::pat_tag(?path,?args,_)) { case (ast::pat_tag(?path,?args,_)) {
print_path(s, path); print_path(s, path);
if (_vec::len[@ast::pat](args) > 0u) { if (vec::len[@ast::pat](args) > 0u) {
popen_h(s); popen_h(s);
auto f = print_pat; auto f = print_pat;
commasep[@ast::pat](s, args, f); commasep[@ast::pat](s, args, f);
@ -822,7 +822,7 @@ fn print_fn(ps s, ast::fn_decl decl, str name,
} }
fn print_type_params(ps s, vec[ast::ty_param] params) { fn print_type_params(ps s, vec[ast::ty_param] params) {
if (_vec::len[ast::ty_param](params) > 0u) { if (vec::len[ast::ty_param](params) > 0u) {
wrd(s.s, "["); wrd(s.s, "[");
fn printParam(ps s, &ast::ty_param param) { fn printParam(ps s, &ast::ty_param param) {
wrd(s.s, param); wrd(s.s, param);
@ -840,7 +840,7 @@ fn print_view_item(ps s, @ast::view_item item) {
case (ast::view_item_use(?id,?mta,_,_)) { case (ast::view_item_use(?id,?mta,_,_)) {
wrd1(s, "use"); wrd1(s, "use");
wrd(s.s, id); wrd(s.s, id);
if (_vec::len[@ast::meta_item](mta) > 0u) { if (vec::len[@ast::meta_item](mta) > 0u) {
popen(s); popen(s);
fn print_meta(ps s, &@ast::meta_item item) { fn print_meta(ps s, &@ast::meta_item item) {
hbox(s); hbox(s);
@ -856,7 +856,7 @@ fn print_view_item(ps s, @ast::view_item item) {
} }
case (ast::view_item_import(?id,?ids,_)) { case (ast::view_item_import(?id,?ids,_)) {
wrd1(s, "import"); wrd1(s, "import");
if (!_str::eq(id, ids.(_vec::len[str](ids)-1u))) { if (!str::eq(id, ids.(vec::len[str](ids)-1u))) {
wrd1(s, id); wrd1(s, id);
wrd1(s, "="); wrd1(s, "=");
} }
@ -906,7 +906,7 @@ fn print_maybe_parens(ps s, @ast::expr expr, int outer_prec) {
fn escape_str(str st, char to_escape) -> str { fn escape_str(str st, char to_escape) -> str {
let str out = ""; let str out = "";
auto len = _str::byte_len(st); auto len = str::byte_len(st);
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
alt (st.(i) as char) { alt (st.(i) as char) {
@ -916,7 +916,7 @@ fn escape_str(str st, char to_escape) -> str {
case ('\\') {out += "\\\\";} case ('\\') {out += "\\\\";}
case (?cur) { case (?cur) {
if (cur == to_escape) {out += "\\";} if (cur == to_escape) {out += "\\";}
_str::push_byte(out, cur as u8); str::push_byte(out, cur as u8);
} }
} }
i += 1u; i += 1u;
@ -966,7 +966,7 @@ fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
fn next_comment(ps s) -> option::t[lexer::cmnt] { fn next_comment(ps s) -> option::t[lexer::cmnt] {
alt (s.comments) { alt (s.comments) {
case (option::some[vec[lexer::cmnt]](?cmnts)) { case (option::some[vec[lexer::cmnt]](?cmnts)) {
if (s.cur_cmnt < _vec::len[lexer::cmnt](cmnts)) { if (s.cur_cmnt < vec::len[lexer::cmnt](cmnts)) {
ret option::some[lexer::cmnt](cmnts.(s.cur_cmnt)); ret option::some[lexer::cmnt](cmnts.(s.cur_cmnt));
} else {ret option::none[lexer::cmnt];} } else {ret option::none[lexer::cmnt];}
} }

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

@ -1,8 +1,8 @@
import std::map; import std::map;
import std::map::hashmap; import std::map::hashmap;
import std::_uint; import std::uint;
import std::_int; import std::int;
import std::_vec; import std::vec;
import std::option::none; import std::option::none;
import front::ast; import front::ast;
import front::ast::ty; import front::ast::ty;
@ -60,8 +60,8 @@ fn ty_mach_to_str(ty_mach tm) -> str {
} }
fn new_str_hash[V]() -> std::map::hashmap[str,V] { fn new_str_hash[V]() -> std::map::hashmap[str,V] {
let std::map::hashfn[str] hasher = std::_str::hash; let std::map::hashfn[str] hasher = std::str::hash;
let std::map::eqfn[str] eqer = std::_str::eq; let std::map::eqfn[str] eqer = std::str::eq;
ret std::map::mk_hashmap[str,V](hasher, eqer); ret std::map::mk_hashmap[str,V](hasher, eqer);
} }
@ -99,25 +99,25 @@ fn new_uint_hash[V]() -> std::map::hashmap[uint,V] {
} }
fn istr(int i) -> str { fn istr(int i) -> str {
ret _int::to_str(i, 10u); ret int::to_str(i, 10u);
} }
fn uistr(uint i) -> str { fn uistr(uint i) -> str {
ret _uint::to_str(i, 10u); ret uint::to_str(i, 10u);
} }
fn elt_expr(&ast::elt e) -> @ast::expr { ret e.expr; } fn elt_expr(&ast::elt e) -> @ast::expr { ret e.expr; }
fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] { fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] {
auto f = elt_expr; auto f = elt_expr;
ret _vec::map[ast::elt, @ast::expr](f, elts); ret vec::map[ast::elt, @ast::expr](f, elts);
} }
fn field_expr(&ast::field f) -> @ast::expr { ret f.expr; } fn field_expr(&ast::field f) -> @ast::expr { ret f.expr; }
fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] { fn field_exprs(vec[ast::field] fields) -> vec [@ast::expr] {
auto f = field_expr; auto f = field_expr;
ret _vec::map[ast::field, @ast::expr](f, fields); ret vec::map[ast::field, @ast::expr](f, fields);
} }
fn expr_to_str(&@ast::expr e) -> str { fn expr_to_str(&@ast::expr e) -> str {

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

@ -2,7 +2,7 @@
// allows bidirectional lookup; i.e. given a value, one can easily find the // allows bidirectional lookup; i.e. given a value, one can easily find the
// type, and vice versa. // type, and vice versa.
import std::_vec; import std::vec;
import std::map; import std::map;
import std::map::hashmap; import std::map::hashmap;
import std::map::hashfn; import std::map::hashfn;
@ -28,7 +28,7 @@ fn intern[T](&interner[T] itr, &T val) -> uint {
alt (itr.map.find(val)) { alt (itr.map.find(val)) {
case (some[uint](?idx)) { ret idx; } case (some[uint](?idx)) { ret idx; }
case (none[uint]) { case (none[uint]) {
auto new_idx = _vec::len[T](itr.vect); auto new_idx = vec::len[T](itr.vect);
itr.map.insert(val, new_idx); itr.map.insert(val, new_idx);
itr.vect += [val]; itr.vect += [val];
ret new_idx; ret new_idx;

24
src/lib/bitv.rs
View file

@ -21,19 +21,19 @@ fn create(uint nbits, bool init) -> t {
elt = 0u; elt = 0u;
} }
auto storage = _vec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u); auto storage = vec::init_elt_mut[uint](elt, nbits / uint_bits() + 1u);
ret rec(storage = storage, nbits = nbits); ret rec(storage = storage, nbits = nbits);
} }
fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool { fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool {
auto len = _vec::len(v1.storage); auto len = vec::len(v1.storage);
assert (_vec::len(v0.storage) == len); assert (vec::len(v0.storage) == len);
assert (v0.nbits == v1.nbits); assert (v0.nbits == v1.nbits);
auto changed = false; auto changed = false;
for each (uint i in _uint::range(0u, len)) { for each (uint i in uint::range(0u, len)) {
auto w0 = v0.storage.(i); auto w0 = v0.storage.(i);
auto w1 = v1.storage.(i); auto w1 = v1.storage.(i);
@ -75,9 +75,9 @@ fn copy(&t v0, t v1) -> bool {
} }
fn clone(t v) -> t { fn clone(t v) -> t {
auto storage = _vec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u); auto storage = vec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
auto len = _vec::len(v.storage); auto len = vec::len(v.storage);
for each (uint i in _uint::range(0u, len)) { for each (uint i in uint::range(0u, len)) {
storage.(i) = v.storage.(i); storage.(i) = v.storage.(i);
} }
ret rec(storage = storage, nbits = v.nbits); ret rec(storage = storage, nbits = v.nbits);
@ -97,7 +97,7 @@ fn get(&t v, uint i) -> bool {
fn equal(&t v0, &t v1) -> bool { fn equal(&t v0, &t v1) -> bool {
// FIXME: when we can break or return from inside an iterator loop, // FIXME: when we can break or return from inside an iterator loop,
// we can eliminate this painful while-loop // we can eliminate this painful while-loop
auto len = _vec::len(v1.storage); auto len = vec::len(v1.storage);
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
if (v0.storage.(i) != v1.storage.(i)) { if (v0.storage.(i) != v1.storage.(i)) {
@ -109,13 +109,13 @@ fn equal(&t v0, &t v1) -> bool {
} }
fn clear(&t v) { fn clear(&t v) {
for each (uint i in _uint::range(0u, _vec::len(v.storage))) { for each (uint i in uint::range(0u, vec::len(v.storage))) {
v.storage.(i) = 0u; v.storage.(i) = 0u;
} }
} }
fn invert(&t v) { fn invert(&t v) {
for each (uint i in _uint::range(0u, _vec::len(v.storage))) { for each (uint i in uint::range(0u, vec::len(v.storage))) {
v.storage.(i) = ~v.storage.(i); v.storage.(i) = ~v.storage.(i);
} }
} }
@ -176,7 +176,7 @@ fn init_to_vec(t v, uint i) -> uint {
fn to_vec(&t v) -> vec[uint] { fn to_vec(&t v) -> vec[uint] {
auto sub = bind init_to_vec(v, _); auto sub = bind init_to_vec(v, _);
ret _vec::init_fn[uint](sub, v.nbits); ret vec::init_fn[uint](sub, v.nbits);
} }
fn to_str(&t v) -> str { fn to_str(&t v) -> str {
@ -196,7 +196,7 @@ fn to_str(&t v) -> str {
// FIXME: can we just use structural equality on to_vec? // FIXME: can we just use structural equality on to_vec?
fn eq_vec(&t v0, &vec[uint] v1) -> bool { fn eq_vec(&t v0, &vec[uint] v1) -> bool {
assert (v0.nbits == _vec::len[uint](v1)); assert (v0.nbits == vec::len[uint](v1));
auto len = v0.nbits; auto len = v0.nbits;
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {

2
src/lib/dbg.rs
View file

@ -20,7 +20,7 @@ native "rust" mod rustrt {
} }
fn debug_vec[T](vec[T] v) { fn debug_vec[T](vec[T] v) {
_vec::print_debug_info[T](v); vec::print_debug_info[T](v);
} }
fn debug_tydesc[T]() { fn debug_tydesc[T]() {

22
src/lib/deque.rs
View file

@ -28,7 +28,7 @@ fn create[T]() -> t[T] {
* elsewhere. * elsewhere.
*/ */
fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] { fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] {
assert (nelts == _vec::len[cell[T]](elts)); assert (nelts == vec::len[cell[T]](elts));
fn fill[T](uint i, uint nelts, uint lo, fn fill[T](uint i, uint nelts, uint lo,
vec[cell[T]] old) -> cell[T] { vec[cell[T]] old) -> cell[T] {
@ -39,9 +39,9 @@ fn create[T]() -> t[T] {
} }
} }
let uint nalloc = _uint::next_power_of_two(nelts + 1u); let uint nalloc = uint::next_power_of_two(nelts + 1u);
let _vec::init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts); let vec::init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts);
ret _vec::init_fn[cell[T]](copy_op, nalloc); ret vec::init_fn[cell[T]](copy_op, nalloc);
} }
fn get[T](vec[cell[T]] elts, uint i) -> T { fn get[T](vec[cell[T]] elts, uint i) -> T {
@ -63,14 +63,14 @@ fn create[T]() -> t[T] {
let uint oldlo = lo; let uint oldlo = lo;
if (lo == 0u) { if (lo == 0u) {
lo = _vec::len[cell[T]](elts) - 1u; lo = vec::len[cell[T]](elts) - 1u;
} else { } else {
lo -= 1u; lo -= 1u;
} }
if (lo == hi) { if (lo == hi) {
elts = grow[T](nelts, oldlo, elts); elts = grow[T](nelts, oldlo, elts);
lo = _vec::len[cell[T]](elts) - 1u; lo = vec::len[cell[T]](elts) - 1u;
hi = nelts; hi = nelts;
} }
@ -86,7 +86,7 @@ fn create[T]() -> t[T] {
} }
elts.(hi) = option::some[T](t); elts.(hi) = option::some[T](t);
hi = (hi + 1u) % _vec::len[cell[T]](elts); hi = (hi + 1u) % vec::len[cell[T]](elts);
nelts += 1u; nelts += 1u;
} }
@ -97,14 +97,14 @@ fn create[T]() -> t[T] {
fn pop_front() -> T { fn pop_front() -> T {
let T t = get[T](elts, lo); let T t = get[T](elts, lo);
elts.(lo) = option::none[T]; elts.(lo) = option::none[T];
lo = (lo + 1u) % _vec::len[cell[T]](elts); lo = (lo + 1u) % vec::len[cell[T]](elts);
nelts -= 1u; nelts -= 1u;
ret t; ret t;
} }
fn pop_back() -> T { fn pop_back() -> T {
if (hi == 0u) { if (hi == 0u) {
hi = _vec::len[cell[T]](elts) - 1u; hi = vec::len[cell[T]](elts) - 1u;
} else { } else {
hi -= 1u; hi -= 1u;
} }
@ -124,12 +124,12 @@ fn create[T]() -> t[T] {
} }
fn get(int i) -> T { fn get(int i) -> T {
let uint idx = (lo + (i as uint)) % _vec::len[cell[T]](elts); let uint idx = (lo + (i as uint)) % vec::len[cell[T]](elts);
ret get[T](elts, idx); ret get[T](elts, idx);
} }
} }
let vec[cell[T]] v = _vec::init_elt[cell[T]](option::none[T], let vec[cell[T]] v = vec::init_elt[cell[T]](option::none[T],
initial_capacity); initial_capacity);
ret deque[T](0u, 0u, 0u, v); ret deque[T](0u, 0u, 0u, v);

8
src/lib/ebml.rs
View file

@ -38,7 +38,7 @@ fn vint_at(vec[u8] data, uint start) -> tup(uint, uint) {
} }
fn new_doc(vec[u8] data) -> doc { fn new_doc(vec[u8] data) -> doc {
ret rec(data=data, start=0u, end=_vec::len[u8](data)); ret rec(data=data, start=0u, end=vec::len[u8](data));
} }
fn doc_at(vec[u8] data, uint start) -> doc { fn doc_at(vec[u8] data, uint start) -> doc {
@ -65,7 +65,7 @@ fn get_doc(doc d, uint tg) -> doc {
alt (maybe_get_doc(d, tg)) { alt (maybe_get_doc(d, tg)) {
case (some[doc](?d)) {ret d;} case (some[doc](?d)) {ret d;}
case (none[doc]) { case (none[doc]) {
log_err "failed to find block with tag " + _uint::to_str(tg, 10u); log_err "failed to find block with tag " + uint::to_str(tg, 10u);
fail; fail;
} }
} }
@ -94,7 +94,7 @@ iter tagged_docs(doc d, uint tg) -> doc {
} }
fn doc_data(doc d) -> vec[u8] { fn doc_data(doc d) -> vec[u8] {
ret _vec::slice[u8](d.data, d.start, d.end); ret vec::slice[u8](d.data, d.start, d.end);
} }
fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint { fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint {
@ -175,7 +175,7 @@ fn start_tag(&writer w, uint tag_id) {
} }
fn end_tag(&writer w) { fn end_tag(&writer w) {
auto last_size_pos = _vec::pop[uint](w.size_positions); auto last_size_pos = vec::pop[uint](w.size_positions);
auto cur_pos = w.writer.tell(); auto cur_pos = w.writer.tell();
w.writer.seek(last_size_pos as int, io::seek_set); w.writer.seek(last_size_pos as int, io::seek_set);
write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u); write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u);

64
src/lib/extfmt.rs
View file

@ -80,11 +80,11 @@ mod ct {
fn parse_fmt_string(str s) -> vec[piece] { fn parse_fmt_string(str s) -> vec[piece] {
let vec[piece] pieces = []; let vec[piece] pieces = [];
auto lim = _str::byte_len(s); auto lim = str::byte_len(s);
auto buf = ""; auto buf = "";
fn flush_buf(str buf, &vec[piece] pieces) -> str { fn flush_buf(str buf, &vec[piece] pieces) -> str {
if (_str::byte_len(buf) > 0u) { if (str::byte_len(buf) > 0u) {
auto piece = piece_string(buf); auto piece = piece_string(buf);
pieces += [piece]; pieces += [piece];
} }
@ -93,15 +93,15 @@ mod ct {
auto i = 0u; auto i = 0u;
while (i < lim) { while (i < lim) {
auto curr = _str::substr(s, i, 1u); auto curr = str::substr(s, i, 1u);
if (_str::eq(curr, "%")) { if (str::eq(curr, "%")) {
i += 1u; i += 1u;
if (i >= lim) { if (i >= lim) {
log_err "unterminated conversion at end of string"; log_err "unterminated conversion at end of string";
fail; fail;
} }
auto curr2 = _str::substr(s, i, 1u); auto curr2 = str::substr(s, i, 1u);
if (_str::eq(curr2, "%")) { if (str::eq(curr2, "%")) {
i += 1u; i += 1u;
} else { } else {
buf = flush_buf(buf, pieces); buf = flush_buf(buf, pieces);
@ -270,27 +270,27 @@ mod ct {
} }
auto t; auto t;
auto tstr = _str::substr(s, i, 1u); auto tstr = str::substr(s, i, 1u);
if (_str::eq(tstr, "b")) { if (str::eq(tstr, "b")) {
t = ty_bool; t = ty_bool;
} else if (_str::eq(tstr, "s")) { } else if (str::eq(tstr, "s")) {
t = ty_str; t = ty_str;
} else if (_str::eq(tstr, "c")) { } else if (str::eq(tstr, "c")) {
t = ty_char; t = ty_char;
} else if (_str::eq(tstr, "d") } else if (str::eq(tstr, "d")
|| _str::eq(tstr, "i")) { || str::eq(tstr, "i")) {
// TODO: Do we really want two signed types here? // TODO: Do we really want two signed types here?
// How important is it to be printf compatible? // How important is it to be printf compatible?
t = ty_int(signed); t = ty_int(signed);
} else if (_str::eq(tstr, "u")) { } else if (str::eq(tstr, "u")) {
t = ty_int(unsigned); t = ty_int(unsigned);
} else if (_str::eq(tstr, "x")) { } else if (str::eq(tstr, "x")) {
t = ty_hex(case_lower); t = ty_hex(case_lower);
} else if (_str::eq(tstr, "X")) { } else if (str::eq(tstr, "X")) {
t = ty_hex(case_upper); t = ty_hex(case_upper);
} else if (_str::eq(tstr, "t")) { } else if (str::eq(tstr, "t")) {
t = ty_bits; t = ty_bits;
} else if (_str::eq(tstr, "o")) { } else if (str::eq(tstr, "o")) {
t = ty_octal; t = ty_octal;
} else { } else {
log_err "unknown type in conversion"; log_err "unknown type in conversion";
@ -364,7 +364,7 @@ mod rt {
res = uint_to_str_prec(u, 16u, prec); res = uint_to_str_prec(u, 16u, prec);
} }
case (ty_hex_upper) { case (ty_hex_upper) {
res = _str::to_upper(uint_to_str_prec(u, 16u, prec)); res = str::to_upper(uint_to_str_prec(u, 16u, prec));
} }
case (ty_bits) { case (ty_bits) {
res = uint_to_str_prec(u, 2u, prec); res = uint_to_str_prec(u, 2u, prec);
@ -389,7 +389,7 @@ mod rt {
} }
fn conv_char(&conv cv, char c) -> str { fn conv_char(&conv cv, char c) -> str {
ret pad(cv, _str::from_char(c), pad_nozero); ret pad(cv, str::from_char(c), pad_nozero);
} }
fn conv_str(&conv cv, str s) -> str { fn conv_str(&conv cv, str s) -> str {
@ -399,9 +399,9 @@ mod rt {
} }
case (count_is(?max)) { case (count_is(?max)) {
// For strings, precision is the maximum characters displayed // For strings, precision is the maximum characters displayed
if (max as uint < _str::char_len(s)) { if (max as uint < str::char_len(s)) {
// FIXME: substr works on bytes, not chars! // FIXME: substr works on bytes, not chars!
unpadded = _str::substr(s, 0u, max as uint); unpadded = str::substr(s, 0u, max as uint);
} }
} }
} }
@ -420,15 +420,15 @@ mod rt {
// Convert a uint to string with a minimum number of digits. If precision // Convert a uint to string with a minimum number of digits. If precision
// is 0 and num is 0 then the result is the empty string. Could move this // is 0 and num is 0 then the result is the empty string. Could move this
// to _uint: but it doesn't seem all that useful. // to uint: but it doesn't seem all that useful.
fn uint_to_str_prec(uint num, uint radix, uint prec) -> str { fn uint_to_str_prec(uint num, uint radix, uint prec) -> str {
auto s; auto s;
if (prec == 0u && num == 0u) { if (prec == 0u && num == 0u) {
s = ""; s = "";
} else { } else {
s = _uint::to_str(num, radix); s = uint::to_str(num, radix);
auto len = _str::char_len(s); auto len = str::char_len(s);
if (len < prec) { if (len < prec) {
auto diff = prec - len; auto diff = prec - len;
auto pad = str_init_elt('0', diff); auto pad = str_init_elt('0', diff);
@ -450,12 +450,12 @@ mod rt {
} }
} }
// FIXME: This might be useful in _str: but needs to be utf8 safe first // FIXME: This might be useful in str: but needs to be utf8 safe first
fn str_init_elt(char c, uint n_elts) -> str { fn str_init_elt(char c, uint n_elts) -> str {
auto svec = _vec::init_elt[u8](c as u8, n_elts); auto svec = vec::init_elt[u8](c as u8, n_elts);
// FIXME: Using unsafe_from_bytes because rustboot // FIXME: Using unsafe_from_bytes because rustboot
// can't figure out the is_utf8 predicate on from_bytes? // can't figure out the is_utf8 predicate on from_bytes?
ret _str::unsafe_from_bytes(svec); ret str::unsafe_from_bytes(svec);
} }
tag pad_mode { tag pad_mode {
@ -476,7 +476,7 @@ mod rt {
} }
} }
auto strlen = _str::char_len(s); auto strlen = str::char_len(s);
if (uwidth <= strlen) { if (uwidth <= strlen) {
ret s; ret s;
} }
@ -532,16 +532,16 @@ mod rt {
// instead. // instead.
if (signed if (signed
&& zero_padding && zero_padding
&& _str::byte_len(s) > 0u) { && str::byte_len(s) > 0u) {
auto head = s.(0); auto head = s.(0);
if (head == '+' as u8 if (head == '+' as u8
|| head == '-' as u8 || head == '-' as u8
|| head == ' ' as u8) { || head == ' ' as u8) {
auto headstr = _str::unsafe_from_bytes([head]); auto headstr = str::unsafe_from_bytes([head]);
auto bytelen = _str::byte_len(s); auto bytelen = str::byte_len(s);
auto numpart = _str::substr(s, 1u, bytelen - 1u); auto numpart = str::substr(s, 1u, bytelen - 1u);
ret headstr + padstr + numpart; ret headstr + padstr + numpart;
} }
} }

16
src/lib/fs.rs
View file

@ -3,24 +3,24 @@ native "rust" mod rustrt {
} }
fn path_sep() -> str { fn path_sep() -> str {
ret _str::from_char(os_fs::path_sep); ret str::from_char(os_fs::path_sep);
} }
type path = str; type path = str;
fn dirname(path p) -> path { fn dirname(path p) -> path {
let int i = _str::rindex(p, os_fs::path_sep as u8); let int i = str::rindex(p, os_fs::path_sep as u8);
if (i == -1) { if (i == -1) {
i = _str::rindex(p, os_fs::alt_path_sep as u8); i = str::rindex(p, os_fs::alt_path_sep as u8);
if (i == -1) { if (i == -1) {
ret p; ret p;
} }
} }
ret _str::substr(p, 0u, i as uint); ret str::substr(p, 0u, i as uint);
} }
fn connect(path pre, path post) -> path { fn connect(path pre, path post) -> path {
auto len = _str::byte_len(pre); auto len = str::byte_len(pre);
if (pre.(len - 1u) == (os_fs::path_sep as u8)) { // Trailing '/'? if (pre.(len - 1u) == (os_fs::path_sep as u8)) { // Trailing '/'?
ret pre + post; ret pre + post;
} }
@ -32,14 +32,14 @@ fn file_is_dir(path p) -> bool {
} }
fn list_dir(path p) -> vec[str] { fn list_dir(path p) -> vec[str] {
auto pl = _str::byte_len(p); auto pl = str::byte_len(p);
if (pl == 0u || p.(pl - 1u) as char != os_fs::path_sep) { if (pl == 0u || p.(pl - 1u) as char != os_fs::path_sep) {
p += path_sep(); p += path_sep();
} }
let vec[str] full_paths = []; let vec[str] full_paths = [];
for (str filename in os_fs::list_dir(p)) { for (str filename in os_fs::list_dir(p)) {
if (!_str::eq(filename, ".")) {if (!_str::eq(filename, "..")) { if (!str::eq(filename, ".")) {if (!str::eq(filename, "..")) {
_vec::push[str](full_paths, p + filename); vec::push[str](full_paths, p + filename);
}} }}
} }
ret full_paths; ret full_paths;

4
src/lib/generic_os.rs
View file

@ -1,9 +1,9 @@
fn getenv(str n) -> option::t[str] { fn getenv(str n) -> option::t[str] {
auto s = os::libc::getenv(_str::buf(n)); auto s = os::libc::getenv(str::buf(n));
if ((s as int) == 0) { if ((s as int) == 0) {
ret option::none[str]; ret option::none[str];
} else { } else {
ret option::some[str](_str::str_from_cstr(s)); ret option::some[str](str::str_from_cstr(s));
} }
} }

60
src/lib/getopts.rs
View file

@ -17,7 +17,7 @@ tag occur { req; optional; multi; }
type opt = rec(name name, hasarg hasarg, occur occur); type opt = rec(name name, hasarg hasarg, occur occur);
fn mkname(str nm) -> name { fn mkname(str nm) -> name {
if (_str::char_len(nm) == 1u) { ret short(_str::char_at(nm, 0u)); } if (str::char_len(nm) == 1u) { ret short(str::char_at(nm, 0u)); }
else { ret long(nm); } else { ret long(nm); }
} }
fn reqopt(str name) -> opt { fn reqopt(str name) -> opt {
@ -41,11 +41,11 @@ tag optval {
type match = rec(vec[opt] opts, vec[mutable vec[optval]] vals, vec[str] free); type match = rec(vec[opt] opts, vec[mutable vec[optval]] vals, vec[str] free);
fn is_arg(str arg) -> bool { fn is_arg(str arg) -> bool {
ret _str::byte_len(arg) > 1u && arg.(0) == '-' as u8; ret str::byte_len(arg) > 1u && arg.(0) == '-' as u8;
} }
fn name_str(name nm) -> str { fn name_str(name nm) -> str {
alt (nm) { alt (nm) {
case (short(?ch)) {ret _str::from_char(ch);} case (short(?ch)) {ret str::from_char(ch);}
case (long(?s)) {ret s;} case (long(?s)) {ret s;}
} }
} }
@ -55,7 +55,7 @@ fn name_eq(name a, name b) -> bool {
alt (a) { alt (a) {
case (long(?a)) { case (long(?a)) {
alt (b) { alt (b) {
case (long(?b)) { ret _str::eq(a, b); } case (long(?b)) { ret str::eq(a, b); }
case (_) { ret false; } case (_) { ret false; }
} }
} }
@ -64,7 +64,7 @@ fn name_eq(name a, name b) -> bool {
} }
fn find_opt(vec[opt] opts, name nm) -> option::t[uint] { fn find_opt(vec[opt] opts, name nm) -> option::t[uint] {
auto i = 0u; auto i = 0u;
auto l = _vec::len[opt](opts); auto l = vec::len[opt](opts);
while (i < l) { while (i < l) {
if (name_eq(opts.(i).name, nm)) { ret some[uint](i); } if (name_eq(opts.(i).name, nm)) { ret some[uint](i); }
i += 1u; i += 1u;
@ -102,41 +102,41 @@ tag result {
} }
fn getopts(vec[str] args, vec[opt] opts) -> result { fn getopts(vec[str] args, vec[opt] opts) -> result {
auto n_opts = _vec::len[opt](opts); auto n_opts = vec::len[opt](opts);
fn empty_(uint x) -> vec[optval]{ret _vec::empty[optval]();} fn empty_(uint x) -> vec[optval]{ret vec::empty[optval]();}
auto f = empty_; auto f = empty_;
auto vals = _vec::init_fn_mut[vec[optval]](f, n_opts); auto vals = vec::init_fn_mut[vec[optval]](f, n_opts);
let vec[str] free = []; let vec[str] free = [];
auto l = _vec::len[str](args); auto l = vec::len[str](args);
auto i = 0u; auto i = 0u;
while (i < l) { while (i < l) {
auto cur = args.(i); auto cur = args.(i);
auto curlen = _str::byte_len(cur); auto curlen = str::byte_len(cur);
if (!is_arg(cur)) { if (!is_arg(cur)) {
_vec::push[str](free, cur); vec::push[str](free, cur);
} else if (_str::eq(cur, "--")) { } else if (str::eq(cur, "--")) {
free += _vec::slice[str](args, i + 1u, l); free += vec::slice[str](args, i + 1u, l);
break; break;
} else { } else {
auto names; auto names;
auto i_arg = option::none[str]; auto i_arg = option::none[str];
if (cur.(1) == '-' as u8) { if (cur.(1) == '-' as u8) {
auto tail = _str::slice(cur, 2u, curlen); auto tail = str::slice(cur, 2u, curlen);
auto eq = _str::index(tail, '=' as u8); auto eq = str::index(tail, '=' as u8);
if (eq == -1) { if (eq == -1) {
names = [long(tail)]; names = [long(tail)];
} else { } else {
names = [long(_str::slice(tail, 0u, eq as uint))]; names = [long(str::slice(tail, 0u, eq as uint))];
i_arg = option::some[str] i_arg = option::some[str]
(_str::slice(tail, (eq as uint) + 1u, curlen - 2u)); (str::slice(tail, (eq as uint) + 1u, curlen - 2u));
} }
} else { } else {
auto j = 1u; auto j = 1u;
names = []; names = [];
while (j < curlen) { while (j < curlen) {
auto range = _str::char_range_at(cur, j); auto range = str::char_range_at(cur, j);
_vec::push[name](names, short(range._0)); vec::push[name](names, short(range._0));
j = range._1; j = range._1;
} }
} }
@ -152,29 +152,29 @@ fn getopts(vec[str] args, vec[opt] opts) -> result {
} }
alt (opts.(optid).hasarg) { alt (opts.(optid).hasarg) {
case (no) { case (no) {
_vec::push[optval](vals.(optid), given); vec::push[optval](vals.(optid), given);
} }
case (maybe) { case (maybe) {
if (!option::is_none[str](i_arg)) { if (!option::is_none[str](i_arg)) {
_vec::push[optval](vals.(optid), vec::push[optval](vals.(optid),
val(option::get[str](i_arg))); val(option::get[str](i_arg)));
} else if (name_pos < _vec::len[name](names) || } else if (name_pos < vec::len[name](names) ||
i + 1u == l || is_arg(args.(i + 1u))) { i + 1u == l || is_arg(args.(i + 1u))) {
_vec::push[optval](vals.(optid), given); vec::push[optval](vals.(optid), given);
} else { } else {
i += 1u; i += 1u;
_vec::push[optval](vals.(optid), val(args.(i))); vec::push[optval](vals.(optid), val(args.(i)));
} }
} }
case (yes) { case (yes) {
if (!option::is_none[str](i_arg)) { if (!option::is_none[str](i_arg)) {
_vec::push[optval](vals.(optid), vec::push[optval](vals.(optid),
val(option::get[str](i_arg))); val(option::get[str](i_arg)));
} else if (i + 1u == l) { } else if (i + 1u == l) {
ret failure(argument_missing(name_str(nm))); ret failure(argument_missing(name_str(nm)));
} else { } else {
i += 1u; i += 1u;
_vec::push[optval](vals.(optid), val(args.(i))); vec::push[optval](vals.(optid), val(args.(i)));
} }
} }
} }
@ -185,7 +185,7 @@ fn getopts(vec[str] args, vec[opt] opts) -> result {
i = 0u; i = 0u;
while (i < n_opts) { while (i < n_opts) {
auto n = _vec::len[optval](vals.(i)); auto n = vec::len[optval](vals.(i));
auto occ = opts.(i).occur; auto occ = opts.(i).occur;
if (occ == req) {if (n == 0u) { if (occ == req) {if (n == 0u) {
ret failure(option_missing(name_str(opts.(i).name))); ret failure(option_missing(name_str(opts.(i).name)));
@ -212,7 +212,7 @@ fn opt_val(match m, str nm) -> optval {
ret opt_vals(m, nm).(0); ret opt_vals(m, nm).(0);
} }
fn opt_present(match m, str nm) -> bool { fn opt_present(match m, str nm) -> bool {
ret _vec::len[optval](opt_vals(m, nm)) > 0u; ret vec::len[optval](opt_vals(m, nm)) > 0u;
} }
fn opt_str(match m, str nm) -> str { fn opt_str(match m, str nm) -> str {
alt (opt_val(m, nm)) { alt (opt_val(m, nm)) {
@ -224,7 +224,7 @@ fn opt_strs(match m, str nm) -> vec[str] {
let vec[str] acc = []; let vec[str] acc = [];
for (optval v in opt_vals(m, nm)) { for (optval v in opt_vals(m, nm)) {
alt (v) { alt (v) {
case (val(?s)) { _vec::push[str](acc, s); } case (val(?s)) { vec::push[str](acc, s); }
case (_) {} case (_) {}
} }
} }
@ -232,7 +232,7 @@ fn opt_strs(match m, str nm) -> vec[str] {
} }
fn opt_maybe_str(match m, str nm) -> option::t[str] { fn opt_maybe_str(match m, str nm) -> option::t[str] {
auto vals = opt_vals(m, nm); auto vals = opt_vals(m, nm);
if (_vec::len[optval](vals) == 0u) { ret none[str]; } if (vec::len[optval](vals) == 0u) { ret none[str]; }
alt (vals.(0)) { alt (vals.(0)) {
case (val(?s)) { ret some[str](s); } case (val(?s)) { ret some[str](s); }
case (_) { ret none[str]; } case (_) { ret none[str]; }

4
src/lib/_int.rs → src/lib/int.rs
View file

@ -29,9 +29,9 @@ fn to_str(int n, uint radix) -> str
{ {
assert (0u < radix && radix <= 16u); assert (0u < radix && radix <= 16u);
if (n < 0) { if (n < 0) {
ret "-" + _uint::to_str((-n) as uint, radix); ret "-" + uint::to_str((-n) as uint, radix);
} else { } else {
ret _uint::to_str(n as uint, radix); ret uint::to_str(n as uint, radix);
} }
} }

66
src/lib/io.rs
View file

@ -57,9 +57,9 @@ fn convert_whence(seek_style whence) -> int {
state obj FILE_buf_reader(os::libc::FILE f, bool must_close) { state obj FILE_buf_reader(os::libc::FILE f, bool must_close) {
fn read(uint len) -> vec[u8] { fn read(uint len) -> vec[u8] {
auto buf = _vec::alloc[u8](len); auto buf = vec::alloc[u8](len);
auto read = os::libc::fread(_vec::buf[u8](buf), 1u, len, f); auto read = os::libc::fread(vec::buf[u8](buf), 1u, len, f);
_vec::len_set[u8](buf, read); vec::len_set[u8](buf, read);
ret buf; ret buf;
} }
fn read_byte() -> int { fn read_byte() -> int {
@ -100,7 +100,7 @@ state obj new_reader(buf_reader rdr) {
auto c0 = rdr.read_byte(); auto c0 = rdr.read_byte();
if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid? if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid?
auto b0 = c0 as u8; auto b0 = c0 as u8;
auto w = _str::utf8_char_width(b0); auto w = str::utf8_char_width(b0);
assert (w > 0u); assert (w > 0u);
if (w == 1u) {ret b0 as char;} if (w == 1u) {ret b0 as char;}
auto val = 0u; auto val = 0u;
@ -112,7 +112,7 @@ state obj new_reader(buf_reader rdr) {
val <<= 6u; val <<= 6u;
val += (next & 0x3f) as uint; val += (next & 0x3f) as uint;
} }
// See _str::char_at // See str::char_at
val += ((b0 << ((w + 1u) as u8)) as uint) << ((w - 1u) * 6u - w - 1u); val += ((b0 << ((w + 1u) as u8)) as uint) << ((w - 1u) * 6u - w - 1u);
ret val as char; ret val as char;
} }
@ -126,9 +126,9 @@ state obj new_reader(buf_reader rdr) {
while (go_on) { while (go_on) {
auto ch = rdr.read_byte(); auto ch = rdr.read_byte();
if (ch == -1 || ch == 10) {go_on = false;} if (ch == -1 || ch == 10) {go_on = false;}
else {_vec::push[u8](buf, ch as u8);} else {vec::push[u8](buf, ch as u8);}
} }
ret _str::unsafe_from_bytes(buf); ret str::unsafe_from_bytes(buf);
} }
fn read_c_str() -> str { fn read_c_str() -> str {
let vec[u8] buf = []; let vec[u8] buf = [];
@ -136,9 +136,9 @@ state obj new_reader(buf_reader rdr) {
while (go_on) { while (go_on) {
auto ch = rdr.read_byte(); auto ch = rdr.read_byte();
if (ch < 1) {go_on = false;} if (ch < 1) {go_on = false;}
else {_vec::push[u8](buf, ch as u8);} else {vec::push[u8](buf, ch as u8);}
} }
ret _str::unsafe_from_bytes(buf); ret str::unsafe_from_bytes(buf);
} }
// FIXME deal with eof? // FIXME deal with eof?
fn read_le_uint(uint size) -> uint { fn read_le_uint(uint size) -> uint {
@ -191,7 +191,7 @@ fn stdin() -> reader {
} }
fn file_reader(str path) -> reader { fn file_reader(str path) -> reader {
auto f = os::libc::fopen(_str::buf(path), _str::buf("r")); auto f = os::libc::fopen(str::buf(path), str::buf("r"));
if (f as uint == 0u) { if (f as uint == 0u) {
log_err "error opening " + path; log_err "error opening " + path;
fail; fail;
@ -212,17 +212,17 @@ type byte_buf = @rec(vec[u8] buf, mutable uint pos);
state obj byte_buf_reader(byte_buf bbuf) { state obj byte_buf_reader(byte_buf bbuf) {
fn read(uint len) -> vec[u8] { fn read(uint len) -> vec[u8] {
auto rest = _vec::len[u8](bbuf.buf) - bbuf.pos; auto rest = vec::len[u8](bbuf.buf) - bbuf.pos;
auto to_read = len; auto to_read = len;
if (rest < to_read) { if (rest < to_read) {
to_read = rest; to_read = rest;
} }
auto range = _vec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read); auto range = vec::slice[u8](bbuf.buf, bbuf.pos, bbuf.pos + to_read);
bbuf.pos += to_read; bbuf.pos += to_read;
ret range; ret range;
} }
fn read_byte() -> int { fn read_byte() -> int {
if (bbuf.pos == _vec::len[u8](bbuf.buf)) {ret -1;} if (bbuf.pos == vec::len[u8](bbuf.buf)) {ret -1;}
auto b = bbuf.buf.(bbuf.pos); auto b = bbuf.buf.(bbuf.pos);
bbuf.pos += 1u; bbuf.pos += 1u;
ret b as int; ret b as int;
@ -234,12 +234,12 @@ state obj byte_buf_reader(byte_buf bbuf) {
} }
fn eof() -> bool { fn eof() -> bool {
ret bbuf.pos == _vec::len[u8](bbuf.buf); ret bbuf.pos == vec::len[u8](bbuf.buf);
} }
fn seek(int offset, seek_style whence) { fn seek(int offset, seek_style whence) {
auto pos = bbuf.pos; auto pos = bbuf.pos;
auto len = _vec::len[u8](bbuf.buf); auto len = vec::len[u8](bbuf.buf);
bbuf.pos = seek_in_buf(offset, pos, len, whence); bbuf.pos = seek_in_buf(offset, pos, len, whence);
} }
@ -270,8 +270,8 @@ type buf_writer = state obj {
state obj FILE_writer(os::libc::FILE f, bool must_close) { state obj FILE_writer(os::libc::FILE f, bool must_close) {
fn write(vec[u8] v) { fn write(vec[u8] v) {
auto len = _vec::len[u8](v); auto len = vec::len[u8](v);
auto vbuf = _vec::buf[u8](v); auto vbuf = vec::buf[u8](v);
auto nout = os::libc::fwrite(vbuf, len, 1u, f); auto nout = os::libc::fwrite(vbuf, len, 1u, f);
if (nout < 1u) { if (nout < 1u) {
log_err "error dumping buffer"; log_err "error dumping buffer";
@ -293,11 +293,11 @@ state obj FILE_writer(os::libc::FILE f, bool must_close) {
state obj fd_buf_writer(int fd, bool must_close) { state obj fd_buf_writer(int fd, bool must_close) {
fn write(vec[u8] v) { fn write(vec[u8] v) {
auto len = _vec::len[u8](v); auto len = vec::len[u8](v);
auto count = 0u; auto count = 0u;
auto vbuf; auto vbuf;
while (count < len) { while (count < len) {
vbuf = _vec::buf_off[u8](v, count); vbuf = vec::buf_off[u8](v, count);
auto nout = os::libc::write(fd, vbuf, len); auto nout = os::libc::write(fd, vbuf, len);
if (nout < 0) { if (nout < 0) {
log_err "error dumping buffer"; log_err "error dumping buffer";
@ -337,7 +337,7 @@ fn file_buf_writer(str path, vec[fileflag] flags) -> buf_writer {
} }
} }
auto fd = os::libc::open(_str::buf(path), auto fd = os::libc::open(str::buf(path),
fflags, fflags,
os::libc_constants::S_IRUSR() | os::libc_constants::S_IRUSR() |
os::libc_constants::S_IWUSR()); os::libc_constants::S_IWUSR());
@ -390,17 +390,17 @@ state obj new_writer(buf_writer out) {
ret out; ret out;
} }
fn write_str(str s) { fn write_str(str s) {
out.write(_str::bytes(s)); out.write(str::bytes(s));
} }
fn write_char(char ch) { fn write_char(char ch) {
// FIXME needlessly consy // FIXME needlessly consy
out.write(_str::bytes(_str::from_char(ch))); out.write(str::bytes(str::from_char(ch)));
} }
fn write_int(int n) { fn write_int(int n) {
out.write(_str::bytes(_int::to_str(n, 10u))); out.write(str::bytes(int::to_str(n, 10u)));
} }
fn write_uint(uint n) { fn write_uint(uint n) {
out.write(_str::bytes(_uint::to_str(n, 10u))); out.write(str::bytes(uint::to_str(n, 10u)));
} }
fn write_bytes(vec[u8] bytes) { fn write_bytes(vec[u8] bytes) {
out.write(bytes); out.write(bytes);
@ -427,7 +427,7 @@ fn file_writer(str path, vec[fileflag] flags) -> writer {
// FIXME: fileflags // FIXME: fileflags
fn buffered_file_buf_writer(str path) -> buf_writer { fn buffered_file_buf_writer(str path) -> buf_writer {
auto f = os::libc::fopen(_str::buf(path), _str::buf("w")); auto f = os::libc::fopen(str::buf(path), str::buf("w"));
if (f as uint == 0u) { if (f as uint == 0u) {
log_err "error opening " + path; log_err "error opening " + path;
fail; fail;
@ -451,21 +451,21 @@ type mutable_byte_buf = @rec(mutable vec[mutable u8] buf, mutable uint pos);
state obj byte_buf_writer(mutable_byte_buf buf) { state obj byte_buf_writer(mutable_byte_buf buf) {
fn write(vec[u8] v) { fn write(vec[u8] v) {
// Fast path. // Fast path.
if (buf.pos == _vec::len(buf.buf)) { if (buf.pos == vec::len(buf.buf)) {
// FIXME: Fix our type system. There's no reason you shouldn't be // FIXME: Fix our type system. There's no reason you shouldn't be
// able to add a mutable vector to an immutable one. // able to add a mutable vector to an immutable one.
auto mv = _vec::rustrt::unsafe_vec_to_mut[u8](v); auto mv = vec::rustrt::unsafe_vec_to_mut[u8](v);
buf.buf += mv; buf.buf += mv;
buf.pos += _vec::len[u8](v); buf.pos += vec::len[u8](v);
ret; ret;
} }
// FIXME: Optimize: These should be unique pointers. // FIXME: Optimize: These should be unique pointers.
auto vlen = _vec::len[u8](v); auto vlen = vec::len[u8](v);
auto vpos = 0u; auto vpos = 0u;
while (vpos < vlen) { while (vpos < vlen) {
auto b = v.(vpos); auto b = v.(vpos);
if (buf.pos == _vec::len(buf.buf)) { if (buf.pos == vec::len(buf.buf)) {
buf.buf += [mutable b]; buf.buf += [mutable b];
} else { } else {
buf.buf.(buf.pos) = b; buf.buf.(buf.pos) = b;
@ -477,7 +477,7 @@ state obj byte_buf_writer(mutable_byte_buf buf) {
fn seek(int offset, seek_style whence) { fn seek(int offset, seek_style whence) {
auto pos = buf.pos; auto pos = buf.pos;
auto len = _vec::len(buf.buf); auto len = vec::len(buf.buf);
buf.pos = seek_in_buf(offset, pos, len, whence); buf.pos = seek_in_buf(offset, pos, len, whence);
} }
@ -487,12 +487,12 @@ state obj byte_buf_writer(mutable_byte_buf buf) {
fn string_writer() -> str_writer { fn string_writer() -> str_writer {
// FIXME: yikes, this is bad. Needs fixing of mutable syntax. // FIXME: yikes, this is bad. Needs fixing of mutable syntax.
let vec[mutable u8] b = [mutable 0u8]; let vec[mutable u8] b = [mutable 0u8];
_vec::pop(b); vec::pop(b);
let mutable_byte_buf buf = @rec(mutable buf = b, mutable pos = 0u); let mutable_byte_buf buf = @rec(mutable buf = b, mutable pos = 0u);
state obj str_writer_wrap(writer wr, mutable_byte_buf buf) { state obj str_writer_wrap(writer wr, mutable_byte_buf buf) {
fn get_writer() -> writer {ret wr;} fn get_writer() -> writer {ret wr;}
fn get_str() -> str {ret _str::unsafe_from_bytes(buf.buf);} fn get_str() -> str {ret str::unsafe_from_bytes(buf.buf);}
} }
ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf); ret str_writer_wrap(new_writer(byte_buf_writer(buf)), buf);
} }

10
src/lib/linux_os.rs
View file

@ -1,5 +1,5 @@
import _str::sbuf; import str::sbuf;
import _vec::vbuf; import vec::vbuf;
// FIXME Somehow merge stuff duplicated here and macosx_os.rs. Made difficult // FIXME Somehow merge stuff duplicated here and macosx_os.rs. Made difficult
// by https://github.com/graydon/rust/issues#issue/268 // by https://github.com/graydon/rust/issues#issue/268
@ -66,17 +66,17 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = [mutable 0, 0]; let vec[mutable int] fds = [mutable 0, 0];
assert (os::libc::pipe(_vec::buf(fds)) == 0); assert (os::libc::pipe(vec::buf(fds)) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }
fn fd_FILE(int fd) -> libc::FILE { fn fd_FILE(int fd) -> libc::FILE {
ret libc::fdopen(fd, _str::buf("r")); ret libc::fdopen(fd, str::buf("r"));
} }
fn waitpid(int pid) -> int { fn waitpid(int pid) -> int {
let vec[mutable int] status = [mutable 0]; let vec[mutable int] status = [mutable 0];
assert (os::libc::waitpid(pid, _vec::buf(status), 0) != -1); assert (os::libc::waitpid(pid, vec::buf(status), 0) != -1);
ret status.(0); ret status.(0);
} }

10
src/lib/macos_os.rs
View file

@ -1,5 +1,5 @@
import _str::sbuf; import str::sbuf;
import _vec::vbuf; import vec::vbuf;
native mod libc = "libc.dylib" { native mod libc = "libc.dylib" {
@ -63,17 +63,17 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = [mutable 0, 0]; let vec[mutable int] fds = [mutable 0, 0];
assert (os::libc::pipe(_vec::buf(fds)) == 0); assert (os::libc::pipe(vec::buf(fds)) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }
fn fd_FILE(int fd) -> libc::FILE { fn fd_FILE(int fd) -> libc::FILE {
ret libc::fdopen(fd, _str::buf("r")); ret libc::fdopen(fd, str::buf("r"));
} }
fn waitpid(int pid) -> int { fn waitpid(int pid) -> int {
let vec[mutable int] status = [mutable 0]; let vec[mutable int] status = [mutable 0];
assert (os::libc::waitpid(pid, _vec::buf(status), 0) != -1); assert (os::libc::waitpid(pid, vec::buf(status), 0) != -1);
ret status.(0); ret status.(0);
} }

4
src/lib/map.rs
View file

@ -29,7 +29,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
} }
fn make_buckets[K, V](uint nbkts) -> vec[mutable bucket[K, V]] { fn make_buckets[K, V](uint nbkts) -> vec[mutable bucket[K, V]] {
ret _vec::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 // Derive two hash functions from the one given by taking the upper
@ -148,7 +148,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
let util::rational load = rec(num=(nelts + 1u) as int, let util::rational load = rec(num=(nelts + 1u) as int,
den=nbkts as int); den=nbkts as int);
if (!util::rational_leq(load, lf)) { if (!util::rational_leq(load, lf)) {
let uint nnewbkts = _uint::next_power_of_two(nbkts + 1u); let uint nnewbkts = uint::next_power_of_two(nbkts + 1u);
let vec[mutable bucket[K, V]] newbkts = let vec[mutable bucket[K, V]] newbkts =
make_buckets[K, V](nnewbkts); make_buckets[K, V](nnewbkts);
rehash[K, V](hasher, eqer, bkts, nbkts, rehash[K, V](hasher, eqer, bkts, nbkts,

4
src/lib/posix_fs.rs
View file

@ -4,7 +4,7 @@ native "rust" mod rustrt {
fn list_dir(str path) -> vec[str] { fn list_dir(str path) -> vec[str] {
// TODO ensure this is always closed // TODO ensure this is always closed
auto dir = os::libc::opendir(_str::buf(path)); auto dir = os::libc::opendir(str::buf(path));
assert (dir as uint != 0u); assert (dir as uint != 0u);
let vec[str] result = []; let vec[str] result = [];
while (true) { while (true) {
@ -13,7 +13,7 @@ fn list_dir(str path) -> vec[str] {
os::libc::closedir(dir); os::libc::closedir(dir);
ret result; ret result;
} }
_vec::push[str](result, rustrt::rust_dirent_filename(ent)); vec::push[str](result, rustrt::rust_dirent_filename(ent));
} }
os::libc::closedir(dir); os::libc::closedir(dir);
ret result; ret result;

16
src/lib/run_program.rs
View file

@ -1,21 +1,21 @@
import _str::sbuf; import str::sbuf;
import _vec::vbuf; import vec::vbuf;
native "rust" mod rustrt { native "rust" mod rustrt {
fn rust_run_program(vbuf argv, int in_fd, int out_fd, int err_fd) -> int; fn rust_run_program(vbuf argv, int in_fd, int out_fd, int err_fd) -> int;
} }
fn arg_vec(str prog, vec[str] args) -> vec[sbuf] { fn arg_vec(str prog, vec[str] args) -> vec[sbuf] {
auto argptrs = [_str::buf(prog)]; auto argptrs = [str::buf(prog)];
for (str arg in args) { for (str arg in args) {
_vec::push[sbuf](argptrs, _str::buf(arg)); vec::push[sbuf](argptrs, str::buf(arg));
} }
_vec::push[sbuf](argptrs, 0 as sbuf); vec::push[sbuf](argptrs, 0 as sbuf);
ret argptrs; ret argptrs;
} }
fn run_program(str prog, vec[str] args) -> int { fn run_program(str prog, vec[str] args) -> int {
auto pid = rustrt::rust_run_program(_vec::buf[sbuf](arg_vec(prog, args)), auto pid = rustrt::rust_run_program(vec::buf[sbuf](arg_vec(prog, args)),
0, 0, 0); 0, 0, 0);
ret os::waitpid(pid); ret os::waitpid(pid);
} }
@ -33,7 +33,7 @@ fn start_program(str prog, vec[str] args) -> @program {
auto pipe_input = os::pipe(); auto pipe_input = os::pipe();
auto pipe_output = os::pipe(); auto pipe_output = os::pipe();
auto pid = rustrt::rust_run_program auto pid = rustrt::rust_run_program
(_vec::buf[sbuf](arg_vec(prog, args)), (vec::buf[sbuf](arg_vec(prog, args)),
pipe_input._0, pipe_output._1, 0); pipe_input._0, pipe_output._1, 0);
if (pid == -1) {fail;} if (pid == -1) {fail;}
os::libc::close(pipe_input._0); os::libc::close(pipe_input._0);
@ -80,7 +80,7 @@ fn program_output(str prog, vec[str] args)
auto buf = ""; auto buf = "";
while (!out.eof()) { while (!out.eof()) {
auto bytes = out.read_bytes(4096u); auto bytes = out.read_bytes(4096u);
buf += _str::unsafe_from_bytes(bytes); buf += str::unsafe_from_bytes(bytes);
} }
ret rec(status=pr.finish(), out=buf); ret rec(status=pr.finish(), out=buf);
} }

18
src/lib/sha1.rs
View file

@ -74,8 +74,8 @@ fn mk_sha1() -> sha1 {
fn process_msg_block(&sha1state st) { fn process_msg_block(&sha1state st) {
// FIXME: Make precondition // FIXME: Make precondition
assert (_vec::len(st.h) == digest_buf_len); assert (vec::len(st.h) == digest_buf_len);
assert (_vec::len(st.work_buf) == work_buf_len); assert (vec::len(st.work_buf) == work_buf_len);
let int t; // Loop counter let int t; // Loop counter
auto w = st.work_buf; auto w = st.work_buf;
@ -196,7 +196,7 @@ fn mk_sha1() -> sha1 {
*/ */
fn pad_msg(&sha1state st) { fn pad_msg(&sha1state st) {
// FIXME: Should be a precondition // FIXME: Should be a precondition
assert (_vec::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 * Check to see if the current message block is too small to hold
@ -240,7 +240,7 @@ fn mk_sha1() -> sha1 {
fn reset() { fn reset() {
// FIXME: Should be typestate precondition // FIXME: Should be typestate precondition
assert (_vec::len(st.h) == digest_buf_len); assert (vec::len(st.h) == digest_buf_len);
st.len_low = 0u32; st.len_low = 0u32;
st.len_high = 0u32; st.len_high = 0u32;
@ -260,7 +260,7 @@ fn mk_sha1() -> sha1 {
} }
fn input_str(&str msg) { fn input_str(&str msg) {
add_input(st, _str::bytes(msg)); add_input(st, str::bytes(msg));
} }
fn result() -> vec[u8] { fn result() -> vec[u8] {
@ -271,19 +271,19 @@ fn mk_sha1() -> sha1 {
auto r = mk_result(st); auto r = mk_result(st);
auto s = ""; auto s = "";
for (u8 b in r) { for (u8 b in r) {
s += _uint::to_str(b as uint, 16u); s += uint::to_str(b as uint, 16u);
} }
ret s; ret s;
} }
} }
auto st = rec(h = _vec::init_elt_mut[u32](0u32, digest_buf_len), auto st = rec(h = vec::init_elt_mut[u32](0u32, digest_buf_len),
mutable len_low = 0u32, mutable len_low = 0u32,
mutable len_high = 0u32, mutable len_high = 0u32,
msg_block = _vec::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 msg_block_idx = 0u,
mutable computed = false, mutable computed = false,
work_buf = _vec::init_elt_mut[u32](0u32, work_buf_len)); work_buf = vec::init_elt_mut[u32](0u32, work_buf_len));
auto sh = sha1(st); auto sh = sha1(st);
sh.reset(); sh.reset();
ret sh; ret sh;

4
src/lib/sort.rs
View file

@ -1,5 +1,5 @@
import _vec::len; import vec::len;
import _vec::slice; import vec::slice;
type lteq[T] = fn(&T a, &T b) -> bool; type lteq[T] = fn(&T a, &T b) -> bool;

16
src/lib/std.rc
View file

@ -6,11 +6,11 @@ meta (name = "std",
// Built-in types support modules. // Built-in types support modules.
mod _int; mod int;
mod _uint; mod uint;
mod _u8; mod u8;
mod _vec; mod vec;
mod _str; mod str;
// General io and system-services modules. // General io and system-services modules.
@ -29,13 +29,13 @@ auth io = unsafe;
auth fs = unsafe; auth fs = unsafe;
auth os_fs = unsafe; auth os_fs = unsafe;
auth run = unsafe; auth run = unsafe;
auth _str = unsafe; auth str = unsafe;
auth _vec = unsafe; auth vec = unsafe;
auth _task = unsafe; auth _task = unsafe;
auth dbg = unsafe; auth dbg = unsafe;
auth _uint::next_power_of_two = unsafe; auth uint::next_power_of_two = unsafe;
auth map::mk_hashmap = unsafe; auth map::mk_hashmap = unsafe;
auth rand::mk_rng = unsafe; auth rand::mk_rng = unsafe;

12
src/lib/_str.rs → src/lib/str.rs
View file

@ -1,6 +1,6 @@
import rustrt::sbuf; import rustrt::sbuf;
import _vec::rustrt::vbuf; import vec::rustrt::vbuf;
native "rust" mod rustrt { native "rust" mod rustrt {
type sbuf; type sbuf;
@ -84,7 +84,7 @@ const uint tag_six_b = 0xfc_u;
fn is_utf8(vec[u8] v) -> bool { fn is_utf8(vec[u8] v) -> bool {
auto i = 0u; auto i = 0u;
auto total = _vec::len[u8](v); auto total = vec::len[u8](v);
while (i < total) { while (i < total) {
auto chsize = utf8_char_width(v.(i)); auto chsize = utf8_char_width(v.(i));
if (chsize == 0u) {ret false;} if (chsize == 0u) {ret false;}
@ -253,7 +253,7 @@ fn to_chars(str s) -> vec[char] {
auto len = byte_len(s); auto len = byte_len(s);
while (i < len) { while (i < len) {
auto cur = char_range_at(s, i); auto cur = char_range_at(s, i);
_vec::push[char](buf, cur._0); vec::push[char](buf, cur._0);
i = cur._1; i = cur._1;
} }
ret buf; ret buf;
@ -311,7 +311,7 @@ fn index(str s, u8 c) -> int {
} }
fn rindex(str s, u8 c) -> int { fn rindex(str s, u8 c) -> int {
let int n = _str::byte_len(s) as int; let int n = str::byte_len(s) as int;
while (n >= 0) { while (n >= 0) {
if (s.(n) == c) { if (s.(n) == c) {
ret n; ret n;
@ -387,7 +387,7 @@ fn substr(str s, uint begin, uint len) -> str {
fn slice(str s, uint begin, uint end) -> str { fn slice(str s, uint begin, uint end) -> str {
// FIXME: Typestate precondition // FIXME: Typestate precondition
assert (begin <= end); assert (begin <= end);
assert (end <= _str::byte_len(s)); assert (end <= str::byte_len(s));
ret rustrt::str_slice(s, begin, end); ret rustrt::str_slice(s, begin, end);
} }
@ -432,7 +432,7 @@ fn split(str s, u8 sep) -> vec[str] {
ends_with_sep = false; ends_with_sep = false;
} }
} }
if (_str::byte_len(accum) != 0u || if (str::byte_len(accum) != 0u ||
ends_with_sep) { ends_with_sep) {
v += [accum]; v += [accum];
} }

0
src/lib/_u8.rs → src/lib/u8.rs
View file

4
src/lib/ufind.rs
View file

@ -8,12 +8,12 @@ type ufind = rec(mutable vec[mutable node] nodes);
fn make() -> ufind { fn make() -> ufind {
let vec[mutable node] v = [mutable none[uint]]; let vec[mutable node] v = [mutable none[uint]];
_vec::pop(v); // FIXME: botch vec::pop(v); // FIXME: botch
ret rec(mutable nodes=v); ret rec(mutable nodes=v);
} }
fn make_set(&ufind ufnd) -> uint { fn make_set(&ufind ufnd) -> uint {
auto idx = _vec::len(ufnd.nodes); auto idx = vec::len(ufnd.nodes);
ufnd.nodes += [mutable none[uint]]; ufnd.nodes += [mutable none[uint]];
ret idx; ret idx;
} }

10
src/lib/_uint.rs → src/lib/uint.rs
View file

@ -34,12 +34,12 @@ fn next_power_of_two(uint n) -> uint {
} }
fn parse_buf(vec[u8] buf, uint radix) -> uint { fn parse_buf(vec[u8] buf, uint radix) -> uint {
if (_vec::len[u8](buf) == 0u) { if (vec::len[u8](buf) == 0u) {
log_err "parse_buf(): buf is empty"; log_err "parse_buf(): buf is empty";
fail; fail;
} }
auto i = _vec::len[u8](buf) - 1u; auto i = vec::len[u8](buf) - 1u;
auto power = 1u; auto power = 1u;
auto n = 0u; auto n = 0u;
while (true) { while (true) {
@ -83,15 +83,15 @@ fn to_str(uint num, uint radix) -> str
let str s = ""; let str s = "";
while (n != 0u) { while (n != 0u) {
s += _str::unsafe_from_byte(digit(n % radix) as u8); s += str::unsafe_from_byte(digit(n % radix) as u8);
n /= radix; n /= radix;
} }
let str s1 = ""; let str s1 = "";
let uint len = _str::byte_len(s); let uint len = str::byte_len(s);
while (len != 0u) { while (len != 0u) {
len -= 1u; len -= 1u;
s1 += _str::unsafe_from_byte(s.(len)); s1 += str::unsafe_from_byte(s.(len));
} }
ret s1; ret s1;

2
src/lib/util.rs
View file

@ -4,7 +4,7 @@ fn id[T](&T x) -> T {
/* FIXME (issue #141): See test/run-pass/constrained-type.rs. Uncomment /* FIXME (issue #141): See test/run-pass/constrained-type.rs. Uncomment
* the constraint once fixed. */ * the constraint once fixed. */
type rational = rec(int num, int den); // : _int::positive(*.den); type rational = rec(int num, int den); // : int::positive(*.den);
fn rational_leq(&rational x, &rational y) -> bool { fn rational_leq(&rational x, &rational y) -> bool {
// NB: Uses the fact that rationals have positive denominators WLOG: // NB: Uses the fact that rationals have positive denominators WLOG:

4
src/lib/_vec.rs → src/lib/vec.rs
View file

@ -199,7 +199,7 @@ fn grow[T](&array[T] v, uint n, &T initval) {
} }
fn grow_set[T](&vec[mutable T] v, uint index, &T initval, &T val) { fn grow_set[T](&vec[mutable T] v, uint index, &T initval, &T val) {
auto length = _vec::len(v); auto length = vec::len(v);
if (index >= length) { if (index >= length) {
grow(v, index - length + 1u, initval); grow(v, index - length + 1u, initval);
} }
@ -270,7 +270,7 @@ fn unzip[T, U](&vec[tup(T, U)] v) -> tup(vec[T], vec[U]) {
fn or(&vec[bool] v) -> bool { fn or(&vec[bool] v) -> bool {
auto f = orb; auto f = orb;
ret _vec::foldl[bool, bool](f, false, v); ret vec::foldl[bool, bool](f, false, v);
} }
fn clone[T](&vec[T] v) -> vec[T] { fn clone[T](&vec[T] v) -> vec[T] {

8
src/lib/win32_os.rs
View file

@ -1,5 +1,5 @@
import _str::sbuf; import str::sbuf;
import _vec::vbuf; import vec::vbuf;
native mod libc = "msvcrt.dll" { native mod libc = "msvcrt.dll" {
fn open(sbuf s, int flags, uint mode) -> int = "_open"; fn open(sbuf s, int flags, uint mode) -> int = "_open";
@ -53,13 +53,13 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = [mutable 0, 0]; let vec[mutable int] fds = [mutable 0, 0];
assert (os::libc::_pipe(_vec::buf(fds), 1024u, assert (os::libc::_pipe(vec::buf(fds), 1024u,
libc_constants::O_BINARY()) == 0); libc_constants::O_BINARY()) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }
fn fd_FILE(int fd) -> libc::FILE { fn fd_FILE(int fd) -> libc::FILE {
ret libc::_fdopen(fd, _str::buf("r")); ret libc::_fdopen(fd, str::buf("r"));
} }
native "rust" mod rustrt { native "rust" mod rustrt {

10
src/test/bench/99-bottles/99bob-iter.rs
View file

@ -3,8 +3,8 @@
* http://99-bottles-of-beer.net/ * http://99-bottles-of-beer.net/
*/ */
use std; use std;
import std::_int; import std::int;
import std::_str; import std::str;
fn b1() -> str { fn b1() -> str {
ret "# of beer on the wall, # of beer."; ret "# of beer on the wall, # of beer.";
@ -32,15 +32,15 @@ case (1) {
ns = "1 bottle"; ns = "1 bottle";
} }
case (_) { case (_) {
ns = _int::to_str(n, 10u) + " bottles"; ns = int::to_str(n, 10u) + " bottles";
} }
} }
while (i < _str::byte_len(t)) { while (i < str::byte_len(t)) {
if (t.(i) == ('#' as u8)) { if (t.(i) == ('#' as u8)) {
b += ns; b += ns;
} }
else { else {
_str::push_byte(b, t.(i)); str::push_byte(b, t.(i));
} }
i += 1u; i += 1u;
} }

8
src/test/bench/99-bottles/99bob-pattern.rs
View file

@ -3,8 +3,8 @@
* http://99-bottles-of-beer.net/ * http://99-bottles-of-beer.net/
*/ */
use std; use std;
import std::_int; import std::int;
import std::_str; import std::str;
tag bottle { none; dual; single; multiple(int);} tag bottle { none; dual; single; multiple(int);}
@ -25,8 +25,8 @@ fn show(bottle b) {
log "Take one down and pass it around, 1 bottle of beer on the wall."; log "Take one down and pass it around, 1 bottle of beer on the wall.";
} }
case (multiple(?n)) { case (multiple(?n)) {
let str nb = _int::to_str(n, 10u); let str nb = int::to_str(n, 10u);
let str mb = _int::to_str(n - 1, 10u); let str mb = int::to_str(n - 1, 10u);
log nb + " bottles of beer on the wall, " + nb + " bottles of beer,"; log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
log "Take one down and pass it around, " log "Take one down and pass it around, "
+ mb + " bottles of beer on the wall."; + mb + " bottles of beer on the wall.";

10
src/test/bench/99-bottles/99bob-simple.rs
View file

@ -3,8 +3,8 @@
* http://99-bottles-of-beer.net/ * http://99-bottles-of-beer.net/
*/ */
use std; use std;
import std::_int; import std::int;
import std::_str; import std::str;
fn b1() -> str { fn b1() -> str {
ret "# of beer on the wall, # of beer."; ret "# of beer on the wall, # of beer.";
@ -31,15 +31,15 @@ case (1) {
ns = "1 bottle"; ns = "1 bottle";
} }
case (_) { case (_) {
ns = _int::to_str(n, 10u) + " bottles"; ns = int::to_str(n, 10u) + " bottles";
} }
} }
while (i < _str::byte_len(t)) { while (i < str::byte_len(t)) {
if (t.(i) == ('#' as u8)) { if (t.(i) == ('#' as u8)) {
b += ns; b += ns;
} }
else { else {
_str::push_byte(b, t.(i)); str::push_byte(b, t.(i));
} }
i += 1u; i += 1u;
} }

8
src/test/bench/99-bottles/99bob-tail.rs
View file

@ -3,13 +3,13 @@
* http://99-bottles-of-beer.net/ * http://99-bottles-of-beer.net/
*/ */
use std; use std;
import std::_int; import std::int;
import std::_str; import std::str;
fn main() { fn main() {
fn multiple(int n) { fn multiple(int n) {
let str nb = _int::to_str(n, 10u); let str nb = int::to_str(n, 10u);
let str mb = _int::to_str(n - 1, 10u); let str mb = int::to_str(n - 1, 10u);
log nb + " bottles of beer on the wall, " + nb + " bottles of beer,"; log nb + " bottles of beer on the wall, " + nb + " bottles of beer,";
log "Take one down and pass it around, " log "Take one down and pass it around, "
+ mb + " bottles of beer on the wall."; + mb + " bottles of beer on the wall.";

4
src/test/bench/shootout/binarytrees.rs
View file

@ -1,6 +1,6 @@
use std; use std;
import std::_int; import std::int;
tag tree { tag tree {
nil; nil;
@ -49,7 +49,7 @@ fn main() {
auto depth = min_depth; auto depth = min_depth;
while (depth <= max_depth) { while (depth <= max_depth) {
auto iterations = _int::pow(2, (max_depth - depth + min_depth) as uint); auto iterations = int::pow(2, (max_depth - depth + min_depth) as uint);
auto chk = 0; auto chk = 0;
auto i = 1; auto i = 1;

10
src/test/bench/shootout/fannkuchredux.rs
View file

@ -2,8 +2,8 @@
use std; use std;
import std::_int; import std::int;
import std::_vec; import std::vec;
fn fannkuch(int n) -> int { fn fannkuch(int n) -> int {
@ -12,9 +12,9 @@ fn fannkuch(int n) -> int {
} }
auto perm1init_ = perm1init; // Rustboot workaround auto perm1init_ = perm1init; // Rustboot workaround
auto perm = _vec::init_elt(0, n as uint); auto perm = vec::init_elt(0, n as uint);
auto perm1 = _vec::init_fn(perm1init_, n as uint); auto perm1 = vec::init_fn(perm1init_, n as uint);
auto count = _vec::init_elt(0, n as uint); auto count = vec::init_elt(0, n as uint);
auto f = 0; auto f = 0;
auto i = 0; auto i = 0;

28
src/test/bench/shootout/fasta.rs
View file

@ -7,10 +7,10 @@
* http://shootout.alioth.debian.org/ * http://shootout.alioth.debian.org/
*/ */
use std; use std;
import std::_vec; import std::vec;
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::_int; import std::int;
fn LINE_LENGTH() -> uint { fn LINE_LENGTH() -> uint {
ret 60u; ret 60u;
@ -54,21 +54,21 @@ fn select_random(u32 r, vec[aminoacids] genelist) -> char {
ret v.(hi)._0; ret v.(hi)._0;
} }
} }
ret bisect(genelist, 0u, _vec::len[aminoacids](genelist) - 1u, r); ret bisect(genelist, 0u, vec::len[aminoacids](genelist) - 1u, r);
} }
fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) { fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
log(">" + id + " " + desc); log(">" + id + " " + desc);
auto rng = myrandom(std::rand::mk_rng().next()); auto rng = myrandom(std::rand::mk_rng().next());
let str op = ""; let str op = "";
for each (uint i in _uint::range(0u, n as uint)) { for each (uint i in uint::range(0u, n as uint)) {
_str::push_byte(op, select_random(rng.next(100u32), genelist) as u8); str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
if (_str::byte_len(op) >= LINE_LENGTH()) { if (str::byte_len(op) >= LINE_LENGTH()) {
log(op); log(op);
op = ""; op = "";
} }
} }
if (_str::byte_len(op) > 0u) { if (str::byte_len(op) > 0u) {
log(op); log(op);
} }
} }
@ -76,16 +76,16 @@ fn make_random_fasta(str id, str desc, vec[aminoacids] genelist, int n) {
fn make_repeat_fasta(str id, str desc, str s, int n) { fn make_repeat_fasta(str id, str desc, str s, int n) {
log(">" + id + " " + desc); log(">" + id + " " + desc);
let str op = ""; let str op = "";
let uint sl = _str::byte_len(s); let uint sl = str::byte_len(s);
for each (uint i in _uint::range(0u, n as uint)) { for each (uint i in uint::range(0u, n as uint)) {
_str::push_byte(op, s.(i % sl)); str::push_byte(op, s.(i % sl));
if (_str::byte_len(op) >= LINE_LENGTH()) { if (str::byte_len(op) >= LINE_LENGTH()) {
log(op); log(op);
op = ""; op = "";
} }
} }
if (_str::byte_len(op) > 0u) { if (str::byte_len(op) > 0u) {
log(op); log(op);
} }
} }

10
src/test/run-pass/alt-pattern-drop.rs
View file

@ -1,7 +1,7 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_str; import std::str;
// FIXME: import std::dbg.const_refcount. Currently // FIXME: import std::dbg.const_refcount. Currently
// cross-crate const references don't work. // cross-crate const references don't work.
@ -20,13 +20,13 @@ fn foo(str s) {
case (_) { log "?"; fail; } case (_) { log "?"; fail; }
} }
log _str::refcount(s); log str::refcount(s);
assert (_str::refcount(s) == const_refcount); assert (str::refcount(s) == const_refcount);
} }
fn main() { fn main() {
let str s = "hi"; // ref up let str s = "hi"; // ref up
foo(s); // ref up then down foo(s); // ref up then down
log _str::refcount(s); log str::refcount(s);
assert (_str::refcount(s) == const_refcount); assert (str::refcount(s) == const_refcount);
} }

2
src/test/run-pass/box-inside-if.rs
View file

@ -1,7 +1,7 @@
// -*- rust -*- // -*- rust -*-
// xfail-stage0 // xfail-stage0
use std; use std;
import std::_vec; import std::vec;
fn some_vec(int x) -> vec[int] { fn some_vec(int x) -> vec[int] {
ret []; ret [];

2
src/test/run-pass/box-inside-if2.rs
View file

@ -1,7 +1,7 @@
// -*- rust -*- // -*- rust -*-
// xfail-stage0 // xfail-stage0
use std; use std;
import std::_vec; import std::vec;
fn some_vec(int x) -> vec[int] { fn some_vec(int x) -> vec[int] {
ret []; ret [];

4
src/test/run-pass/lib-bitv.rs
View file

@ -1,5 +1,5 @@
use std; use std;
import std::_vec; import std::vec;
import std::bitv; import std::bitv;
fn test_0_elements() { fn test_0_elements() {
@ -7,7 +7,7 @@ fn test_0_elements() {
auto exp; auto exp;
act = bitv::create(0u, false); act = bitv::create(0u, false);
exp = _vec::init_elt[uint](0u, 0u); exp = vec::init_elt[uint](0u, 0u);
// FIXME: why can't I write vec[uint]()? // FIXME: why can't I write vec[uint]()?
assert (bitv::eq_vec(act, exp)); assert (bitv::eq_vec(act, exp));
} }

30
src/test/run-pass/lib-int.rs
View file

@ -1,25 +1,25 @@
use std; use std;
import std::_int; import std::int;
import std::_str::eq; import std::str::eq;
fn test_to_str() { fn test_to_str() {
assert (eq(_int::to_str(0, 10u), "0")); assert (eq(int::to_str(0, 10u), "0"));
assert (eq(_int::to_str(1, 10u), "1")); assert (eq(int::to_str(1, 10u), "1"));
assert (eq(_int::to_str(-1, 10u), "-1")); assert (eq(int::to_str(-1, 10u), "-1"));
assert (eq(_int::to_str(255, 16u), "ff")); assert (eq(int::to_str(255, 16u), "ff"));
assert (eq(_int::to_str(100, 10u), "100")); assert (eq(int::to_str(100, 10u), "100"));
} }
fn test_pow() { fn test_pow() {
assert (_int::pow(0, 0u) == 1); assert (int::pow(0, 0u) == 1);
assert (_int::pow(0, 1u) == 0); assert (int::pow(0, 1u) == 0);
assert (_int::pow(0, 2u) == 0); assert (int::pow(0, 2u) == 0);
assert (_int::pow(-1, 0u) == -1); assert (int::pow(-1, 0u) == -1);
assert (_int::pow(1, 0u) == 1); assert (int::pow(1, 0u) == 1);
assert (_int::pow(-3, 2u) == 9); assert (int::pow(-3, 2u) == 9);
assert (_int::pow(-3, 3u) == -27); assert (int::pow(-3, 3u) == -27);
assert (_int::pow(4, 9u) == 262144); assert (int::pow(4, 9u) == 262144);
} }
fn main() { fn main() {

4
src/test/run-pass/lib-io.rs
View file

@ -5,7 +5,7 @@
use std; use std;
import std::io; import std::io;
import std::_str; import std::str;
fn test_simple(str tmpfilebase) { fn test_simple(str tmpfilebase) {
let str tmpfile = tmpfilebase + ".tmp"; let str tmpfile = tmpfilebase + ".tmp";
@ -21,7 +21,7 @@ fn test_simple(str tmpfilebase) {
let io::reader inp = io::file_reader(tmpfile); let io::reader inp = io::file_reader(tmpfile);
let str frood2 = inp.read_c_str(); let str frood2 = inp.read_c_str();
log frood2; log frood2;
assert (_str::eq(frood, frood2)); assert (str::eq(frood, frood2));
} }
fn main(vec[str] argv) { fn main(vec[str] argv) {

98
src/test/run-pass/lib-map.rs
View file

@ -2,8 +2,8 @@
use std; use std;
import std::map; import std::map;
import std::_str; import std::str;
import std::_uint; import std::uint;
import std::util; import std::util;
fn test_simple() { fn test_simple() {
@ -19,8 +19,8 @@ fn test_simple() {
let map::hashfn[uint] hasher_uint = hash_uint; let map::hashfn[uint] hasher_uint = hash_uint;
let map::eqfn[uint] eqer_uint = eq_uint; let map::eqfn[uint] eqer_uint = eq_uint;
let map::hashfn[str] hasher_str = _str::hash; let map::hashfn[str] hasher_str = str::hash;
let map::eqfn[str] eqer_str = _str::eq; let map::eqfn[str] eqer_str = str::eq;
log "uint -> uint"; log "uint -> uint";
@ -77,15 +77,15 @@ fn test_simple() {
assert (hm_us.insert(11u, "thirteen")); assert (hm_us.insert(11u, "thirteen"));
assert (hm_us.insert(12u, "fourteen")); assert (hm_us.insert(12u, "fourteen"));
assert (_str::eq(hm_us.get(11u), "thirteen")); assert (str::eq(hm_us.get(11u), "thirteen"));
assert (_str::eq(hm_us.get(12u), "fourteen")); assert (str::eq(hm_us.get(12u), "fourteen"));
assert (_str::eq(hm_us.get(10u), "twelve")); assert (str::eq(hm_us.get(10u), "twelve"));
assert (!hm_us.insert(12u, "fourteen")); assert (!hm_us.insert(12u, "fourteen"));
assert (_str::eq(hm_us.get(12u), "fourteen")); assert (str::eq(hm_us.get(12u), "fourteen"));
assert (!hm_us.insert(12u, "twelve")); assert (!hm_us.insert(12u, "twelve"));
assert (_str::eq(hm_us.get(12u), "twelve")); assert (str::eq(hm_us.get(12u), "twelve"));
log "str -> str"; log "str -> str";
@ -97,15 +97,15 @@ fn test_simple() {
assert (hm_ss.insert(eleven, "thirteen")); assert (hm_ss.insert(eleven, "thirteen"));
assert (hm_ss.insert(twelve, "fourteen")); assert (hm_ss.insert(twelve, "fourteen"));
assert (_str::eq(hm_ss.get("eleven"), "thirteen")); assert (str::eq(hm_ss.get("eleven"), "thirteen"));
assert (_str::eq(hm_ss.get("twelve"), "fourteen")); assert (str::eq(hm_ss.get("twelve"), "fourteen"));
assert (_str::eq(hm_ss.get("ten"), "twelve")); assert (str::eq(hm_ss.get("ten"), "twelve"));
assert (!hm_ss.insert("twelve", "fourteen")); assert (!hm_ss.insert("twelve", "fourteen"));
assert (_str::eq(hm_ss.get("twelve"), "fourteen")); assert (str::eq(hm_ss.get("twelve"), "fourteen"));
assert (!hm_ss.insert("twelve", "twelve")); assert (!hm_ss.insert("twelve", "twelve"));
assert (_str::eq(hm_ss.get("twelve"), "twelve")); assert (str::eq(hm_ss.get("twelve"), "twelve"));
log "*** finished test_simple"; log "*** finished test_simple";
} }
@ -136,8 +136,8 @@ fn test_growth() {
let uint i = 0u; let uint i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
assert (hm_uu.insert(i, i * i)); assert (hm_uu.insert(i, i * i));
log "inserting " + _uint::to_str(i, 10u) log "inserting " + uint::to_str(i, 10u)
+ " -> " + _uint::to_str(i * i, 10u); + " -> " + uint::to_str(i * i, 10u);
i += 1u; i += 1u;
} }
@ -145,8 +145,8 @@ fn test_growth() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm_uu.get(i), 10u); + uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i); assert (hm_uu.get(i) == i * i);
i += 1u; i += 1u;
} }
@ -160,8 +160,8 @@ fn test_growth() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm_uu.get(i), 10u); + uint::to_str(hm_uu.get(i), 10u);
assert (hm_uu.get(i) == i * i); assert (hm_uu.get(i) == i * i);
i += 1u; i += 1u;
} }
@ -169,16 +169,16 @@ fn test_growth() {
log "str -> str"; log "str -> str";
let map::hashfn[str] hasher_str = _str::hash; let map::hashfn[str] hasher_str = str::hash;
let map::eqfn[str] eqer_str = _str::eq; let map::eqfn[str] eqer_str = str::eq;
let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str, let map::hashmap[str, str] hm_ss = map::mk_hashmap[str, str](hasher_str,
eqer_str); eqer_str);
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
assert (hm_ss.insert(_uint::to_str(i, 2u), _uint::to_str(i * i, 2u))); assert (hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)));
log "inserting \"" + _uint::to_str(i, 2u) log "inserting \"" + uint::to_str(i, 2u)
+ "\" -> \"" + _uint::to_str(i * i, 2u) + "\""; + "\" -> \"" + uint::to_str(i * i, 2u) + "\"";
i += 1u; i += 1u;
} }
@ -187,20 +187,20 @@ fn test_growth() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(\"" log "get(\""
+ _uint::to_str(i, 2u) + uint::to_str(i, 2u)
+ "\") = \"" + "\") = \""
+ hm_ss.get(_uint::to_str(i, 2u)) + "\""; + hm_ss.get(uint::to_str(i, 2u)) + "\"";
assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)), assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
_uint::to_str(i * i, 2u))); uint::to_str(i * i, 2u)));
i += 1u; i += 1u;
} }
assert (hm_ss.insert(_uint::to_str(num_to_insert, 2u), assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
_uint::to_str(17u, 2u))); uint::to_str(17u, 2u)));
assert (_str::eq(hm_ss.get(_uint::to_str(num_to_insert, 2u)), assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)),
_uint::to_str(17u, 2u))); uint::to_str(17u, 2u)));
log "-----"; log "-----";
@ -208,10 +208,10 @@ fn test_growth() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(\"" + _uint::to_str(i, 2u) + "\") = \"" log "get(\"" + uint::to_str(i, 2u) + "\") = \""
+ hm_ss.get(_uint::to_str(i, 2u)) + "\""; + hm_ss.get(uint::to_str(i, 2u)) + "\"";
assert (_str::eq(hm_ss.get(_uint::to_str(i, 2u)), assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
_uint::to_str(i * i, 2u))); uint::to_str(i * i, 2u)));
i += 1u; i += 1u;
} }
@ -241,8 +241,8 @@ fn test_removal() {
let uint i = 0u; let uint i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
assert (hm.insert(i, i * i)); assert (hm.insert(i, i * i));
log "inserting " + _uint::to_str(i, 10u) log "inserting " + uint::to_str(i, 10u)
+ " -> " + _uint::to_str(i * i, 10u); + " -> " + uint::to_str(i * i, 10u);
i += 1u; i += 1u;
} }
@ -279,8 +279,8 @@ fn test_removal() {
i = 1u; i = 1u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm.get(i), 10u); + uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i); assert (hm.get(i) == i * i);
i += 2u; i += 2u;
} }
@ -294,8 +294,8 @@ fn test_removal() {
i = 1u; i = 1u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm.get(i), 10u); + uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i); assert (hm.get(i) == i * i);
i += 2u; i += 2u;
} }
@ -305,8 +305,8 @@ fn test_removal() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
assert (hm.insert(i, i * i)); assert (hm.insert(i, i * i));
log "inserting " + _uint::to_str(i, 10u) log "inserting " + uint::to_str(i, 10u)
+ " -> " + _uint::to_str(i * i, 10u); + " -> " + uint::to_str(i * i, 10u);
i += 2u; i += 2u;
} }
@ -316,8 +316,8 @@ fn test_removal() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm.get(i), 10u); + uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i); assert (hm.get(i) == i * i);
i += 1u; i += 1u;
} }
@ -333,8 +333,8 @@ fn test_removal() {
i = 0u; i = 0u;
while (i < num_to_insert) { while (i < num_to_insert) {
log "get(" + _uint::to_str(i, 10u) + ") = " log "get(" + uint::to_str(i, 10u) + ") = "
+ _uint::to_str(hm.get(i), 10u); + uint::to_str(hm.get(i), 10u);
assert (hm.get(i) == i * i); assert (hm.get(i) == i * i);
i += 1u; i += 1u;
} }

2
src/test/run-pass/lib-qsort.rs
View file

@ -1,7 +1,7 @@
use std; use std;
fn check_sort(vec[mutable int] v1, vec[mutable int] v2) { fn check_sort(vec[mutable int] v1, vec[mutable int] v2) {
auto len = std::_vec::len[int](v1); auto len = std::vec::len[int](v1);
fn ltequal(&int a, &int b) -> bool { fn ltequal(&int a, &int b) -> bool {
ret a <= b; ret a <= b;

12
src/test/run-pass/lib-sha1.rs
View file

@ -5,8 +5,8 @@
use std; use std;
import std::sha1; import std::sha1;
import std::_vec; import std::vec;
import std::_str; import std::str;
fn main() { fn main() {
@ -66,8 +66,8 @@ fn main() {
auto tests = fips_180_1_tests + wikipedia_tests; auto tests = fips_180_1_tests + wikipedia_tests;
fn check_vec_eq(vec[u8] v0, vec[u8] v1) { fn check_vec_eq(vec[u8] v0, vec[u8] v1) {
assert (_vec::len[u8](v0) == _vec::len[u8](v1)); assert (vec::len[u8](v0) == vec::len[u8](v1));
auto len = _vec::len[u8](v0); auto len = vec::len[u8](v0);
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {
auto a = v0.(i); auto a = v0.(i);
@ -88,11 +88,11 @@ fn main() {
// Test that it works when accepting the message in pieces // Test that it works when accepting the message in pieces
for (test t in tests) { for (test t in tests) {
auto len = _str::byte_len(t.input); auto len = str::byte_len(t.input);
auto left = len; auto left = len;
while (left > 0u) { while (left > 0u) {
auto take = (left + 1u) / 2u; auto take = (left + 1u) / 2u;
sh.input_str(_str::substr(t.input, len - left, take)); sh.input_str(str::substr(t.input, len - left, take));
left = left - take; left = left - take;
} }
auto out = sh.result(); auto out = sh.result();

2
src/test/run-pass/lib-sort.rs
View file

@ -1,7 +1,7 @@
use std; use std;
fn check_sort(vec[int] v1, vec[int] v2) { fn check_sort(vec[int] v1, vec[int] v2) {
auto len = std::_vec::len[int](v1); auto len = std::vec::len[int](v1);
fn lteq(&int a, &int b) -> bool { fn lteq(&int a, &int b) -> bool {
ret a <= b; ret a <= b;
} }

2
src/test/run-pass/lib-str-buf.rs
View file

@ -4,7 +4,7 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_str; import std::str;
fn main() { fn main() {
auto s = "hello"; auto s = "hello";

56
src/test/run-pass/lib-str.rs
View file

@ -1,38 +1,38 @@
// xfail-stage0 // xfail-stage0
use std; use std;
import std::_str; import std::str;
fn test_bytes_len() { fn test_bytes_len() {
assert (_str::byte_len("") == 0u); assert (str::byte_len("") == 0u);
assert (_str::byte_len("hello world") == 11u); assert (str::byte_len("hello world") == 11u);
assert (_str::byte_len("\x63") == 1u); assert (str::byte_len("\x63") == 1u);
assert (_str::byte_len("\xa2") == 2u); assert (str::byte_len("\xa2") == 2u);
assert (_str::byte_len("\u03c0") == 2u); assert (str::byte_len("\u03c0") == 2u);
assert (_str::byte_len("\u2620") == 3u); assert (str::byte_len("\u2620") == 3u);
assert (_str::byte_len("\U0001d11e") == 4u); assert (str::byte_len("\U0001d11e") == 4u);
} }
fn test_index_and_rindex() { fn test_index_and_rindex() {
assert (_str::index("hello", 'e' as u8) == 1); assert (str::index("hello", 'e' as u8) == 1);
assert (_str::index("hello", 'o' as u8) == 4); assert (str::index("hello", 'o' as u8) == 4);
assert (_str::index("hello", 'z' as u8) == -1); assert (str::index("hello", 'z' as u8) == -1);
assert (_str::rindex("hello", 'l' as u8) == 3); assert (str::rindex("hello", 'l' as u8) == 3);
assert (_str::rindex("hello", 'h' as u8) == 0); assert (str::rindex("hello", 'h' as u8) == 0);
assert (_str::rindex("hello", 'z' as u8) == -1); assert (str::rindex("hello", 'z' as u8) == -1);
} }
fn test_split() { fn test_split() {
fn t(&str s, char c, int i, &str k) { fn t(&str s, char c, int i, &str k) {
log "splitting: " + s; log "splitting: " + s;
log i; log i;
auto v = _str::split(s, c as u8); auto v = str::split(s, c as u8);
log "split to: "; log "split to: ";
for (str z in v) { for (str z in v) {
log z; log z;
} }
log "comparing: " + v.(i) + " vs. " + k; log "comparing: " + v.(i) + " vs. " + k;
assert (_str::eq(v.(i), k)); assert (str::eq(v.(i), k));
} }
t("abc.hello.there", '.', 0, "abc"); t("abc.hello.there", '.', 0, "abc");
t("abc.hello.there", '.', 1, "hello"); t("abc.hello.there", '.', 1, "hello");
@ -45,7 +45,7 @@ fn test_split() {
fn test_find() { fn test_find() {
fn t(&str haystack, &str needle, int i) { fn t(&str haystack, &str needle, int i) {
let int j = _str::find(haystack,needle); let int j = str::find(haystack,needle);
log "searched for " + needle; log "searched for " + needle;
log j; log j;
assert (i == j); assert (i == j);
@ -59,8 +59,8 @@ fn test_find() {
fn test_substr() { fn test_substr() {
fn t(&str a, &str b, int start) { fn t(&str a, &str b, int start) {
assert (_str::eq(_str::substr(a, start as uint, assert (str::eq(str::substr(a, start as uint,
_str::byte_len(b)), b)); str::byte_len(b)), b));
} }
t("hello", "llo", 2); t("hello", "llo", 2);
@ -70,7 +70,7 @@ fn test_substr() {
fn test_concat() { fn test_concat() {
fn t(&vec[str] v, &str s) { fn t(&vec[str] v, &str s) {
assert (_str::eq(_str::concat(v), s)); assert (str::eq(str::concat(v), s));
} }
t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood"); t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
@ -81,7 +81,7 @@ fn test_concat() {
fn test_connect() { fn test_connect() {
fn t(&vec[str] v, &str sep, &str s) { fn t(&vec[str] v, &str sep, &str s) {
assert (_str::eq(_str::connect(v, sep), s)); assert (str::eq(str::connect(v, sep), s));
} }
t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good"); t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
@ -96,14 +96,14 @@ fn test_to_upper() {
auto unicode = "\u65e5\u672c"; auto unicode = "\u65e5\u672c";
auto input = "abcDEF" + unicode + "xyz:.;"; auto input = "abcDEF" + unicode + "xyz:.;";
auto expected = "ABCDEF" + unicode + "XYZ:.;"; auto expected = "ABCDEF" + unicode + "XYZ:.;";
auto actual = _str::to_upper(input); auto actual = str::to_upper(input);
assert (_str::eq(expected, actual)); assert (str::eq(expected, actual));
} }
fn test_slice() { fn test_slice() {
assert (_str::eq("ab", _str::slice("abc", 0u, 2u))); assert (str::eq("ab", str::slice("abc", 0u, 2u)));
assert (_str::eq("bc", _str::slice("abc", 1u, 3u))); assert (str::eq("bc", str::slice("abc", 1u, 3u)));
assert (_str::eq("", _str::slice("abc", 1u, 1u))); assert (str::eq("", str::slice("abc", 1u, 1u)));
fn a_million_letter_a() -> str { fn a_million_letter_a() -> str {
auto i = 0; auto i = 0;
@ -125,8 +125,8 @@ fn test_slice() {
ret res; ret res;
} }
assert (_str::eq(half_a_million_letter_a(), assert (str::eq(half_a_million_letter_a(),
_str::slice(a_million_letter_a(), str::slice(a_million_letter_a(),
0u, 0u,
500000u))); 500000u)));
} }

82
src/test/run-pass/lib-uint.rs
View file

@ -1,47 +1,47 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_uint; import std::uint;
fn main() { fn main() {
assert (_uint::next_power_of_two(0u) == 0u); assert (uint::next_power_of_two(0u) == 0u);
assert (_uint::next_power_of_two(1u) == 1u); assert (uint::next_power_of_two(1u) == 1u);
assert (_uint::next_power_of_two(2u) == 2u); assert (uint::next_power_of_two(2u) == 2u);
assert (_uint::next_power_of_two(3u) == 4u); assert (uint::next_power_of_two(3u) == 4u);
assert (_uint::next_power_of_two(4u) == 4u); assert (uint::next_power_of_two(4u) == 4u);
assert (_uint::next_power_of_two(5u) == 8u); assert (uint::next_power_of_two(5u) == 8u);
assert (_uint::next_power_of_two(6u) == 8u); assert (uint::next_power_of_two(6u) == 8u);
assert (_uint::next_power_of_two(7u) == 8u); assert (uint::next_power_of_two(7u) == 8u);
assert (_uint::next_power_of_two(8u) == 8u); assert (uint::next_power_of_two(8u) == 8u);
assert (_uint::next_power_of_two(9u) == 16u); assert (uint::next_power_of_two(9u) == 16u);
assert (_uint::next_power_of_two(10u) == 16u); assert (uint::next_power_of_two(10u) == 16u);
assert (_uint::next_power_of_two(11u) == 16u); assert (uint::next_power_of_two(11u) == 16u);
assert (_uint::next_power_of_two(12u) == 16u); assert (uint::next_power_of_two(12u) == 16u);
assert (_uint::next_power_of_two(13u) == 16u); assert (uint::next_power_of_two(13u) == 16u);
assert (_uint::next_power_of_two(14u) == 16u); assert (uint::next_power_of_two(14u) == 16u);
assert (_uint::next_power_of_two(15u) == 16u); assert (uint::next_power_of_two(15u) == 16u);
assert (_uint::next_power_of_two(16u) == 16u); assert (uint::next_power_of_two(16u) == 16u);
assert (_uint::next_power_of_two(17u) == 32u); assert (uint::next_power_of_two(17u) == 32u);
assert (_uint::next_power_of_two(18u) == 32u); assert (uint::next_power_of_two(18u) == 32u);
assert (_uint::next_power_of_two(19u) == 32u); assert (uint::next_power_of_two(19u) == 32u);
assert (_uint::next_power_of_two(20u) == 32u); assert (uint::next_power_of_two(20u) == 32u);
assert (_uint::next_power_of_two(21u) == 32u); assert (uint::next_power_of_two(21u) == 32u);
assert (_uint::next_power_of_two(22u) == 32u); assert (uint::next_power_of_two(22u) == 32u);
assert (_uint::next_power_of_two(23u) == 32u); assert (uint::next_power_of_two(23u) == 32u);
assert (_uint::next_power_of_two(24u) == 32u); assert (uint::next_power_of_two(24u) == 32u);
assert (_uint::next_power_of_two(25u) == 32u); assert (uint::next_power_of_two(25u) == 32u);
assert (_uint::next_power_of_two(26u) == 32u); assert (uint::next_power_of_two(26u) == 32u);
assert (_uint::next_power_of_two(27u) == 32u); assert (uint::next_power_of_two(27u) == 32u);
assert (_uint::next_power_of_two(28u) == 32u); assert (uint::next_power_of_two(28u) == 32u);
assert (_uint::next_power_of_two(29u) == 32u); assert (uint::next_power_of_two(29u) == 32u);
assert (_uint::next_power_of_two(30u) == 32u); assert (uint::next_power_of_two(30u) == 32u);
assert (_uint::next_power_of_two(31u) == 32u); assert (uint::next_power_of_two(31u) == 32u);
assert (_uint::next_power_of_two(32u) == 32u); assert (uint::next_power_of_two(32u) == 32u);
assert (_uint::next_power_of_two(33u) == 64u); assert (uint::next_power_of_two(33u) == 64u);
assert (_uint::next_power_of_two(34u) == 64u); assert (uint::next_power_of_two(34u) == 64u);
assert (_uint::next_power_of_two(35u) == 64u); assert (uint::next_power_of_two(35u) == 64u);
assert (_uint::next_power_of_two(36u) == 64u); assert (uint::next_power_of_two(36u) == 64u);
assert (_uint::next_power_of_two(37u) == 64u); assert (uint::next_power_of_two(37u) == 64u);
assert (_uint::next_power_of_two(38u) == 64u); assert (uint::next_power_of_two(38u) == 64u);
assert (_uint::next_power_of_two(39u) == 64u); assert (uint::next_power_of_two(39u) == 64u);
} }

14
src/test/run-pass/lib-vec-str-conversions.rs
View file

@ -1,8 +1,8 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_str; import std::str;
import std::_vec; import std::vec;
fn test_simple() { fn test_simple() {
let str s1 = "All mimsy were the borogoves"; let str s1 = "All mimsy were the borogoves";
@ -14,12 +14,12 @@ fn test_simple() {
* working, but we should implement is_utf8 before that happens. * working, but we should implement is_utf8 before that happens.
*/ */
let vec[u8] v = _str::bytes(s1); let vec[u8] v = str::bytes(s1);
let str s2 = _str::from_bytes(v); let str s2 = str::from_bytes(v);
let uint i = 0u; let uint i = 0u;
let uint n1 = _str::byte_len(s1); let uint n1 = str::byte_len(s1);
let uint n2 = _vec::len[u8](v); let uint n2 = vec::len[u8](v);
assert (n1 == n2); assert (n1 == n2);
@ -33,7 +33,7 @@ fn test_simple() {
} }
log "refcnt is"; log "refcnt is";
log _str::refcount(s1); log str::refcount(s1);
} }
fn main() { fn main() {

16
src/test/run-pass/lib-vec.rs
View file

@ -1,8 +1,8 @@
use std; use std;
fn test_init_elt() { fn test_init_elt() {
let vec[uint] v = std::_vec::init_elt[uint](5u, 3u); let vec[uint] v = std::vec::init_elt[uint](5u, 3u);
assert (std::_vec::len[uint](v) == 3u); assert (std::vec::len[uint](v) == 3u);
assert (v.(0) == 5u); assert (v.(0) == 5u);
assert (v.(1) == 5u); assert (v.(1) == 5u);
assert (v.(2) == 5u); assert (v.(2) == 5u);
@ -13,8 +13,8 @@ fn id(uint x) -> uint {
} }
fn test_init_fn() { fn test_init_fn() {
let fn(uint)->uint op = id; let fn(uint)->uint op = id;
let vec[uint] v = std::_vec::init_fn[uint](op, 5u); let vec[uint] v = std::vec::init_fn[uint](op, 5u);
assert (std::_vec::len[uint](v) == 5u); assert (std::vec::len[uint](v) == 5u);
assert (v.(0) == 0u); assert (v.(0) == 0u);
assert (v.(1) == 1u); assert (v.(1) == 1u);
assert (v.(2) == 2u); assert (v.(2) == 2u);
@ -24,8 +24,8 @@ fn test_init_fn() {
fn test_slice() { fn test_slice() {
let vec[int] v = [1,2,3,4,5]; let vec[int] v = [1,2,3,4,5];
auto v2 = std::_vec::slice[int](v, 2u, 4u); auto v2 = std::vec::slice[int](v, 2u, 4u);
assert (std::_vec::len[int](v2) == 2u); assert (std::vec::len[int](v2) == 2u);
assert (v2.(0) == 3); assert (v2.(0) == 3);
assert (v2.(1) == 4); assert (v2.(1) == 4);
} }
@ -34,7 +34,7 @@ fn test_map() {
fn square(&int x) -> int { ret x * x; } fn square(&int x) -> int { ret x * x; }
let std::option::operator[int, int] op = square; let std::option::operator[int, int] op = square;
let vec[int] v = [1, 2, 3, 4, 5]; let vec[int] v = [1, 2, 3, 4, 5];
let vec[int] s = std::_vec::map[int, int](op, v); let vec[int] s = std::vec::map[int, int](op, v);
let int i = 0; let int i = 0;
while (i < 5) { while (i < 5) {
assert (v.(i) * v.(i) == s.(i)); assert (v.(i) * v.(i) == s.(i));
@ -47,7 +47,7 @@ fn test_map2() {
auto f = times; auto f = times;
auto v0 = [1, 2, 3, 4, 5]; auto v0 = [1, 2, 3, 4, 5];
auto v1 = [5, 4, 3, 2, 1]; auto v1 = [5, 4, 3, 2, 1];
auto u = std::_vec::map2[int,int,int](f, v0, v1); auto u = std::vec::map2[int,int,int](f, v0, v1);
auto i = 0; auto i = 0;
while (i < 5) { while (i < 5) {

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

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

18
src/test/run-pass/rt-circular-buffer.rs
View file

@ -6,8 +6,8 @@
use std; use std;
import std::option; import std::option;
import std::_uint; import std::uint;
import std::_vec; import std::vec;
// A 12-byte unit to send over the channel // A 12-byte unit to send over the channel
type record = rec(u32 val1, u32 val2, u32 val3); type record = rec(u32 val1, u32 val2, u32 val3);
@ -33,7 +33,7 @@ fn test_grow() {
let record val = rec(val1=0u32, val2=0u32, val3=0u32); let record val = rec(val1=0u32, val2=0u32, val3=0u32);
for each (uint i in _uint::range(0u, 100u)) { for each (uint i in uint::range(0u, 100u)) {
mychan <| val; mychan <| val;
} }
} }
@ -53,11 +53,11 @@ fn test_shrink2() {
let record val = rec(val1=0u32, val2=0u32, val3=0u32); let record val = rec(val1=0u32, val2=0u32, val3=0u32);
for each (uint i in _uint::range(0u, 100u)) { for each (uint i in uint::range(0u, 100u)) {
mychan <| val; mychan <| val;
} }
for each (uint i in _uint::range(0u, 100u)) { for each (uint i in uint::range(0u, 100u)) {
auto x <- myport; auto x <- myport;
} }
} }
@ -67,7 +67,7 @@ fn test_rotate() {
let port[record] myport = port(); let port[record] myport = port();
auto mychan = chan(myport); auto mychan = chan(myport);
for each (uint i in _uint::range(0u, 100u)) { for each (uint i in uint::range(0u, 100u)) {
auto val = rec(val1=i as u32, auto val = rec(val1=i as u32,
val2=i as u32, val2=i as u32,
val3=i as u32); val3=i as u32);
@ -86,15 +86,15 @@ fn test_rotate_grow() {
let port[record] myport = port(); let port[record] myport = port();
auto mychan = chan(myport); auto mychan = chan(myport);
for each (uint j in _uint::range(0u, 10u)) { for each (uint j in uint::range(0u, 10u)) {
for each (uint i in _uint::range(0u, 10u)) { for each (uint i in uint::range(0u, 10u)) {
let record val = rec(val1=i as u32, let record val = rec(val1=i as u32,
val2=i as u32, val2=i as u32,
val3=i as u32); val3=i as u32);
mychan <| val; mychan <| val;
} }
for each (uint i in _uint::range(0u, 10u)) { for each (uint i in uint::range(0u, 10u)) {
auto x <- myport; auto x <- myport;
assert (x.val1 == i as u32); assert (x.val1 == i as u32);
assert (x.val2 == i as u32); assert (x.val2 == i as u32);

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

@ -1,7 +1,7 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_str; import std::str;
fn test1() { fn test1() {
let str s = "hello"; let str s = "hello";
@ -20,8 +20,8 @@ fn test2() {
log a; log a;
log b; log b;
assert (_str::eq(a, "abcABCabc")); assert (str::eq(a, "abcABCabc"));
assert (_str::eq(b, "ABCabcABC")); assert (str::eq(b, "ABCabcABC"));
} }
fn main() { fn main() {

4
src/test/run-pass/syntax-extension-fmt.rs
View file

@ -1,10 +1,10 @@
use std; use std;
import std::_str; import std::str;
fn test(str actual, str expected) { fn test(str actual, str expected) {
log actual; log actual;
log expected; log expected;
assert (_str::eq(actual, expected)); assert (str::eq(actual, expected));
} }
fn main() { fn main() {

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

@ -2,34 +2,34 @@
// xfail-stage1 // xfail-stage1
// xfail-stage2 // xfail-stage2
use std; use std;
import std::_str; import std::str;
import std::_vec; import std::vec;
import std::io; import std::io;
fn main() { fn main() {
// Chars of 1, 2, 3, and 4 bytes // Chars of 1, 2, 3, and 4 bytes
let vec[char] chs = ['e', 'é', '€', 0x10000 as char]; let vec[char] chs = ['e', 'é', '€', 0x10000 as char];
let str s = _str::from_chars(chs); let str s = str::from_chars(chs);
assert (_str::byte_len(s) == 10u); assert (str::byte_len(s) == 10u);
assert (_str::char_len(s) == 4u); assert (str::char_len(s) == 4u);
assert (_vec::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::eq(str::from_chars(str::to_chars(s)), s));
assert (_str::char_at(s, 0u) == 'e'); assert (str::char_at(s, 0u) == 'e');
assert (_str::char_at(s, 1u) == 'é'); assert (str::char_at(s, 1u) == 'é');
assert (_str::is_utf8(_str::bytes(s))); assert (str::is_utf8(str::bytes(s)));
assert (!_str::is_utf8([0x80_u8])); assert (!str::is_utf8([0x80_u8]));
assert (!_str::is_utf8([0xc0_u8])); assert (!str::is_utf8([0xc0_u8]));
assert (!_str::is_utf8([0xc0_u8, 0x10_u8])); assert (!str::is_utf8([0xc0_u8, 0x10_u8]));
auto stack = "a×c€"; auto stack = "a×c€";
assert (_str::pop_char(stack) == '€'); assert (str::pop_char(stack) == '€');
assert (_str::pop_char(stack) == 'c'); assert (str::pop_char(stack) == 'c');
_str::push_char(stack, 'u'); str::push_char(stack, 'u');
assert (_str::eq(stack, "a×u")); assert (str::eq(stack, "a×u"));
assert (_str::shift_char(stack) == 'a'); assert (str::shift_char(stack) == 'a');
assert (_str::shift_char(stack) == '×'); assert (str::shift_char(stack) == '×');
_str::unshift_char(stack, 'ß'); str::unshift_char(stack, 'ß');
assert (_str::eq(stack, "ßu")); assert (str::eq(stack, "ßu"));
} }

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

@ -4,8 +4,8 @@
// -*- rust -*- // -*- rust -*-
use std; use std;
import std::_str; import std::str;
import std::_vec; import std::vec;
// FIXME: import std::dbg::const_refcount. Currently // FIXME: import std::dbg::const_refcount. Currently
@ -53,30 +53,30 @@ fn slow_growth2_helper(str s) { // ref up: s
let vec[str] v = [mumble]; // ref up: v, mumble let vec[str] v = [mumble]; // ref up: v, mumble
let acc a = acc(v); // ref up: a, v let acc a = acc(v); // ref up: a, v
log _vec::refcount[str](v); log vec::refcount[str](v);
assert (_vec::refcount[str](v) == 2u); assert (vec::refcount[str](v) == 2u);
a.add(s); // ref up: mumble, s. ref down: v a.add(s); // ref up: mumble, s. ref down: v
log _vec::refcount[str](v); log vec::refcount[str](v);
log _str::refcount(s); log str::refcount(s);
log _str::refcount(mumble); log str::refcount(mumble);
assert (_vec::refcount[str](v) == 1u); assert (vec::refcount[str](v) == 1u);
assert (_str::refcount(s) == const_refcount); assert (str::refcount(s) == const_refcount);
assert (_str::refcount(mumble) == const_refcount); assert (str::refcount(mumble) == const_refcount);
log v.(0); log v.(0);
log _vec::len[str](v); log vec::len[str](v);
assert (_str::eq(v.(0), mumble)); assert (str::eq(v.(0), mumble));
assert (_vec::len[str](v) == 1u); assert (vec::len[str](v) == 1u);
} // ref down: a, mumble, s, v } // ref down: a, mumble, s, v
log _str::refcount(s); log str::refcount(s);
log _str::refcount(mumble); log str::refcount(mumble);
assert (_str::refcount(s) == const_refcount); assert (str::refcount(s) == const_refcount);
assert (_str::refcount(mumble) == const_refcount); assert (str::refcount(mumble) == const_refcount);
log mumble; log mumble;
log ss; log ss;
@ -85,8 +85,8 @@ fn slow_growth2_helper(str s) { // ref up: s
fn slow_growth2() { fn slow_growth2() {
let str s = "hi"; // ref up: s let str s = "hi"; // ref up: s
slow_growth2_helper(s); slow_growth2_helper(s);
log _str::refcount(s); log str::refcount(s);
assert (_str::refcount(s) == const_refcount); assert (str::refcount(s) == const_refcount);
} }
fn main() { fn main() {

12
src/test/run-pass/vec-ref-count.rs
View file

@ -1,12 +1,12 @@
use std; use std;
import std::_vec; import std::vec;
fn main() { fn main() {
auto v = [1, 2, 3]; auto v = [1, 2, 3];
log_err _vec::refcount[int](v); log_err vec::refcount[int](v);
log_err _vec::refcount[int](v); log_err vec::refcount[int](v);
log_err _vec::refcount[int](v); log_err vec::refcount[int](v);
assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u); assert (vec::refcount[int](v) == 1u || vec::refcount[int](v) == 2u);
assert (_vec::refcount[int](v) == 1u || _vec::refcount[int](v) == 2u); assert (vec::refcount[int](v) == 1u || vec::refcount[int](v) == 2u);
} }