diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 90fe0e0c4e7..7ad0cdc74fd 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -61,6 +61,14 @@ impure fn compile_input(session.session sess,
trans.trans_crate(sess, crate, output, shared);
}
+impure fn pretty_print_input(session.session sess,
+ eval.env env,
+ str input) {
+ auto p = front.parser.new_parser(sess, env, 0, input);
+ auto crate = front.parser.parse_crate_from_source_file(p);
+ pretty.pprust.print_ast(crate.node.module);
+}
+
fn warn_wrong_compiler() {
log "This is the rust 'self-hosted' compiler.";
log "The one written in rust.";
@@ -75,6 +83,7 @@ fn usage(session.session sess, str argv0) {
log " -o <filename> write output to <filename>";
log " -nowarn suppress wrong-compiler warning";
log " -shared compile a shared-library crate";
+ log " -pp pretty-print the input instead of compiling";
log " -h display this message";
log "";
log "";
@@ -101,6 +110,7 @@ impure fn main(vec[str] args) {
let option.t[str] output_file = none[str];
let bool do_warn = true;
let bool shared = false;
+ let bool pretty = false;
auto i = 1u;
auto len = _vec.len[str](args);
@@ -113,6 +123,8 @@ impure fn main(vec[str] args) {
do_warn = false;
} else if (_str.eq(arg, "-shared")) {
shared = true;
+ } else if (_str.eq(arg, "-pp")) {
+ pretty = true;
} else if (_str.eq(arg, "-o")) {
if (i+1u < len) {
output_file = some(args.(i+1u));
@@ -153,24 +165,27 @@ impure fn main(vec[str] args) {
case (some[str](?ifile)) {
auto env = default_environment(sess, args.(0), ifile);
-
- alt (output_file) {
- case (none[str]) {
- let vec[str] parts = _str.split(ifile, '.' as u8);
- parts = _vec.pop[str](parts);
- parts += ".bc";
- auto ofile = _str.concat(parts);
- compile_input(sess, env, ifile, ofile, shared);
- }
- case (some[str](?ofile)) {
- compile_input(sess, env, ifile, ofile, shared);
+ if (pretty) {
+ pretty_print_input(sess, env, ifile);
+ }
+ else {
+ alt (output_file) {
+ case (none[str]) {
+ let vec[str] parts = _str.split(ifile, '.' as u8);
+ parts = _vec.pop[str](parts);
+ parts += ".bc";
+ auto ofile = _str.concat(parts);
+ compile_input(sess, env, ifile, ofile, shared);
+ }
+ case (some[str](?ofile)) {
+ compile_input(sess, env, ifile, ofile, shared);
+ }
}
}
}
}
}
-
// Local Variables:
// mode: rust
// fill-column: 78;
diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index ed1e21142c5..d45260f3ad1 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -122,6 +122,31 @@ tag binop {
gt;
}
+fn binop_to_str(binop op) -> str {
+ alt (op) {
+ case (add) {ret "+";}
+ case (sub) {ret "-";}
+ case (mul) {ret "*";}
+ case (div) {ret "/";}
+ case (rem) {ret "%";}
+ case (and) {ret "&&";}
+ case (or) {ret "||";}
+ case (bitxor) {ret "^";}
+ case (bitand) {ret "&";}
+ case (bitor) {ret "|";}
+ case (lsl) {ret "<<";}
+ case (lsr) {ret ">>";}
+ case (asr) {ret ">>>";}
+ case (eq) {ret "==";}
+ case (lt) {ret "<";}
+ case (le) {ret "<=";}
+ case (ne) {ret "!=";}
+ case (ge) {ret ">=";}
+ case (gt) {ret ">";}
+ }
+}
+
+
tag unop {
box;
deref;
@@ -131,6 +156,17 @@ tag unop {
_mutable;
}
+fn unop_to_str(unop op) -> str {
+ alt (op) {
+ case (box) {ret "@";}
+ case (deref) {ret "*";}
+ case (bitnot) {ret "~";}
+ case (not) {ret "!";}
+ case (neg) {ret "-";}
+ case (_mutable) {ret "mutable";}
+ }
+}
+
tag mode {
val;
alias;
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index 6f3111c74d0..f60ff36b65f 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -983,6 +983,7 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
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 vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11),
rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11),
diff --git a/src/comp/front/pretty.rs b/src/comp/front/pretty.rs
index 267763e3997..2fd58126cee 100644
--- a/src/comp/front/pretty.rs
+++ b/src/comp/front/pretty.rs
@@ -5,6 +5,8 @@ import std._vec;
export print_expr;
+// FIXME this is superseded by ../pretty/pprust.rs. can it be dropped?
+
fn unknown() -> str {
ret "<unknown ast node>";
}
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 62d9a2f057b..c33b5d8d17d 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -169,6 +169,8 @@ fn path_to_str(&ast.path pth) -> str {
ret result;
}
+// FIXME use the pretty-printer for this once it has a concept of an
+// abstract stream
fn ty_to_str(&@t typ) -> str {
fn fn_input_to_str(&rec(ast.mode mode, @t ty) input) -> str {
diff --git a/src/comp/pretty/pp.rs b/src/comp/pretty/pp.rs
new file mode 100644
index 00000000000..43a9220f4e5
--- /dev/null
+++ b/src/comp/pretty/pp.rs
@@ -0,0 +1,207 @@
+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;}
+
+tag token {
+ brk(uint);
+ word(str);
+ cword(str); // closing token
+ open(boxtype, uint);
+ close;
+}
+
+type context = rec(contexttype tp, uint indent);
+
+type ps = @rec(mutable vec[context] context,
+ uint width,
+ mutable vec[token] buffered,
+ mutable uint scandepth,
+ mutable uint bufferedcol,
+ mutable uint col,
+ mutable bool start_of_line);
+
+fn mkstate(uint width) -> ps {
+ let vec[context] stack = vec(rec(tp=cx_v, indent=0u));
+ let vec[token] buff = vec();
+ ret @rec(mutable context=stack,
+ width=width,
+ mutable buffered=buff,
+ mutable scandepth=0u,
+ mutable bufferedcol=0u,
+ mutable col=0u,
+ mutable start_of_line=true);
+}
+
+impure fn push_context(ps p, contexttype tp, uint indent) {
+ before_print(p, false);
+ p.context = _vec.push[context](p.context, rec(tp=tp, indent=base_indent(p)
+ + indent));
+}
+
+impure fn pop_context(ps p) {
+ p.context = _vec.pop[context](p.context);
+}
+
+impure fn add_token(ps p, token tok) {
+ if (p.scandepth == 0u) {do_token(p, tok);}
+ else {buffer_token(p, tok);}
+}
+
+impure fn buffer_token(ps p, token tok) {
+ p.buffered += vec(tok);
+ p.bufferedcol += token_size(tok);
+ alt (p.buffered.(0)) {
+ case (brk(_)) {
+ alt (tok) {
+ case (brk(_)) {
+ if (p.scandepth == 1u) {finish_break_scan(p);}
+ }
+ case (open(box_h,_)) {p.scandepth += 1u;}
+ case (open(_,_)) {finish_break_scan(p);}
+ case (close) {
+ p.scandepth -= 1u;
+ if (p.scandepth == 0u) {finish_break_scan(p);}
+ }
+ case (_) {}
+ }
+ }
+ case (open(_,_)) {
+ if (p.bufferedcol > p.width) {finish_block_scan(p, cx_v);}
+ else {
+ alt (tok) {
+ case (open(_,_)) {p.scandepth += 1u;}
+ case (close) {
+ p.scandepth -= 1u;
+ if (p.scandepth == 0u) {finish_block_scan(p, cx_h);}
+ }
+ case (_) {}
+ }
+ }
+ }
+ }
+}
+
+impure fn finish_block_scan(ps p, contexttype tp) {
+ auto indent;
+ alt (p.buffered.(0)){
+ case (open(box_hv,?ind)) {
+ indent = ind;
+ }
+ case (open(box_align, _)) {
+ indent = p.col - base_indent(p);
+ }
+ }
+ p.scandepth = 0u;
+ push_context(p, tp, indent);
+ for (token t in _vec.shift[token](p.buffered)) {add_token(p, t);}
+}
+
+impure fn finish_break_scan(ps p) {
+ if (p.bufferedcol > p.width) {
+ write_str("\n");
+ p.col = 0u;
+ }
+ else {
+ auto width;
+ alt (p.buffered.(0)) {case(brk(?w)) {width = w;}}
+ auto i = 0u;
+ while (i < width) {write_str(" "); i+=1u;}
+ p.col += width;
+ }
+ p.scandepth = 0u;
+ for (token t in _vec.shift[token](p.buffered)) {add_token(p, t);}
+}
+
+impure fn start_scan(ps p, token tok) {
+ p.buffered = vec(tok);
+ p.scandepth = 1u;
+ p.bufferedcol = p.col;
+}
+
+fn cur_context(ps p) -> context {
+ ret p.context.(_vec.len[context](p.context)-1u);
+}
+fn base_indent(ps p) -> uint {
+ auto i = _vec.len[context](p.context);
+ while (i > 0u) {
+ i -= 1u;
+ auto cx = p.context.(i);
+ if (cx.tp == cx_v) {ret cx.indent;}
+ }
+}
+
+impure fn do_token(ps p, token tok) {
+ alt (tok) {
+ case (brk(?sz)) {
+ alt (cur_context(p).tp) {
+ case (cx_h) {
+ before_print(p, false);
+ start_scan(p, tok);
+ }
+ case (cx_v) {
+ write_str("\n");
+ p.col = 0u;
+ p.start_of_line = true;
+ }
+ }
+ }
+ case (word(?w)) {
+ before_print(p, false);
+ write_str(w);
+ p.col += _str.byte_len(w); // TODO char_len
+ }
+ case (cword(?w)) {
+ before_print(p, true);
+ write_str(w);
+ p.col += _str.byte_len(w); // TODO char_len
+ }
+ case (open(?tp, ?indent)) {
+ alt (tp) {
+ case (box_hv) {start_scan(p, tok);}
+ case (box_align) {start_scan(p, tok);}
+ case (box_h) {push_context(p, cx_h, indent);}
+ case (box_v) {push_context(p, cx_v, indent);}
+ }
+ }
+ case (close) {pop_context(p);}
+ }
+}
+
+impure fn before_print(ps p, bool closing) {
+ if (p.start_of_line) {
+ p.start_of_line = false;
+ auto ind;
+ if (closing) {ind = base_indent(p);}
+ else {ind = cur_context(p).indent;}
+ p.col = ind;
+ while (ind > 0u) {write_str(" "); ind -= 1u;}
+ }
+}
+
+fn write_str(str s) {
+ io.writefd(1, _str.bytes(s));
+}
+
+fn token_size(token tok) -> uint {
+ alt (tok) {
+ case (brk(?sz)) {ret sz;}
+ case (word(?w)) {ret _str.byte_len(w);}
+ case (cword(?w)) {ret _str.byte_len(w);}
+ case (open(_, _)) {ret 0u;} // TODO exception for V blocks?
+ case (close) {ret 0u;}
+ }
+}
+
+impure fn box(ps p, uint indent) {add_token(p, open(box_hv, indent));}
+impure fn abox(ps p) {add_token(p, open(box_align, 0u));}
+impure fn vbox(ps p, uint indent) {add_token(p, open(box_v, indent));}
+impure fn hbox(ps p, uint indent) {add_token(p, open(box_h, indent));}
+impure fn end(ps p) {add_token(p, close);}
+impure fn wrd(ps p, str wrd) {add_token(p, word(wrd));}
+impure fn cwrd(ps p, str wrd) {add_token(p, cword(wrd));}
+impure fn space(ps p) {add_token(p, brk(1u));}
+impure fn spaces(ps p, uint n) {add_token(p, brk(n));}
+impure fn line(ps p) {add_token(p, brk(0u));}
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
new file mode 100644
index 00000000000..d10f5e7cdaa
--- /dev/null
+++ b/src/comp/pretty/pprust.rs
@@ -0,0 +1,716 @@
+import std._vec;
+import std._str;
+import std.option;
+import front.ast;
+import pp.box; import pp.abox; import pp.vbox;
+import pp.end; import pp.wrd; import pp.space; import pp.line;
+import pp.ps;
+
+import foo = std.io;
+
+const uint indent_unit = 2u;
+const int as_prec = 5;
+
+impure fn print_ast(ast._mod _mod) {
+ auto s = pp.mkstate(80u);
+ for (@ast.view_item vitem in _mod.view_items) {print_view_item(s, vitem);}
+ line(s);
+ for (@ast.item item in _mod.items) {print_item(s, item);}
+}
+
+impure fn hbox(ps s) {
+ pp.hbox(s, indent_unit);
+}
+impure fn wrd1(ps s, str word) {
+ wrd(s, word);
+ space(s);
+}
+impure fn popen(ps s) {
+ wrd(s, "(");
+ abox(s);
+}
+impure fn pclose(ps s) {
+ end(s);
+ wrd(s, ")");
+}
+impure fn bopen(ps s) {
+ wrd1(s, "{");
+ vbox(s, indent_unit);
+ line(s);
+}
+impure fn bclose(ps s) {
+ end(s);
+ pp.cwrd(s, "}");
+}
+impure fn commasep[IN](ps s, vec[IN] elts, impure fn (ps, IN) op) {
+ auto first = true;
+ for (IN elt in elts) {
+ if (first) {first = false;}
+ else {wrd1(s, ",");}
+ op(s, elt);
+ }
+}
+
+impure fn print_type(ps s, @ast.ty ty) {
+ hbox(s);
+ alt (ty.node) {
+ case (ast.ty_nil) {wrd(s, "()");}
+ case (ast.ty_bool) {wrd(s, "bool");}
+ case (ast.ty_int) {wrd(s, "int");}
+ case (ast.ty_uint) {wrd(s, "uint");}
+ case (ast.ty_machine(?tm)) {wrd(s, util.common.ty_mach_to_str(tm));}
+ case (ast.ty_char) {wrd(s, "char");}
+ case (ast.ty_str) {wrd(s, "str");}
+ case (ast.ty_box(?t)) {wrd(s, "@"); print_type(s, t);}
+ case (ast.ty_vec(?t)) {wrd(s, "vec["); print_type(s, t); wrd(s, "]");}
+ case (ast.ty_type) {wrd(s, "type");}
+ case (ast.ty_tup(?elts)) {
+ wrd(s, "tup");
+ popen(s);
+ auto f = print_type;
+ commasep[@ast.ty](s, elts, f);
+ pclose(s);
+ }
+ case (ast.ty_rec(?fields)) {
+ wrd(s, "rec");
+ popen(s);
+ impure fn print_field(ps s, ast.ty_field f) {
+ hbox(s);
+ print_type(s, f.ty);
+ space(s);
+ wrd(s, f.ident);
+ end(s);
+ }
+ auto f = print_field;
+ commasep[ast.ty_field](s, fields, f);
+ pclose(s);
+ }
+ case (ast.ty_fn(?proto,?inputs,?output)) {
+ if (proto == ast.proto_fn) {wrd(s, "fn");}
+ else {wrd(s, "iter");}
+ popen(s);
+ impure fn print_arg(ps s, ast.ty_arg input) {
+ if (middle.ty.mode_is_alias(input.mode)) {wrd(s, "&");}
+ print_type(s, input.ty);
+ }
+ auto f = print_arg;
+ commasep[ast.ty_arg](s, inputs, f);
+ pclose(s);
+ if (output.node != ast.ty_nil) {
+ space(s);
+ hbox(s);
+ wrd1(s, "->");
+ print_type(s, output);
+ end(s);
+ }
+ }
+ case (ast.ty_path(?path,_)) {
+ print_path(s, path);
+ }
+ case (ast.ty_mutable(?t)) {
+ wrd1(s, "mutable");
+ print_type(s, t);
+ }
+ }
+ end(s);
+}
+
+impure fn print_item(ps s, @ast.item item) {
+ hbox(s);
+ alt (item.node) {
+ case (ast.item_const(?id, ?ty, ?expr, _, _)) {
+ wrd1(s, "const");
+ print_type(s, ty);
+ space(s);
+ wrd1(s, id);
+ wrd1(s, "=");
+ print_expr(s, expr);
+ wrd(s, ";");
+ }
+ case (ast.item_fn(?name,?_fn,?typarams,_,_)) {
+ print_fn(s, _fn.decl, name, typarams);
+ space(s);
+ print_block(s, _fn.body);
+ }
+ 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);}
+ bclose(s);
+ }
+ 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\"");}
+ }
+ wrd1(s, "mod");
+ wrd1(s, id);
+ bopen(s);
+ for (@ast.native_item item in nmod.items) {
+ hbox(s);
+ alt (item.node) {
+ case (ast.native_item_ty(?id,_)) {
+ wrd1(s, "type");
+ wrd(s, id);
+ }
+ case (ast.native_item_fn(?id,?decl,?typarams,_,_)) {
+ print_fn(s, decl, id, typarams);
+ }
+ }
+ wrd(s, ";");
+ end(s);
+ }
+ bclose(s);
+ }
+ case (ast.item_ty(?id,?ty,?params,_,_)) {
+ wrd1(s, "type");
+ wrd(s, id);
+ print_type_params(s, params);
+ space(s);
+ wrd1(s, "=");
+ print_type(s, ty);
+ wrd(s, ";");
+ }
+ case (ast.item_tag(?id,?variants,?params,_)) {
+ wrd1(s, "tag");
+ wrd(s, id);
+ print_type_params(s, params);
+ space(s);
+ bopen(s);
+ for (ast.variant v in variants) {
+ wrd(s, v.name);
+ if (_vec.len[ast.variant_arg](v.args) > 0u) {
+ popen(s);
+ impure 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.args, f);
+ pclose(s);
+ }
+ wrd(s, ";");
+ line(s);
+ }
+ bclose(s);
+ }
+ case (ast.item_obj(?id,?_obj,?params,_,_)) {
+ wrd1(s, "obj");
+ wrd(s, id);
+ print_type_params(s, params);
+ popen(s);
+ impure fn print_field(ps s, ast.obj_field field) {
+ hbox(s);
+ print_type(s, field.ty);
+ space(s);
+ wrd(s, field.ident);
+ end(s);
+ }
+ auto f = print_field;
+ commasep[ast.obj_field](s, _obj.fields, f);
+ pclose(s);
+ space(s);
+ bopen(s);
+ for (@ast.method meth in _obj.methods) {
+ hbox(s);
+ let vec[ast.ty_param] typarams = vec();
+ print_fn(s, meth.node.meth.decl, meth.node.ident, typarams);
+ space(s);
+ print_block(s, meth.node.meth.body);
+ end(s);
+ line(s);
+ }
+ alt (_obj.dtor) {
+ case (option.some[ast.block](?dtor)) {
+ hbox(s);
+ wrd1(s, "close");
+ print_block(s, dtor);
+ end(s);
+ line(s);
+ }
+ case (_) {}
+ }
+ bclose(s);
+ }
+ }
+ end(s);
+ line(s);
+ line(s);
+}
+
+impure fn print_block(ps s, ast.block blk) {
+ bopen(s);
+ for (@ast.stmt st in blk.node.stmts) {
+ alt (st.node) {
+ 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, ";");}
+ line(s);
+ }
+ alt (blk.node.expr) {
+ case (option.some[@ast.expr](?expr)) {
+ print_expr(s, expr);
+ line(s);
+ }
+ case (_) {}
+ }
+ bclose(s);
+}
+
+impure fn print_literal(ps s, @ast.lit lit) {
+ alt (lit.node) {
+ case (ast.lit_str(?st)) {print_string(s, st);}
+ case (ast.lit_char(?ch)) {
+ wrd(s, "'" + escape_str(_str.from_bytes(vec(ch as u8)), '\'') + "'");
+ }
+ case (ast.lit_int(?val)) {
+ wrd(s, util.common.istr(val));
+ }
+ case (ast.lit_uint(?val)) { // TODO clipping? uistr?
+ wrd(s, util.common.istr(val as int) + "u");
+ }
+ case (ast.lit_mach_int(?mach,?val)) {
+ wrd(s, util.common.istr(val as int));
+ wrd(s, util.common.ty_mach_to_str(mach));
+ }
+ case (ast.lit_nil) {wrd(s, "()");}
+ case (ast.lit_bool(?val)) {
+ if (val) {wrd(s, "true");} else {wrd(s, "false");}
+ }
+ }
+}
+
+impure fn print_expr(ps s, @ast.expr expr) {
+ auto pe = print_expr;
+ hbox(s);
+ alt (expr.node) {
+ case (ast.expr_vec(?exprs,_)) {
+ wrd(s, "vec");
+ popen(s);
+ commasep[@ast.expr](s, exprs, pe);
+ pclose(s);
+ }
+ case (ast.expr_tup(?exprs,_)) {
+ impure fn printElt(ps s, ast.elt elt) {
+ hbox(s);
+ if (elt.mut == ast.mut) {wrd1(s, "mutable");}
+ print_expr(s, elt.expr);
+ end(s);
+ }
+ wrd(s, "tup");
+ popen(s);
+ auto f = printElt;
+ commasep[ast.elt](s, exprs, f);
+ pclose(s);
+ }
+ case (ast.expr_rec(?fields,_,_)) {
+ impure fn print_field(ps s, ast.field field) {
+ hbox(s);
+ if (field.mut == ast.mut) {wrd1(s, "mutable");}
+ wrd(s, field.ident);
+ wrd(s, "=");
+ print_expr(s, field.expr);
+ end(s);
+ }
+ wrd(s, "rec");
+ popen(s);
+ auto f = print_field;
+ commasep[ast.field](s, fields, f);
+ pclose(s);
+ }
+ case (ast.expr_call(?func,?args,_)) {
+ print_expr(s, func);
+ popen(s);
+ commasep[@ast.expr](s, args, pe);
+ pclose(s);
+ }
+ case (ast.expr_bind(?func,?args,_)) {
+ impure fn print_opt(ps s, option.t[@ast.expr] expr) {
+ alt (expr) {
+ case (option.some[@ast.expr](?expr)) {
+ print_expr(s, expr);
+ }
+ case (_) {wrd(s, "_");}
+ }
+ }
+ wrd1(s, "bind");
+ print_expr(s, func);
+ popen(s);
+ auto f = print_opt;
+ commasep[option.t[@ast.expr]](s, args, f);
+ pclose(s);
+ }
+ case (ast.expr_binary(?op,?lhs,?rhs,_)) {
+ auto prec = operator_prec(op);
+ print_maybe_parens(s, lhs, prec);
+ space(s);
+ wrd1(s, ast.binop_to_str(op));
+ print_maybe_parens(s, rhs, prec + 1);
+ }
+ case (ast.expr_unary(?op,?expr,_)) {
+ wrd(s, ast.unop_to_str(op));
+ if (op == ast._mutable) {space(s);}
+ print_expr(s, expr);
+ }
+ case (ast.expr_lit(?lit,_)) {
+ print_literal(s, lit);
+ }
+ case (ast.expr_cast(?expr,?ty,_)) {
+ print_maybe_parens(s, expr, as_prec);
+ space(s);
+ wrd1(s, "as");
+ print_type(s, ty);
+ }
+ case (ast.expr_if(?test,?block,?clauses,?_else,_)) {
+ impure fn print_clause(ps s, @ast.expr test, ast.block blk) {
+ wrd1(s, "if");
+ popen(s);
+ print_expr(s, test);
+ pclose(s);
+ space(s);
+ print_block(s, blk);
+ }
+ print_clause(s, test, block);
+ for (tup(@ast.expr, ast.block) clause in clauses) {
+ space(s);
+ wrd1(s, "else");
+ print_clause(s, clause._0, clause._1);
+ }
+ alt (_else) {
+ case (option.some[ast.block](?blk)) {
+ space(s);
+ wrd1(s, "else");
+ print_block(s, blk);
+ }
+ }
+ }
+ case (ast.expr_while(?test,?block,_)) {
+ wrd1(s, "while");
+ popen(s);
+ print_expr(s, test);
+ pclose(s);
+ space(s);
+ print_block(s, block);
+ }
+ case (ast.expr_for(?decl,?expr,?block,_)) {
+ wrd1(s, "for");
+ popen(s);
+ print_decl(s, decl);
+ space(s);
+ wrd1(s, "in");
+ print_expr(s, expr);
+ pclose(s);
+ space(s);
+ print_block(s, block);
+ }
+ case (ast.expr_for_each(?decl,?expr,?block,_)) {
+ wrd1(s, "for each");
+ popen(s);
+ print_decl(s, decl);
+ space(s);
+ wrd1(s, "in");
+ print_expr(s, expr);
+ space(s);
+ print_block(s, block);
+ }
+ case (ast.expr_do_while(?block,?expr,_)) {
+ wrd1(s, "do");
+ space(s);
+ print_block(s, block);
+ space(s);
+ wrd1(s, "while");
+ popen(s);
+ print_expr(s, expr);
+ pclose(s);
+ }
+ case (ast.expr_alt(?expr,?arms,_)) {
+ wrd1(s, "alt");
+ popen(s);
+ print_expr(s, expr);
+ pclose(s);
+ space(s);
+ bopen(s);
+ for (ast.arm arm in arms) {
+ hbox(s);
+ wrd1(s, "case");
+ popen(s);
+ print_pat(s, arm.pat);
+ pclose(s);
+ space(s);
+ print_block(s, arm.block);
+ end(s);
+ line(s);
+ }
+ bclose(s);
+ }
+ case (ast.expr_block(?block,_)) {
+ print_block(s, block);
+ }
+ case (ast.expr_assign(?lhs,?rhs,_)) {
+ print_expr(s, lhs);
+ space(s);
+ wrd1(s, "=");
+ print_expr(s, rhs);
+ }
+ case (ast.expr_assign_op(?op,?lhs,?rhs,_)) {
+ print_expr(s, lhs);
+ space(s);
+ wrd(s, ast.binop_to_str(op));
+ wrd1(s, "=");
+ print_expr(s, rhs);
+ }
+ case (ast.expr_field(?expr,?id,_)) {
+ print_expr(s, expr);
+ wrd(s, ".");
+ wrd(s, id);
+ }
+ case (ast.expr_index(?expr,?index,_)) {
+ print_expr(s, expr);
+ wrd(s, ".");
+ popen(s);
+ print_expr(s, index);
+ pclose(s);
+ }
+ case (ast.expr_path(?path,_,_)) {
+ print_path(s, path);
+ }
+ case (ast.expr_fail) {
+ wrd(s, "fail");
+ }
+ case (ast.expr_ret(?result)) {
+ wrd(s, "ret");
+ alt (result) {
+ case (option.some[@ast.expr](?expr)) {
+ space(s);
+ print_expr(s, expr);
+ }
+ case (_) {}
+ }
+ }
+ case (ast.expr_put(?result)) {
+ wrd(s, "put");
+ alt (result) {
+ case (option.some[@ast.expr](?expr)) {
+ space(s);
+ print_expr(s, expr);
+ }
+ case (_) {}
+ }
+ }
+ case (ast.expr_be(?result)) {
+ wrd1(s, "be");
+ print_expr(s, result);
+ }
+ case (ast.expr_log(?expr)) {
+ wrd1(s, "log");
+ print_expr(s, expr);
+ }
+ case (ast.expr_check_expr(?expr)) {
+ wrd1(s, "check");
+ print_expr(s, expr);
+ }
+ case (_) {wrd(s, "X");}
+ // TODO expr_ext(path, vec[@expr], option.t[@expr], @expr, ann);
+ }
+ end(s);
+}
+
+impure fn print_decl(ps s, @ast.decl decl) {
+ hbox(s);
+ alt (decl.node) {
+ case (ast.decl_local(?loc)) {
+ alt (loc.ty) {
+ case (option.some[@ast.ty](?ty)) {
+ wrd1(s, "let");
+ print_type(s, ty);
+ space(s);
+ }
+ case (_) {
+ wrd1(s, "auto");
+ }
+ }
+ wrd(s, loc.ident);
+ alt (loc.init) {
+ case (option.some[@ast.expr](?init)) {
+ space(s);
+ wrd1(s, "=");
+ print_expr(s, init);
+ }
+ case (_) {}
+ }
+ }
+ case (ast.decl_item(?item)) {
+ print_item(s, item);
+ }
+ }
+ end(s);
+}
+
+impure fn print_path(ps s, ast.path path) {
+ auto first = true;
+ for (str id in path.node.idents) {
+ if (first) {first = false;}
+ else {wrd(s, ".");}
+ wrd(s, id);
+ }
+ if (_vec.len[@ast.ty](path.node.types) > 0u) {
+ wrd(s, "[");
+ auto f = print_type;
+ commasep[@ast.ty](s, path.node.types, f);
+ wrd(s, "]");
+ }
+}
+
+impure fn print_pat(ps s, @ast.pat pat) {
+ alt (pat.node) {
+ case (ast.pat_wild(_)) {wrd(s, "_");}
+ case (ast.pat_bind(?id,_,_)) {wrd(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) {
+ popen(s);
+ auto f = print_pat;
+ commasep[@ast.pat](s, args, f);
+ pclose(s);
+ }
+ }
+ }
+}
+
+impure fn print_fn(ps s, ast.fn_decl decl, str name,
+ vec[ast.ty_param] typarams) {
+ alt (decl.effect) {
+ case (ast.eff_impure) {wrd1(s, "impure");}
+ case (ast.eff_unsafe) {wrd1(s, "unsafe");}
+ case (_) {}
+ }
+ wrd1(s, "fn");
+ wrd(s, name);
+ print_type_params(s, typarams);
+ popen(s);
+ impure fn print_arg(ps s, ast.arg x) {
+ hbox(s);
+ print_type(s, x.ty);
+ space(s);
+ wrd(s, x.ident);
+ end(s);
+ }
+ auto f = print_arg;
+ commasep[ast.arg](s, decl.inputs, f);
+ pclose(s);
+ if (decl.output.node != ast.ty_nil) {
+ space(s);
+ hbox(s);
+ wrd1(s, "->");
+ print_type(s, decl.output);
+ end(s);
+ }
+}
+
+impure fn print_type_params(ps s, vec[ast.ty_param] params) {
+ if (_vec.len[ast.ty_param](params) > 0u) {
+ wrd(s, "[");
+ impure fn printParam(ps s, ast.ty_param param) {wrd(s, param.ident);}
+ auto f = printParam;
+ commasep[ast.ty_param](s, params, f);
+ wrd(s, "]");
+ }
+}
+
+impure fn print_view_item(ps s, @ast.view_item item) {
+ hbox(s);
+ alt (item.node) {
+ case (ast.view_item_use(?id,?mta,_)) {
+ wrd1(s, "use");
+ wrd(s, id);
+ if (_vec.len[@ast.meta_item](mta) > 0u) {
+ popen(s);
+ impure fn print_meta(ps s, @ast.meta_item item) {
+ hbox(s);
+ wrd1(s, item.node.name);
+ wrd1(s, "=");
+ print_string(s, item.node.value);
+ end(s);
+ }
+ auto f = print_meta;
+ commasep[@ast.meta_item](s, mta, f);
+ pclose(s);
+ }
+ }
+ case (ast.view_item_import(?id,?ids,_,_)) {
+ wrd1(s, "import");
+ if (!_str.eq(id, ids.(_vec.len[str](ids)-1u))) {
+ wrd1(s, id);
+ wrd1(s, "=");
+ }
+ auto first = true;
+ for (str elt in ids) {
+ if (first) {first = false;}
+ else {wrd(s, ".");}
+ wrd(s, elt);
+ }
+ }
+ case (ast.view_item_export(?id)) {
+ wrd1(s, "export");
+ wrd(s, id);
+ }
+ }
+ end(s);
+ wrd(s, ";");
+ line(s);
+}
+
+// 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()) {
+ if (spec.op == op) {ret spec.prec;}
+ }
+ fail;
+}
+
+impure fn print_maybe_parens(ps s, @ast.expr expr, int outer_prec) {
+ auto add_them;
+ alt (expr.node) {
+ case (ast.expr_binary(?op,_,_,_)) {
+ add_them = operator_prec(op) < outer_prec;
+ }
+ case (ast.expr_cast(_,_,_)) {
+ add_them = as_prec < outer_prec;
+ }
+ case (_) {
+ add_them = false;
+ }
+ }
+ if (add_them) {popen(s);}
+ print_expr(s, expr);
+ if (add_them) {pclose(s);}
+}
+
+// TODO non-ascii
+fn escape_str(str st, char to_escape) -> str {
+ let str out = "";
+ auto len = _str.byte_len(st);
+ auto i = 0u;
+ while (i < len) {
+ alt (st.(i) as char) {
+ case ('\n') {out += "\\n";}
+ case ('\t') {out += "\\t";}
+ case ('\r') {out += "\\r";}
+ case ('\\') {out += "\\\\";}
+ case (?cur) {
+ if (cur == to_escape) {out += "\\";}
+ out += cur as u8;
+ }
+ }
+ i += 1u;
+ }
+ ret out;
+}
+
+impure fn print_string(ps s, str st) {
+ wrd(s, "\""); wrd(s, escape_str(st, '"')); wrd(s, "\"");
+}
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index 43a04117680..e483340949e 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -31,6 +31,11 @@ mod driver {
mod session;
}
+mod pretty {
+ mod pp;
+ mod pprust;
+}
+
mod util {
mod common;
}
diff --git a/src/lib/io.rs b/src/lib/io.rs
index 9f428cee349..0c4eb39e1aa 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -91,24 +91,28 @@ tag fileflag {
truncate;
}
+fn writefd(int fd, vec[u8] v) {
+ auto len = _vec.len[u8](v);
+ auto count = 0u;
+ auto vbuf;
+ while (count < len) {
+ vbuf = _vec.buf_off[u8](v, count);
+ auto nout = os.libc.write(fd, vbuf, len);
+ if (nout < 0) {
+ log "error dumping buffer";
+ log sys.rustrt.last_os_error();
+ fail;
+ }
+ count += nout as uint;
+ }
+}
+
fn new_buf_writer(str path, vec[fileflag] flags) -> buf_writer {
state obj fd_buf_writer(int fd) {
fn write(vec[u8] v) {
- auto len = _vec.len[u8](v);
- auto count = 0u;
- auto vbuf;
- while (count < len) {
- vbuf = _vec.buf_off[u8](v, count);
- auto nout = os.libc.write(fd, vbuf, len);
- if (nout < 0) {
- log "error dumping buffer";
- log sys.rustrt.last_os_error();
- fail;
- }
- count += nout as uint;
- }
+ writefd(fd, v);
}
drop {