aboutsummaryrefslogtreecommitdiff
path: root/src/comp/pretty
diff options
context:
space:
mode:
Diffstat (limited to 'src/comp/pretty')
-rw-r--r--src/comp/pretty/pp.rs36
-rw-r--r--src/comp/pretty/pprust.rs508
2 files changed, 273 insertions, 271 deletions
diff --git a/src/comp/pretty/pp.rs b/src/comp/pretty/pp.rs
index f9667042..aff0843d 100644
--- a/src/comp/pretty/pp.rs
+++ b/src/comp/pretty/pp.rs
@@ -1,6 +1,6 @@
-import std.IO;
-import std.Vec;
-import std.Str;
+import std::io;
+import std::_vec;
+import std::_str;
tag boxtype {box_h; box_v; box_hv; box_align;}
tag contexttype {cx_h; cx_v;}
@@ -19,7 +19,7 @@ type context = rec(contexttype tp, uint indent);
type ps = @rec(mutable vec[context] context,
uint width,
- IO.writer out,
+ io::writer out,
mutable uint col,
mutable uint spaces,
mutable vec[token] buffered,
@@ -30,7 +30,7 @@ type ps = @rec(mutable vec[context] context,
mutable bool start_of_box,
mutable bool potential_brk);
-fn mkstate(IO.writer out, uint width) -> ps {
+fn mkstate(io::writer out, uint width) -> ps {
let vec[context] stack = vec(rec(tp=cx_v, indent=0u));
let vec[token] buff = vec();
let vec[boxtype] sd = vec();
@@ -57,12 +57,12 @@ fn write_spaces(ps p, uint i) {
fn push_context(ps p, contexttype tp, uint indent) {
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;
}
fn pop_context(ps p) {
- Vec.pop[context](p.context);
+ _vec::pop[context](p.context);
}
fn add_token(ps p, token tok) {
@@ -89,7 +89,7 @@ fn buffer_token(ps p, token tok) {
} else {
alt (tok) {
case (open(?tp,_)) {
- Vec.push[boxtype](p.scandepth, tp);
+ _vec::push[boxtype](p.scandepth, tp);
if (p.scanning == scan_h) {
if (tp == box_h) {
check_potential_brk(p);
@@ -97,14 +97,14 @@ fn buffer_token(ps p, token tok) {
}
}
case (close) {
- Vec.pop[boxtype](p.scandepth);
- if (Vec.len[boxtype](p.scandepth) == 0u) {
+ _vec::pop[boxtype](p.scandepth);
+ if (_vec::len[boxtype](p.scandepth) == 0u) {
finish_scan(p, true);
}
}
case (brk(_)) {
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);
}
}
@@ -123,7 +123,7 @@ fn check_potential_brk(ps p) {
fn finish_scan(ps p, bool fits) {
auto buf = p.buffered;
- auto front = Vec.shift[token](buf);
+ auto front = _vec::shift[token](buf);
auto chosen_tp = cx_h;
if (!fits) {chosen_tp = cx_v;}
alt (front) {
@@ -154,10 +154,10 @@ fn start_scan(ps p, token tok, scantype tp) {
}
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 {
- auto i = Vec.len[context](p.context);
+ auto i = _vec::len[context](p.context);
while (i > 0u) {
i -= 1u;
auto cx = p.context.(i);
@@ -190,7 +190,7 @@ fn do_token(ps p, token tok) {
line_break(p);
}
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 &&
!p.start_of_line) {
line_break(p);
@@ -202,7 +202,7 @@ fn do_token(ps p, token tok) {
case (cword(?w)) {
before_print(p, true);
p.out.write_str(w);
- p.col += Str.char_len(w);
+ p.col += _str::char_len(w);
}
case (open(?tp, ?indent)) {
if (tp == box_v) {
@@ -247,8 +247,8 @@ fn token_size(token tok) -> uint {
alt (tok) {
case (brk(?sz)) {ret sz;}
case (hardbrk) {ret 0xFFFFFFu;}
- case (word(?w)) {ret Str.char_len(w);}
- case (cword(?w)) {ret Str.char_len(w);}
+ case (word(?w)) {ret _str::char_len(w);}
+ case (cword(?w)) {ret _str::char_len(w);}
case (open(_, _)) {ret 0u;}
case (close) {ret 0u;}
}
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index 071e076c..3c959b99 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -1,58 +1,58 @@
-import std.Vec;
-import std.Str;
-import std.IO;
-import std.Option;
-import driver.session.session;
-import front.ast;
-import front.lexer;
-import util.common;
-import pp.end; import pp.wrd; import pp.space; import pp.line;
+import std::_vec;
+import std::_str;
+import std::io;
+import std::option;
+import driver::session::session;
+import front::ast;
+import front::lexer;
+import util::common;
+import pp::end; import pp::wrd; import pp::space; import pp::line;
const uint indent_unit = 4u;
const int as_prec = 5;
const uint default_columns = 78u;
-type ps = @rec(pp.ps s,
- Option.t[vec[lexer.cmnt]] comments,
+type ps = @rec(pp::ps s,
+ option::t[vec[lexer::cmnt]] comments,
mutable uint cur_cmnt);
-fn print_file(session sess, ast._mod _mod, str filename, IO.writer out) {
- auto cmnts = lexer.gather_comments(sess, filename);
- auto s = @rec(s=pp.mkstate(out, default_columns),
- comments=Option.some[vec[lexer.cmnt]](cmnts),
+fn print_file(session sess, ast::_mod _mod, str filename, io::writer out) {
+ auto cmnts = lexer::gather_comments(sess, filename);
+ auto s = @rec(s=pp::mkstate(out, default_columns),
+ comments=option::some[vec[lexer::cmnt]](cmnts),
mutable cur_cmnt=0u);
print_mod(s, _mod);
}
-fn ty_to_str(&@ast.ty ty) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 0u),
- comments=Option.none[vec[lexer.cmnt]],
+fn ty_to_str(&@ast::ty ty) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 0u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_type(s, ty);
ret writer.get_str();
}
-fn block_to_str(&ast.block blk) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
- comments=Option.none[vec[lexer.cmnt]],
+fn block_to_str(&ast::block blk) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_block(s, blk);
ret writer.get_str();
}
-fn pat_to_str(&@ast.pat p) -> str {
- auto writer = IO.string_writer();
- auto s = @rec(s=pp.mkstate(writer.get_writer(), 78u),
- comments=Option.none[vec[lexer.cmnt]],
+fn pat_to_str(&@ast::pat p) -> str {
+ auto writer = io::string_writer();
+ auto s = @rec(s=pp::mkstate(writer.get_writer(), 78u),
+ comments=option::none[vec[lexer::cmnt]],
mutable cur_cmnt=0u);
print_pat(s, p);
ret writer.get_str();
}
fn hbox(ps s) {
- pp.hbox(s.s, indent_unit);
+ pp::hbox(s.s, indent_unit);
}
fn wrd1(ps s, str word) {
wrd(s.s, word);
@@ -60,11 +60,11 @@ fn wrd1(ps s, str word) {
}
fn popen(ps s) {
wrd(s.s, "(");
- pp.abox(s.s);
+ pp::abox(s.s);
}
fn popen_h(ps s) {
wrd(s.s, "(");
- pp.hbox(s.s, 0u);
+ pp::hbox(s.s, 0u);
}
fn pclose(ps s) {
end(s.s);
@@ -72,14 +72,14 @@ fn pclose(ps s) {
}
fn bopen(ps s) {
wrd(s.s, "{");
- pp.vbox(s.s, indent_unit);
+ pp::vbox(s.s, indent_unit);
line(s.s);
}
fn bclose(ps s) {
end(s.s);
- pp.cwrd(s.s, "}");
+ pp::cwrd(s.s, "}");
}
-fn bclose_c(ps s, common.span span) {
+fn bclose_c(ps s, common::span span) {
maybe_print_comment(s, span.hi);
bclose(s);
}
@@ -92,8 +92,8 @@ 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(&IN) -> common.span get_span) {
- auto len = Vec.len[IN](elts);
+ fn(&IN) -> common::span get_span) {
+ auto len = _vec::len[IN](elts);
auto i = 0u;
for (IN elt in elts) {
op(s, elt);
@@ -104,77 +104,79 @@ fn commasep_cmnt[IN](ps s, vec[IN] elts, fn(ps, &IN) op,
}
}
}
-fn commasep_exprs(ps s, vec[@ast.expr] exprs) {
- fn expr_span(&@ast.expr expr) -> common.span {ret expr.span;}
+fn commasep_exprs(ps s, vec[@ast::expr] exprs) {
+ fn expr_span(&@ast::expr expr) -> common::span {ret expr.span;}
auto f = print_expr;
auto gs = expr_span;
- commasep_cmnt[@ast.expr](s, exprs, f, gs);
+ commasep_cmnt[@ast::expr](s, exprs, f, gs);
}
-fn print_mod(ps s, ast._mod _mod) {
- for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);}
+fn print_mod(ps s, ast::_mod _mod) {
+ for (@ast::view_item vitem in _mod.view_items) {
+ print_view_item(s, vitem);
+ }
line(s.s);
- for (@ast.item item in _mod.items) {print_item(s, item);}
+ for (@ast::item item in _mod.items) {print_item(s, item);}
print_remaining_comments(s);
}
-fn print_type(ps s, &@ast.ty ty) {
+fn print_type(ps s, &@ast::ty ty) {
maybe_print_comment(s, ty.span.lo);
hbox(s);
alt (ty.node) {
- case (ast.ty_nil) {wrd(s.s, "()");}
- case (ast.ty_bool) {wrd(s.s, "bool");}
- case (ast.ty_int) {wrd(s.s, "int");}
- case (ast.ty_uint) {wrd(s.s, "uint");}
- case (ast.ty_float) {wrd(s.s, "float");}
- case (ast.ty_machine(?tm)) {wrd(s.s, common.ty_mach_to_str(tm));}
- case (ast.ty_char) {wrd(s.s, "char");}
- case (ast.ty_str) {wrd(s.s, "str");}
- case (ast.ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
- case (ast.ty_vec(?mt)) {
+ case (ast::ty_nil) {wrd(s.s, "()");}
+ case (ast::ty_bool) {wrd(s.s, "bool");}
+ case (ast::ty_int) {wrd(s.s, "int");}
+ case (ast::ty_uint) {wrd(s.s, "uint");}
+ case (ast::ty_float) {wrd(s.s, "float");}
+ case (ast::ty_machine(?tm)) {wrd(s.s, common::ty_mach_to_str(tm));}
+ case (ast::ty_char) {wrd(s.s, "char");}
+ case (ast::ty_str) {wrd(s.s, "str");}
+ case (ast::ty_box(?mt)) {wrd(s.s, "@"); print_mt(s, mt);}
+ case (ast::ty_vec(?mt)) {
wrd(s.s, "vec["); print_mt(s, mt); wrd(s.s, "]");
}
- case (ast.ty_port(?t)) {
+ case (ast::ty_port(?t)) {
wrd(s.s, "port["); print_type(s, t); wrd(s.s, "]");
}
- case (ast.ty_chan(?t)) {
+ case (ast::ty_chan(?t)) {
wrd(s.s, "chan["); print_type(s, t); wrd(s.s, "]");
}
- case (ast.ty_type) {wrd(s.s, "type");}
- case (ast.ty_tup(?elts)) {
+ case (ast::ty_type) {wrd(s.s, "type");}
+ case (ast::ty_tup(?elts)) {
wrd(s.s, "tup");
popen(s);
auto f = print_mt;
- commasep[ast.mt](s, elts, f);
+ commasep[ast::mt](s, elts, f);
pclose(s);
}
- case (ast.ty_rec(?fields)) {
+ case (ast::ty_rec(?fields)) {
wrd(s.s, "rec");
popen(s);
- fn print_field(ps s, &ast.ty_field f) {
+ fn print_field(ps s, &ast::ty_field f) {
hbox(s);
print_mt(s, f.mt);
space(s.s);
wrd(s.s, f.ident);
end(s.s);
}
- 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
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);
}
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.ty_field](s, fields, f, gs);
+ commasep_cmnt[ast::ty_field](s, fields, f, gs);
pclose(s);
}
- case (ast.ty_obj(?methods)) {
+ case (ast::ty_obj(?methods)) {
wrd1(s, "obj");
bopen(s);
- for (ast.ty_method m in methods) {
+ for (ast::ty_method m in methods) {
hbox(s);
- print_ty_fn(s, m.proto, Option.some[str](m.ident),
+ print_ty_fn(s, m.proto, option::some[str](m.ident),
m.inputs, m.output);
wrd(s.s, ";");
end(s.s);
@@ -182,21 +184,21 @@ fn print_type(ps s, &@ast.ty ty) {
}
bclose_c(s, ty.span);
}
- case (ast.ty_fn(?proto,?inputs,?output)) {
- print_ty_fn(s, proto, Option.none[str], inputs, output);
+ case (ast::ty_fn(?proto,?inputs,?output)) {
+ print_ty_fn(s, proto, option::none[str], inputs, output);
}
- case (ast.ty_path(?path,_)) {
+ case (ast::ty_path(?path,_)) {
print_path(s, path);
}
}
end(s.s);
}
-fn print_item(ps s, @ast.item item) {
+fn print_item(ps s, @ast::item item) {
maybe_print_comment(s, item.span.lo);
hbox(s);
alt (item.node) {
- case (ast.item_const(?id, ?ty, ?expr, _, _)) {
+ case (ast::item_const(?id, ?ty, ?expr, _, _)) {
wrd1(s, "const");
print_type(s, ty);
space(s.s);
@@ -205,44 +207,44 @@ fn print_item(ps s, @ast.item item) {
print_expr(s, expr);
wrd(s.s, ";");
}
- case (ast.item_fn(?name,?_fn,?typarams,_,_)) {
+ case (ast::item_fn(?name,?_fn,?typarams,_,_)) {
print_fn(s, _fn.decl, name, typarams);
space(s.s);
print_block(s, _fn.body);
}
- case (ast.item_mod(?id,?_mod,_)) {
+ case (ast::item_mod(?id,?_mod,_)) {
wrd1(s, "mod");
wrd1(s, id);
bopen(s);
- for (@ast.item itm in _mod.items) {print_item(s, itm);}
+ for (@ast::item itm in _mod.items) {print_item(s, itm);}
bclose_c(s, item.span);
}
- case (ast.item_native_mod(?id,?nmod,_)) {
+ case (ast::item_native_mod(?id,?nmod,_)) {
wrd1(s, "native");
alt (nmod.abi) {
- case (ast.native_abi_rust) {wrd1(s, "\"rust\"");}
- case (ast.native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
- case (ast.native_abi_rust_intrinsic) {
+ case (ast::native_abi_rust) {wrd1(s, "\"rust\"");}
+ case (ast::native_abi_cdecl) {wrd1(s, "\"cdecl\"");}
+ case (ast::native_abi_rust_intrinsic) {
wrd1(s, "\"rust-intrinstic\"");
}
}
wrd1(s, "mod");
wrd1(s, id);
bopen(s);
- for (@ast.native_item item in nmod.items) {
+ for (@ast::native_item item in nmod.items) {
hbox(s);
maybe_print_comment(s, item.span.lo);
alt (item.node) {
- case (ast.native_item_ty(?id,_)) {
+ case (ast::native_item_ty(?id,_)) {
wrd1(s, "type");
wrd(s.s, id);
}
- case (ast.native_item_fn(?id,?lname,?decl,
+ case (ast::native_item_fn(?id,?lname,?decl,
?typarams,_,_)) {
print_fn(s, decl, id, typarams);
alt (lname) {
- case (Option.none[str]) {}
- case (Option.some[str](?ss)) {
+ case (option::none[str]) {}
+ case (option::some[str](?ss)) {
print_string(s, ss);
}
}
@@ -253,7 +255,7 @@ fn print_item(ps s, @ast.item item) {
}
bclose_c(s, item.span);
}
- case (ast.item_ty(?id,?ty,?params,_,_)) {
+ case (ast::item_ty(?id,?ty,?params,_,_)) {
wrd1(s, "type");
wrd(s.s, id);
print_type_params(s, params);
@@ -262,22 +264,22 @@ fn print_item(ps s, @ast.item item) {
print_type(s, ty);
wrd(s.s, ";");
}
- case (ast.item_tag(?id,?variants,?params,_,_)) {
+ case (ast::item_tag(?id,?variants,?params,_,_)) {
wrd1(s, "tag");
wrd(s.s, id);
print_type_params(s, params);
space(s.s);
bopen(s);
- for (ast.variant v in variants) {
+ for (ast::variant v in variants) {
maybe_print_comment(s, v.span.lo);
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);
- 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);
}
auto f = print_variant_arg;
- commasep[ast.variant_arg](s, v.node.args, f);
+ commasep[ast::variant_arg](s, v.node.args, f);
pclose(s);
}
wrd(s.s, ";");
@@ -285,28 +287,28 @@ fn print_item(ps s, @ast.item item) {
}
bclose_c(s, item.span);
}
- case (ast.item_obj(?id,?_obj,?params,_,_)) {
+ case (ast::item_obj(?id,?_obj,?params,_,_)) {
wrd1(s, "obj");
wrd(s.s, id);
print_type_params(s, params);
popen(s);
- fn print_field(ps s, &ast.obj_field field) {
+ fn print_field(ps s, &ast::obj_field field) {
hbox(s);
print_type(s, field.ty);
space(s.s);
wrd(s.s, field.ident);
end(s.s);
}
- fn get_span(&ast.obj_field f) -> common.span {ret f.ty.span;}
+ fn get_span(&ast::obj_field f) -> common::span {ret f.ty.span;}
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.obj_field](s, _obj.fields, f, gs);
+ commasep_cmnt[ast::obj_field](s, _obj.fields, f, gs);
pclose(s);
space(s.s);
bopen(s);
- for (@ast.method meth in _obj.methods) {
+ for (@ast::method meth in _obj.methods) {
hbox(s);
- let vec[ast.ty_param] typarams = vec();
+ let vec[ast::ty_param] typarams = vec();
maybe_print_comment(s, meth.span.lo);
print_fn(s, meth.node.meth.decl, meth.node.ident, typarams);
space(s.s);
@@ -315,7 +317,7 @@ fn print_item(ps s, @ast.item item) {
line(s.s);
}
alt (_obj.dtor) {
- case (Option.some[@ast.method](?dtor)) {
+ case (option::some[@ast::method](?dtor)) {
hbox(s);
wrd1(s, "close");
print_block(s, dtor.node.meth.body);
@@ -332,20 +334,20 @@ fn print_item(ps s, @ast.item item) {
line(s.s);
}
-fn print_block(ps s, ast.block blk) {
+fn print_block(ps s, ast::block blk) {
maybe_print_comment(s, blk.span.lo);
bopen(s);
- for (@ast.stmt st in blk.node.stmts) {
+ for (@ast::stmt st in blk.node.stmts) {
maybe_print_comment(s, st.span.lo);
alt (st.node) {
- case (ast.stmt_decl(?decl,_)) {print_decl(s, decl);}
- case (ast.stmt_expr(?expr,_)) {print_expr(s, expr);}
+ case (ast::stmt_decl(?decl,_)) {print_decl(s, decl);}
+ case (ast::stmt_expr(?expr,_)) {print_expr(s, expr);}
}
- if (front.parser.stmt_ends_with_semi(st)) {wrd(s.s, ";");}
+ if (front::parser::stmt_ends_with_semi(st)) {wrd(s.s, ";");}
if (!maybe_print_line_comment(s, st.span)) {line(s.s);}
}
alt (blk.node.expr) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
print_expr(s, expr);
if (!maybe_print_line_comment(s, expr.span)) {line(s.s);}
}
@@ -354,45 +356,45 @@ fn print_block(ps s, ast.block blk) {
bclose_c(s, blk.span);
}
-fn print_literal(ps s, @ast.lit lit) {
+fn print_literal(ps s, @ast::lit lit) {
maybe_print_comment(s, lit.span.lo);
alt (lit.node) {
- case (ast.lit_str(?st)) {print_string(s, st);}
- case (ast.lit_char(?ch)) {
- wrd(s.s, "'" + escape_str(Str.from_bytes(vec(ch as u8)), '\'')
+ case (ast::lit_str(?st)) {print_string(s, st);}
+ case (ast::lit_char(?ch)) {
+ wrd(s.s, "'" + escape_str(_str::from_bytes(vec(ch as u8)), '\'')
+ "'");
}
- case (ast.lit_int(?val)) {
- wrd(s.s, common.istr(val));
+ case (ast::lit_int(?val)) {
+ wrd(s.s, common::istr(val));
}
- case (ast.lit_uint(?val)) { // FIXME clipping? uistr?
- wrd(s.s, common.istr(val as int) + "u");
+ case (ast::lit_uint(?val)) { // FIXME clipping? uistr?
+ wrd(s.s, common::istr(val as int) + "u");
}
- case (ast.lit_float(?fstr)) {
+ case (ast::lit_float(?fstr)) {
wrd(s.s, fstr);
}
- case (ast.lit_mach_int(?mach,?val)) {
- wrd(s.s, common.istr(val as int));
- wrd(s.s, common.ty_mach_to_str(mach));
+ case (ast::lit_mach_int(?mach,?val)) {
+ wrd(s.s, common::istr(val as int));
+ wrd(s.s, common::ty_mach_to_str(mach));
}
- case (ast.lit_mach_float(?mach,?val)) {
+ case (ast::lit_mach_float(?mach,?val)) {
// val is already a str
wrd(s.s, val);
- wrd(s.s, common.ty_mach_to_str(mach));
+ wrd(s.s, common::ty_mach_to_str(mach));
}
- case (ast.lit_nil) {wrd(s.s, "()");}
- case (ast.lit_bool(?val)) {
+ case (ast::lit_nil) {wrd(s.s, "()");}
+ case (ast::lit_bool(?val)) {
if (val) {wrd(s.s, "true");} else {wrd(s.s, "false");}
}
}
}
-fn print_expr(ps s, &@ast.expr expr) {
+fn print_expr(ps s, &@ast::expr expr) {
maybe_print_comment(s, expr.span.lo);
hbox(s);
alt (expr.node) {
- case (ast.expr_vec(?exprs,?mut,_)) {
- if (mut == ast.mut) {
+ case (ast::expr_vec(?exprs,?mut,_)) {
+ if (mut == ast::mut) {
wrd1(s, "mutable");
}
wrd(s.s, "vec");
@@ -400,41 +402,41 @@ fn print_expr(ps s, &@ast.expr expr) {
commasep_exprs(s, exprs);
pclose(s);
}
- case (ast.expr_tup(?exprs,_)) {
- fn printElt(ps s, &ast.elt elt) {
+ case (ast::expr_tup(?exprs,_)) {
+ fn printElt(ps s, &ast::elt elt) {
hbox(s);
- if (elt.mut == ast.mut) {wrd1(s, "mutable");}
+ if (elt.mut == ast::mut) {wrd1(s, "mutable");}
print_expr(s, elt.expr);
end(s.s);
}
- fn get_span(&ast.elt elt) -> common.span {ret elt.expr.span;}
+ fn get_span(&ast::elt elt) -> common::span {ret elt.expr.span;}
wrd(s.s, "tup");
popen(s);
auto f = printElt;
auto gs = get_span;
- commasep_cmnt[ast.elt](s, exprs, f, gs);
+ commasep_cmnt[ast::elt](s, exprs, f, gs);
pclose(s);
}
- case (ast.expr_rec(?fields,?wth,_)) {
- fn print_field(ps s, &ast.field field) {
+ case (ast::expr_rec(?fields,?wth,_)) {
+ fn print_field(ps s, &ast::field field) {
hbox(s);
- if (field.mut == ast.mut) {wrd1(s, "mutable");}
+ if (field.mut == ast::mut) {wrd1(s, "mutable");}
wrd(s.s, field.ident);
wrd(s.s, "=");
print_expr(s, field.expr);
end(s.s);
}
- fn get_span(&ast.field field) -> common.span {
+ fn get_span(&ast::field field) -> common::span {
ret field.expr.span;
}
wrd(s.s, "rec");
popen(s);
auto f = print_field;
auto gs = get_span;
- commasep_cmnt[ast.field](s, fields, f, gs);
+ commasep_cmnt[ast::field](s, fields, f, gs);
alt (wth) {
- case (Option.some[@ast.expr](?expr)) {
- if (Vec.len[ast.field](fields) > 0u) {space(s.s);}
+ case (option::some[@ast::expr](?expr)) {
+ if (_vec::len[ast::field](fields) > 0u) {space(s.s);}
hbox(s);
wrd1(s, "with");
print_expr(s, expr);
@@ -444,20 +446,20 @@ fn print_expr(ps s, &@ast.expr expr) {
}
pclose(s);
}
- case (ast.expr_call(?func,?args,_)) {
+ case (ast::expr_call(?func,?args,_)) {
print_expr(s, func);
popen(s);
commasep_exprs(s, args);
pclose(s);
}
- case (ast.expr_self_method(?ident,_)) {
+ case (ast::expr_self_method(?ident,_)) {
wrd(s.s, "self.");
print_ident(s, ident);
}
- case (ast.expr_bind(?func,?args,_)) {
- fn print_opt(ps s, &Option.t[@ast.expr] expr) {
+ case (ast::expr_bind(?func,?args,_)) {
+ fn print_opt(ps s, &option::t[@ast::expr] expr) {
alt (expr) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
print_expr(s, expr);
}
case (_) {wrd(s.s, "_");}
@@ -467,37 +469,37 @@ fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, func);
popen(s);
auto f = print_opt;
- commasep[Option.t[@ast.expr]](s, args, f);
+ commasep[option::t[@ast::expr]](s, args, f);
pclose(s);
}
- case (ast.expr_spawn(_,_,?e,?es,_)) {
+ case (ast::expr_spawn(_,_,?e,?es,_)) {
wrd1(s, "spawn");
print_expr(s, e);
popen(s);
commasep_exprs(s, es);
pclose(s);
}
- case (ast.expr_binary(?op,?lhs,?rhs,_)) {
+ case (ast::expr_binary(?op,?lhs,?rhs,_)) {
auto prec = operator_prec(op);
print_maybe_parens(s, lhs, prec);
space(s.s);
- wrd1(s, ast.binop_to_str(op));
+ wrd1(s, ast::binop_to_str(op));
print_maybe_parens(s, rhs, prec + 1);
}
- case (ast.expr_unary(?op,?expr,_)) {
- wrd(s.s, ast.unop_to_str(op));
+ case (ast::expr_unary(?op,?expr,_)) {
+ wrd(s.s, ast::unop_to_str(op));
print_expr(s, expr);
}
- case (ast.expr_lit(?lit,_)) {
+ case (ast::expr_lit(?lit,_)) {
print_literal(s, lit);
}
- case (ast.expr_cast(?expr,?ty,_)) {
+ case (ast::expr_cast(?expr,?ty,_)) {
print_maybe_parens(s, expr, as_prec);
space(s.s);
wrd1(s, "as");
print_type(s, ty);
}
- case (ast.expr_if(?test,?block,?elseopt,_)) {
+ case (ast::expr_if(?test,?block,?elseopt,_)) {
wrd1(s, "if");
popen_h(s);
print_expr(s, test);
@@ -505,7 +507,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
alt (elseopt) {
- case (Option.some[@ast.expr](?_else)) {
+ case (option::some[@ast::expr](?_else)) {
space(s.s);
wrd1(s, "else");
print_expr(s, _else);
@@ -513,7 +515,7 @@ fn print_expr(ps s, &@ast.expr expr) {
case (_) { /* fall through */ }
}
}
- case (ast.expr_while(?test,?block,_)) {
+ case (ast::expr_while(?test,?block,_)) {
wrd1(s, "while");
popen_h(s);
print_expr(s, test);
@@ -521,7 +523,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_for(?decl,?expr,?block,_)) {
+ case (ast::expr_for(?decl,?expr,?block,_)) {
wrd1(s, "for");
popen_h(s);
print_for_decl(s, decl);
@@ -532,7 +534,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_for_each(?decl,?expr,?block,_)) {
+ case (ast::expr_for_each(?decl,?expr,?block,_)) {
wrd1(s, "for each");
popen_h(s);
print_for_decl(s, decl);
@@ -543,7 +545,7 @@ fn print_expr(ps s, &@ast.expr expr) {
space(s.s);
print_block(s, block);
}
- case (ast.expr_do_while(?block,?expr,_)) {
+ case (ast::expr_do_while(?block,?expr,_)) {
wrd1(s, "do");
space(s.s);
print_block(s, block);
@@ -553,14 +555,14 @@ fn print_expr(ps s, &@ast.expr expr) {
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_alt(?expr,?arms,_)) {
+ case (ast::expr_alt(?expr,?arms,_)) {
wrd1(s, "alt");
popen_h(s);
print_expr(s, expr);
pclose(s);
space(s.s);
bopen(s);
- for (ast.arm arm in arms) {
+ for (ast::arm arm in arms) {
hbox(s);
wrd1(s, "case");
popen_h(s);
@@ -573,117 +575,117 @@ fn print_expr(ps s, &@ast.expr expr) {
}
bclose_c(s, expr.span);
}
- case (ast.expr_block(?block,_)) {
+ case (ast::expr_block(?block,_)) {
print_block(s, block);
}
- case (ast.expr_assign(?lhs,?rhs,_)) {
+ case (ast::expr_assign(?lhs,?rhs,_)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "=");
print_expr(s, rhs);
}
- case (ast.expr_assign_op(?op,?lhs,?rhs,_)) {
+ case (ast::expr_assign_op(?op,?lhs,?rhs,_)) {
print_expr(s, lhs);
space(s.s);
- wrd(s.s, ast.binop_to_str(op));
+ wrd(s.s, ast::binop_to_str(op));
wrd1(s, "=");
print_expr(s, rhs);
}
- case (ast.expr_send(?lhs, ?rhs, _)) {
+ case (ast::expr_send(?lhs, ?rhs, _)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "<|");
print_expr(s, rhs);
}
- case (ast.expr_recv(?lhs, ?rhs, _)) {
+ case (ast::expr_recv(?lhs, ?rhs, _)) {
print_expr(s, lhs);
space(s.s);
wrd1(s, "<-");
print_expr(s, rhs);
}
- case (ast.expr_field(?expr,?id,_)) {
+ case (ast::expr_field(?expr,?id,_)) {
print_expr(s, expr);
wrd(s.s, ".");
wrd(s.s, id);
}
- case (ast.expr_index(?expr,?index,_)) {
+ case (ast::expr_index(?expr,?index,_)) {
print_expr(s, expr);
wrd(s.s, ".");
popen_h(s);
print_expr(s, index);
pclose(s);
}
- case (ast.expr_path(?path,_)) {
+ case (ast::expr_path(?path,_)) {
print_path(s, path);
}
- case (ast.expr_fail(_)) {
+ case (ast::expr_fail(_)) {
wrd(s.s, "fail");
}
- case (ast.expr_break(_)) {
+ case (ast::expr_break(_)) {
wrd(s.s, "break");
}
- case (ast.expr_cont(_)) {
+ case (ast::expr_cont(_)) {
wrd(s.s, "cont");
}
- case (ast.expr_ret(?result,_)) {
+ case (ast::expr_ret(?result,_)) {
wrd(s.s, "ret");
alt (result) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
space(s.s);
print_expr(s, expr);
}
case (_) {}
}
}
- case (ast.expr_put(?result,_)) {
+ case (ast::expr_put(?result,_)) {
wrd(s.s, "put");
alt (result) {
- case (Option.some[@ast.expr](?expr)) {
+ case (option::some[@ast::expr](?expr)) {
space(s.s);
print_expr(s, expr);
}
case (_) {}
}
}
- case (ast.expr_be(?result,_)) {
+ case (ast::expr_be(?result,_)) {
wrd1(s, "be");
print_expr(s, result);
}
- case (ast.expr_log(?lvl,?expr,_)) {
+ case (ast::expr_log(?lvl,?expr,_)) {
alt (lvl) {
case (1) {wrd1(s, "log");}
case (0) {wrd1(s, "log_err");}
}
print_expr(s, expr);
}
- case (ast.expr_check(?expr,_)) {
+ case (ast::expr_check(?expr,_)) {
wrd1(s, "check");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_assert(?expr,_)) {
+ case (ast::expr_assert(?expr,_)) {
wrd1(s, "assert");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
- case (ast.expr_ext(?path, ?args, ?body, _, _)) {
+ case (ast::expr_ext(?path, ?args, ?body, _, _)) {
wrd(s.s, "#");
print_path(s, path);
- if (Vec.len[@ast.expr](args) > 0u) {
+ if (_vec::len[@ast::expr](args) > 0u) {
popen(s);
commasep_exprs(s, args);
pclose(s);
}
// FIXME: extension 'body'
}
- case (ast.expr_port(_)) {
+ case (ast::expr_port(_)) {
wrd(s.s, "port");
popen_h(s);
pclose(s);
}
- case (ast.expr_chan(?expr, _)) {
+ case (ast::expr_chan(?expr, _)) {
wrd(s.s, "chan");
popen_h(s);
print_expr(s, expr);
@@ -693,13 +695,13 @@ fn print_expr(ps s, &@ast.expr expr) {
end(s.s);
}
-fn print_decl(ps s, @ast.decl decl) {
+fn print_decl(ps s, @ast::decl decl) {
maybe_print_comment(s, decl.span.lo);
hbox(s);
alt (decl.node) {
- case (ast.decl_local(?loc)) {
+ case (ast::decl_local(?loc)) {
alt (loc.ty) {
- case (Option.some[@ast.ty](?ty)) {
+ case (option::some[@ast::ty](?ty)) {
wrd1(s, "let");
print_type(s, ty);
space(s.s);
@@ -710,13 +712,13 @@ fn print_decl(ps s, @ast.decl decl) {
}
wrd(s.s, loc.ident);
alt (loc.init) {
- case (Option.some[ast.initializer](?init)) {
+ case (option::some[ast::initializer](?init)) {
space(s.s);
alt (init.op) {
- case (ast.init_assign) {
+ case (ast::init_assign) {
wrd1(s, "=");
}
- case (ast.init_recv) {
+ case (ast::init_recv) {
wrd1(s, "<-");
}
}
@@ -725,28 +727,28 @@ fn print_decl(ps s, @ast.decl decl) {
case (_) {}
}
}
- case (ast.decl_item(?item)) {
+ case (ast::decl_item(?item)) {
print_item(s, item);
}
}
end(s.s);
}
-fn print_ident(ps s, ast.ident ident) {
+fn print_ident(ps s, ast::ident ident) {
wrd(s.s, ident);
}
-fn print_for_decl(ps s, @ast.decl decl) {
+fn print_for_decl(ps s, @ast::decl decl) {
alt (decl.node) {
- case (ast.decl_local(?loc)) {
- print_type(s, Option.get[@ast.ty](loc.ty));
+ case (ast::decl_local(?loc)) {
+ print_type(s, option::get[@ast::ty](loc.ty));
space(s.s);
wrd(s.s, loc.ident);
}
}
}
-fn print_path(ps s, ast.path path) {
+fn print_path(ps s, ast::path path) {
maybe_print_comment(s, path.span.lo);
auto first = true;
for (str id in path.node.idents) {
@@ -754,36 +756,36 @@ fn print_path(ps s, ast.path path) {
else {wrd(s.s, "::");}
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, "[");
auto f = print_type;
- commasep[@ast.ty](s, path.node.types, f);
+ commasep[@ast::ty](s, path.node.types, f);
wrd(s.s, "]");
}
}
-fn print_pat(ps s, &@ast.pat pat) {
+fn print_pat(ps s, &@ast::pat pat) {
maybe_print_comment(s, pat.span.lo);
alt (pat.node) {
- case (ast.pat_wild(_)) {wrd(s.s, "_");}
- case (ast.pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
- case (ast.pat_lit(?lit,_)) {print_literal(s, lit);}
- case (ast.pat_tag(?path,?args,_)) {
+ case (ast::pat_wild(_)) {wrd(s.s, "_");}
+ case (ast::pat_bind(?id,_,_)) {wrd(s.s, "?" + id);}
+ case (ast::pat_lit(?lit,_)) {print_literal(s, lit);}
+ case (ast::pat_tag(?path,?args,_)) {
print_path(s, path);
- if (Vec.len[@ast.pat](args) > 0u) {
+ if (_vec::len[@ast::pat](args) > 0u) {
popen_h(s);
auto f = print_pat;
- commasep[@ast.pat](s, args, f);
+ commasep[@ast::pat](s, args, f);
pclose(s);
}
}
}
}
-fn print_fn(ps s, ast.fn_decl decl, str name,
- vec[ast.ty_param] typarams) {
+fn print_fn(ps s, ast::fn_decl decl, str name,
+ vec[ast::ty_param] typarams) {
alt (decl.purity) {
- case (ast.impure_fn) {
+ case (ast::impure_fn) {
wrd1(s, "fn");
}
case (_) {
@@ -793,19 +795,19 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
wrd(s.s, name);
print_type_params(s, typarams);
popen(s);
- fn print_arg(ps s, &ast.arg x) {
+ fn print_arg(ps s, &ast::arg x) {
hbox(s);
- if (x.mode == ast.alias) {wrd(s.s, "&");}
+ if (x.mode == ast::alias) {wrd(s.s, "&");}
print_type(s, x.ty);
space(s.s);
wrd(s.s, x.ident);
end(s.s);
}
auto f = print_arg;
- commasep[ast.arg](s, decl.inputs, f);
+ commasep[ast::arg](s, decl.inputs, f);
pclose(s);
maybe_print_comment(s, decl.output.span.lo);
- if (decl.output.node != ast.ty_nil) {
+ if (decl.output.node != ast::ty_nil) {
space(s.s);
hbox(s);
wrd1(s, "->");
@@ -814,28 +816,28 @@ fn print_fn(ps s, ast.fn_decl decl, str name,
}
}
-fn print_type_params(ps s, vec[ast.ty_param] params) {
- if (Vec.len[ast.ty_param](params) > 0u) {
+fn print_type_params(ps s, vec[ast::ty_param] params) {
+ if (_vec::len[ast::ty_param](params) > 0u) {
wrd(s.s, "[");
- fn printParam(ps s, &ast.ty_param param) {
+ fn printParam(ps s, &ast::ty_param param) {
wrd(s.s, param);
}
auto f = printParam;
- commasep[ast.ty_param](s, params, f);
+ commasep[ast::ty_param](s, params, f);
wrd(s.s, "]");
}
}
-fn print_view_item(ps s, @ast.view_item item) {
+fn print_view_item(ps s, @ast::view_item item) {
maybe_print_comment(s, item.span.lo);
hbox(s);
alt (item.node) {
- case (ast.view_item_use(?id,?mta,_,_)) {
+ case (ast::view_item_use(?id,?mta,_,_)) {
wrd1(s, "use");
wrd(s.s, id);
- if (Vec.len[@ast.meta_item](mta) > 0u) {
+ if (_vec::len[@ast::meta_item](mta) > 0u) {
popen(s);
- fn print_meta(ps s, &@ast.meta_item item) {
+ fn print_meta(ps s, &@ast::meta_item item) {
hbox(s);
wrd1(s, item.node.name);
wrd1(s, "=");
@@ -843,13 +845,13 @@ fn print_view_item(ps s, @ast.view_item item) {
end(s.s);
}
auto f = print_meta;
- commasep[@ast.meta_item](s, mta, f);
+ commasep[@ast::meta_item](s, mta, f);
pclose(s);
}
}
- case (ast.view_item_import(?id,?ids,_)) {
+ case (ast::view_item_import(?id,?ids,_)) {
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, "=");
}
@@ -860,7 +862,7 @@ fn print_view_item(ps s, @ast.view_item item) {
wrd(s.s, elt);
}
}
- case (ast.view_item_export(?id)) {
+ case (ast::view_item_export(?id)) {
wrd1(s, "export");
wrd(s.s, id);
}
@@ -872,20 +874,20 @@ 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 (front.parser.op_spec spec in front.parser.prec_table()) {
+fn operator_prec(ast::binop op) -> int {
+ for (front::parser::op_spec spec in front::parser::prec_table()) {
if (spec.op == op) {ret spec.prec;}
}
fail;
}
-fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
+fn print_maybe_parens(ps s, @ast::expr expr, int outer_prec) {
auto add_them;
alt (expr.node) {
- case (ast.expr_binary(?op,_,_,_)) {
+ case (ast::expr_binary(?op,_,_,_)) {
add_them = operator_prec(op) < outer_prec;
}
- case (ast.expr_cast(_,_,_)) {
+ case (ast::expr_cast(_,_,_)) {
add_them = as_prec < outer_prec;
}
case (_) {
@@ -899,7 +901,7 @@ fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
fn escape_str(str st, char to_escape) -> str {
let str out = "";
- auto len = Str.byte_len(st);
+ auto len = _str::byte_len(st);
auto i = 0u;
while (i < len) {
alt (st.(i) as char) {
@@ -909,7 +911,7 @@ fn escape_str(str st, char to_escape) -> str {
case ('\\') {out += "\\\\";}
case (?cur) {
if (cur == to_escape) {out += "\\";}
- Str.push_byte(out, cur as u8);
+ _str::push_byte(out, cur as u8);
}
}
i += 1u;
@@ -917,11 +919,11 @@ fn escape_str(str st, char to_escape) -> str {
ret out;
}
-fn print_mt(ps s, &ast.mt mt) {
+fn print_mt(ps s, &ast::mt mt) {
alt (mt.mut) {
- case (ast.mut) { wrd1(s, "mutable"); }
- case (ast.maybe_mut) { wrd1(s, "mutable?"); }
- case (ast.imm) { /* nothing */ }
+ case (ast::mut) { wrd1(s, "mutable"); }
+ case (ast::maybe_mut) { wrd1(s, "mutable?"); }
+ case (ast::imm) { /* nothing */ }
}
print_type(s, mt.ty);
}
@@ -930,24 +932,24 @@ fn print_string(ps s, str st) {
wrd(s.s, "\""); wrd(s.s, escape_str(st, '"')); wrd(s.s, "\"");
}
-fn print_ty_fn(ps s, ast.proto proto, Option.t[str] id,
- vec[ast.ty_arg] inputs, @ast.ty output) {
- if (proto == ast.proto_fn) {wrd(s.s, "fn");}
+fn print_ty_fn(ps s, ast::proto proto, option::t[str] id,
+ vec[ast::ty_arg] inputs, @ast::ty output) {
+ if (proto == ast::proto_fn) {wrd(s.s, "fn");}
else {wrd(s.s, "iter");}
alt (id) {
- case (Option.some[str](?id)) {space(s.s); wrd(s.s, id);}
+ case (option::some[str](?id)) {space(s.s); wrd(s.s, id);}
case (_) {}
}
popen_h(s);
- fn print_arg(ps s, &ast.ty_arg input) {
- if (input.mode == ast.alias) {wrd(s.s, "&");}
+ fn print_arg(ps s, &ast::ty_arg input) {
+ if (input.mode == ast::alias) {wrd(s.s, "&");}
print_type(s, input.ty);
}
auto f = print_arg;
- commasep[ast.ty_arg](s, inputs, f);
+ commasep[ast::ty_arg](s, inputs, f);
pclose(s);
maybe_print_comment(s, output.span.lo);
- if (output.node != ast.ty_nil) {
+ if (output.node != ast::ty_nil) {
space(s.s);
hbox(s);
wrd1(s, "->");
@@ -956,21 +958,21 @@ 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) {
- case (Option.some[vec[lexer.cmnt]](?cmnts)) {
- if (s.cur_cmnt < Vec.len[lexer.cmnt](cmnts)) {
- ret Option.some[lexer.cmnt](cmnts.(s.cur_cmnt));
- } else {ret Option.none[lexer.cmnt];}
+ case (option::some[vec[lexer::cmnt]](?cmnts)) {
+ if (s.cur_cmnt < _vec::len[lexer::cmnt](cmnts)) {
+ ret option::some[lexer::cmnt](cmnts.(s.cur_cmnt));
+ } else {ret option::none[lexer::cmnt];}
}
- case (_) {ret Option.none[lexer.cmnt];}
+ case (_) {ret option::none[lexer::cmnt];}
}
}
fn maybe_print_comment(ps s, uint pos) {
while (true) {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
if (cmnt.pos < pos) {
print_comment(s, cmnt.val);
if (cmnt.space_after) {line(s.s);}
@@ -982,9 +984,9 @@ fn maybe_print_comment(ps s, uint pos) {
}
}
-fn maybe_print_line_comment(ps s, common.span span) -> bool {
+fn maybe_print_line_comment(ps s, common::span span) -> bool {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
if (span.hi + 4u >= cmnt.pos) {
wrd(s.s, " ");
print_comment(s, cmnt.val);
@@ -1000,7 +1002,7 @@ fn maybe_print_line_comment(ps s, common.span span) -> bool {
fn print_remaining_comments(ps s) {
while (true) {
alt (next_comment(s)) {
- case (Option.some[lexer.cmnt](?cmnt)) {
+ case (option::some[lexer::cmnt](?cmnt)) {
print_comment(s, cmnt.val);
if (cmnt.space_after) {line(s.s);}
s.cur_cmnt += 1u;
@@ -1010,20 +1012,20 @@ fn print_remaining_comments(ps s) {
}
}
-fn print_comment(ps s, lexer.cmnt_ cmnt) {
+fn print_comment(ps s, lexer::cmnt_ cmnt) {
alt (cmnt) {
- case (lexer.cmnt_line(?val)) {
+ case (lexer::cmnt_line(?val)) {
wrd(s.s, "// " + val);
- pp.hardbreak(s.s);
+ pp::hardbreak(s.s);
}
- case (lexer.cmnt_block(?lines)) {
- pp.abox(s.s);
+ case (lexer::cmnt_block(?lines)) {
+ pp::abox(s.s);
wrd(s.s, "/* ");
- pp.abox(s.s);
+ pp::abox(s.s);
auto first = true;
for (str ln in lines) {
if (first) {first = false;}
- else {pp.hardbreak(s.s);}
+ else {pp::hardbreak(s.s);}
wrd(s.s, ln);
}
end(s.s);
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 08:56:43 +0000