obj {
fn peek() -> token::token ;
fn bump() ;
+ fn swap(token::token, uint, uint) ;
fn look_ahead(uint) -> token::token ;
fn fatal(str) -> ! ;
fn warn(str) ;
tok_span = next.span;
}
}
+ fn swap(next: token::token, lo: uint, hi: uint) {
+ tok = next;
+ tok_span = ast::mk_sp(lo, hi);
+ }
fn look_ahead(distance: uint) -> token::token {
while vec::len(buffer) < distance {
let next = lexer::next_token(rdr);
}
}
+fn expect_gt(p: &parser) {
+ if p.peek() == token::GT {
+ p.bump();
+ } else if p.peek() == token::BINOP(token::LSR) {
+ p.swap(token::GT, p.get_lo_pos() + 1u, p.get_hi_pos());
+ } else if p.peek() == token::BINOP(token::ASR) {
+ p.swap(token::BINOP(token::LSR), p.get_lo_pos() + 1u,
+ p.get_hi_pos());
+ } else {
+ let s: str = "expecting ";
+ s += token::to_str(p.get_reader(), token::GT);
+ s += ", found ";
+ s += token::to_str(p.get_reader(), p.peek());
+ p.fatal(s);
+ }
+}
+
fn spanned[T](lo: uint, hi: uint, node: &T) -> spanned[T] {
ret {node: node, span: ast::mk_sp(lo, hi)};
}
-> @ast::ty {
let lo = p.get_lo_pos();
- let end;
+ let seq;
if p.peek() == token::LBRACKET {
p.bump();
- end = token::RBRACKET;
+ seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA),
+ bind parse_ty(_, false), p);
} else if colons_before_params && p.peek() == token::MOD_SEP {
p.bump();
expect(p, token::LT);
- end = token::GT;
+ seq = parse_seq_to_gt(some(token::COMMA), bind parse_ty(_, false), p);
} else if !colons_before_params && p.peek() == token::LT {
p.bump();
- end = token::GT;
+ seq = parse_seq_to_gt(some(token::COMMA), bind parse_ty(_, false), p);
} else {
ret @spanned(lo, p.get_lo_pos(), orig_t);
}
// If we're here, we have explicit type parameter instantiation.
- let seq = parse_seq_to_end(end, some(token::COMMA),
- bind parse_ty(_, false), p);
alt orig_t {
ast::ty_path(pth, ann) {
parse_type_constraints(p));
}
} else if (eat_word(p, "vec")) {
- expect(p, token::LBRACKET);
- t = ast::ty_vec(parse_mt(p));
- hi = p.get_hi_pos();
- expect(p, token::RBRACKET);
+ if p.peek() == token::LBRACKET {
+ p.bump();
+ t = ast::ty_vec(parse_mt(p));
+ hi = p.get_hi_pos();
+ expect(p, token::RBRACKET);
+ } else {
+ expect(p, token::LT);
+ t = ast::ty_vec(parse_mt(p));
+ hi = p.get_hi_pos();
+ expect_gt(p);
+ }
} else if (p.peek() == token::LBRACKET) {
expect(p, token::LBRACKET);
t = ast::ty_ivec(parse_mt(p));
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
+fn parse_seq_to_gt[T](sep: option::t[token::token], f: fn(&parser) -> T,
+ p: &parser) -> [T] {
+ let first = true;
+ let v = ~[];
+ while p.peek() != token::GT &&
+ p.peek() != token::BINOP(token::LSR) &&
+ p.peek() != token::BINOP(token::ASR) {
+ alt sep {
+ some(t) { if first { first = false; } else { expect(p, t); } }
+ _ { }
+ }
+ v += ~[f(p)];
+ }
+
+ expect_gt(p);
+
+ ret v;
+}
+
fn parse_seq_to_end[T](ket: token::token, sep: option::t[token::token],
f: fn(&parser) -> T , p: &parser) -> [T] {
let val = parse_seq_to_before_end(ket, sep, f, p);
ast::ty_str. { word(s.s, "str"); }
ast::ty_istr. { word(s.s, "istr"); }
ast::ty_box(mt) { word(s.s, "@"); print_mt(s, mt); }
- ast::ty_vec(mt) { word(s.s, "vec["); print_mt(s, mt); word(s.s, "]"); }
+ ast::ty_vec(mt) { word(s.s, "vec<"); print_mt(s, mt); word(s.s, ">"); }
ast::ty_ivec(mt) {
word(s.s, "[");
alt mt.mut {
ast::ty_ptr(mt) { word(s.s, "*"); print_mt(s, mt); }
ast::ty_task. { word(s.s, "task"); }
ast::ty_port(t) {
- word(s.s, "port[");
+ word(s.s, "port<");
print_type(s, t);
- word(s.s, "]");
+ word(s.s, ">");
}
ast::ty_chan(t) {
- word(s.s, "chan[");
+ word(s.s, "chan<");
print_type(s, t);
- word(s.s, "]");
+ word(s.s, ">");
}
ast::ty_rec(fields) {
word(s.s, "{");
word(s.s, id);
}
if vec::len(path.node.types) > 0u {
- word(s.s, "[");
+ word(s.s, "<");
commasep(s, inconsistent, path.node.types, print_type);
- word(s.s, "]");
+ word(s.s, ">");
}
}