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

Author: marijnh

src/comp/driver/rustc.rs

@@ -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() {

src/comp/middle/ty.rs

@@ -81,96 +81,17 @@ 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 += "]";
     }
     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 {

src/comp/pretty/pp.rs

@@ -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,21 +181,23 @@ 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;
     auto ind;
     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;}

src/comp/pretty/pprust.rs

@@ -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);
 }

src/comp/rustc.rc

@@ -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) {

src/lib/io.rs

@@ -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 {