Have the pretty-printer take a writer stream as argument
It now uses a string writer to also fill in for middle.ty.ast_ty_to_str
This commit is contained in:
parent
dddd7d8f44
commit
aed40fbcd8
6 changed files with 61 additions and 119 deletions
|
@ -66,7 +66,7 @@ impure fn pretty_print_input(session.session sess,
|
|||
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);
|
||||
pretty.pprust.print_ast(crate.node.module, std.io.stdout_writer());
|
||||
}
|
||||
|
||||
fn warn_wrong_compiler() {
|
||||
|
|
|
@ -81,87 +81,10 @@ tag unify_result {
|
|||
|
||||
// Stringification
|
||||
|
||||
fn ast_ty_to_str(&@ast.ty ty) -> str {
|
||||
|
||||
fn ast_fn_input_to_str(&rec(ast.mode mode, @ast.ty ty) input) -> str {
|
||||
auto s;
|
||||
if (mode_is_alias(input.mode)) {
|
||||
s = "&";
|
||||
} else {
|
||||
s = "";
|
||||
}
|
||||
|
||||
ret s + ast_ty_to_str(input.ty);
|
||||
}
|
||||
|
||||
fn ast_ty_field_to_str(&ast.ty_field f) -> str {
|
||||
ret ast_ty_to_str(f.ty) + " " + f.ident;
|
||||
}
|
||||
|
||||
auto s;
|
||||
alt (ty.node) {
|
||||
case (ast.ty_nil) { s = "()"; }
|
||||
case (ast.ty_bool) { s = "bool"; }
|
||||
case (ast.ty_int) { s = "int"; }
|
||||
case (ast.ty_uint) { s = "uint"; }
|
||||
case (ast.ty_machine(?tm)) { s = common.ty_mach_to_str(tm); }
|
||||
case (ast.ty_char) { s = "char"; }
|
||||
case (ast.ty_str) { s = "str"; }
|
||||
case (ast.ty_box(?t)) { s = "@" + ast_ty_to_str(t); }
|
||||
case (ast.ty_vec(?t)) { s = "vec[" + ast_ty_to_str(t) + "]"; }
|
||||
case (ast.ty_type) { s = "type"; }
|
||||
|
||||
case (ast.ty_tup(?elts)) {
|
||||
auto f = ast_ty_to_str;
|
||||
s = "tup(";
|
||||
s += _str.connect(_vec.map[@ast.ty,str](f, elts), ",");
|
||||
s += ")";
|
||||
}
|
||||
|
||||
case (ast.ty_rec(?fields)) {
|
||||
auto f = ast_ty_field_to_str;
|
||||
s = "rec(";
|
||||
s += _str.connect(_vec.map[ast.ty_field,str](f, fields), ",");
|
||||
s += ")";
|
||||
}
|
||||
|
||||
case (ast.ty_fn(?proto, ?inputs, ?output)) {
|
||||
auto f = ast_fn_input_to_str;
|
||||
if (proto == ast.proto_fn) {
|
||||
s = "fn(";
|
||||
} else {
|
||||
s = "iter(";
|
||||
}
|
||||
auto is = _vec.map[rec(ast.mode mode, @ast.ty ty),str](f, inputs);
|
||||
s += _str.connect(is, ", ");
|
||||
s += ")";
|
||||
|
||||
if (output.node != ast.ty_nil) {
|
||||
s += " -> " + ast_ty_to_str(output);
|
||||
}
|
||||
}
|
||||
|
||||
case (ast.ty_path(?path, _)) {
|
||||
s = path_to_str(path);
|
||||
}
|
||||
|
||||
case (ast.ty_mutable(?t)) {
|
||||
s = "mutable " + ast_ty_to_str(t);
|
||||
}
|
||||
|
||||
|
||||
case (_) {
|
||||
fail; // FIXME: typestate bug
|
||||
}
|
||||
}
|
||||
|
||||
ret s;
|
||||
}
|
||||
|
||||
fn path_to_str(&ast.path pth) -> str {
|
||||
auto result = _str.connect(pth.node.idents, ".");
|
||||
if (_vec.len[@ast.ty](pth.node.types) > 0u) {
|
||||
auto f = ast_ty_to_str;
|
||||
auto f = pretty.pprust.ty_to_str;
|
||||
result += "[";
|
||||
result += _str.connect(_vec.map[@ast.ty,str](f, pth.node.types), ",");
|
||||
result += "]";
|
||||
|
@ -169,8 +92,6 @@ 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 {
|
||||
|
|
|
@ -17,17 +17,19 @@ type context = rec(contexttype tp, uint indent);
|
|||
|
||||
type ps = @rec(mutable vec[context] context,
|
||||
uint width,
|
||||
io.writer out,
|
||||
mutable vec[token] buffered,
|
||||
mutable uint scandepth,
|
||||
mutable uint bufferedcol,
|
||||
mutable uint col,
|
||||
mutable bool start_of_line);
|
||||
|
||||
fn mkstate(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();
|
||||
ret @rec(mutable context=stack,
|
||||
width=width,
|
||||
out=out,
|
||||
mutable buffered=buff,
|
||||
mutable scandepth=0u,
|
||||
mutable bufferedcol=0u,
|
||||
|
@ -46,10 +48,22 @@ impure fn pop_context(ps p) {
|
|||
}
|
||||
|
||||
impure fn add_token(ps p, token tok) {
|
||||
if (p.scandepth == 0u) {do_token(p, tok);}
|
||||
if (p.width == 0u) {direct_token(p, tok);}
|
||||
else if (p.scandepth == 0u) {do_token(p, tok);}
|
||||
else {buffer_token(p, tok);}
|
||||
}
|
||||
|
||||
impure fn direct_token(ps p, token tok) {
|
||||
alt (tok) {
|
||||
case (brk(?sz)) {
|
||||
while (sz > 0u) {p.out.write_str(" "); sz -= 1u;}
|
||||
}
|
||||
case (word(?w)) {p.out.write_str(w);}
|
||||
case (cword(?w)) {p.out.write_str(w);}
|
||||
case (_) {}
|
||||
}
|
||||
}
|
||||
|
||||
impure fn buffer_token(ps p, token tok) {
|
||||
p.buffered += vec(tok);
|
||||
p.bufferedcol += token_size(tok);
|
||||
|
@ -101,14 +115,13 @@ impure fn finish_block_scan(ps p, contexttype tp) {
|
|||
|
||||
impure fn finish_break_scan(ps p) {
|
||||
if (p.bufferedcol > p.width) {
|
||||
write_str("\n");
|
||||
p.col = 0u;
|
||||
line_break(p);
|
||||
}
|
||||
else {
|
||||
auto width;
|
||||
alt (p.buffered.(0)) {case(brk(?w)) {width = w;}}
|
||||
auto i = 0u;
|
||||
while (i < width) {write_str(" "); i+=1u;}
|
||||
while (i < width) {p.out.write_str(" "); i+=1u;}
|
||||
p.col += width;
|
||||
}
|
||||
p.scandepth = 0u;
|
||||
|
@ -142,20 +155,18 @@ impure fn do_token(ps p, token tok) {
|
|||
start_scan(p, tok);
|
||||
}
|
||||
case (cx_v) {
|
||||
write_str("\n");
|
||||
p.col = 0u;
|
||||
p.start_of_line = true;
|
||||
line_break(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
case (word(?w)) {
|
||||
before_print(p, false);
|
||||
write_str(w);
|
||||
p.out.write_str(w);
|
||||
p.col += _str.byte_len(w); // TODO char_len
|
||||
}
|
||||
case (cword(?w)) {
|
||||
before_print(p, true);
|
||||
write_str(w);
|
||||
p.out.write_str(w);
|
||||
p.col += _str.byte_len(w); // TODO char_len
|
||||
}
|
||||
case (open(?tp, ?indent)) {
|
||||
|
@ -170,6 +181,12 @@ impure fn do_token(ps p, token tok) {
|
|||
}
|
||||
}
|
||||
|
||||
impure fn line_break(ps p) {
|
||||
p.out.write_str("\n");
|
||||
p.col = 0u;
|
||||
p.start_of_line = true;
|
||||
}
|
||||
|
||||
impure fn before_print(ps p, bool closing) {
|
||||
if (p.start_of_line) {
|
||||
p.start_of_line = false;
|
||||
|
@ -177,14 +194,10 @@ impure fn before_print(ps p, bool closing) {
|
|||
if (closing) {ind = base_indent(p);}
|
||||
else {ind = cur_context(p).indent;}
|
||||
p.col = ind;
|
||||
while (ind > 0u) {write_str(" "); ind -= 1u;}
|
||||
while (ind > 0u) {p.out.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;}
|
||||
|
|
|
@ -11,13 +11,19 @@ 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);
|
||||
impure fn print_ast(ast._mod _mod, std.io.writer out) {
|
||||
auto s = pp.mkstate(out, 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);}
|
||||
}
|
||||
|
||||
fn ty_to_str(&@ast.ty ty) -> str {
|
||||
auto writer = std.io.string_writer();
|
||||
print_type(pp.mkstate(writer.get_writer(), 0u), ty);
|
||||
ret writer.get_str();
|
||||
}
|
||||
|
||||
impure fn hbox(ps s) {
|
||||
pp.hbox(s, indent_unit);
|
||||
}
|
||||
|
|
|
@ -44,6 +44,7 @@ auth middle.trans = unsafe;
|
|||
auth middle.trans.copy_args_to_allocas = impure;
|
||||
auth middle.trans.trans_block = impure;
|
||||
auth lib.llvm = unsafe;
|
||||
auth pretty.pprust = impure;
|
||||
|
||||
mod lib {
|
||||
alt (target_os) {
|
||||
|
|
|
@ -91,26 +91,21 @@ tag fileflag {
|
|||
truncate;
|
||||
}
|
||||
|
||||
// FIXME move into fd_buf_writer
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
state obj fd_buf_writer(int fd, bool must_close) {
|
||||
fn write(vec[u8] v) {
|
||||
writefd(fd, 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;
|
||||
}
|
||||
}
|
||||
|
||||
drop {
|
||||
|
@ -152,9 +147,15 @@ type writer =
|
|||
};
|
||||
|
||||
state obj new_writer(buf_writer out) {
|
||||
impure fn write_str(str s) { out.write(_str.bytes(s)); }
|
||||
impure fn write_int(int n) { out.write(_str.bytes(_int.to_str(n, 10u))); }
|
||||
impure fn write_uint(uint n) { out.write(_str.bytes(_uint.to_str(n, 10u))); }
|
||||
impure fn write_str(str s) {
|
||||
out.write(_str.bytes(s));
|
||||
}
|
||||
impure fn write_int(int n) {
|
||||
out.write(_str.bytes(_int.to_str(n, 10u)));
|
||||
}
|
||||
impure fn write_uint(uint n) {
|
||||
out.write(_str.bytes(_uint.to_str(n, 10u)));
|
||||
}
|
||||
}
|
||||
|
||||
fn file_writer(str path, vec[fileflag] flags) -> writer {
|
||||
|
|
Loading…
Reference in a new issue