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

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

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

@ -1,7 +1,7 @@
import std::map::hashmap;
import std::option;
import std::_str;
import std::_vec;
import std::str;
import std::vec;
import util::common::span;
import util::common::spanned;
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) {
alt (vi.node) {
case (ast::view_item_export(?id)) {
if (_str::eq(i, id)) {
if (str::eq(i, id)) {
ret true;
}
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
* 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) {
_vec::push[uint](file.lines, pos);
vec::push[uint](file.lines, pos);
}
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) {
auto m = (a + b) / 2u;
if (map.files.(m).start_pos > pos) { b = m; }
else { a = m; }
}
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) {
auto m = (a + b) / 2u;
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::span;
import std::_str;
import std::_uint;
import std::_vec;
import std::str;
import std::uint;
import std::vec;
import std::ebml;
import std::fs;
import std::io;
@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
while (peek(st) as char != ']') {
auto name = "";
while (peek(st) as char != '=') {
name += _str::unsafe_from_byte(next(st));
name += str::unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
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 = "";
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);
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 {
auto def = "";
while (peek(st) as char != '|') {
def += _str::unsafe_from_byte(next(st));
def += str::unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
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 {
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)) {
colon_idx += 1u;
}
@ -269,10 +269,10 @@ fn parse_def_id(vec[u8] buf) -> ast::def_id {
fail;
}
auto crate_part = _vec::slice[u8](buf, 0u, colon_idx);
auto def_part = _vec::slice[u8](buf, colon_idx + 1u, len);
auto crate_num = _uint::parse_buf(crate_part, 10u) as int;
auto def_num = _uint::parse_buf(def_part, 10u) as int;
auto crate_part = vec::slice[u8](buf, 0u, colon_idx);
auto def_part = vec::slice[u8](buf, colon_idx + 1u, len);
auto crate_num = uint::parse_buf(crate_part, 10u) as int;
auto def_num = uint::parse_buf(def_part, 10u) as int;
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;
for each (ebml::doc elt in ebml::tagged_docs(bucket, belt)) {
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))) {
_vec::push(result, ebml::doc_at(d.data, pos));
if (eq_fn(vec::slice[u8](elt.data, elt.start+4u, elt.end))) {
vec::push(result, ebml::doc_at(d.data, pos));
}
}
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.
fn resolve_path(vec[ast::ident] path, vec[u8] data) -> vec[ast::def_id] {
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 paths = ebml::get_doc(md, metadata::tag_paths);
auto eqer = bind eq_item(_, s);
let vec[ast::def_id] result = [];
for (ebml::doc doc in lookup_hash(paths, eqer, metadata::hash_path(s))) {
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;
}
@ -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 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];
} else {
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 {
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 {
@ -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
// from crate ID to crate "meta" attributes as part of the crate
// metadata:
auto buf = _str::bytes(s);
auto buf = str::bytes(s);
auto external_def_id = parse_def_id(buf);
ret tup(this_cnum, external_def_id._1);
}
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,
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;
for each (ebml::doc p in ebml::tagged_docs(item, v)) {
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;
}
fn get_metadata_section(str filename) -> option::t[vec[u8]] {
auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile
(_str::buf(filename));
(str::buf(filename));
if (mb as int == 0) {ret option::none[vec[u8]];}
auto of = mk_object_file(mb);
auto si = mk_section_iter(of.llof);
while (llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
auto name_buf = llvm::LLVMGetSectionName(si.llsi);
auto name = _str::str_from_cstr(name_buf);
if (_str::eq(name, x86::get_meta_sect_name())) {
auto name = str::str_from_cstr(name_buf);
if (str::eq(name, x86::get_meta_sect_name())) {
auto cbuf = llvm::LLVMGetSectionContents(si.llsi);
auto csz = llvm::LLVMGetSectionSize(si.llsi);
auto cvbuf = cbuf as _vec::vbuf;
ret option::some[vec[u8]](_vec::vec_from_vbuf[u8](cvbuf, csz));
auto cvbuf = cbuf as vec::vbuf;
ret option::some[vec[u8]](vec::vec_from_vbuf[u8](cvbuf, csz));
}
llvm::LLVMMoveToNextSection(si.llsi);
}
@ -481,7 +481,7 @@ fn lookup_defs(session::session sess, int cnum, vec[ast::ident] path)
-> vec[ast::def] {
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));
}
@ -580,8 +580,8 @@ fn list_file_metadata(str path, io::writer out) {
fn read_path(&ebml::doc d) -> tup(str, uint) {
auto desc = ebml::doc_data(d);
auto pos = ebml::be_uint_from_bytes(desc, 0u, 4u);
auto pathbytes = _vec::slice[u8](desc, 4u, _vec::len[u8](desc));
auto path = _str::unsafe_from_bytes(pathbytes);
auto pathbytes = vec::slice[u8](desc, 4u, vec::len[u8](desc));
auto path = str::unsafe_from_bytes(pathbytes);
ret tup(path, pos);
}

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

@ -1,5 +1,5 @@
import std::_vec;
import std::_str;
import std::vec;
import std::str;
import std::option;
import std::option::some;
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 {
for (tup(ident, val) pair in e) {
if (_str::eq(i, pair._0)) {
if (str::eq(i, pair._0)) {
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 {
alt (x.node) {
case (ast::expr_path(?pth, _)) {
if (_vec::len[ident](pth.node.idents) == 1u &&
_vec::len[@ast::ty](pth.node.types) == 0u) {
if (vec::len[ident](pth.node.idents) == 1u &&
vec::len[@ast::ty](pth.node.types) == 0u) {
ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
}
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);
}
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));
}
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();
auto im = ast::item_mod(id, m0, next_id);
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)) {
@ -411,11 +411,11 @@ fn eval_crate_directive(ctx cx,
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 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)) {
_vec::push[@ast::view_item](view_items, vi);
vec::push[@ast::view_item](view_items, vi);
}
case (ast::cdir_meta(?mi)) {

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

@ -6,8 +6,8 @@
import util::common;
import std::_str;
import std::_vec;
import std::str;
import std::vec;
import std::option;
import std::generic_os;
@ -19,7 +19,7 @@ fn expand_syntax_ext(parser::parser p,
vec[@ast::expr] args,
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");
}

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

@ -7,8 +7,8 @@
import front::parser::parser;
import util::common;
import std::_str;
import std::_vec;
import std::str;
import std::vec;
import std::option;
import std::option::none;
import std::option::some;
@ -50,7 +50,7 @@ fn expand_syntax_ext(parser p,
vec[@ast::expr] args,
option::t[str] body) -> @ast::expr {
if (_vec::len[@ast::expr](args) == 0u) {
if (vec::len[@ast::expr](args) == 0u) {
// FIXME: Handle error correctly.
log_err "malformed #fmt call";
fail;
@ -62,8 +62,8 @@ fn expand_syntax_ext(parser p,
// log fmt;
auto pieces = parse_fmt_string(fmt);
auto args_len = _vec::len[@ast::expr](args);
auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u);
auto args_len = vec::len[@ast::expr](args);
auto fmt_args = vec::slice[@ast::expr](args, 1u, args_len - 1u);
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
// through the rec that these flags are a member of, so
// 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")];
}
@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
fn log_conv(conv c) {
alt (c.param) {
case (some[int](?p)) {
log "param: " + std::_int::to_str(p, 10u);
log "param: " + std::int::to_str(p, 10u);
}
case (_) {
log "param: none";
@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args)
}
alt (c.width) {
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)) {
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) {
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) {
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)) {
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) {
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);
}
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";
fail;
}

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

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

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

@ -1,6 +1,6 @@
import std::io;
import std::_vec;
import std::_str;
import std::vec;
import std::str;
import std::option;
import std::option::some;
import std::option::none;
@ -156,13 +156,13 @@ fn new_parser(session::session sess,
}
}
auto ftype = SOURCE_FILE;
if (_str::ends_with(path, ".rc")) {
if (str::ends_with(path, ".rc")) {
ftype = CRATE_FILE;
}
auto srdr = io::file_reader(path);
auto filemap = codemap::new_filemap(path, pos);
_vec::push[codemap::filemap](sess.get_codemap().files, filemap);
auto itr = @interner::mk_interner[str](_str::hash, _str::eq);
vec::push[codemap::filemap](sess.get_codemap().files, filemap);
auto itr = @interner::mk_interner[str](str::hash, str::eq);
auto rdr = lexer::new_reader(sess, srdr, filemap, itr);
// Make sure npos points at first actual token:
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 {
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 }
};
}
fn eat_word(&parser p, &str word) -> bool {
alt (p.peek()) {
case (token::IDENT(?sid, false)) {
if (_str::eq(word, p.get_str(sid))) {
if (str::eq(word, p.get_str(sid))) {
p.bump();
ret true;
} else { ret false; }
@ -433,7 +433,7 @@ fn parse_constrs(parser p) -> common::spanned[vec[@ast::constr]] {
while (true) {
auto constr = parse_ty_constr(p);
hi = constr.span.hi;
_vec::push[@ast::constr](constrs, constr);
vec::push[@ast::constr](constrs, constr);
if (p.peek() == token::COMMA) {
p.bump();
} else {
@ -818,7 +818,7 @@ fn parse_bottom_expr(parser p) -> @ast::expr {
if (eat_word(p, "with")) {
with_obj = some[ast::ident](parse_ident(p));
} else {
_vec::push[@ast::method](meths,
vec::push[@ast::method](meths,
parse_method(p));
}
}
@ -1004,16 +1004,16 @@ fn expand_syntax_ext(parser p, ast::span sp,
&ast::path path, vec[@ast::expr] args,
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);
if (_str::eq(extname, "fmt")) {
if (str::eq(extname, "fmt")) {
auto expanded = extfmt::expand_syntax_ext(p, args, body);
auto newexpr = ast::expr_ext(path, args, body,
expanded,
p.get_ann());
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 newexpr = ast::expr_ext(path, args, body,
expanded,
@ -1833,7 +1833,7 @@ fn parse_item_obj(parser p, ast::layer lyr) -> @ast::item {
if (eat_word(p, "drop")) {
dtor = some[@ast::method](parse_dtor(p));
} else {
_vec::push[@ast::method](meths,
vec::push[@ast::method](meths,
parse_method(p));
}
}
@ -1953,12 +1953,12 @@ fn parse_item_native_mod(parser p) -> @ast::item {
auto abi = ast::native_abi_cdecl;
if (!is_word(p, "mod")) {
auto t = parse_str_lit_or_env_ident(p);
if (_str::eq(t, "cdecl")) {
} else if (_str::eq(t, "rust")) {
if (str::eq(t, "cdecl")) {
} else if (str::eq(t, "rust")) {
abi = ast::native_abi_rust;
} else if (_str::eq(t, "llvm")) {
} else if (str::eq(t, "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;
} else {
p.err("unsupported abi: " + t);
@ -2079,16 +2079,16 @@ fn peeking_at_item(parser p) -> bool {
alt (p.peek()) {
case (token::IDENT(?sid, false)) {
auto st = p.get_str(sid);
ret _str::eq(st, "state") ||
_str::eq(st, "gc") ||
_str::eq(st, "const") ||
_str::eq(st, "fn") ||
_str::eq(st, "pred") ||
_str::eq(st, "iter") ||
_str::eq(st, "mod") ||
_str::eq(st, "type") ||
_str::eq(st, "tag") ||
_str::eq(st, "obj");
ret str::eq(st, "state") ||
str::eq(st, "gc") ||
str::eq(st, "const") ||
str::eq(st, "fn") ||
str::eq(st, "pred") ||
str::eq(st, "iter") ||
str::eq(st, "mod") ||
str::eq(st, "type") ||
str::eq(st, "tag") ||
str::eq(st, "obj");
}
case (_) { ret false; }
}
@ -2193,7 +2193,7 @@ fn parse_rest_import_name(parser p, ast::ident first,
defined_id = i;
}
case (_) {
auto len = _vec::len[ast::ident](identifiers);
auto len = vec::len[ast::ident](identifiers);
defined_id = identifiers.(len - 1u);
}
}
@ -2262,8 +2262,8 @@ fn is_view_item(&parser p) -> bool {
alt (p.peek()) {
case (token::IDENT(?sid, false)) {
auto st = p.get_str(sid);
ret _str::eq(st, "use") || _str::eq(st, "import") ||
_str::eq(st, "export");
ret str::eq(st, "use") || str::eq(st, "import") ||
str::eq(st, "export");
}
case (_) { ret false; }
}
@ -2389,7 +2389,7 @@ fn parse_crate_directives(parser p, token::token term)
while (p.peek() != term) {
auto cdir = @parse_crate_directive(p);
_vec::push[@ast::crate_directive](cdirs, cdir);
vec::push[@ast::crate_directive](cdirs, cdir);
}
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::new_str_hash;
import util::interner;
import std::_int;
import std::_uint;
import std::_str;
import std::int;
import std::uint;
import std::str;
type str_num = uint;
@ -133,10 +133,10 @@ fn to_str(lexer::reader r, token t) -> str {
case (POUND) { ret "#"; }
/* Literals */
case (LIT_INT(?i)) { ret _int::to_str(i, 10u); }
case (LIT_UINT(?u)) { ret _uint::to_str(u, 10u); }
case (LIT_INT(?i)) { ret int::to_str(i, 10u); }
case (LIT_UINT(?u)) { ret uint::to_str(u, 10u); }
case (LIT_MACH_INT(?tm, ?i)) {
ret _int::to_str(i, 10u)
ret int::to_str(i, 10u)
+ "_" + ty_mach_to_str(tm);
}
case (LIT_MACH_FLOAT(?tm, ?s)) {
@ -152,8 +152,8 @@ fn to_str(lexer::reader r, token t) -> str {
case (LIT_CHAR(?c)) {
// FIXME: escape.
auto tmp = "'";
_str::push_char(tmp, c);
_str::push_byte(tmp, '\'' as u8);
str::push_char(tmp, c);
str::push_byte(tmp, '\'' as u8);
ret tmp;
}
@ -163,7 +163,7 @@ fn to_str(lexer::reader r, token t) -> str {
/* Name components */
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 (BRACEQUOTE(_)) { ret "<bracequote>"; }