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

rustc: Remove a bunch of exterior vectors

Browse source
This commit is contained in:
Patrick Walton 2011-07-14 17:26:10 -07:00
parent a716eb28ec
commit 917afa4cc9
18 changed files with 302 additions and 331 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
import std::ivec;
import std::uint;
import std::str;
import std::vec;
import std::termivec;
import std::ioivec;
import std::option;
@ -14,33 +14,33 @@ type filename = str;
* with single-word things, rather than passing records all over the
* compiler.
*/
type filemap = @rec(filename name, uint start_pos, mutable vec[uint] lines);
type filemap = @rec(filename name, uint start_pos, mutable uint[] lines);
type codemap = @rec(mutable vec[filemap] files);
type codemap = @rec(mutable filemap[] files);
type loc = rec(filename filename, uint line, uint col);
fn new_codemap() -> codemap {
let vec[filemap] files = [];
let filemap[] files = ~[];
ret @rec(mutable files=files);
}
fn new_filemap(filename filename, uint start_pos) -> filemap {
ret @rec(name=filename, start_pos=start_pos, mutable lines=[0u]);
ret @rec(name=filename, start_pos=start_pos, mutable lines=~[0u]);
}
fn next_line(filemap file, uint pos) { vec::push[uint](file.lines, pos); }
fn next_line(filemap file, uint pos) { file.lines += ~[pos]; }
fn lookup_pos(codemap map, uint pos) -> loc {
auto a = 0u;
auto b = vec::len[filemap](map.files);
auto b = ivec::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);
b = ivec::len[uint](f.lines);
while (b - a > 1u) {
auto m = (a + b) / 2u;
if (f.lines.(m) > pos) { b = m; } else { a = m; }
@ -91,8 +91,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
auto max_lines = 6u;
auto elided = false;
auto display_lines = lines.lines;
if (vec::len(display_lines) > max_lines) {
display_lines = vec::slice(display_lines, 0u, max_lines);
if (ivec::len(display_lines) > max_lines) {
display_lines = ivec::slice(display_lines, 0u, max_lines);
elided = true;
}
// Print the offending lines
@ -106,7 +106,8 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
ioivec::stdout().write_str(s);
}
if (elided) {
auto last_line = display_lines.(vec::len(display_lines) - 1u);
auto last_line = display_lines.(ivec::len(display_lines) -
1u);
auto s = #fmt("%s:%u ", fm.name, last_line + 1u);
auto indent = str::char_len(s);
auto out = "";
@ -116,7 +117,7 @@ fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
}
// If there's one line at fault we can easily point to the problem
if (vec::len(lines.lines) == 1u) {
if (ivec::len(lines.lines) == 1u) {
auto lo = codemap::lookup_pos(cm, option::get(sp).lo);
auto digits = 0u;
auto num = lines.lines.(0) / 10u;
@ -156,21 +157,21 @@ fn emit_note(&option::t[span] sp, &str msg, &codemap cm) {
emit_diagnostic(sp, msg, "note", 10u8, cm);
}
type file_lines = rec(str name, vec[uint] lines);
type file_lines = rec(str name, uint[] lines);
fn span_to_lines(span sp, codemap::codemap cm) -> @file_lines {
auto lo = codemap::lookup_pos(cm, sp.lo);
auto hi = codemap::lookup_pos(cm, sp.hi);
auto lines = [];
auto lines = ~[];
for each (uint i in uint::range(lo.line - 1u, hi.line as uint)) {
lines += [i];
lines += ~[i];
}
ret @rec(name=lo.filename, lines=lines);
}
fn get_line(filemap fm, int line, &str file) -> str {
let uint end;
if ((line as uint) + 1u >= vec::len(fm.lines)) {
if ((line as uint) + 1u >= ivec::len(fm.lines)) {
end = str::byte_len(file);
} else {
end = fm.lines.(line + 1);

5
src/comp/syntax/parse/eval.rs
View file

@ -1,5 +1,4 @@
import std::vec;
import std::str;
import std::option;
import std::option::some;
@ -19,7 +18,7 @@ tag eval_mode { mode_depend; mode_parse; }
type ctx =
@rec(parser p,
eval_mode mode,
mutable vec[str] deps,
mutable str[] deps,
parser::parse_sess sess,
mutable uint chpos,
ast::crate_cfg cfg);
@ -55,7 +54,7 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
} else {
prefix + std::fs::path_sep() + file_path
};
if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; }
if (cx.mode == mode_depend) { cx.deps += ~[full_path]; ret; }
auto p0 =
new_parser_from_file(cx.sess, cx.cfg, full_path, cx.chpos);
auto inner_attrs = parse_inner_attrs_and_next(p0);

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

@ -1,8 +1,8 @@
import std::ioivec;
import std::str;
import std::vec;
import std::int;
import std::ivec;
import std::str;
import std::map;
import std::map::hashmap;
import std::option;
@ -40,7 +40,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
mutable uint mark_pos,
mutable uint mark_chpos,
mutable uint chpos,
mutable vec[str] strs,
mutable str[] strs,
codemap::filemap fm,
@interner::interner[str] itr) {
fn is_eof() -> bool { ret ch == -1 as char; }
@ -83,7 +83,7 @@ fn new_reader(&codemap::codemap cm, str src, codemap::filemap filemap,
codemap::emit_error(some(rec(lo=chpos, hi=chpos)), m, cm);
}
}
let vec[str] strs = [];
let str[] strs = ~[];
auto rd =
reader(cm, src, str::byte_len(src), 0u, 0u, -1 as char, 0u,
filemap.start_pos, filemap.start_pos, strs, filemap, itr);
@ -578,7 +578,7 @@ tag cmnt_style {
}
type cmnt = rec(cmnt_style style, vec[str] lines, uint pos);
type cmnt = rec(cmnt_style style, str[] lines, uint pos);
fn read_to_eol(&reader rdr) -> str {
auto val = "";
@ -610,7 +610,7 @@ fn consume_whitespace_counting_blank_lines(&reader rdr,
while (is_whitespace(rdr.curr()) && !rdr.is_eof()) {
if (rdr.curr() == '\n' && rdr.next() == '\n') {
log ">>> blank-line comment";
let vec[str] v = [];
let str[] v = ~[];
comments += ~[rec(style=blank_line, lines=v,
pos=rdr.get_chpos())];
}
@ -621,11 +621,11 @@ fn consume_whitespace_counting_blank_lines(&reader rdr,
fn read_line_comments(&reader rdr, bool code_to_the_left) -> cmnt {
log ">>> line comments";
auto p = rdr.get_chpos();
let vec[str] lines = [];
let str[] lines = ~[];
while (rdr.curr() == '/' && rdr.next() == '/') {
auto line = read_one_line_comment(rdr);
log line;
lines += [line];
lines += ~[line];
consume_non_eol_whitespace(rdr);
}
log "<<< line comments";
@ -643,7 +643,7 @@ fn all_whitespace(&str s, uint begin, uint end) -> bool {
ret true;
}
fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s,
fn trim_whitespace_prefix_and_push_line(&mutable str[] lines, &str s,
uint col) {
auto s1;
if (all_whitespace(s, 0u, col)) {
@ -652,13 +652,13 @@ fn trim_whitespace_prefix_and_push_line(&mutable vec[str] lines, &str s,
} else { s1 = ""; }
} else { s1 = s; }
log "pushing line: " + s1;
lines += [s1];
lines += ~[s1];
}
fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt {
log ">>> block comment";
auto p = rdr.get_chpos();
let vec[str] lines = [];
let str[] lines = ~[];
let uint col = rdr.get_col();
rdr.bump();
rdr.bump();
@ -693,7 +693,7 @@ fn read_block_comment(&reader rdr, bool code_to_the_left) -> cmnt {
}
auto style = if (code_to_the_left) { trailing } else { isolated };
consume_non_eol_whitespace(rdr);
if (!rdr.is_eof() && rdr.curr() != '\n' && vec::len(lines) == 1u) {
if (!rdr.is_eof() && rdr.curr() != '\n' && ivec::len(lines) == 1u) {
style = mixed;
}
log "<<< block comment";

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

@ -1,7 +1,6 @@
import std::ioivec;
import std::ivec;
import std::vec;
import std::str;
import std::option;
import std::option::some;
@ -45,7 +44,7 @@ type parser =
fn get_lo_pos() -> uint ;
fn get_hi_pos() -> uint ;
fn get_last_lo_pos() -> uint ;
fn get_prec_table() -> vec[op_spec] ;
fn get_prec_table() -> @op_spec[] ;
fn get_str(token::str_num) -> str ;
fn get_reader() -> lexer::reader ;
fn get_filemap() -> codemap::filemap ;
@ -62,7 +61,7 @@ fn new_parser_from_file(parse_sess sess, ast::crate_cfg cfg,
auto srdr = ioivec::file_reader(path);
auto src = str::unsafe_from_bytes_ivec(srdr.read_whole_stream());
auto filemap = codemap::new_filemap(path, pos);
vec::push(sess.cm.files, filemap);
sess.cm.files += ~[filemap];
auto itr = @interner::mk(str::hash, str::eq);
auto rdr = lexer::new_reader(sess.cm, src, filemap, itr);
@ -80,7 +79,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
mutable uint last_lo,
mutable restriction restr,
lexer::reader rdr,
vec[op_spec] precs,
@op_spec[] precs,
hashmap[str, ()] bad_words) {
fn peek() -> token::token { ret tok; }
fn bump() {
@ -107,7 +106,7 @@ fn new_parser(parse_sess sess, ast::crate_cfg cfg, lexer::reader rdr,
fn get_last_lo_pos() -> uint { ret last_lo; }
fn get_file_type() -> file_type { ret ftype; }
fn get_cfg() -> ast::crate_cfg { ret cfg; }
fn get_prec_table() -> vec[op_spec] { ret precs; }
fn get_prec_table() -> @op_spec[] { ret precs; }
fn get_str(token::str_num i) -> str {
ret interner::get(*rdr.get_interner(), i);
}
@ -258,7 +257,7 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo) -> ast::ty_ {
}
auto lo = p.get_lo_pos();
auto inputs =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_fn_input_ty, p);
auto constrs = parse_constrs(~[], p);
let @ast::ty output;
@ -308,7 +307,7 @@ fn parse_ty_obj(&parser p, &mutable uint hi) -> ast::ty_ {
fail;
}
auto f = parse_method_sig;
auto meths = parse_seq_ivec(token::LBRACE, token::RBRACE, none, f, p);
auto meths = parse_seq(token::LBRACE, token::RBRACE, none, f, p);
hi = meths.span.hi;
ret ast::ty_obj(meths.node);
}
@ -352,7 +351,7 @@ fn parse_ty_constr(&ast::arg[] fn_args, &parser p) -> @ast::constr {
auto path = parse_path(p);
auto pf = bind parse_constr_arg(fn_args, _);
let rec((@ast::constr_arg)[] node, span span) args =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), pf,
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), pf,
p);
// FIXME fix the def_id
@ -409,12 +408,8 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
if (mut == ast::imm && p.peek() != token::RBRACKET) {
// This is explicit type parameter instantiation.
auto seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA),
parse_ty, p);
// FIXME: Remove this vec->ivec conversion.
auto seq_ivec = ~[];
for (@ast::ty typ in seq) { seq_ivec += ~[typ]; }
auto seq = parse_seq_to_end(token::RBRACKET,
some(token::COMMA), parse_ty, p);
alt (orig_t.node) {
case (ast::ty_path(?pth, ?ann)) {
@ -423,7 +418,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
ast::ty_path(spanned(lo, hi,
rec(global=pth.node.global,
idents=pth.node.idents,
types=seq_ivec)),
types=seq)),
ann));
}
case (_) {
@ -522,13 +517,13 @@ fn parse_ty(&parser p) -> @ast::ty {
expect(p, token::RBRACKET);
} else if (eat_word(p, "tup")) {
auto elems =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_mt, p);
hi = elems.span.hi;
t = ast::ty_tup(elems.node);
} else if (eat_word(p, "rec")) {
auto elems =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_ty_field, p);
hi = elems.span.hi;
t = ast::ty_rec(elems.node);
@ -577,23 +572,6 @@ fn parse_arg(&parser p) -> ast::arg {
}
fn parse_seq_to_end[T](token::token ket, option::t[token::token] sep,
fn(&parser) -> T f, &parser p) -> vec[T] {
let bool first = true;
let vec[T] v = [];
while (p.peek() != ket) {
alt (sep) {
case (some(?t)) {
if (first) { first = false; } else { expect(p, t); }
}
case (_) { }
}
v += [f(p)];
}
expect(p, ket);
ret v;
}
fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep,
fn(&parser)->T f, &parser p) -> T[] {
let bool first = true;
let T[] v = ~[];
@ -612,21 +590,11 @@ fn parse_seq_to_end_ivec[T](token::token ket, option::t[token::token] sep,
fn parse_seq[T](token::token bra, token::token ket,
option::t[token::token] sep, fn(&parser) -> T f, &parser p)
-> ast::spanned[vec[T]] {
auto lo = p.get_lo_pos();
expect(p, bra);
auto result = parse_seq_to_end[T](ket, sep, f, p);
auto hi = p.get_hi_pos();
ret spanned(lo, hi, result);
}
fn parse_seq_ivec[T](token::token bra, token::token ket,
option::t[token::token] sep,
fn(&parser)->T f, &parser p) -> ast::spanned[T[]] {
auto lo = p.get_lo_pos();
expect(p, bra);
auto result = parse_seq_to_end_ivec[T](ket, sep, f, p);
auto result = parse_seq_to_end[T](ket, sep, f, p);
auto hi = p.get_hi_pos();
ret spanned(lo, hi, result);
}
@ -704,15 +672,10 @@ fn parse_path_and_ty_param_substs(&parser p) -> ast::path {
if (p.peek() == token::LBRACKET) {
auto seq = parse_seq(token::LBRACKET, token::RBRACKET,
some(token::COMMA), parse_ty, p);
// FIXME: Remove this vec->ivec conversion.
auto seq_ivec = ~[];
for (@ast::ty typ in seq.node) { seq_ivec += ~[typ]; }
auto hi = p.get_hi_pos();
path = spanned(lo, hi, rec(global=path.node.global,
idents=path.node.idents,
types=seq_ivec));
types=seq.node));
}
ret path;
}
@ -793,7 +756,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
ret rec(mut=m, expr=e);
}
auto es =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_elt, p);
hi = es.span.hi;
ex = ast::expr_tup(es.node);
@ -801,7 +764,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
p.bump();
auto mut = parse_mutability(p);
auto es =
parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
parse_seq_to_end(token::RBRACKET, some(token::COMMA),
parse_expr, p);
ex = ast::expr_vec(es, mut, ast::sk_rc);
} else if (p.peek() == token::POUND_LT) {
@ -822,7 +785,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
p.bump();
auto mut = parse_mutability(p);
auto es =
parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
parse_seq_to_end(token::RBRACKET, some(token::COMMA),
parse_expr, p);
ex = ast::expr_vec(es, mut, ast::sk_unique);
}
@ -848,7 +811,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
if (p.peek() == token::LPAREN) {
p.bump();
fields =
some(parse_seq_to_end_ivec(token::RPAREN, some(token::COMMA),
some(parse_seq_to_end(token::RPAREN, some(token::COMMA),
parse_anon_obj_field, p));
}
let (@ast::method)[] meths = ~[];
@ -902,7 +865,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
}
}
auto es =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_expr_opt, p);
hi = es.span.hi;
ex = ast::expr_bind(e, es.node);
@ -1003,7 +966,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
let @ast::expr f = parse_self_method(p);
auto es =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_expr, p);
hi = es.span.hi;
ex = ast::expr_call(f, es.node);
@ -1033,7 +996,7 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr {
if (ivec::len(pth.node.idents) == 0u) {
p.fatal("expected a syntax expander name");
}
auto es = parse_seq_ivec(token::LPAREN, token::RPAREN,
auto es = parse_seq(token::LPAREN, token::RPAREN,
some(token::COMMA), parse_expr, p);
auto hi = es.span.hi;
ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, es.node, none));
@ -1061,7 +1024,7 @@ fn parse_dot_or_call_expr_with(&parser p, @ast::expr e) -> @ast::expr {
// Call expr.
auto es =
parse_seq_ivec(token::LPAREN, token::RPAREN,
parse_seq(token::LPAREN, token::RPAREN,
some(token::COMMA), parse_expr, p);
hi = es.span.hi;
e = mk_expr(p, lo, hi, ast::expr_call(e, es.node));
@ -1157,27 +1120,27 @@ type op_spec = rec(token::token tok, ast::binop op, int prec);
// FIXME make this a const, don't store it in parser state
fn prec_table() -> vec[op_spec] {
ret [rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10),
rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9),
rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9),
rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9),
rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8),
rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6),
rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6),
// 'as' sits between here with 5
rec(tok=token::LT, op=ast::lt, prec=4),
rec(tok=token::LE, op=ast::le, prec=4),
rec(tok=token::GE, op=ast::ge, prec=4),
rec(tok=token::GT, op=ast::gt, prec=4),
rec(tok=token::EQEQ, op=ast::eq, prec=3),
rec(tok=token::NE, op=ast::ne, prec=3),
rec(tok=token::ANDAND, op=ast::and, prec=2),
rec(tok=token::OROR, op=ast::or, prec=1)];
fn prec_table() -> @op_spec[] {
ret @~[rec(tok=token::BINOP(token::STAR), op=ast::mul, prec=11),
rec(tok=token::BINOP(token::SLASH), op=ast::div, prec=11),
rec(tok=token::BINOP(token::PERCENT), op=ast::rem, prec=11),
rec(tok=token::BINOP(token::PLUS), op=ast::add, prec=10),
rec(tok=token::BINOP(token::MINUS), op=ast::sub, prec=10),
rec(tok=token::BINOP(token::LSL), op=ast::lsl, prec=9),
rec(tok=token::BINOP(token::LSR), op=ast::lsr, prec=9),
rec(tok=token::BINOP(token::ASR), op=ast::asr, prec=9),
rec(tok=token::BINOP(token::AND), op=ast::bitand, prec=8),
rec(tok=token::BINOP(token::CARET), op=ast::bitxor, prec=6),
rec(tok=token::BINOP(token::OR), op=ast::bitor, prec=6),
// 'as' sits between here with 5
rec(tok=token::LT, op=ast::lt, prec=4),
rec(tok=token::LE, op=ast::le, prec=4),
rec(tok=token::GE, op=ast::ge, prec=4),
rec(tok=token::GT, op=ast::gt, prec=4),
rec(tok=token::EQEQ, op=ast::eq, prec=3),
rec(tok=token::NE, op=ast::ne, prec=3),
rec(tok=token::ANDAND, op=ast::and, prec=2),
rec(tok=token::OROR, op=ast::or, prec=1)];
}
fn parse_binops(&parser p) -> @ast::expr {
@ -1191,7 +1154,7 @@ const int ternary_prec = 0;
fn parse_more_binops(&parser p, @ast::expr lhs, int min_prec) -> @ast::expr {
auto peeked = p.peek();
for (op_spec cur in p.get_prec_table()) {
for (op_spec cur in *p.get_prec_table()) {
if (cur.prec > min_prec && cur.tok == peeked) {
p.bump();
auto rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec);
@ -1378,7 +1341,7 @@ fn parse_spawn_expr(&parser p) -> @ast::expr {
auto fn_expr = parse_bottom_expr(p);
auto es =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_expr, p);
auto hi = es.span.hi;
ret mk_expr(p, lo, hi, ast::expr_spawn
@ -1515,7 +1478,7 @@ fn parse_pat(&parser p) -> @ast::pat {
case (token::LPAREN) {
auto f = parse_pat;
auto a =
parse_seq_ivec(token::LPAREN, token::RPAREN,
parse_seq(token::LPAREN, token::RPAREN,
some(token::COMMA), f, p);
args = a.node;
hi = a.span.hi;
@ -1763,7 +1726,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] {
let ast::ty_param[] ty_params = ~[];
if (p.peek() == token::LBRACKET) {
ty_params =
parse_seq_ivec(token::LBRACKET, token::RBRACKET,
parse_seq(token::LBRACKET, token::RBRACKET,
some(token::COMMA), parse_ty_param, p).node;
}
ret ty_params;
@ -1771,7 +1734,7 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] {
fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
let ast::spanned[ast::arg[]] inputs =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_arg, p);
let ty_or_bang rslt;
auto constrs = parse_constrs(inputs.node, p).node;
@ -1879,7 +1842,7 @@ fn parse_item_obj(&parser p, ast::layer lyr, &ast::attribute[] attrs) ->
auto ident = parse_value_ident(p);
auto ty_params = parse_ty_params(p);
let ast::spanned[ast::obj_field[]] fields =
parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_obj_field, p);
let (@ast::method)[] meths = ~[];
let option::t[@ast::method] dtor = none;
@ -2110,7 +2073,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item {
case (token::LPAREN) {
auto arg_tys =
parse_seq(token::LPAREN, token::RPAREN,
some(token::COMMA), parse_ty, p);
some(token::COMMA), parse_ty, p);
for (@ast::ty ty in arg_tys.node) {
args += ~[rec(ty=ty, id=p.get_id())];
}
@ -2284,8 +2247,8 @@ fn parse_meta_item(&parser p) -> @ast::meta_item {
}
fn parse_meta_seq(&parser p) -> (@ast::meta_item)[] {
ret parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_meta_item, p).node;
ret parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_meta_item, p).node;
}
fn parse_optional_meta(&parser p) -> (@ast::meta_item)[] {
@ -2424,7 +2387,7 @@ fn parse_crate_from_source_str(&str name, &str source, &ast::crate_cfg cfg,
auto sess = @rec(cm=cm, mutable next_id=0);
auto ftype = SOURCE_FILE;
auto filemap = codemap::new_filemap(name, 0u);
sess.cm.files += [filemap];
sess.cm.files += ~[filemap];
auto itr = @interner::mk(str::hash, str::eq);
auto rdr = lexer::new_reader(sess.cm, source, filemap, itr);
auto p = new_parser(sess, cfg, rdr, ftype);
@ -2548,15 +2511,14 @@ fn parse_crate_from_crate_file(&str input, &ast::crate_cfg cfg,
auto crate_attrs = leading_attrs._0;
auto first_cdir_attr = leading_attrs._1;
auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
let vec[str] deps = [];
let str[] deps = ~[];
auto cx = @rec(p=p,
mode=eval::mode_parse,
mutable deps=deps,
sess=sess,
mutable chpos=p.get_chpos(),
cfg = p.get_cfg());
auto m =
eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
auto m = eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
auto hi = p.get_hi_pos();
expect(p, token::EOF);
ret @spanned(lo, hi, rec(directives=cdirs,

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

@ -1,6 +1,6 @@
import std::ioivec;
import std::vec;
import std::ivec;
import std::str;
@ -74,10 +74,10 @@ fn tok_str(token t) -> str {
}
}
fn buf_str(vec[mutable token] toks, vec[mutable int] szs, uint left,
uint right, uint lim) -> str {
auto n = vec::len(toks);
assert (n == vec::len(szs));
fn buf_str(&token[mutable] toks, &int[mutable] szs, uint left, uint right,
uint lim) -> str {
auto n = ivec::len(toks);
assert (n == ivec::len(szs));
auto i = left;
auto L = lim;
auto s = "[";
@ -104,10 +104,10 @@ fn mk_printer(ioivec::writer out, uint linewidth) -> printer {
let uint n = 3u * linewidth;
log #fmt("mk_printer %u", linewidth);
let vec[mutable token] token = vec::init_elt_mut(EOF, n);
let vec[mutable int] size = vec::init_elt_mut(0, n);
let vec[mutable uint] scan_stack = vec::init_elt_mut(0u, n);
let vec[print_stack_elt] print_stack = [];
let token[mutable] token = ivec::init_elt_mut(EOF, n);
let int[mutable] size = ivec::init_elt_mut(0, n);
let uint[mutable] scan_stack = ivec::init_elt_mut(0u, n);
let print_stack_elt[] print_stack = ~[];
ret printer(out, n, linewidth as int, // margin
linewidth as int, // space
0u, // left
@ -208,9 +208,9 @@ obj printer(ioivec::writer out,
mutable uint right, // index of right side of input stream
mutable vec[mutable token] token,
mutable token[mutable] token,
// ring-buffr stream goes through
mutable vec[mutable int] size, // ring-buffer of calculated sizes
mutable int[mutable] size, // ring-buffer of calculated sizes
mutable int left_total, // running size of stream "...left"
@ -222,7 +222,7 @@ obj printer(ioivec::writer out,
// BEGIN (if there is any) on top of it. Stuff is flushed off the
// bottom as it becomes irrelevant due to the primary ring-buffer
// advancing.
mutable vec[mutable uint] scan_stack,
mutable uint[mutable] scan_stack,
mutable bool scan_stack_empty, // top==bottom disambiguator
mutable uint top, // index of top of scan_stack
@ -230,7 +230,7 @@ obj printer(ioivec::writer out,
mutable uint bottom, // index of bottom of scan_stack
// stack of blocks-in-progress being flushed by print
mutable vec[print_stack_elt] print_stack,
mutable print_stack_elt[] print_stack,
// buffered indentation to avoid writing trailing whitespace
mutable int pending_indentation) {
@ -403,7 +403,7 @@ obj printer(ioivec::writer out,
pending_indentation += amount;
}
fn top() -> print_stack_elt {
auto n = vec::len(print_stack);
auto n = ivec::len(print_stack);
let print_stack_elt top = rec(offset=0, pbreak=broken(inconsistent));
if (n != 0u) { top = print_stack.(n - 1u); }
ret top;
@ -425,17 +425,17 @@ obj printer(ioivec::writer out,
auto col = margin - space + b.offset;
log #fmt("print BEGIN -> push broken block at col %d",
col);
vec::push(print_stack,
rec(offset=col, pbreak=broken(b.breaks)));
print_stack += ~[rec(offset=col,
pbreak=broken(b.breaks))];
} else {
log "print BEGIN -> push fitting block";
vec::push(print_stack, rec(offset=0, pbreak=fits));
print_stack += ~[rec(offset=0, pbreak=fits)];
}
}
case (END) {
log "print END -> pop END";
assert (vec::len(print_stack) != 0u);
vec::pop(print_stack);
assert (ivec::len(print_stack) != 0u);
ivec::pop(print_stack);
}
case (BREAK(?b)) {
auto top = self.top();

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

@ -4,7 +4,6 @@ import std::int;
import std::ioivec;
import std::str;
import std::uint;
import std::vec;
import std::option;
import parse::lexer;
import syntax::codemap::codemap;
@ -1267,7 +1266,7 @@ fn print_view_item(&ps s, &@ast::view_item item) {
// FIXME: The fact that this builds up the table anew for every call is
// not good. Eventually, table should be a const.
fn operator_prec(ast::binop op) -> int {
for (parse::parser::op_spec spec in parse::parser::prec_table()) {
for (parse::parser::op_spec spec in *parse::parser::prec_table()) {
if (spec.op == op) { ret spec.prec; }
}
fail;
@ -1445,7 +1444,7 @@ fn maybe_print_comment(&ps s, uint pos) {
fn print_comment(&ps s, lexer::cmnt cmnt) {
alt (cmnt.style) {
case (lexer::mixed) {
assert (vec::len(cmnt.lines) == 1u);
assert (ivec::len(cmnt.lines) == 1u);
zerobreak(s.s);
word(s.s, cmnt.lines.(0));
zerobreak(s.s);
@ -1456,7 +1455,7 @@ fn print_comment(&ps s, lexer::cmnt cmnt) {
}
case (lexer::trailing) {
word(s.s, " ");
if (vec::len(cmnt.lines) == 1u) {
if (ivec::len(cmnt.lines) == 1u) {
word(s.s, cmnt.lines.(0));
hardbreak(s.s);
} else {