diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index 562b029dfe8e..47168a3dd8c5 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -13,7 +13,7 @@ import option::none;
import std::sha1::sha1;
import std::sort;
import trans::crate_ctxt;
-import front::ast;
+import syntax::ast;
import lib::llvm::llvm::ModuleRef;
import lib::llvm::llvm::ValueRef;
import lib::llvm::mk_pass_manager;
@@ -436,7 +436,7 @@ fn mangle_exported_name(&@crate_ctxt ccx, &vec[str] path, &ty::t t) -> str {
fn mangle_internal_name_by_type_only(&@crate_ctxt ccx, &ty::t t, &str name) ->
str {
- auto s = pretty::ppaux::ty_to_short_str(ccx.tcx, t);
+ auto s = util::ppaux::ty_to_short_str(ccx.tcx, t);
auto hash = get_symbol_hash(ccx, t);
ret mangle([name, s, hash]);
}
diff --git a/src/comp/back/x86.rs b/src/comp/back/x86.rs
index 6a0872734ff0..018c99e153a7 100644
--- a/src/comp/back/x86.rs
+++ b/src/comp/back/x86.rs
@@ -4,7 +4,7 @@ import lib::llvm::llvm::ModuleRef;
import std::str;
import std::vec;
import std::os::target_os;
-import util::common::istr;
+import syntax::_std::istr;
fn get_module_asm() -> str { ret ""; }
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 10f374d2392f..9ad42103a901 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -2,19 +2,19 @@
// -*- rust -*-
import metadata::creader;
-import front::parser;
-import front::token;
-import front::eval;
-import front::ast;
+import syntax::parse::parser;
+import syntax::parse::token;
+import syntax::ast;
+import syntax::codemap;
import front::attr;
import middle::trans;
import middle::resolve;
import middle::ty;
import middle::typeck;
import middle::tstate::ck;
-import pretty::pp;
-import pretty::pprust;
-import pretty::ppaux;
+import syntax::print::pp;
+import syntax::print::pprust;
+import util::ppaux;
import back::link;
import lib::llvm;
import util::common;
@@ -76,12 +76,14 @@ fn parse_cfgspecs(&vec[str] cfgspecs) -> ast::crate_cfg {
ret vec::map(to_meta_word, cfgspecs);
}
-fn parse_input(session::session sess, parser::parser p, str input) ->
- @ast::crate {
+fn parse_input(session::session sess, &ast::crate_cfg cfg, str input)
+ -> @ast::crate {
ret if (str::ends_with(input, ".rc")) {
- parser::parse_crate_from_crate_file(p)
+ parser::parse_crate_from_crate_file
+ (input, cfg, sess.get_codemap())
} else if (str::ends_with(input, ".rs")) {
- parser::parse_crate_from_source_file(p)
+ parser::parse_crate_from_source_file
+ (input, cfg, sess.get_codemap())
} else { sess.fatal("unknown input file type: " + input); fail };
}
@@ -99,9 +101,8 @@ fn time[T](bool do_it, str what, fn() -> T thunk) -> T {
fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
str output) {
auto time_passes = sess.get_opts().time_passes;
- auto p = parser::new_parser(sess, cfg, input, 0u, 0);
auto crate =
- time(time_passes, "parsing", bind parse_input(sess, p, input));
+ time(time_passes, "parsing", bind parse_input(sess, cfg, input));
if (sess.get_opts().output_type == link::output_type_none) { ret; }
crate = time(time_passes, "configuration",
bind front::config::strip_unconfigured_items(crate));
@@ -129,17 +130,17 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
str input, pp_mode ppm) {
- fn ann_paren_for_expr(&ppaux::ann_node node) {
+ fn ann_paren_for_expr(&pprust::ann_node node) {
alt (node) {
- case (ppaux::node_expr(?s, ?expr)) {
+ case (pprust::node_expr(?s, ?expr)) {
pprust::popen(s);
}
case (_) {}
}
}
- fn ann_typed_post(&ty::ctxt tcx, &ppaux::ann_node node) {
+ fn ann_typed_post(&ty::ctxt tcx, &pprust::ann_node node) {
alt (node) {
- case (ppaux::node_expr(?s, ?expr)) {
+ case (pprust::node_expr(?s, ?expr)) {
pp::space(s.s);
pp::word(s.s, "as");
pp::space(s.s);
@@ -149,18 +150,18 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
case (_) {}
}
}
- fn ann_identified_post(&ppaux::ann_node node) {
+ fn ann_identified_post(&pprust::ann_node node) {
alt (node) {
- case (ppaux::node_item(?s, ?item)) {
+ case (pprust::node_item(?s, ?item)) {
pp::space(s.s);
pprust::synth_comment(s, int::to_str(item.id, 10u));
}
- case (ppaux::node_block(?s, ?blk)) {
+ case (pprust::node_block(?s, ?blk)) {
pp::space(s.s);
pprust::synth_comment(s, "block " +
int::to_str(blk.node.id, 10u));
}
- case (ppaux::node_expr(?s, ?expr)) {
+ case (pprust::node_expr(?s, ?expr)) {
pp::space(s.s);
pprust::synth_comment(s, int::to_str(expr.id, 10u));
pprust::pclose(s);
@@ -169,8 +170,7 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
}
}
- auto p = front::parser::new_parser(sess, cfg, input, 0u, 0);
- auto crate = parse_input(sess, p, input);
+ auto crate = parse_input(sess, cfg, input);
auto ann;
alt (ppm) {
case (ppm_typed) {
@@ -186,10 +186,11 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
post=ann_identified_post);
}
case (ppm_normal) {
- ann = ppaux::no_ann();
+ ann = pprust::no_ann();
}
}
- pprust::print_crate(sess, crate, input, std::io::stdout(), ann);
+ pprust::print_crate(sess.get_codemap(), crate, input,
+ std::io::stdout(), ann);
}
fn version(str argv0) {
@@ -268,9 +269,9 @@ fn build_target_config() -> @session::config {
let @session::config target_cfg =
@rec(os=get_os(triple),
arch=get_arch(triple),
- int_type=common::ty_i32,
- uint_type=common::ty_u32,
- float_type=common::ty_f64);
+ int_type=ast::ty_i32,
+ uint_type=ast::ty_u32,
+ float_type=ast::ty_f64);
ret target_cfg;
}
@@ -342,11 +343,11 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
fn build_session(@session::options sopts) -> session::session {
auto target_cfg = build_target_config();
- auto crate_cache = common::new_int_hash[session::crate_metadata]();
+ auto crate_cache = syntax::_std::new_int_hash[session::crate_metadata]();
auto target_crate_num = 0;
auto sess =
session::session(target_crate_num, target_cfg, sopts, crate_cache, [],
- [], [], front::codemap::new_codemap(), 0u);
+ [], [], codemap::new_codemap(), 0u);
ret sess;
}
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index 8d296f355ae5..8ef558f2fdeb 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -1,10 +1,9 @@
-import front::ast;
-import front::codemap;
-import util::common::span;
-import util::common::ty_mach;
+import syntax::ast;
+import syntax::codemap;
+import codemap::span;
+import syntax::ast::ty_mach;
import std::uint;
-import std::term;
import std::io;
import std::map;
import std::option;
@@ -42,30 +41,6 @@ type options =
type crate_metadata = rec(str name, vec[u8] data);
-fn span_to_str(span sp, codemap::codemap cm) -> str {
- auto lo = codemap::lookup_pos(cm, sp.lo);
- auto hi = codemap::lookup_pos(cm, sp.hi);
- ret #fmt("%s:%u:%u:%u:%u", lo.filename, lo.line, lo.col, hi.line, hi.col);
-}
-
-fn emit_diagnostic(option::t[span] sp, str msg, str kind, u8 color,
- codemap::codemap cm) {
- auto ss = ":0:0:0:0";
- alt (sp) {
- case (some(?ssp)) { ss = span_to_str(ssp, cm); }
- case (none) { }
- }
- io::stdout().write_str(ss + ": ");
- if (term::color_supported()) {
- term::fg(io::stdout().get_buf_writer(), color);
- }
- io::stdout().write_str(#fmt("%s:", kind));
- if (term::color_supported()) {
- term::reset(io::stdout().get_buf_writer());
- }
- io::stdout().write_str(#fmt(" %s\n", msg));
-}
-
obj session(ast::crate_num cnum,
@config targ_cfg,
@options opts,
@@ -80,20 +55,19 @@ obj session(ast::crate_num cnum,
fn get_targ_crate_num() -> ast::crate_num { ret cnum; }
fn span_fatal(span sp, str msg) -> ! {
// FIXME: Use constants, but rustboot doesn't know how to export them.
-
- emit_diagnostic(some(sp), msg, "error", 9u8, cm);
+ codemap::emit_error(some(sp), msg, cm);
fail;
}
fn fatal(str msg) -> ! {
- emit_diagnostic(none[span], msg, "error", 9u8, cm);
+ codemap::emit_error(none, msg, cm);
fail;
}
fn span_err(span sp, str msg) {
- emit_diagnostic(some(sp), msg, "error", 9u8, cm);
+ codemap::emit_error(some(sp), msg, cm);
err_count += 1u;
}
fn err(str msg) {
- emit_diagnostic(none, msg, "error", 9u8, cm);
+ codemap::emit_error(none, msg, cm);
err_count += 1u;
}
fn abort_if_errors() {
@@ -103,19 +77,17 @@ obj session(ast::crate_num cnum,
}
fn span_warn(span sp, str msg) {
// FIXME: Use constants, but rustboot doesn't know how to export them.
-
- emit_diagnostic(some(sp), msg, "warning", 11u8, cm);
+ codemap::emit_warning(some(sp), msg, cm);
}
fn warn(str msg) {
- emit_diagnostic(none[span], msg, "warning", 11u8, cm);
+ codemap::emit_warning(none, msg, cm);
}
fn span_note(span sp, str msg) {
// FIXME: Use constants, but rustboot doesn't know how to export them.
-
- emit_diagnostic(some(sp), msg, "note", 10u8, cm);
+ codemap::emit_note(some(sp), msg, cm);
}
fn note(str msg) {
- emit_diagnostic(none, msg, "note", 10u8, cm);
+ codemap::emit_note(none, msg, cm);
}
fn span_bug(span sp, str msg) -> ! {
self.span_fatal(sp, #fmt("internal compiler error %s", msg));
@@ -172,7 +144,9 @@ obj session(ast::crate_num cnum,
fn lookup_pos(uint pos) -> codemap::loc {
ret codemap::lookup_pos(cm, pos);
}
- fn span_str(span sp) -> str { ret span_to_str(sp, self.get_codemap()); }
+ fn span_str(span sp) -> str {
+ ret codemap::span_to_str(sp, self.get_codemap());
+ }
}
// Local Variables:
// fill-column: 78;
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index 1312851c5f01..00e64e33f6bb 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -2,7 +2,7 @@
import std::vec;
import std::option;
-import front::ast;
+import syntax::ast;
import util::common;
export attr_metas;
@@ -105,9 +105,11 @@ fn eq(@ast::meta_item a, @ast::meta_item b) -> bool {
}
fn contains(&vec[@ast::meta_item] haystack, @ast::meta_item needle) -> bool {
- log #fmt("looking for %s", pretty::pprust::meta_item_to_str(*needle));
+ log #fmt("looking for %s",
+ syntax::print::pprust::meta_item_to_str(*needle));
for (@ast::meta_item item in haystack) {
- log #fmt("looking in %s", pretty::pprust::meta_item_to_str(*item));
+ log #fmt("looking in %s",
+ syntax::print::pprust::meta_item_to_str(*item));
if (eq(item, needle)) {
log "found it!";
ret true;
@@ -166,7 +168,7 @@ fn remove_meta_items_by_name(&vec[@ast::meta_item] items,
ret vec::filter_map(filter, items);
}
-fn span[T](&T item) -> common::spanned[T] {
+fn span[T](&T item) -> ast::spanned[T] {
ret rec(node=item, span=rec(lo=0u, hi=0u));
}
diff --git a/src/comp/front/codemap.rs b/src/comp/front/codemap.rs
deleted file mode 100644
index 3e1aa3c59400..000000000000
--- a/src/comp/front/codemap.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-
-import std::vec;
-
-
-/* A codemap is a thing that maps uints to file/line/column positions
- * in a crate. This to make it possible to represent the positions
- * with single-word things, rather than passing records all over the
- * compiler.
- */
-type filemap = @rec(str name, uint start_pos, mutable vec[uint] lines);
-
-type codemap = @rec(mutable vec[filemap] files);
-
-type loc = rec(str filename, uint line, uint col);
-
-fn new_codemap() -> codemap {
- let vec[filemap] files = [];
- ret @rec(mutable files=files);
-}
-
-fn new_filemap(str filename, uint start_pos) -> filemap {
- ret @rec(name=filename, start_pos=start_pos, mutable lines=[0u]);
-}
-
-fn next_line(filemap file, uint pos) { vec::push[uint](file.lines, pos); }
-
-fn lookup_pos(codemap map, uint pos) -> loc {
- auto a = 0u;
- auto b = vec::len[filemap](map.files);
- while (b - a > 1u) {
- auto m = (a + b) / 2u;
- if (map.files.(m).start_pos > pos) { b = m; } else { a = m; }
- }
- auto f = map.files.(a);
- a = 0u;
- b = vec::len[uint](f.lines);
- while (b - a > 1u) {
- auto m = (a + b) / 2u;
- if (f.lines.(m) > pos) { b = m; } else { a = m; }
- }
- ret rec(filename=f.name, line=a + 1u, col=pos - f.lines.(a));
-}
-//
-// Local Variables:
-// mode: rust
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
-// End:
-//
diff --git a/src/comp/front/config.rs b/src/comp/front/config.rs
index bbfc90015723..63646ffca69d 100644
--- a/src/comp/front/config.rs
+++ b/src/comp/front/config.rs
@@ -1,7 +1,7 @@
import std::option;
import std::vec;
-import ast;
-import fold;
+import syntax::ast;
+import syntax::fold;
import attr;
export strip_unconfigured_items;
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 1cbd4c0a98ce..8a9c5aa58570 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1457,7 +1457,7 @@ state obj type_names(std::map::hashmap[TypeRef, str] type_names,
}
fn mk_type_names() -> type_names {
- auto nt = util::common::new_str_hash[TypeRef]();
+ auto nt = syntax::_std::new_str_hash[TypeRef]();
fn hash(&TypeRef t) -> uint {
ret t as uint;
@@ -1519,7 +1519,7 @@ fn type_to_str_inner(type_names names,
case (6) { ret "Label"; }
case (7) {
- ret "i" + util::common::istr(llvm::LLVMGetIntTypeWidth(ty)
+ ret "i" + syntax::_std::istr(llvm::LLVMGetIntTypeWidth(ty)
as int);
}
@@ -1558,7 +1558,7 @@ fn type_to_str_inner(type_names names,
i += 1u;
if (tout as int == ty as int) {
let uint n = vec::len[TypeRef](outer0) - i;
- ret "*\\" + util::common::istr(n as int);
+ ret "*\\" + syntax::_std::istr(n as int);
}
}
ret "*" + type_to_str_inner(names, outer,
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index 5e9cf52a2829..5ef08cfd02d0 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -1,14 +1,15 @@
// Extracting metadata from crate files
import driver::session;
-import front::ast;
+import syntax::ast;
import lib::llvm::False;
import lib::llvm::llvm;
import lib::llvm::mk_object_file;
import lib::llvm::mk_section_iter;
import front::attr;
import middle::resolve;
-import middle::walk;
+import syntax::walk;
+import syntax::codemap::span;
import back::x86;
import util::common;
import std::str;
@@ -20,7 +21,7 @@ import std::option;
import std::option::none;
import std::option::some;
import std::map::hashmap;
-import pretty::pprust;
+import syntax::print::pprust;
import tags::*;
export read_crates;
@@ -129,7 +130,7 @@ fn get_metadata_section(str filename) -> option::t[vec[u8]] {
ret option::none[vec[u8]];
}
-fn load_library_crate(&session::session sess, common::span span, int cnum,
+fn load_library_crate(&session::session sess, span span, int cnum,
&ast::ident ident, vec[@ast::meta_item] metas,
&vec[str] library_search_paths) {
alt (find_library_crate(sess, ident, metas, library_search_paths)) {
@@ -202,7 +203,7 @@ fn read_crates(session::session sess, resolve::crate_map crate_map,
auto e =
@rec(sess=sess,
crate_map=crate_map,
- crate_cache=@common::new_str_hash[int](),
+ crate_cache=@syntax::_std::new_str_hash[int](),
library_search_paths=sess.get_opts().library_search_paths,
mutable next_crate_num=1);
auto v =
diff --git a/src/comp/metadata/cwriter.rs b/src/comp/metadata/cwriter.rs
index 9956a46c828c..3c1875d07d4b 100644
--- a/src/comp/metadata/cwriter.rs
+++ b/src/comp/metadata/cwriter.rs
@@ -2,7 +2,7 @@
import std::str;
import middle::trans;
-import front::ast::crate;
+import syntax::ast::crate;
import back::x86;
import lib::llvm::llvm;
import lib::llvm::llvm::ValueRef;
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index 0eda4bbf5af6..14d4035185f0 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -6,7 +6,7 @@ import std::vec;
import std::str;
import std::io;
import std::map::hashmap;
-import front::ast;
+import syntax::ast;
import front::attr;
import middle::ty;
import tags::*;
@@ -14,7 +14,7 @@ import tydecode::parse_def_id;
import tydecode::parse_ty_data;
import driver::session;
import util::common;
-import pretty::pprust;
+import syntax::print::pprust;
export get_symbol;
export get_tag_variants;
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index c867f483dd34..4526e515f798 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -8,7 +8,7 @@ import std::option;
import std::option::some;
import std::option::none;
import std::ebml;
-import front::ast::*;
+import syntax::ast::*;
import tags::*;
import middle::trans::crate_ctxt;
import middle::trans::node_id_type;
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index d0ef42f4d14d..b40a84ec3055 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -6,12 +6,9 @@ import std::uint;
import std::option;
import std::option::none;
import std::option::some;
-import front::ast;
+import syntax::ast;
+import ast::respan;
import middle::ty;
-import util::common;
-import util::common::respan;
-import util::common::a_ty;
-import util::common::a_bang;
export parse_def_id;
export parse_ty_data;
@@ -26,7 +23,7 @@ type str_def = fn(str) -> ast::def_id ;
type pstate =
rec(vec[u8] data, int crate, mutable uint pos, uint len, ty::ctxt tcx);
-type ty_or_bang = util::common::ty_or_bang[ty::t];
+tag ty_or_bang { a_ty(ty::t); a_bang; }
fn peek(@pstate st) -> u8 { ret st.data.(st.pos); }
@@ -63,8 +60,8 @@ fn parse_ty_data(vec[u8] data, int crate_num, uint pos, uint len, str_def sd,
fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
alt (peek(st) as char) {
- case ('!') { next(st); ret a_bang[ty::t]; }
- case (_) { ret a_ty[ty::t](parse_ty(st, sd)); }
+ case ('!') { next(st); ret a_bang; }
+ case (_) { ret a_ty(parse_ty(st, sd)); }
}
}
@@ -154,16 +151,16 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
case ('l') { ret ty::mk_float(st.tcx); }
case ('M') {
alt (next(st) as char) {
- case ('b') { ret ty::mk_mach(st.tcx, common::ty_u8); }
- case ('w') { ret ty::mk_mach(st.tcx, common::ty_u16); }
- case ('l') { ret ty::mk_mach(st.tcx, common::ty_u32); }
- case ('d') { ret ty::mk_mach(st.tcx, common::ty_u64); }
- case ('B') { ret ty::mk_mach(st.tcx, common::ty_i8); }
- case ('W') { ret ty::mk_mach(st.tcx, common::ty_i16); }
- case ('L') { ret ty::mk_mach(st.tcx, common::ty_i32); }
- case ('D') { ret ty::mk_mach(st.tcx, common::ty_i64); }
- case ('f') { ret ty::mk_mach(st.tcx, common::ty_f32); }
- case ('F') { ret ty::mk_mach(st.tcx, common::ty_f64); }
+ case ('b') { ret ty::mk_mach(st.tcx, ast::ty_u8); }
+ case ('w') { ret ty::mk_mach(st.tcx, ast::ty_u16); }
+ case ('l') { ret ty::mk_mach(st.tcx, ast::ty_u32); }
+ case ('d') { ret ty::mk_mach(st.tcx, ast::ty_u64); }
+ case ('B') { ret ty::mk_mach(st.tcx, ast::ty_i8); }
+ case ('W') { ret ty::mk_mach(st.tcx, ast::ty_i16); }
+ case ('L') { ret ty::mk_mach(st.tcx, ast::ty_i32); }
+ case ('D') { ret ty::mk_mach(st.tcx, ast::ty_i64); }
+ case ('f') { ret ty::mk_mach(st.tcx, ast::ty_f32); }
+ case ('F') { ret ty::mk_mach(st.tcx, ast::ty_f64); }
}
}
case ('c') { ret ty::mk_char(st.tcx); }
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index a9090c3624c1..af7f3f67118c 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/src/comp/metadata/tyencode.rs
@@ -5,9 +5,9 @@ import std::map::hashmap;
import std::option::some;
import std::option::none;
import std::uint;
-import front::ast::*;
+import syntax::ast::*;
import middle::ty;
-import pretty::ppaux::lit_to_str;
+import syntax::print::pprust::lit_to_str;
import util::common;
export ctxt;
@@ -105,16 +105,16 @@ fn enc_sty(&io::writer w, &@ctxt cx, &ty::sty st) {
case (ty::ty_float) { w.write_char('l'); }
case (ty::ty_machine(?mach)) {
alt (mach) {
- case (common::ty_u8) { w.write_str("Mb"); }
- case (common::ty_u16) { w.write_str("Mw"); }
- case (common::ty_u32) { w.write_str("Ml"); }
- case (common::ty_u64) { w.write_str("Md"); }
- case (common::ty_i8) { w.write_str("MB"); }
- case (common::ty_i16) { w.write_str("MW"); }
- case (common::ty_i32) { w.write_str("ML"); }
- case (common::ty_i64) { w.write_str("MD"); }
- case (common::ty_f32) { w.write_str("Mf"); }
- case (common::ty_f64) { w.write_str("MF"); }
+ case (ty_u8) { w.write_str("Mb"); }
+ case (ty_u16) { w.write_str("Mw"); }
+ case (ty_u32) { w.write_str("Ml"); }
+ case (ty_u64) { w.write_str("Md"); }
+ case (ty_i8) { w.write_str("MB"); }
+ case (ty_i16) { w.write_str("MW"); }
+ case (ty_i32) { w.write_str("ML"); }
+ case (ty_i64) { w.write_str("MD"); }
+ case (ty_f32) { w.write_str("Mf"); }
+ case (ty_f64) { w.write_str("MF"); }
}
}
case (ty::ty_char) { w.write_char('c'); }
@@ -182,7 +182,7 @@ fn enc_sty(&io::writer w, &@ctxt cx, &ty::sty st) {
}
case (ty::ty_var(?id)) {
w.write_char('X');
- w.write_str(common::istr(id));
+ w.write_str(syntax::_std::istr(id));
}
case (ty::ty_native(?def)) {
w.write_char('E');
@@ -191,7 +191,7 @@ fn enc_sty(&io::writer w, &@ctxt cx, &ty::sty st) {
}
case (ty::ty_param(?id)) {
w.write_char('p');
- w.write_str(common::uistr(id));
+ w.write_str(syntax::_std::uistr(id));
}
case (ty::ty_type) { w.write_char('Y'); }
case (ty::ty_task) { w.write_char('a'); }
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index 3c482cc252e7..e419426c9691 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -1,10 +1,11 @@
-import front::ast;
-import front::ast::ident;
-import front::ast::fn_ident;
-import front::ast::node_id;
-import front::ast::def_id;
-import util::common::span;
+import syntax::ast;
+import ast::ident;
+import ast::fn_ident;
+import ast::node_id;
+import ast::def_id;
+import syntax::codemap::span;
+import syntax::visit;
import visit::vt;
import std::vec;
import std::str;
@@ -44,7 +45,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
// Stores information about object fields and function
// arguments that's otherwise not easily available.
- local_map=util::common::new_int_hash());
+ local_map=syntax::_std::new_int_hash());
auto v =
@rec(visit_fn=bind visit_fn(cx, _, _, _, _, _, _, _),
visit_item=bind visit_item(cx, _, _, _),
@@ -348,7 +349,7 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
case (ty::ty_istr) { /* no-op */ }
case (_) {
cx.tcx.sess.span_unimpl(seq.span, "unknown seq type " +
- pretty::ppaux::ty_to_str(*cx.tcx, seq_t));
+ util::ppaux::ty_to_str(*cx.tcx, seq_t));
}
}
auto new_sc =
diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs
index eeee41493458..9b19e6a9970d 100644
--- a/src/comp/middle/ast_map.rs
+++ b/src/comp/middle/ast_map.rs
@@ -1,6 +1,7 @@
import std::smallintmap;
import std::option;
-import front::ast::*;
+import syntax::ast::*;
+import syntax::visit;
import visit::vt;
tag ast_node {
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 0fdf92192461..2e3ed8129005 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -1,21 +1,22 @@
-import front::ast;
-import front::ast::ident;
-import front::ast::fn_ident;
-import front::ast::def;
-import front::ast::def_id;
-import front::ast::node_id;
-import front::ast::local_def;
+import syntax::ast;
+import ast::ident;
+import ast::fn_ident;
+import ast::def;
+import ast::def_id;
+import ast::node_id;
+import ast::local_def;
import metadata::creader;
import metadata::decoder;
import driver::session::session;
import util::common::new_def_hash;
-import util::common::new_int_hash;
-import util::common::new_str_hash;
-import util::common::span;
-import util::common::respan;
+import syntax::_std::new_int_hash;
+import syntax::_std::new_str_hash;
+import syntax::codemap::span;
+import syntax::ast::respan;
import middle::ty::constr_table;
+import syntax::visit;
import visit::vt;
import std::map::hashmap;
import std::list;
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index d05f65d5fd7d..f2c00abd6f10 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -24,7 +24,8 @@ import std::option;
import std::option::some;
import std::option::none;
import std::fs;
-import front::ast;
+import syntax::ast;
+import syntax::walk;
import driver::session;
import middle::ty;
import back::link;
@@ -32,14 +33,15 @@ import back::x86;
import back::abi;
import back::upcall;
import middle::ty::pat_ty;
+import syntax::visit;
import visit::vt;
import util::common;
-import util::common::istr;
+import syntax::_std::istr;
import util::common::new_def_hash;
-import util::common::new_int_hash;
-import util::common::new_str_hash;
+import syntax::_std::new_int_hash;
+import syntax::_std::new_str_hash;
import util::common::local_rhs_span;
-import util::common::span;
+import syntax::codemap::span;
import lib::llvm::llvm;
import lib::llvm::builder;
import lib::llvm::target_data;
@@ -65,10 +67,10 @@ import link::mangle_exported_name;
import metadata::tyencode;
import metadata::creader;
import metadata::decoder;
-import pretty::ppaux::ty_to_str;
-import pretty::ppaux::ty_to_short_str;
-import pretty::pprust::expr_to_str;
-import pretty::pprust::path_to_str;
+import util::ppaux::ty_to_str;
+import util::ppaux::ty_to_short_str;
+import syntax::print::pprust::expr_to_str;
+import syntax::print::pprust::path_to_str;
obj namegen(mutable int i) {
fn next(str prefix) -> str { i += 1; ret prefix + istr(i); }
@@ -795,16 +797,16 @@ fn type_of_inner(&@crate_ctxt cx, &span sp, &ty::t t) -> TypeRef {
case (ty::ty_uint) { llty = T_int(); }
case (ty::ty_machine(?tm)) {
alt (tm) {
- case (common::ty_i8) { llty = T_i8(); }
- case (common::ty_u8) { llty = T_i8(); }
- case (common::ty_i16) { llty = T_i16(); }
- case (common::ty_u16) { llty = T_i16(); }
- case (common::ty_i32) { llty = T_i32(); }
- case (common::ty_u32) { llty = T_i32(); }
- case (common::ty_i64) { llty = T_i64(); }
- case (common::ty_u64) { llty = T_i64(); }
- case (common::ty_f32) { llty = T_f32(); }
- case (common::ty_f64) { llty = T_f64(); }
+ case (ast::ty_i8) { llty = T_i8(); }
+ case (ast::ty_u8) { llty = T_i8(); }
+ case (ast::ty_i16) { llty = T_i16(); }
+ case (ast::ty_u16) { llty = T_i16(); }
+ case (ast::ty_i32) { llty = T_i32(); }
+ case (ast::ty_u32) { llty = T_i32(); }
+ case (ast::ty_i64) { llty = T_i64(); }
+ case (ast::ty_u64) { llty = T_i64(); }
+ case (ast::ty_f32) { llty = T_f32(); }
+ case (ast::ty_f64) { llty = T_f64(); }
}
}
case (ty::ty_char) { llty = T_char(); }
@@ -2363,7 +2365,7 @@ fn make_cmp_glue(&@block_ctxt cx, ValueRef lhs0, ValueRef rhs0, &ty::t t,
} else {
// FIXME: compare obj, fn by pointer?
- trans_fail(cx, none[common::span],
+ trans_fail(cx, none[span],
"attempt to compare values of type " +
ty_to_str(cx.fcx.lcx.ccx.tcx, t));
}
@@ -2402,7 +2404,7 @@ fn compare_scalar_types(@block_ctxt cx, ValueRef lhs, ValueRef rhs, &ty::t t,
}
case (ty::ty_char) { ret f(unsigned_int); }
case (ty::ty_type) {
- trans_fail(cx, none[common::span],
+ trans_fail(cx, none[span],
"attempt to compare values of type type");
// This is a bit lame, because we return a dummy block to the
@@ -2412,7 +2414,7 @@ fn compare_scalar_types(@block_ctxt cx, ValueRef lhs, ValueRef rhs, &ty::t t,
C_bool(false));
}
case (ty::ty_native(_)) {
- trans_fail(cx, none[common::span],
+ trans_fail(cx, none[span],
"attempt to compare values of type native");
ret rslt(new_sub_block_ctxt(cx, "after_fail_dummy"),
C_bool(false));
@@ -2752,7 +2754,7 @@ fn iter_structural_ty_full(&@block_ctxt cx, ValueRef av, ValueRef bv,
ret iter_ivec(cx, av, bv, unit_tm.ty, f);
}
case (ty::ty_istr) {
- auto unit_ty = ty::mk_mach(cx.fcx.lcx.ccx.tcx, common::ty_u8);
+ auto unit_ty = ty::mk_mach(cx.fcx.lcx.ccx.tcx, ast::ty_u8);
ret iter_ivec(cx, av, bv, unit_ty, f);
}
case (_) {
@@ -2858,14 +2860,14 @@ fn iter_sequence(@block_ctxt cx, ValueRef v, &ty::t t, &val_and_ty_fn f) ->
ret iter_sequence_body(cx, v, elt.ty, f, false, false);
}
case (ty::ty_str) {
- auto et = ty::mk_mach(cx.fcx.lcx.ccx.tcx, common::ty_u8);
+ auto et = ty::mk_mach(cx.fcx.lcx.ccx.tcx, ast::ty_u8);
ret iter_sequence_body(cx, v, et, f, true, false);
}
case (ty::ty_ivec(?elt)) {
ret iter_sequence_body(cx, v, elt.ty, f, false, true);
}
case (ty::ty_istr) {
- auto et = ty::mk_mach(cx.fcx.lcx.ccx.tcx, common::ty_u8);
+ auto et = ty::mk_mach(cx.fcx.lcx.ccx.tcx, ast::ty_u8);
ret iter_sequence_body(cx, v, et, f, true, true);
}
case (_) {
@@ -3179,7 +3181,7 @@ fn duplicate_heap_parts_if_necessary(&@block_ctxt cx, ValueRef vptr,
}
case (ty::ty_istr) {
ret ivec::duplicate_heap_part(cx, vptr,
- ty::mk_mach(cx.fcx.lcx.ccx.tcx, common::ty_u8));
+ ty::mk_mach(cx.fcx.lcx.ccx.tcx, ast::ty_u8));
}
case (_) { ret rslt(cx, C_nil()); }
}
@@ -3276,14 +3278,14 @@ fn trans_lit(&@crate_ctxt cx, &ast::lit lit, ast::node_id id) -> ValueRef {
auto t = T_int();
auto s = True;
alt (tm) {
- case (common::ty_u8) { t = T_i8(); s = False; }
- case (common::ty_u16) { t = T_i16(); s = False; }
- case (common::ty_u32) { t = T_i32(); s = False; }
- case (common::ty_u64) { t = T_i64(); s = False; }
- case (common::ty_i8) { t = T_i8(); }
- case (common::ty_i16) { t = T_i16(); }
- case (common::ty_i32) { t = T_i32(); }
- case (common::ty_i64) { t = T_i64(); }
+ case (ast::ty_u8) { t = T_i8(); s = False; }
+ case (ast::ty_u16) { t = T_i16(); s = False; }
+ case (ast::ty_u32) { t = T_i32(); s = False; }
+ case (ast::ty_u64) { t = T_i64(); s = False; }
+ case (ast::ty_i8) { t = T_i8(); }
+ case (ast::ty_i16) { t = T_i16(); }
+ case (ast::ty_i32) { t = T_i32(); }
+ case (ast::ty_i64) { t = T_i64(); }
}
ret C_integral(t, i as uint, s);
}
@@ -3291,8 +3293,8 @@ fn trans_lit(&@crate_ctxt cx, &ast::lit lit, ast::node_id id) -> ValueRef {
case (ast::lit_mach_float(?tm, ?s)) {
auto t = T_float();
alt (tm) {
- case (common::ty_f32) { t = T_f32(); }
- case (common::ty_f64) { t = T_f64(); }
+ case (ast::ty_f32) { t = T_f32(); }
+ case (ast::ty_f64) { t = T_f64(); }
}
ret C_floating(s, t);
}
@@ -4768,7 +4770,7 @@ fn trans_alt(&@block_ctxt cx, &@ast::expr expr, &vec[ast::arm] arms,
this_cx = next_cx;
}
auto default_cx = this_cx;
- trans_fail(default_cx, some[common::span](expr.span),
+ trans_fail(default_cx, some[span](expr.span),
"non-exhaustive match failure");
ret rslt(join_branches(cx, arm_results), C_nil());
}
@@ -5028,7 +5030,7 @@ fn trans_index(&@block_ctxt cx, &span sp, &@ast::expr base, &@ast::expr idx,
bcx.build.CondBr(bounds_check, next_cx.llbb, fail_cx.llbb);
// fail: bad bounds check.
- trans_fail(fail_cx, some[common::span](sp), "bounds check");
+ trans_fail(fail_cx, some[span](sp), "bounds check");
auto body;
alt (interior_len_and_data) {
case (some(?lad)) { body = lad._1; }
@@ -6313,11 +6315,11 @@ fn trans_log(int lvl, &@block_ctxt cx, &@ast::expr e) -> result {
let TypeRef tr;
let bool is32bit = false;
alt (ty::struct(cx.fcx.lcx.ccx.tcx, e_ty)) {
- case (ty::ty_machine(util::common::ty_f32)) {
+ case (ty::ty_machine(ast::ty_f32)) {
tr = T_f32();
is32bit = true;
}
- case (ty::ty_machine(util::common::ty_f64)) { tr = T_f64(); }
+ case (ty::ty_machine(ast::ty_f64)) { tr = T_f64(); }
case (_) { tr = T_float(); }
}
if (is32bit) {
@@ -6366,13 +6368,13 @@ fn trans_check_expr(&@block_ctxt cx, &@ast::expr e, &str s) -> result {
auto cond_res = trans_expr(cx, e);
auto expr_str = s + " " + expr_to_str(e) + " failed";
auto fail_cx = new_sub_block_ctxt(cx, "fail");
- trans_fail(fail_cx, some[common::span](e.span), expr_str);
+ trans_fail(fail_cx, some[span](e.span), expr_str);
auto next_cx = new_sub_block_ctxt(cx, "next");
cond_res.bcx.build.CondBr(cond_res.val, next_cx.llbb, fail_cx.llbb);
ret rslt(next_cx, C_nil());
}
-fn trans_fail_expr(&@block_ctxt cx, &option::t[common::span] sp_opt,
+fn trans_fail_expr(&@block_ctxt cx, &option::t[span] sp_opt,
&option::t[@ast::expr] fail_expr)
-> result {
auto bcx = cx;
@@ -6399,13 +6401,13 @@ fn trans_fail_expr(&@block_ctxt cx, &option::t[common::span] sp_opt,
}
}
-fn trans_fail(&@block_ctxt cx, &option::t[common::span] sp_opt, &str fail_str)
+fn trans_fail(&@block_ctxt cx, &option::t[span] sp_opt, &str fail_str)
-> result {
auto V_fail_str = C_cstr(cx.fcx.lcx.ccx, fail_str);
ret trans_fail_value(cx, sp_opt, V_fail_str);
}
-fn trans_fail_value(&@block_ctxt cx, &option::t[common::span] sp_opt,
+fn trans_fail_value(&@block_ctxt cx, &option::t[span] sp_opt,
&ValueRef V_fail_str)
-> result {
auto V_filename;
diff --git a/src/comp/middle/tstate/ann.rs b/src/comp/middle/tstate/ann.rs
index 882dc4a42f7e..aa9267656e45 100644
--- a/src/comp/middle/tstate/ann.rs
+++ b/src/comp/middle/tstate/ann.rs
@@ -1,5 +1,4 @@
-import front::ast::ident;
import std::vec;
import tritv::*;
diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs
index 3ed1a56928ac..abffc3a97e35 100644
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -3,11 +3,12 @@ import std::vec;
import std::option;
import std::option::some;
import std::option::none;
-import front::ast::*;
-import util::common::istr;
-import util::common::uistr;
-import util::common::span;
-import util::common::new_str_hash;
+import syntax::ast::*;
+import syntax::walk;
+import syntax::codemap::span;
+import syntax::_std::istr;
+import syntax::_std::uistr;
+import syntax::_std::new_str_hash;
import util::common::log_expr_err;
import util::common::log_block_err;
import util::common::log_item_err;
diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index 9aa529c4e416..123f51e7a702 100644
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -7,20 +7,17 @@ import std::option;
import std::option::none;
import std::option::some;
import std::option::maybe;
-import front::ast;
-import front::ast::*;
+import syntax::ast::*;
+import syntax::codemap::span;
import util::common;
-import util::common::span;
-import util::common::spanned;
-import util::common::respan;
import util::common::log_block;
-import util::common::new_int_hash;
-import util::common::new_uint_hash;
+import syntax::_std::new_int_hash;
+import syntax::_std::new_uint_hash;
import util::common::log_expr_err;
-import util::common::istr;
-import util::common::uistr;
+import syntax::_std::istr;
+import syntax::_std::uistr;
import util::common::lit_eq;
-import pretty::pprust::path_to_str;
+import syntax::print::pprust::path_to_str;
import tstate::ann::pre_and_post;
import tstate::ann::pre_and_post_state;
import tstate::ann::empty_ann;
@@ -42,8 +39,8 @@ import tstate::ann::clear_in_poststate;
import tstate::ann::clear_in_poststate_;
import tritv::*;
-import pretty::ppaux::constr_args_to_str;
-import pretty::ppaux::lit_to_str;
+import syntax::print::pprust::constr_args_to_str;
+import syntax::print::pprust::lit_to_str;
/* logging funs */
@@ -188,10 +185,10 @@ same predicate are collapsed into one entry in the table, makes it
easier to look up a specific instance.
Both types are in constrast with the constraint type defined in
-front::ast, which is for predicate constraints only, and is what
+syntax::ast, which is for predicate constraints only, and is what
gets generated by the parser. aux and ast share the same type
to represent predicate *arguments* however. This type
-(constr_arg_general) is parameterized (see comments in front::ast).
+(constr_arg_general) is parameterized (see comments in syntax::ast).
Both types store an ident and span, for error-logging purposes.
*/
@@ -507,7 +504,7 @@ fn constraints(&fn_ctxt fcx) -> vec[norm_constraint] {
fn match_args(&fn_ctxt fcx, vec[pred_desc] occs, vec[@constr_arg_use] occ) ->
uint {
log "match_args: looking at " +
- pretty::ppaux::constr_args_to_str(std::util::fst[ident, def_id], occ);
+ constr_args_to_str(std::util::fst[ident, def_id], occ);
for (pred_desc pd in occs) {
log "match_args: candidate " + pred_desc_to_str(pd);
fn eq(&tup(ident, def_id) p, &tup(ident, def_id) q) -> bool {
@@ -594,8 +591,7 @@ fn expr_to_constr(ty::ctxt tcx, &@expr e) -> constr {
fn pred_desc_to_str(&pred_desc p) -> str {
ret "<" + uistr(p.node.bit_num) + ", " +
- pretty::ppaux::constr_args_to_str(std::util::fst[ident, def_id],
- p.node.args) + ">";
+ constr_args_to_str(std::util::fst[ident, def_id], p.node.args) + ">";
}
fn substitute_constr_args(&ty::ctxt cx, &vec[@expr] actuals,
@@ -609,7 +605,7 @@ fn substitute_constr_args(&ty::ctxt cx, &vec[@expr] actuals,
type subst = vec[tup(arg, @expr)];
-fn substitute_arg(&ty::ctxt cx, &vec[@expr] actuals, @ast::constr_arg a) ->
+fn substitute_arg(&ty::ctxt cx, &vec[@expr] actuals, @constr_arg a) ->
@constr_arg_use {
auto num_actuals = vec::len(actuals);
alt (a.node) {
diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs
index c7e77881e854..3dea3cef30dc 100644
--- a/src/comp/middle/tstate/bitvectors.rs
+++ b/src/comp/middle/tstate/bitvectors.rs
@@ -1,5 +1,6 @@
-import front::ast::*;
+import syntax::ast::*;
+import syntax::walk;
import std::option::*;
import std::vec;
import std::vec::len;
diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index 679ac234a7e6..084a11aa5fd4 100644
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -1,25 +1,26 @@
-import front::ast;
-import front::ast::method;
-import front::ast::item;
-import front::ast::item_fn;
-import front::ast::_fn;
-import front::ast::obj_field;
-import front::ast::_obj;
-import front::ast::stmt;
-import front::ast::ident;
-import front::ast::fn_ident;
-import front::ast::node_id;
-import front::ast::def_id;
-import front::ast::local_def;
-import front::ast::ty_param;
-import front::ast::crate;
-import front::ast::return;
-import front::ast::noreturn;
-import front::ast::expr;
+import syntax::ast;
+import ast::method;
+import ast::item;
+import ast::item_fn;
+import ast::_fn;
+import ast::obj_field;
+import ast::_obj;
+import ast::stmt;
+import ast::ident;
+import ast::fn_ident;
+import ast::node_id;
+import ast::def_id;
+import ast::local_def;
+import ast::ty_param;
+import ast::crate;
+import ast::return;
+import ast::noreturn;
+import ast::expr;
+import syntax::walk;
+import syntax::codemap::span;
import middle::ty::type_is_nil;
import middle::ty::ret_ty_of_fn;
-import util::common::span;
import tstate::ann::ts_ann;
import tstate::ann::empty_poststate;
import tstate::ann::true_precond;
@@ -43,7 +44,7 @@ import std::option::t;
import std::option::some;
import std::option::none;
import aux::*;
-import pretty::pprust::ty_to_str;
+import syntax::print::pprust::ty_to_str;
import util::common::log_stmt_err;
import bitvectors::promises;
import annotate::annotate_crate;
@@ -86,7 +87,7 @@ fn check_states_expr(&fn_ctxt fcx, &@expr e) {
s +=
"Unsatisfied precondition constraint (for example, " + diff +
") for expression:\n";
- s += pretty::pprust::expr_to_str(e);
+ s += syntax::print::pprust::expr_to_str(e);
s += "\nPrecondition:\n";
s += tritv_to_str(fcx, prec);
s += "\nPrestate:\n";
@@ -115,7 +116,7 @@ fn check_states_stmt(&fn_ctxt fcx, &@stmt s) {
ss +=
"Unsatisfied precondition constraint (for example, " + diff +
") for statement:\n";
- ss += pretty::pprust::stmt_to_str(*s);
+ ss += syntax::print::pprust::stmt_to_str(*s);
ss += "\nPrecondition:\n";
ss += tritv_to_str(fcx, prec);
ss += "\nPrestate: \n";
diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs
index 2ec43efe0c9b..e3b4f0421d40 100644
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -1,13 +1,14 @@
import std::vec;
import std::vec::plus_option;
-import front::ast;
-import front::ast::*;
-import pretty::ppaux::fn_ident_to_string;
+import syntax::ast::*;
+import util::ppaux::fn_ident_to_string;
import std::option::*;
-import middle::walk::walk_crate;
-import middle::walk::walk_fn;
-import middle::walk::ast_visitor;
+import syntax::walk;
+import syntax::visit;
+import walk::walk_crate;
+import walk::walk_fn;
+import walk::ast_visitor;
import aux::cinit;
import aux::ninit;
import aux::npred;
@@ -20,11 +21,11 @@ import aux::constr_map;
import aux::expr_to_constr;
import aux::constraints_expr;
import aux::node_id_to_def_strict;
-import util::common::new_int_hash;
+import syntax::_std::new_int_hash;
import util::common::new_def_hash;
-import util::common::uistr;
-import util::common::span;
-import util::common::respan;
+import syntax::_std::uistr;
+import syntax::codemap::span;
+import syntax::ast::respan;
type ctxt = rec(@mutable vec[aux::constr] cs, ty::ctxt tcx);
@@ -64,7 +65,7 @@ fn do_nothing(&_fn f, &vec[ty_param] tp, &span sp, &fn_ident i,
node_id iid, &ctxt cx, &visit::vt[ctxt] v) {
}
-fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ast::ty_param] tps,
+fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ty_param] tps,
&span sp, &fn_ident i, node_id id)
-> ctxt {
let ctxt cx = rec(cs=@mutable vec::alloc(0u), tcx=tcx);
@@ -81,7 +82,7 @@ fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ast::ty_param] tps,
fn add_constraint(&ty::ctxt tcx, aux::constr c, uint next, constr_map tbl) ->
uint {
- log aux::constraint_to_str(tcx, c) + " |-> " + util::common::uistr(next);
+ log aux::constraint_to_str(tcx, c) + " |-> " + uistr(next);
alt (c.node.c) {
case (ninit(?i)) { tbl.insert(c.node.id, cinit(next, c.span, i)); }
case (npred(?p, ?args)) {
@@ -115,7 +116,7 @@ fn add_constraint(&ty::ctxt tcx, aux::constr c, uint next, constr_map tbl) ->
/* builds a table mapping each local var defined in f
to a bit number in the precondition/postcondition vectors */
-fn mk_fn_info(&crate_ctxt ccx, &_fn f, &vec[ast::ty_param] tp,
+fn mk_fn_info(&crate_ctxt ccx, &_fn f, &vec[ty_param] tp,
&span f_sp, &fn_ident f_name,
node_id id) {
auto res_map = @new_int_hash[constraint]();
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index 25d6fb98a92b..9ce0d7ce5eb7 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -65,10 +65,11 @@ import bitvectors::declare_var;
import bitvectors::gen_poststate;
import bitvectors::relax_precond_block;
import bitvectors::gen;
-import front::ast::*;
-import util::common::new_int_hash;
+import syntax::ast::*;
+import syntax::_std::new_int_hash;
import util::common::new_def_hash;
-import util::common::uistr;
+import syntax::_std::istr;
+import syntax::_std::uistr;
import util::common::log_expr;
import util::common::log_fn;
import util::common::elt_exprs;
@@ -79,9 +80,8 @@ import util::common::log_stmt_err;
import util::common::log_expr_err;
import util::common::log_block_err;
import util::common::log_block;
-import util::common::span;
-import util::common::istr;
-import pretty::ppaux::fn_ident_to_string;
+import syntax::codemap::span;
+import util::ppaux::fn_ident_to_string;
fn find_pre_post_mod(&_mod m) -> _mod {
log "implement find_pre_post_mod!";
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index 4e4c3a961d7d..ff999c1aa1c6 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/src/comp/middle/tstate/states.rs
@@ -75,13 +75,12 @@ import bitvectors::gen_poststate;
import bitvectors::kill_poststate;
import bitvectors::clear_in_poststate_ident;
import bitvectors::intersect_states;
-import front::ast;
-import front::ast::*;
+import syntax::ast::*;
import middle::ty::expr_ty;
import middle::ty::type_is_nil;
import middle::ty::type_is_bot;
import util::common::new_def_hash;
-import util::common::uistr;
+import syntax::_std::uistr;
import util::common::log_expr;
import util::common::log_block;
import util::common::log_block_err;
@@ -171,7 +170,7 @@ fn find_pre_post_state_call(&fn_ctxt fcx, &prestate pres, &@expr a,
expr_poststate(fcx.ccx, a), id, bs, cf) || changed;
}
-fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, ast::node_id id,
+fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, node_id id,
&vec[@expr] es, controlflow cf) -> bool {
auto rs = seq_states(fcx, pres, es);
auto changed = rs._0 | set_prestate_ann(fcx.ccx, id, pres);
@@ -229,7 +228,7 @@ fn gen_if_local(&fn_ctxt fcx, &poststate p, &@expr e) -> bool {
}
fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
- &option::t[@expr] maybe_alt, ast::node_id id, &if_ty chk,
+ &option::t[@expr] maybe_alt, node_id id, &if_ty chk,
&prestate pres) -> bool {
auto changed = set_prestate_ann(fcx.ccx, id, pres) |
find_pre_post_state_expr(fcx, pres, antec);
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 254fd130681b..760a9b2fa949 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -13,18 +13,20 @@ import std::option::none;
import std::option::some;
import std::smallintmap;
import driver::session;
-import front::ast;
-import front::ast::def_id;
-import front::ast::constr_arg_general;
-import front::ast::mutability;
-import front::ast::controlflow;
-import front::ast::path_to_str;
+import syntax::ast;
+import ast::def_id;
+import ast::constr_arg_general;
+import ast::mutability;
+import ast::controlflow;
+import ast::path_to_str;
+import ast::spanned;
+import syntax::codemap::span;
import metadata::creader;
import metadata::decoder;
import util::common::*;
-import util::data::interner;
-import pretty::ppaux::ty_to_str;
-import pretty::ppaux::mode_str_1;
+import syntax::util::interner;
+import util::ppaux::ty_to_str;
+import util::ppaux::mode_str_1;
export node_id_to_monotype;
@@ -251,7 +253,7 @@ tag sty {
ty_int;
ty_float;
ty_uint;
- ty_machine(ty_mach);
+ ty_machine(ast::ty_mach);
ty_char;
ty_str;
ty_istr;
@@ -360,16 +362,16 @@ fn populate_type_store(&ctxt cx) {
intern(cx, ty_int, none[str]);
intern(cx, ty_float, none[str]);
intern(cx, ty_uint, none[str]);
- intern(cx, ty_machine(ty_i8), none[str]);
- intern(cx, ty_machine(ty_i16), none[str]);
- intern(cx, ty_machine(ty_i32), none[str]);
- intern(cx, ty_machine(ty_i64), none[str]);
- intern(cx, ty_machine(ty_u8), none[str]);
- intern(cx, ty_machine(ty_u16), none[str]);
- intern(cx, ty_machine(ty_u32), none[str]);
- intern(cx, ty_machine(ty_u64), none[str]);
- intern(cx, ty_machine(ty_f32), none[str]);
- intern(cx, ty_machine(ty_f64), none[str]);
+ intern(cx, ty_machine(ast::ty_i8), none[str]);
+ intern(cx, ty_machine(ast::ty_i16), none[str]);
+ intern(cx, ty_machine(ast::ty_i32), none[str]);
+ intern(cx, ty_machine(ast::ty_i64), none[str]);
+ intern(cx, ty_machine(ast::ty_u8), none[str]);
+ intern(cx, ty_machine(ast::ty_u16), none[str]);
+ intern(cx, ty_machine(ast::ty_u32), none[str]);
+ intern(cx, ty_machine(ast::ty_u64), none[str]);
+ intern(cx, ty_machine(ast::ty_f32), none[str]);
+ intern(cx, ty_machine(ast::ty_f64), none[str]);
intern(cx, ty_char, none[str]);
intern(cx, ty_str, none[str]);
intern(cx, ty_istr, none[str]);
@@ -534,18 +536,18 @@ fn mk_float(&ctxt cx) -> t { ret idx_float; }
fn mk_uint(&ctxt cx) -> t { ret idx_uint; }
-fn mk_mach(&ctxt cx, &ty_mach tm) -> t {
+fn mk_mach(&ctxt cx, &ast::ty_mach tm) -> t {
alt (tm) {
- case (ty_u8) { ret idx_u8; }
- case (ty_u16) { ret idx_u16; }
- case (ty_u32) { ret idx_u32; }
- case (ty_u64) { ret idx_u64; }
- case (ty_i8) { ret idx_i8; }
- case (ty_i16) { ret idx_i16; }
- case (ty_i32) { ret idx_i32; }
- case (ty_i64) { ret idx_i64; }
- case (ty_f32) { ret idx_f32; }
- case (ty_f64) { ret idx_f64; }
+ case (ast::ty_u8) { ret idx_u8; }
+ case (ast::ty_u16) { ret idx_u16; }
+ case (ast::ty_u32) { ret idx_u32; }
+ case (ast::ty_u64) { ret idx_u64; }
+ case (ast::ty_i8) { ret idx_i8; }
+ case (ast::ty_i16) { ret idx_i16; }
+ case (ast::ty_i32) { ret idx_i32; }
+ case (ast::ty_i64) { ret idx_i64; }
+ case (ast::ty_f32) { ret idx_f32; }
+ case (ast::ty_f64) { ret idx_f64; }
}
}
@@ -938,8 +940,8 @@ fn sequence_is_interior(&ctxt cx, &t ty) -> bool {
fn sequence_element_type(&ctxt cx, &t ty) -> t {
alt (struct(cx, ty)) {
- case (ty_str) { ret mk_mach(cx, ty_u8); }
- case (ty_istr) { ret mk_mach(cx, ty_u8); }
+ case (ty_str) { ret mk_mach(cx, ast::ty_u8); }
+ case (ty_istr) { ret mk_mach(cx, ast::ty_u8); }
case (ty_vec(?mt)) { ret mt.ty; }
case (ty_ivec(?mt)) { ret mt.ty; }
case (_) {
@@ -1135,14 +1137,14 @@ fn type_is_integral(&ctxt cx, &t ty) -> bool {
case (ty_uint) { ret true; }
case (ty_machine(?m)) {
alt (m) {
- case (ty_i8) { ret true; }
- case (ty_i16) { ret true; }
- case (ty_i32) { ret true; }
- case (ty_i64) { ret true; }
- case (ty_u8) { ret true; }
- case (ty_u16) { ret true; }
- case (ty_u32) { ret true; }
- case (ty_u64) { ret true; }
+ case (ast::ty_i8) { ret true; }
+ case (ast::ty_i16) { ret true; }
+ case (ast::ty_i32) { ret true; }
+ case (ast::ty_i64) { ret true; }
+ case (ast::ty_u8) { ret true; }
+ case (ast::ty_u16) { ret true; }
+ case (ast::ty_u32) { ret true; }
+ case (ast::ty_u64) { ret true; }
case (_) { ret false; }
}
}
@@ -1155,8 +1157,8 @@ fn type_is_fp(&ctxt cx, &t ty) -> bool {
alt (struct(cx, ty)) {
case (ty_machine(?tm)) {
alt (tm) {
- case (ty_f32) { ret true; }
- case (ty_f64) { ret true; }
+ case (ast::ty_f32) { ret true; }
+ case (ast::ty_f64) { ret true; }
case (_) { ret false; }
}
}
@@ -1170,10 +1172,10 @@ fn type_is_signed(&ctxt cx, &t ty) -> bool {
case (ty_int) { ret true; }
case (ty_machine(?tm)) {
alt (tm) {
- case (ty_i8) { ret true; }
- case (ty_i16) { ret true; }
- case (ty_i32) { ret true; }
- case (ty_i64) { ret true; }
+ case (ast::ty_i8) { ret true; }
+ case (ast::ty_i16) { ret true; }
+ case (ast::ty_i32) { ret true; }
+ case (ast::ty_i64) { ret true; }
case (_) { ret false; }
}
}
@@ -1322,16 +1324,16 @@ fn hash_type_structure(&sty st) -> uint {
case (ty_uint) { ret 4u; }
case (ty_machine(?tm)) {
alt (tm) {
- case (ty_i8) { ret 5u; }
- case (ty_i16) { ret 6u; }
- case (ty_i32) { ret 7u; }
- case (ty_i64) { ret 8u; }
- case (ty_u8) { ret 9u; }
- case (ty_u16) { ret 10u; }
- case (ty_u32) { ret 11u; }
- case (ty_u64) { ret 12u; }
- case (ty_f32) { ret 13u; }
- case (ty_f64) { ret 14u; }
+ case (ast::ty_i8) { ret 5u; }
+ case (ast::ty_i16) { ret 6u; }
+ case (ast::ty_i32) { ret 7u; }
+ case (ast::ty_i64) { ret 8u; }
+ case (ast::ty_u8) { ret 9u; }
+ case (ast::ty_u16) { ret 10u; }
+ case (ast::ty_u32) { ret 11u; }
+ case (ast::ty_u64) { ret 12u; }
+ case (ast::ty_f32) { ret 13u; }
+ case (ast::ty_f64) { ret 14u; }
}
}
case (ty_char) { ret 15u; }
@@ -2644,7 +2646,7 @@ mod unify {
alt (smallintmap::find[t](vb.types, i)) {
case (none[t]) { typespec = ""; }
case (some[t](?typ)) {
- typespec = " =" + pretty::ppaux::ty_to_str(tcx, typ);
+ typespec = " =" + ty_to_str(tcx, typ);
}
}
log_err #fmt("set %u:%s%s", i, typespec, sets);
@@ -2948,17 +2950,17 @@ fn is_binopable(&ctxt cx, t ty, ast::binop op) -> bool {
case (ty_bool) { tycat_bool }
case (ty_int) { tycat_int }
case (ty_uint) { tycat_int }
- case (ty_machine(ty_i8)) { tycat_int }
- case (ty_machine(ty_i16)) { tycat_int }
- case (ty_machine(ty_i32)) { tycat_int }
- case (ty_machine(ty_i64)) { tycat_int }
- case (ty_machine(ty_u8)) { tycat_int }
- case (ty_machine(ty_u16)) { tycat_int }
- case (ty_machine(ty_u32)) { tycat_int }
- case (ty_machine(ty_u64)) { tycat_int }
+ case (ty_machine(ast::ty_i8)) { tycat_int }
+ case (ty_machine(ast::ty_i16)) { tycat_int }
+ case (ty_machine(ast::ty_i32)) { tycat_int }
+ case (ty_machine(ast::ty_i64)) { tycat_int }
+ case (ty_machine(ast::ty_u8)) { tycat_int }
+ case (ty_machine(ast::ty_u16)) { tycat_int }
+ case (ty_machine(ast::ty_u32)) { tycat_int }
+ case (ty_machine(ast::ty_u64)) { tycat_int }
case (ty_float) { tycat_float }
- case (ty_machine(ty_f32)) { tycat_float }
- case (ty_machine(ty_f64)) { tycat_float }
+ case (ty_machine(ast::ty_f32)) { tycat_float }
+ case (ty_machine(ast::ty_f64)) { tycat_float }
case (ty_char) { tycat_int }
case (ty_ptr(_)) { tycat_int }
case (ty_str) { tycat_str }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 785393e13c90..5c4e4f1572b1 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1,14 +1,15 @@
-import front::ast;
-import front::ast::mutability;
-import front::ast::local_def;
-import front::ast::path_to_str;
+import syntax::ast;
+import ast::mutability;
+import ast::local_def;
+import ast::path_to_str;
+import ast::respan;
+import syntax::walk;
import metadata::decoder;
import driver::session;
import util::common;
-import util::common::span;
-import util::common::respan;
-import util::common::new_int_hash;
+import syntax::codemap::span;
+import syntax::_std::new_int_hash;
import util::common::new_def_hash;
import util::common::log_expr_err;
import middle::ty;
@@ -24,7 +25,7 @@ import middle::ty::mo_alias;
import middle::ty::node_type_table;
import middle::ty::pat_ty;
import middle::ty::ty_param_substs_opt_and_ty;
-import pretty::ppaux::ty_to_str;
+import util::ppaux::ty_to_str;
import middle::ty::ty_param_count_and_ty;
import middle::ty::ty_nil;
import middle::ty::unify::ures_ok;
@@ -537,7 +538,7 @@ mod collect {
}
case (_) {
cx.tcx.sess.fatal("internal error " +
- util::common::istr(id._1));
+ syntax::_std::istr(id._1));
}
}
ret tpt;
@@ -1375,7 +1376,7 @@ fn require_pure_call(@crate_ctxt ccx, &ast::purity caller_purity,
fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
// fcx.ccx.tcx.sess.span_warn(expr.span, "typechecking expr " +
- // pretty::pprust::expr_to_str(expr));
+ // syntax::print::pprust::expr_to_str(expr));
// A generic function to factor out common logic from call and bind
// expressions.
@@ -1545,7 +1546,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
}
// Checks the compatibility
- fn check_binop_type_compat(&@fn_ctxt fcx, common::span span,
+ fn check_binop_type_compat(&@fn_ctxt fcx, span span,
ty::t ty, ast::binop binop) {
auto resolved_t = resolve_type_vars_if_possible(fcx, ty);
if (!ty::is_binopable(fcx.ccx.tcx, resolved_t, binop)) {
@@ -1794,11 +1795,11 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
alt (structure_of(fcx, expr.span, ety)) {
case (ty::ty_vec(?vec_elt_ty)) { elt_ty = vec_elt_ty.ty; }
case (ty::ty_str) {
- elt_ty = ty::mk_mach(fcx.ccx.tcx, util::common::ty_u8);
+ elt_ty = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8);
}
case (ty::ty_ivec(?vec_elt_ty)) { elt_ty = vec_elt_ty.ty; }
case (ty::ty_istr) {
- elt_ty = ty::mk_mach(fcx.ccx.tcx, util::common::ty_u8);
+ elt_ty = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8);
}
case (_) {
fcx.ccx.tcx.sess.span_fatal(expr.span,
@@ -2150,11 +2151,11 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
write::ty_only_fixup(fcx, id, mt.ty);
}
case (ty::ty_str) {
- auto typ = ty::mk_mach(fcx.ccx.tcx, common::ty_u8);
+ auto typ = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8);
write::ty_only_fixup(fcx, id, typ);
}
case (ty::ty_istr) {
- auto typ = ty::mk_mach(fcx.ccx.tcx, common::ty_u8);
+ auto typ = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8);
write::ty_only_fixup(fcx, id, typ);
}
case (_) {
diff --git a/src/comp/pretty/ppaux.rs b/src/comp/pretty/ppaux.rs
deleted file mode 100644
index ea4136182ba8..000000000000
--- a/src/comp/pretty/ppaux.rs
+++ /dev/null
@@ -1,433 +0,0 @@
-
-import std::io;
-import std::vec;
-import std::str;
-import std::option;
-import std::option::none;
-import std::option::some;
-import middle::ty;
-import middle::ty::*;
-import front::lexer;
-import front::ast;
-import pp::word;
-import pp::eof;
-import pp::zerobreak;
-import pp::hardbreak;
-import front::codemap;
-import front::codemap::codemap;
-import util::common::istr;
-import util::common::uistr;
-import util::common::ty_mach_to_str;
-
-fn mode_str(&ty::mode m) -> str {
- alt (m) {
- case (mo_val) { "" }
- case (mo_alias(false)) { "&" }
- case (mo_alias(true)) { "&mutable " }
- }
-}
-
-fn mode_str_1(&ty::mode m) -> str {
- alt (m) {
- case (mo_val) { "val" }
- case (_) { mode_str(m) }
- }
-}
-
-fn fn_ident_to_string(ast::node_id id, &ast::fn_ident i) -> str {
- ret alt (i) {
- case (none) { "anon" + istr(id) }
- case (some(?s)) { s }
- };
-}
-
-fn ty_to_str(&ctxt cx, &t typ) -> str {
- fn fn_input_to_str(&ctxt cx, &rec(middle::ty::mode mode, t ty) input) ->
- str {
- auto s = mode_str(input.mode);
- ret s + ty_to_str(cx, input.ty);
- }
- fn fn_to_str(&ctxt cx, ast::proto proto, option::t[ast::ident] ident,
- &arg[] inputs, t output, ast::controlflow cf,
- &vec[@constr_def] constrs) -> str {
- auto s;
- alt (proto) {
- case (ast::proto_iter) { s = "iter"; }
- case (ast::proto_fn) { s = "fn"; }
- }
- alt (ident) { case (some(?i)) { s += " "; s += i; } case (_) { } }
- s += "(";
- auto strs = [];
- for (arg a in inputs) { strs += [fn_input_to_str(cx, a)]; }
- s += str::connect(strs, ", ");
- s += ")";
- if (struct(cx, output) != ty_nil) {
- alt (cf) {
- case (ast::noreturn) { s += " -> !"; }
- case (ast::return) { s += " -> " + ty_to_str(cx, output); }
- }
- }
- s += constrs_str(constrs);
- ret s;
- }
- fn method_to_str(&ctxt cx, &method m) -> str {
- ret fn_to_str(cx, m.proto, some[ast::ident](m.ident), m.inputs,
- m.output, m.cf, m.constrs) + ";";
- }
- fn field_to_str(&ctxt cx, &field f) -> str {
- ret mt_to_str(cx, f.mt) + " " + f.ident;
- }
- fn mt_to_str(&ctxt cx, &mt m) -> str {
- auto mstr;
- alt (m.mut) {
- case (ast::mut) { mstr = "mutable "; }
- case (ast::imm) { mstr = ""; }
- case (ast::maybe_mut) { mstr = "mutable? "; }
- }
- ret mstr + ty_to_str(cx, m.ty);
- }
- alt (cname(cx, typ)) { case (some(?cs)) { ret cs; } case (_) { } }
- auto s = "";
- alt (struct(cx, typ)) {
- case (ty_native(_)) { s += "native"; }
- case (ty_nil) { s += "()"; }
- case (ty_bot) { s += "_|_"; }
- case (ty_bool) { s += "bool"; }
- case (ty_int) { s += "int"; }
- case (ty_float) { s += "float"; }
- case (ty_uint) { s += "uint"; }
- case (ty_machine(?tm)) { s += ty_mach_to_str(tm); }
- case (ty_char) { s += "char"; }
- case (ty_str) { s += "str"; }
- case (ty_istr) { s += "istr"; }
- case (ty_box(?tm)) { s += "@" + mt_to_str(cx, tm); }
- case (ty_vec(?tm)) { s += "vec[" + mt_to_str(cx, tm) + "]"; }
- case (ty_ivec(?tm)) { s += "ivec[" + mt_to_str(cx, tm) + "]"; }
- case (ty_port(?t)) { s += "port[" + ty_to_str(cx, t) + "]"; }
- case (ty_chan(?t)) { s += "chan[" + ty_to_str(cx, t) + "]"; }
- case (ty_type) { s += "type"; }
- case (ty_task) { s += "task"; }
- case (ty_tup(?elems)) {
- let vec[str] strs = [];
- for (mt tm in elems) { strs += [mt_to_str(cx, tm)]; }
- s += "tup(" + str::connect(strs, ",") + ")";
- }
- case (ty_rec(?elems)) {
- let vec[str] strs = [];
- for (field fld in elems) { strs += [field_to_str(cx, fld)]; }
- s += "rec(" + str::connect(strs, ",") + ")";
- }
- case (ty_tag(?id, ?tps)) {
- // The user should never see this if the cname is set properly!
-
- s += "";
- if (vec::len[t](tps) > 0u) {
- auto f = bind ty_to_str(cx, _);
- auto strs = vec::map[t, str](f, tps);
- s += "[" + str::connect(strs, ",") + "]";
- }
- }
- case (ty_fn(?proto, ?inputs, ?output, ?cf, ?constrs)) {
- s += fn_to_str(cx, proto, none, inputs, output, cf, constrs);
- }
- case (ty_native_fn(_, ?inputs, ?output)) {
- s += fn_to_str(cx, ast::proto_fn, none, inputs, output,
- ast::return, []);
- }
- case (ty_obj(?meths)) {
- auto f = bind method_to_str(cx, _);
- auto m = vec::map[method, str](f, meths);
- s += "obj {\n\t" + str::connect(m, "\n\t") + "\n}";
- }
- case (ty_res(?id, _, _)) {
- s += "";
- }
- case (ty_var(?v)) { s += ""; }
- case (ty_param(?id)) {
- s += "'" + str::unsafe_from_bytes([('a' as u8) + (id as u8)]);
- }
- case (_) { s += ty_to_short_str(cx, typ); }
- }
- ret s;
-}
-
-fn ty_to_short_str(&ctxt cx, t typ) -> str {
- auto f = def_to_str;
- auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata::tyencode::ac_no_abbrevs);
- auto s = metadata::tyencode::ty_str(ecx, typ);
- if (str::byte_len(s) >= 32u) { s = str::substr(s, 0u, 32u); }
- ret s;
-}
-
-fn constr_arg_to_str[T](fn(&T) -> str f, &ast::constr_arg_general_[T] c) ->
- str {
- alt (c) {
- case (ast::carg_base) { ret "*"; }
- case (ast::carg_ident(?i)) { ret f(i); }
- case (ast::carg_lit(?l)) { ret lit_to_str(l); }
- }
-}
-
-fn constr_arg_to_str_1(&front::ast::constr_arg_general_[str] c) -> str {
- alt (c) {
- case (ast::carg_base) { ret "*"; }
- case (ast::carg_ident(?i)) { ret i; }
- case (ast::carg_lit(?l)) { ret lit_to_str(l); }
- }
-}
-
-fn constr_args_to_str[T](fn(&T) -> str f,
- &vec[@ast::constr_arg_general[T]] args) -> str {
- auto comma = false;
- auto s = "(";
- for (@ast::constr_arg_general[T] a in args) {
- if (comma) { s += ", "; } else { comma = true; }
- s += constr_arg_to_str[T](f, a.node);
- }
- s += ")";
- ret s;
-}
-
-fn print_literal(&ps s, &@front::ast::lit lit) {
- maybe_print_comment(s, lit.span.lo);
- alt (next_lit(s)) {
- case (some(?lt)) {
- if (lt.pos == lit.span.lo) {
- word(s.s, lt.lit);
- s.cur_lit += 1u;
- ret;
- }
- }
- case (_) { }
- }
- alt (lit.node) {
- case (ast::lit_str(?st, ?kind)) {
- if (kind == ast::sk_unique) { word(s.s, "~"); }
- print_string(s, st);
- }
- case (ast::lit_char(?ch)) {
- word(s.s,
- "'" + escape_str(str::from_bytes([ch as u8]), '\'') + "'");
- }
- case (ast::lit_int(?val)) { word(s.s, istr(val)); }
- case (ast::lit_uint(?val)) { word(s.s, uistr(val) + "u"); }
- case (ast::lit_float(?fstr)) { word(s.s, fstr); }
- case (ast::lit_mach_int(?mach, ?val)) {
- word(s.s, istr(val as int));
- word(s.s, ty_mach_to_str(mach));
- }
- case (ast::lit_mach_float(?mach, ?val)) {
- // val is already a str
-
- word(s.s, val);
- word(s.s, ty_mach_to_str(mach));
- }
- case (ast::lit_nil) { word(s.s, "()"); }
- case (ast::lit_bool(?val)) {
- if (val) { word(s.s, "true"); } else { word(s.s, "false"); }
- }
- }
-}
-
-fn lit_to_str(&@front::ast::lit l) -> str { be to_str(l, print_literal); }
-
-fn next_lit(&ps s) -> option::t[lexer::lit] {
- alt (s.literals) {
- case (some(?lits)) {
- if (s.cur_lit < vec::len(lits)) {
- ret some(lits.(s.cur_lit));
- } else { ret none[lexer::lit]; }
- }
- case (_) { ret none[lexer::lit]; }
- }
-}
-
-fn maybe_print_comment(&ps s, uint pos) {
- while (true) {
- alt (next_comment(s)) {
- case (some(?cmnt)) {
- if (cmnt.pos < pos) {
- print_comment(s, cmnt);
- s.cur_cmnt += 1u;
- } else { break; }
- }
- case (_) { break; }
- }
- }
-}
-
-fn print_comment(&ps s, lexer::cmnt cmnt) {
- alt (cmnt.style) {
- case (lexer::mixed) {
- assert (vec::len(cmnt.lines) == 1u);
- zerobreak(s.s);
- word(s.s, cmnt.lines.(0));
- zerobreak(s.s);
- }
- case (lexer::isolated) {
- pprust::hardbreak_if_not_bol(s);
- for (str line in cmnt.lines) { word(s.s, line); hardbreak(s.s); }
- }
- case (lexer::trailing) {
- word(s.s, " ");
- if (vec::len(cmnt.lines) == 1u) {
- word(s.s, cmnt.lines.(0));
- hardbreak(s.s);
- } else {
- ibox(s, 0u);
- for (str line in cmnt.lines) {
- word(s.s, line);
- hardbreak(s.s);
- }
- end(s);
- }
- }
- case (lexer::blank_line) {
- // We need to do at least one, possibly two hardbreaks.
- pprust::hardbreak_if_not_bol(s);
- hardbreak(s.s);
- }
- }
-}
-
-fn print_string(&ps s, &str st) {
- word(s.s, "\"");
- word(s.s, escape_str(st, '"'));
- word(s.s, "\"");
-}
-
-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 += "\\"; }
- // FIXME some (or all?) non-ascii things should be escaped
-
- str::push_char(out, cur);
- }
- }
- i += 1u;
- }
- ret out;
-}
-
-fn to_str[T](&T t, fn(&ps, &T) f) -> str {
- auto writer = io::string_writer();
- auto s = rust_printer(writer.get_writer());
- f(s, t);
- eof(s.s);
- ret writer.get_str();
-}
-
-fn next_comment(&ps s) -> option::t[lexer::cmnt] {
- alt (s.comments) {
- case (some(?cmnts)) {
- if (s.cur_cmnt < vec::len(cmnts)) {
- ret some(cmnts.(s.cur_cmnt));
- } else { ret none[lexer::cmnt]; }
- }
- case (_) { ret none[lexer::cmnt]; }
- }
-}
-
-// The ps is stored here to prevent recursive type.
-// FIXME use a nominal tag instead
-tag ann_node {
- node_block(ps, ast::block);
- node_item(ps, @ast::item);
- node_expr(ps, @ast::expr);
- node_pat(ps, @ast::pat);
-}
-type pp_ann = rec(fn(&ann_node node) pre,
- fn(&ann_node node) post);
-
-fn no_ann() -> pp_ann {
- fn ignore(&ann_node node) {}
- ret rec(pre=ignore, post=ignore);
-}
-
-type ps =
- @rec(pp::printer s,
- option::t[codemap] cm,
- option::t[vec[lexer::cmnt]] comments,
- option::t[vec[lexer::lit]] literals,
- mutable uint cur_cmnt,
- mutable uint cur_lit,
- mutable vec[pp::breaks] boxes,
- pp_ann ann);
-
-fn ibox(&ps s, uint u) {
- vec::push(s.boxes, pp::inconsistent);
- pp::ibox(s.s, u);
-}
-
-fn end(&ps s) { vec::pop(s.boxes); pp::end(s.s); }
-
-fn rust_printer(io::writer writer) -> ps {
- let vec[pp::breaks] boxes = [];
- ret @rec(s=pp::mk_printer(writer, default_columns),
- cm=none[codemap],
- comments=none[vec[lexer::cmnt]],
- literals=none[vec[lexer::lit]],
- mutable cur_cmnt=0u,
- mutable cur_lit=0u,
- mutable boxes=boxes,
- ann=no_ann());
-}
-
-const uint indent_unit = 4u;
-
-const uint default_columns = 78u;
-
-
-// needed b/c constr_args_to_str needs
-// something that takes an alias
-// (argh)
-fn uint_to_str(&uint i) -> str { ret uistr(i); }
-
-fn constr_to_str(&@constr_def c) -> str {
- ret ast::path_to_str(c.node.path) +
- constr_args_to_str(uint_to_str, c.node.args);
-}
-
-fn ast_constr_to_str(&@front::ast::constr c) -> str {
- ret ast::path_to_str(c.node.path) +
- constr_args_to_str(uint_to_str, c.node.args);
-}
-
-fn constrs_str(&vec[@constr_def] constrs) -> str {
- auto s = "";
- auto colon = true;
- for (@constr_def c in constrs) {
- if (colon) { s += " : "; colon = false; } else { s += ", "; }
- s += constr_to_str(c);
- }
- ret s;
-}
-
-fn ast_constrs_str(&vec[@ast::constr] constrs) -> str {
- auto s = "";
- auto colon = true;
- for (@ast::constr c in constrs) {
- if (colon) { s += " : "; colon = false; } else { s += ", "; }
- s += ast_constr_to_str(c);
- }
- ret s;
-}
-//
-// Local Variables:
-// mode: rust
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
-// End:
-//
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index 0fb9f2332559..d79c221013a0 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -17,8 +17,6 @@ use std (name = "std",
mod middle {
mod trans;
mod ty;
- mod walk;
- mod visit;
mod ast_map;
mod resolve;
mod typeck;
@@ -38,25 +36,36 @@ mod middle {
}
-mod pretty {
- mod pprust;
- mod pp;
- mod ppaux;
+mod syntax {
+ mod _std; // FIXME remove
+ mod ast;
+ mod fold;
+ mod walk;
+ mod visit;
+ mod codemap;
+ mod parse {
+ mod lexer;
+ mod parser;
+ mod token;
+ mod eval;
+ }
+ mod ext {
+ mod base;
+ mod fmt;
+ mod env;
+ mod simplext;
+ }
+ mod print {
+ mod pprust;
+ mod pp;
+ }
+ mod util {
+ mod interner;
+ }
}
mod front {
- mod ast;
mod attr;
- mod ext;
- mod extfmt;
- mod extenv;
- mod extsimplext;
- mod fold;
- mod codemap;
- mod lexer;
- mod parser;
- mod token;
- mod eval;
mod config;
}
@@ -88,11 +97,9 @@ mod driver {
mod util {
mod common;
- mod data;
+ mod ppaux;
}
-auth front::creader::load_crate = unsafe;
-auth front::creader::get_metadata_section = unsafe;
auth middle::metadata = unsafe;
auth middle::trans = unsafe;
auth lib::llvm = unsafe;
diff --git a/src/comp/syntax/_std.rs b/src/comp/syntax/_std.rs
new file mode 100644
index 000000000000..fb4d1449a99d
--- /dev/null
+++ b/src/comp/syntax/_std.rs
@@ -0,0 +1,29 @@
+// FIXME all this stuff should be in the standard lib, and in fact is,
+// but due to the way our snapshots currently work, rustc can't use it
+// until after the next snapshot.
+
+fn new_str_hash[V]() -> std::map::hashmap[str, V] {
+ let std::map::hashfn[str] hasher = std::str::hash;
+ let std::map::eqfn[str] eqer = std::str::eq;
+ ret std::map::mk_hashmap[str, V](hasher, eqer);
+}
+
+fn new_int_hash[V]() -> std::map::hashmap[int, V] {
+ fn hash_int(&int x) -> uint { ret x as uint; }
+ fn eq_int(&int a, &int b) -> bool { ret a == b; }
+ auto hasher = hash_int;
+ auto eqer = eq_int;
+ ret std::map::mk_hashmap[int, V](hasher, eqer);
+}
+
+fn new_uint_hash[V]() -> std::map::hashmap[uint, V] {
+ fn hash_uint(&uint x) -> uint { ret x; }
+ fn eq_uint(&uint a, &uint b) -> bool { ret a == b; }
+ auto hasher = hash_uint;
+ auto eqer = eq_uint;
+ ret std::map::mk_hashmap[uint, V](hasher, eqer);
+}
+
+fn istr(int i) -> str { ret std::int::to_str(i, 10u); }
+
+fn uistr(uint i) -> str { ret std::uint::to_str(i, 10u); }
diff --git a/src/comp/front/ast.rs b/src/comp/syntax/ast.rs
similarity index 95%
rename from src/comp/front/ast.rs
rename to src/comp/syntax/ast.rs
index 600a76c0738b..0b05d2122d58 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -2,10 +2,11 @@
import std::option;
import std::str;
import std::vec;
-import util::common::span;
-import util::common::spanned;
-import util::common::ty_mach;
-import util::common::filename;
+import codemap::span;
+import codemap::filename;
+
+type spanned[T] = rec(T node, span span);
+fn respan[T](&span sp, &T t) -> spanned[T] { ret rec(node=t, span=sp); }
type ident = str;
// Functions may or may not have names.
@@ -342,6 +343,34 @@ type ty_arg = spanned[ty_arg_];
type ty_method = spanned[ty_method_];
+tag ty_mach {
+ ty_i8;
+ ty_i16;
+ ty_i32;
+ ty_i64;
+ ty_u8;
+ ty_u16;
+ ty_u32;
+ ty_u64;
+ ty_f32;
+ ty_f64;
+}
+
+fn ty_mach_to_str(ty_mach tm) -> str {
+ alt (tm) {
+ case (ty_u8) { ret "u8"; }
+ case (ty_u16) { ret "u16"; }
+ case (ty_u32) { ret "u32"; }
+ case (ty_u64) { ret "u64"; }
+ case (ty_i8) { ret "i8"; }
+ case (ty_i16) { ret "i16"; }
+ case (ty_i32) { ret "i32"; }
+ case (ty_i64) { ret "i64"; }
+ case (ty_f32) { ret "f32"; }
+ case (ty_f64) { ret "f64"; }
+ }
+}
+
type ty = spanned[ty_];
tag ty_ {
@@ -357,7 +386,7 @@ tag ty_ {
ty_int;
ty_uint;
ty_float;
- ty_machine(util::common::ty_mach);
+ ty_machine(ty_mach);
ty_char;
ty_str;
ty_istr; // interior string
@@ -604,7 +633,7 @@ fn ternary_to_if(&@expr e) -> @ast::expr {
fn path_to_str(&ast::path pth) -> str {
auto result = str::connect(pth.node.idents, "::");
if (vec::len[@ast::ty](pth.node.types) > 0u) {
- fn f(&@ast::ty t) -> str { ret pretty::pprust::ty_to_str(*t); }
+ fn f(&@ast::ty t) -> str { ret print::pprust::ty_to_str(*t); }
result += "[";
result += str::connect(vec::map(f, pth.node.types), ",");
result += "]";
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
new file mode 100644
index 000000000000..b1f0e7ea5fdf
--- /dev/null
+++ b/src/comp/syntax/codemap.rs
@@ -0,0 +1,96 @@
+
+import std::vec;
+import std::term;
+import std::io;
+import std::option;
+import std::option::some;
+import std::option::none;
+
+type filename = str;
+
+/* A codemap is a thing that maps uints to file/line/column positions
+ * in a crate. This to make it possible to represent the positions
+ * with single-word things, rather than passing records all over the
+ * compiler.
+ */
+type filemap = @rec(filename name, uint start_pos, mutable vec[uint] lines);
+
+type codemap = @rec(mutable vec[filemap] files);
+
+type loc = rec(filename filename, uint line, uint col);
+
+fn new_codemap() -> codemap {
+ let vec[filemap] files = [];
+ ret @rec(mutable files=files);
+}
+
+fn new_filemap(filename filename, uint start_pos) -> filemap {
+ ret @rec(name=filename, start_pos=start_pos, mutable lines=[0u]);
+}
+
+fn next_line(filemap file, uint pos) { vec::push[uint](file.lines, pos); }
+
+fn lookup_pos(codemap map, uint pos) -> loc {
+ auto a = 0u;
+ auto b = vec::len[filemap](map.files);
+ while (b - a > 1u) {
+ auto m = (a + b) / 2u;
+ if (map.files.(m).start_pos > pos) { b = m; } else { a = m; }
+ }
+ auto f = map.files.(a);
+ a = 0u;
+ b = vec::len[uint](f.lines);
+ while (b - a > 1u) {
+ auto m = (a + b) / 2u;
+ if (f.lines.(m) > pos) { b = m; } else { a = m; }
+ }
+ ret rec(filename=f.name, line=a + 1u, col=pos - f.lines.(a));
+}
+
+type span = rec(uint lo, uint hi);
+
+fn span_to_str(&span sp, &codemap cm) -> str {
+ auto lo = lookup_pos(cm, sp.lo);
+ auto hi = lookup_pos(cm, sp.hi);
+ ret #fmt("%s:%u:%u:%u:%u", lo.filename, lo.line, lo.col, hi.line, hi.col);
+}
+
+fn emit_diagnostic(&option::t[span] sp, &str msg, &str kind, u8 color,
+ &codemap cm) {
+ auto ss = ":0:0:0:0";
+ alt (sp) {
+ case (some(?ssp)) { ss = span_to_str(ssp, cm); }
+ case (none) { }
+ }
+ io::stdout().write_str(ss + ": ");
+ if (term::color_supported()) {
+ term::fg(io::stdout().get_buf_writer(), color);
+ }
+ io::stdout().write_str(#fmt("%s:", kind));
+ if (term::color_supported()) {
+ term::reset(io::stdout().get_buf_writer());
+ }
+ io::stdout().write_str(#fmt(" %s\n", msg));
+}
+
+fn emit_warning(&option::t[span] sp, &str msg, &codemap cm) {
+ emit_diagnostic(sp, msg, "warning", 11u8, cm);
+}
+fn emit_error(&option::t[span] sp, &str msg, &codemap cm) {
+ emit_diagnostic(sp, msg, "error", 9u8, cm);
+}
+fn emit_note(&option::t[span] sp, &str msg, &codemap cm) {
+ emit_diagnostic(sp, msg, "note", 10u8, cm);
+}
+
+
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+//
diff --git a/src/comp/front/ext.rs b/src/comp/syntax/ext/base.rs
similarity index 71%
rename from src/comp/front/ext.rs
rename to src/comp/syntax/ext/base.rs
index e4562f2f6403..719e96f5fe6e 100644
--- a/src/comp/front/ext.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -1,10 +1,10 @@
import std::vec;
import std::option;
import std::map::hashmap;
-import driver::session::session;
-import front::parser::parser;
-import util::common::span;
-import util::common::new_str_hash;
+import parse::parser::parse_sess;
+import codemap::span;
+import syntax::_std::new_str_hash;
+import codemap;
type syntax_expander =
fn(&ext_ctxt, span, &vec[@ast::expr], option::t[str]) -> @ast::expr;
@@ -20,10 +20,10 @@ tag syntax_extension {
// AST nodes into full ASTs
fn syntax_expander_table() -> hashmap[str, syntax_extension] {
auto syntax_expanders = new_str_hash[syntax_extension]();
- syntax_expanders.insert("fmt", normal(extfmt::expand_syntax_ext));
- syntax_expanders.insert("env", normal(extenv::expand_syntax_ext));
+ syntax_expanders.insert("fmt", normal(ext::fmt::expand_syntax_ext));
+ syntax_expanders.insert("env", normal(ext::env::expand_syntax_ext));
syntax_expanders.insert("macro",
- macro_defining(extsimplext::add_new_extension));
+ macro_defining(ext::simplext::add_new_extension));
ret syntax_expanders;
}
@@ -39,18 +39,18 @@ type ext_ctxt =
span_msg_fn span_unimpl,
next_id_fn next_id);
-fn mk_ctxt(parser parser) -> ext_ctxt {
- auto sess = parser.get_session();
- fn ext_span_fatal_(session sess, span sp, str msg) -> ! {
- sess.span_fatal(sp, msg);
+fn mk_ctxt(&parse_sess sess) -> ext_ctxt {
+ fn ext_span_fatal_(&codemap::codemap cm, span sp, str msg) -> ! {
+ codemap::emit_error(option::some(sp), msg, cm);
+ fail;
}
- auto ext_span_fatal = bind ext_span_fatal_(sess, _, _);
- fn ext_span_unimpl_(session sess, span sp, str msg) -> ! {
- sess.span_unimpl(sp, msg);
+ auto ext_span_fatal = bind ext_span_fatal_(sess.cm, _, _);
+ fn ext_span_unimpl_(&codemap::codemap cm, span sp, str msg) -> ! {
+ codemap::emit_error(option::some(sp), "unimplemented " + msg, cm);
+ fail;
}
- auto ext_span_unimpl = bind ext_span_unimpl_(sess, _, _);
- fn ext_next_id_(parser parser) -> ast::node_id { parser.get_id() }
- auto ext_next_id = bind ext_next_id_(parser);
+ auto ext_span_unimpl = bind ext_span_unimpl_(sess.cm, _, _);
+ auto ext_next_id = bind parse::parser::next_node_id(sess);
ret rec(span_fatal=ext_span_fatal,
span_unimpl=ext_span_unimpl,
next_id=ext_next_id);
diff --git a/src/comp/front/extenv.rs b/src/comp/syntax/ext/env.rs
similarity index 82%
rename from src/comp/front/extenv.rs
rename to src/comp/syntax/ext/env.rs
index acfb93e1cdce..7b12c0458980 100644
--- a/src/comp/front/extenv.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -5,15 +5,14 @@
* should all get sucked into either the compiler syntax extension plugin
* interface.
*/
-import util::common;
import std::str;
import std::vec;
import std::option;
import std::generic_os;
-import ext::*;
+import base::*;
export expand_syntax_ext;
-fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
+fn expand_syntax_ext(&ext_ctxt cx, codemap::span sp, &vec[@ast::expr] args,
option::t[str] body) -> @ast::expr {
if (vec::len[@ast::expr](args) != 1u) {
cx.span_fatal(sp, "malformed #env call");
@@ -28,12 +27,12 @@ fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
}
}
-fn make_new_lit(&ext_ctxt cx, common::span sp, ast::lit_ lit) -> @ast::expr {
+fn make_new_lit(&ext_ctxt cx, codemap::span sp, ast::lit_ lit) -> @ast::expr {
auto sp_lit = @rec(node=lit, span=sp);
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_lit), span=sp);
}
-fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {
+fn make_new_str(&ext_ctxt cx, codemap::span sp, str s) -> @ast::expr {
ret make_new_lit(cx, sp, ast::lit_str(s, ast::sk_rc));
}
//
diff --git a/src/comp/front/extfmt.rs b/src/comp/syntax/ext/fmt.rs
similarity index 90%
rename from src/comp/front/extfmt.rs
rename to src/comp/syntax/ext/fmt.rs
index 0696e0d2c697..1ea2d6943744 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -5,17 +5,17 @@
* should all get sucked into either the standard library extfmt module or the
* compiler syntax extension plugin interface.
*/
-import util::common;
import std::str;
import std::vec;
import std::option;
import std::option::none;
import std::option::some;
import std::extfmt::ct::*;
-import ext::*;
+import base::*;
+import codemap::span;
export expand_syntax_ext;
-fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
+fn expand_syntax_ext(&ext_ctxt cx, span sp, &vec[@ast::expr] args,
option::t[str] body) -> @ast::expr {
if (vec::len[@ast::expr](args) == 0u) {
cx.span_fatal(sp, "#fmt requires a format string");
@@ -25,7 +25,7 @@ fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
auto fmtspan = args.(0).span;
log "Format string:";
log fmt;
- fn parse_fmt_err_(&ext_ctxt cx, common::span sp, str msg) -> ! {
+ fn parse_fmt_err_(&ext_ctxt cx, span sp, str msg) -> ! {
cx.span_fatal(sp, msg);
}
auto parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
@@ -36,31 +36,31 @@ fn expand_syntax_ext(&ext_ctxt cx, common::span sp, &vec[@ast::expr] args,
// FIXME: A lot of these functions for producing expressions can probably
// be factored out in common with other code that builds expressions.
// FIXME: Cleanup the naming of these functions
-fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
+fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
vec[@ast::expr] args) -> @ast::expr {
- fn make_new_lit(&ext_ctxt cx, common::span sp, ast::lit_ lit) ->
+ fn make_new_lit(&ext_ctxt cx, span sp, ast::lit_ lit) ->
@ast::expr {
auto sp_lit = @rec(node=lit, span=sp);
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_lit), span=sp);
}
- fn make_new_str(&ext_ctxt cx, common::span sp, str s) -> @ast::expr {
+ fn make_new_str(&ext_ctxt cx, span sp, str s) -> @ast::expr {
auto lit = ast::lit_str(s, ast::sk_rc);
ret make_new_lit(cx, sp, lit);
}
- fn make_new_int(&ext_ctxt cx, common::span sp, int i) -> @ast::expr {
+ fn make_new_int(&ext_ctxt cx, span sp, int i) -> @ast::expr {
auto lit = ast::lit_int(i);
ret make_new_lit(cx, sp, lit);
}
- fn make_new_uint(&ext_ctxt cx, common::span sp, uint u) -> @ast::expr {
+ fn make_new_uint(&ext_ctxt cx, span sp, uint u) -> @ast::expr {
auto lit = ast::lit_uint(u);
ret make_new_lit(cx, sp, lit);
}
- fn make_add_expr(&ext_ctxt cx, common::span sp, @ast::expr lhs,
+ fn make_add_expr(&ext_ctxt cx, span sp, @ast::expr lhs,
@ast::expr rhs) -> @ast::expr {
auto binexpr = ast::expr_binary(ast::add, lhs, rhs);
ret @rec(id=cx.next_id(), node=binexpr, span=sp);
}
- fn make_path_expr(&ext_ctxt cx, common::span sp, vec[ast::ident] idents)
+ fn make_path_expr(&ext_ctxt cx, span sp, vec[ast::ident] idents)
-> @ast::expr {
let vec[@ast::ty] types = [];
auto path = rec(idents=idents, types=types);
@@ -68,18 +68,18 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
auto pathexpr = ast::expr_path(sp_path);
ret @rec(id=cx.next_id(), node=pathexpr, span=sp);
}
- fn make_vec_expr(&ext_ctxt cx, common::span sp, vec[@ast::expr] exprs) ->
+ fn make_vec_expr(&ext_ctxt cx, span sp, vec[@ast::expr] exprs) ->
@ast::expr {
auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc);
ret @rec(id=cx.next_id(), node=vecexpr, span=sp);
}
- fn make_call(&ext_ctxt cx, common::span sp, vec[ast::ident] fn_path,
+ fn make_call(&ext_ctxt cx, span sp, vec[ast::ident] fn_path,
vec[@ast::expr] args) -> @ast::expr {
auto pathexpr = make_path_expr(cx, sp, fn_path);
auto callexpr = ast::expr_call(pathexpr, args);
ret @rec(id=cx.next_id(), node=callexpr, span=sp);
}
- fn make_rec_expr(&ext_ctxt cx, common::span sp,
+ fn make_rec_expr(&ext_ctxt cx, span sp,
vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
let vec[ast::field] astfields = [];
for (tup(ast::ident, @ast::expr) field in fields) {
@@ -98,7 +98,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
ret ["std", "extfmt", "rt", ident];
}
- fn make_rt_path_expr(&ext_ctxt cx, common::span sp, str ident) ->
+ fn make_rt_path_expr(&ext_ctxt cx, span sp, str ident) ->
@ast::expr {
auto path = make_path_vec(ident);
ret make_path_expr(cx, sp, path);
@@ -106,9 +106,9 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
// Produces an AST expression that represents a RT::conv record,
// which tells the RT::conv* functions how to perform the conversion
- fn make_rt_conv_expr(&ext_ctxt cx, common::span sp, &conv cnv) ->
+ fn make_rt_conv_expr(&ext_ctxt cx, span sp, &conv cnv) ->
@ast::expr {
- fn make_flags(&ext_ctxt cx, common::span sp, vec[flag] flags) ->
+ fn make_flags(&ext_ctxt cx, span sp, vec[flag] flags) ->
@ast::expr {
let vec[@ast::expr] flagexprs = [];
for (flag f in flags) {
@@ -133,7 +133,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
}
ret make_vec_expr(cx, sp, flagexprs);
}
- fn make_count(&ext_ctxt cx, common::span sp, &count cnt) ->
+ fn make_count(&ext_ctxt cx, span sp, &count cnt) ->
@ast::expr {
alt (cnt) {
case (count_implied) {
@@ -150,7 +150,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
}
}
}
- fn make_ty(&ext_ctxt cx, common::span sp, &ty t) -> @ast::expr {
+ fn make_ty(&ext_ctxt cx, span sp, &ty t) -> @ast::expr {
auto rt_type;
alt (t) {
case (ty_hex(?c)) {
@@ -165,7 +165,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
}
ret make_rt_path_expr(cx, sp, rt_type);
}
- fn make_conv_rec(&ext_ctxt cx, common::span sp, @ast::expr flags_expr,
+ fn make_conv_rec(&ext_ctxt cx, span sp, @ast::expr flags_expr,
@ast::expr width_expr, @ast::expr precision_expr,
@ast::expr ty_expr) -> @ast::expr {
ret make_rec_expr(cx, sp,
@@ -181,7 +181,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
ret make_conv_rec(cx, sp, rt_conv_flags, rt_conv_width,
rt_conv_precision, rt_conv_ty);
}
- fn make_conv_call(&ext_ctxt cx, common::span sp, str conv_type, &conv cnv,
+ fn make_conv_call(&ext_ctxt cx, span sp, str conv_type, &conv cnv,
@ast::expr arg) -> @ast::expr {
auto fname = "conv_" + conv_type;
auto path = make_path_vec(fname);
@@ -189,7 +189,7 @@ fn pieces_to_expr(&ext_ctxt cx, common::span sp, vec[piece] pieces,
auto args = [cnv_expr, arg];
ret make_call(cx, arg.span, path, args);
}
- fn make_new_conv(&ext_ctxt cx, common::span sp, conv cnv, @ast::expr arg)
+ fn make_new_conv(&ext_ctxt cx, span sp, conv cnv, @ast::expr arg)
-> @ast::expr {
// FIXME: Extract all this validation into extfmt::ct
diff --git a/src/comp/front/extsimplext.rs b/src/comp/syntax/ext/simplext.rs
similarity index 96%
rename from src/comp/front/extsimplext.rs
rename to src/comp/syntax/ext/simplext.rs
index 3de737f0d53f..e214524f0b79 100644
--- a/src/comp/front/extsimplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -1,6 +1,6 @@
use std;
-import util::common::span;
+import codemap::span;
import std::vec;
import std::option;
import vec::map;
@@ -8,11 +8,11 @@ import vec::len;
import option::some;
import option::none;
-import ext::syntax_extension;
-import ext::ext_ctxt;
-import ext::normal;
-import ext::expr_to_str;
-import ext::expr_to_ident;
+import base::syntax_extension;
+import base::ext_ctxt;
+import base::normal;
+import base::expr_to_str;
+import base::expr_to_ident;
import fold::*;
import ast::ident;
diff --git a/src/comp/front/fold.rs b/src/comp/syntax/fold.rs
similarity index 99%
rename from src/comp/front/fold.rs
rename to src/comp/syntax/fold.rs
index 0fc884d67c36..5cf447a862c4 100644
--- a/src/comp/front/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -1,4 +1,4 @@
-import util::common::span;
+import syntax::codemap::span;
import ast::*;
import std::vec;
diff --git a/src/comp/front/eval.rs b/src/comp/syntax/parse/eval.rs
similarity index 82%
rename from src/comp/front/eval.rs
rename to src/comp/syntax/parse/eval.rs
index 95b9a85c09f2..89f6ac536c34 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -4,11 +4,12 @@ import std::str;
import std::option;
import std::option::some;
import std::option::none;
-import driver::session;
-import front::parser::parser;
-import front::parser::new_parser;
-import front::parser::parse_inner_attrs_and_next;
-import front::parser::parse_mod_items;
+import syntax::ast;
+import syntax::parse::token;
+import syntax::parse::parser::parser;
+import syntax::parse::parser::new_parser;
+import syntax::parse::parser::parse_inner_attrs_and_next;
+import syntax::parse::parser::parse_mod_items;
export eval_crate_directives_to_mod;
export mode_parse;
@@ -19,9 +20,8 @@ type ctx =
@rec(parser p,
eval_mode mode,
mutable vec[str] deps,
- session::session sess,
+ parser::parse_sess sess,
mutable uint chpos,
- mutable int next_id,
ast::crate_cfg cfg);
fn eval_crate_directives(ctx cx, vec[@ast::crate_directive] cdirs,
@@ -50,8 +50,9 @@ fn eval_crate_directive_block(ctx cx, &ast::block blk, str prefix,
eval_crate_directive(cx, cdir, prefix, view_items, items);
}
case (_) {
- cx.sess.span_fatal(s.span,
- "unsupported stmt in crate-directive block");
+ codemap::emit_warning
+ (some(s.span), "unsupported stmt in crate-directive block",
+ cx.sess.cm);
}
}
}
@@ -74,19 +75,17 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
};
if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; }
auto p0 =
- new_parser(cx.sess, cx.cfg, full_path, cx.chpos,
- cx.next_id);
+ new_parser(cx.sess, cx.cfg, full_path, cx.chpos);
auto inner_attrs = parse_inner_attrs_and_next(p0);
auto mod_attrs = attrs + inner_attrs._0;
auto first_item_outer_attrs = inner_attrs._1;
auto m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
- auto i = front::parser::mk_item(p0, cdir.span.lo, cdir.span.hi,
- id, ast::item_mod(m0),
- mod_attrs);
+ auto i = syntax::parse::parser::mk_item
+ (p0, cdir.span.lo, cdir.span.hi, id, ast::item_mod(m0),
+ mod_attrs);
// Thread defids and chpos through the parsers
cx.chpos = p0.get_chpos();
- cx.next_id = p0.next_id();
vec::push[@ast::item](items, i);
}
case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs, ?attrs)) {
@@ -100,10 +99,10 @@ fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
auto m0 = eval_crate_directives_to_mod(cx, cdirs, full_path);
auto i = @rec(ident=id,
attrs=attrs,
- id=cx.next_id,
+ id=cx.sess.next_id,
node=ast::item_mod(m0),
span=cdir.span);
- cx.next_id += 1;
+ cx.sess.next_id += 1;
vec::push[@ast::item](items, i);
}
case (ast::cdir_view_item(?vi)) {
diff --git a/src/comp/front/lexer.rs b/src/comp/syntax/parse/lexer.rs
similarity index 93%
rename from src/comp/front/lexer.rs
rename to src/comp/syntax/parse/lexer.rs
index d6bc3723bf3e..ffc83bcbbea4 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -8,11 +8,9 @@ import std::map::hashmap;
import std::option;
import std::option::some;
import std::option::none;
-import driver::session::session;
-import util::common;
-import util::common::*;
-import util::data::interner;
-import util::data::interner::intern;
+import util::interner;
+import util::interner::intern;
+import codemap;
type reader =
obj {
@@ -31,9 +29,9 @@ type reader =
fn err(str) ;
};
-fn new_reader(session sess, io::reader rdr, codemap::filemap filemap,
+fn new_reader(&codemap::codemap cm, io::reader rdr, codemap::filemap filemap,
@interner::interner[str] itr) -> reader {
- obj reader(session sess,
+ obj reader(codemap::codemap cm,
str file,
uint len,
mutable uint col,
@@ -75,12 +73,14 @@ fn new_reader(session sess, io::reader rdr, codemap::filemap filemap,
fn get_interner() -> @interner::interner[str] { ret itr; }
fn get_col() -> uint { ret col; }
fn get_filemap() -> codemap::filemap { ret fm; }
- fn err(str m) { sess.span_fatal(rec(lo=chpos, hi=chpos), m); }
+ fn err(str m) {
+ codemap::emit_error(some(rec(lo=chpos, hi=chpos)), m, cm);
+ }
}
auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = [];
auto rd =
- reader(sess, file, str::byte_len(file), 0u, 0u, -1 as char,
+ reader(cm, file, str::byte_len(file), 0u, 0u, -1 as char,
filemap.start_pos, filemap.start_pos, strs, filemap, itr);
rd.init();
ret rd;
@@ -101,6 +101,25 @@ fn is_whitespace(char c) -> bool {
ret c == ' ' || c == '\t' || c == '\r' || c == '\n';
}
+fn may_begin_ident(char c) -> bool { ret is_alpha(c) || c == '_'; }
+
+fn in_range(char c, char lo, char hi) -> bool { ret lo <= c && c <= hi; }
+
+fn is_alpha(char c) -> bool {
+ ret in_range(c, 'a', 'z') || in_range(c, 'A', 'Z');
+}
+
+fn is_dec_digit(char c) -> bool { ret in_range(c, '0', '9'); }
+
+fn is_alnum(char c) -> bool { ret is_alpha(c) || is_dec_digit(c); }
+
+fn is_hex_digit(char c) -> bool {
+ ret in_range(c, '0', '9') || in_range(c, 'a', 'f') ||
+ in_range(c, 'A', 'F');
+}
+
+fn is_bin_digit(char c) -> bool { ret c == '0' || c == '1'; }
+
fn consume_whitespace_and_comments(&reader rdr) {
while (is_whitespace(rdr.curr())) { rdr.bump(); }
be consume_any_line_comment(rdr);
@@ -218,30 +237,30 @@ fn scan_number(char c, &reader rdr) -> token::token {
if (c == '8') {
rdr.bump();
if (signed) {
- ret token::LIT_MACH_INT(common::ty_i8, accum_int);
- } else { ret token::LIT_MACH_INT(common::ty_u8, accum_int); }
+ ret token::LIT_MACH_INT(ast::ty_i8, accum_int);
+ } else { ret token::LIT_MACH_INT(ast::ty_u8, accum_int); }
}
n = rdr.next();
if (c == '1' && n == '6') {
rdr.bump();
rdr.bump();
if (signed) {
- ret token::LIT_MACH_INT(common::ty_i16, accum_int);
- } else { ret token::LIT_MACH_INT(common::ty_u16, accum_int); }
+ ret token::LIT_MACH_INT(ast::ty_i16, accum_int);
+ } else { ret token::LIT_MACH_INT(ast::ty_u16, accum_int); }
}
if (c == '3' && n == '2') {
rdr.bump();
rdr.bump();
if (signed) {
- ret token::LIT_MACH_INT(common::ty_i32, accum_int);
- } else { ret token::LIT_MACH_INT(common::ty_u32, accum_int); }
+ ret token::LIT_MACH_INT(ast::ty_i32, accum_int);
+ } else { ret token::LIT_MACH_INT(ast::ty_u32, accum_int); }
}
if (c == '6' && n == '4') {
rdr.bump();
rdr.bump();
if (signed) {
- ret token::LIT_MACH_INT(common::ty_i64, accum_int);
- } else { ret token::LIT_MACH_INT(common::ty_u64, accum_int); }
+ ret token::LIT_MACH_INT(ast::ty_i64, accum_int);
+ } else { ret token::LIT_MACH_INT(ast::ty_u64, accum_int); }
}
if (signed) {
ret token::LIT_INT(accum_int);
@@ -272,13 +291,13 @@ fn scan_number(char c, &reader rdr) -> token::token {
if (c == '3' && n == '2') {
rdr.bump();
rdr.bump();
- ret token::LIT_MACH_FLOAT(util::common::ty_f32,
+ ret token::LIT_MACH_FLOAT(ast::ty_f32,
intern(*rdr.get_interner(),
float_str));
} else if (c == '6' && n == '4') {
rdr.bump();
rdr.bump();
- ret token::LIT_MACH_FLOAT(util::common::ty_f64,
+ ret token::LIT_MACH_FLOAT(ast::ty_f64,
intern(*rdr.get_interner(),
float_str));
/* FIXME: if this is out of range for either a 32-bit or
@@ -694,11 +713,11 @@ fn is_lit(&token::token t) -> bool {
type lit = rec(str lit, uint pos);
-fn gather_comments_and_literals(session sess, str path) ->
+fn gather_comments_and_literals(&codemap::codemap cm, str path) ->
rec(vec[cmnt] cmnts, vec[lit] lits) {
auto srdr = io::file_reader(path);
auto itr = @interner::mk[str](str::hash, str::eq);
- auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
+ auto rdr = new_reader(cm, srdr, codemap::new_filemap(path, 0u), itr);
let vec[cmnt] comments = [];
let vec[lit] literals = [];
let bool first_read = true;
diff --git a/src/comp/front/parser.rs b/src/comp/syntax/parse/parser.rs
similarity index 95%
rename from src/comp/front/parser.rs
rename to src/comp/syntax/parse/parser.rs
index ce68be6b2464..48213c1f1acd 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -10,32 +10,37 @@ import std::either::left;
import std::either::right;
import std::map::hashmap;
import token::can_begin_expr;
-import driver::session;
-import util::common;
-import util::common::filename;
-import util::common::span;
-import util::common::new_str_hash;
-import util::data::interner;
-import util::common::a_bang;
-import util::common::a_ty;
+import ex=ext::base;
+import codemap::span;
+import _std::new_str_hash;
+import util::interner;
tag restriction { UNRESTRICTED; RESTRICT_NO_CALL_EXPRS; }
tag file_type { CRATE_FILE; SOURCE_FILE; }
-type ty_or_bang = util::common::ty_or_bang[@ast::ty];
+tag ty_or_bang { a_ty(@ast::ty); a_bang; }
+
+type parse_sess = @rec(codemap::codemap cm,
+ mutable ast::node_id next_id);
+
+fn next_node_id(&parse_sess sess) -> ast::node_id {
+ auto rv = sess.next_id;
+ sess.next_id += 1;
+ ret rv;
+}
type parser =
obj {
fn peek() -> token::token ;
fn bump() ;
fn fatal(str) -> ! ;
+ fn warn(str);
fn restrict(restriction) ;
fn get_restriction() -> restriction ;
fn get_file_type() -> file_type ;
fn get_cfg() -> ast::crate_cfg;
- fn get_session() -> session::session ;
- fn get_span() -> common::span ;
+ fn get_span() -> span ;
fn get_lo_pos() -> uint ;
fn get_hi_pos() -> uint ;
fn get_last_lo_pos() -> uint ;
@@ -44,15 +49,15 @@ type parser =
fn get_reader() -> lexer::reader ;
fn get_filemap() -> codemap::filemap ;
fn get_bad_expr_words() -> hashmap[str, ()] ;
- fn get_syntax_expanders() -> hashmap[str, ext::syntax_extension] ;
+ fn get_syntax_expanders() -> hashmap[str, ex::syntax_extension] ;
fn get_chpos() -> uint ;
fn get_id() -> ast::node_id ;
- fn next_id() -> ast::node_id ;
+ fn get_sess() -> parse_sess;
};
-fn new_parser(session::session sess, ast::crate_cfg cfg,
- str path, uint pos, ast::node_id next_id) -> parser {
- obj stdio_parser(session::session sess,
+fn new_parser(parse_sess sess, ast::crate_cfg cfg,
+ str path, uint pos) -> parser {
+ obj stdio_parser(parse_sess sess,
ast::crate_cfg cfg,
file_type ftype,
mutable token::token tok,
@@ -62,9 +67,8 @@ fn new_parser(session::session sess, ast::crate_cfg cfg,
mutable restriction restr,
lexer::reader rdr,
vec[op_spec] precs,
- mutable ast::node_id next_id_var,
hashmap[str, ()] bad_words,
- hashmap[str, ext::syntax_extension] syntax_expanders) {
+ hashmap[str, ex::syntax_extension] syntax_expanders) {
fn peek() -> token::token { ret tok; }
fn bump() {
// log rdr.get_filename()
@@ -75,11 +79,16 @@ fn new_parser(session::session sess, ast::crate_cfg cfg,
lo = rdr.get_mark_chpos();
hi = rdr.get_chpos();
}
- fn fatal(str m) -> ! { sess.span_fatal(rec(lo=lo, hi=hi), m); }
+ fn fatal(str m) -> ! {
+ codemap::emit_error(some(self.get_span()), m, sess.cm);
+ fail;
+ }
+ fn warn(str m) {
+ codemap::emit_warning(some(self.get_span()), m, sess.cm);
+ }
fn restrict(restriction r) { restr = r; }
fn get_restriction() -> restriction { ret restr; }
- fn get_session() -> session::session { ret sess; }
- fn get_span() -> common::span { ret rec(lo=lo, hi=hi); }
+ fn get_span() -> span { ret rec(lo=lo, hi=hi); }
fn get_lo_pos() -> uint { ret lo; }
fn get_hi_pos() -> uint { ret hi; }
fn get_last_lo_pos() -> uint { ret last_lo; }
@@ -92,33 +101,29 @@ fn new_parser(session::session sess, ast::crate_cfg cfg,
fn get_reader() -> lexer::reader { ret rdr; }
fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); }
fn get_bad_expr_words() -> hashmap[str, ()] { ret bad_words; }
- fn get_syntax_expanders() -> hashmap[str, ext::syntax_extension] {
+ fn get_syntax_expanders() -> hashmap[str, ex::syntax_extension] {
ret syntax_expanders;
}
fn get_chpos() -> uint { ret rdr.get_chpos(); }
- fn get_id() -> ast::node_id {
- auto rv = next_id_var;
- next_id_var += 1;
- ret rv;
- }
- fn next_id() -> ast::node_id { ret next_id_var; }
+ fn get_id() -> ast::node_id { ret next_node_id(sess); }
+ fn get_sess() -> parse_sess { ret sess; }
}
auto ftype = SOURCE_FILE;
if (str::ends_with(path, ".rc")) { ftype = CRATE_FILE; }
auto srdr = io::file_reader(path);
auto filemap = codemap::new_filemap(path, pos);
- vec::push(sess.get_codemap().files, filemap);
+ vec::push(sess.cm.files, filemap);
auto itr = @interner::mk(str::hash, str::eq);
- auto rdr = lexer::new_reader(sess, srdr, filemap, itr);
+ auto rdr = lexer::new_reader(sess.cm, srdr, filemap, itr);
// Make sure npos points at first actual token:
lexer::consume_whitespace_and_comments(rdr);
auto npos = rdr.get_chpos();
ret stdio_parser(sess, cfg, ftype, lexer::next_token(rdr),
npos, npos, npos, UNRESTRICTED, rdr,
- prec_table(), next_id, bad_expr_word_table(),
- ext::syntax_expander_table());
+ prec_table(), bad_expr_word_table(),
+ ex::syntax_expander_table());
}
// These are the words that shouldn't be allowed as value identifiers,
@@ -181,7 +186,7 @@ fn expect(&parser p, token::token t) {
}
}
-fn spanned[T](uint lo, uint hi, &T node) -> common::spanned[T] {
+fn spanned[T](uint lo, uint hi, &T node) -> ast::spanned[T] {
ret rec(node=node, span=rec(lo=lo, hi=hi));
}
@@ -326,8 +331,7 @@ fn parse_ty_field(&parser p) -> ast::ty_field {
fn ident_index(&parser p, &vec[ast::arg] args, &ast::ident i) -> uint {
auto j = 0u;
for (ast::arg a in args) { if (a.ident == i) { ret j; } j += 1u; }
- p.get_session().span_fatal(p.get_span(),
- "Unbound variable " + i + " in constraint arg");
+ p.fatal("Unbound variable " + i + " in constraint arg");
}
fn parse_constr_arg(vec[ast::arg] args, &parser p) -> @ast::constr_arg {
@@ -359,7 +363,7 @@ fn parse_ty_constr(&vec[ast::arg] fn_args, &parser p) -> @ast::constr {
// mentioned in a constraint to an arg index.
// Seems weird to do this in the parser, but I'm not sure how else to.
fn parse_constrs(&vec[ast::arg] args, &parser p) ->
- common::spanned[vec[@ast::constr]] {
+ ast::spanned[vec[@ast::constr]] {
auto lo = p.get_lo_pos();
auto hi = p.get_hi_pos();
let vec[@ast::constr] constrs = [];
@@ -431,7 +435,7 @@ fn parse_ty_postfix(@ast::ty orig_t, &parser p) -> @ast::ty {
fn parse_ty_or_bang(&parser p) -> ty_or_bang {
alt (p.peek()) {
- case (token::NOT) { p.bump(); ret a_bang[@ast::ty]; }
+ case (token::NOT) { p.bump(); ret a_bang; }
case (_) { ret a_ty(parse_ty(p)); }
}
}
@@ -460,25 +464,25 @@ fn parse_ty(&parser p) -> @ast::ty {
} else if (eat_word(p, "task")) {
t = ast::ty_task;
} else if (eat_word(p, "i8")) {
- t = ast::ty_machine(common::ty_i8);
+ t = ast::ty_machine(ast::ty_i8);
} else if (eat_word(p, "i16")) {
- t = ast::ty_machine(common::ty_i16);
+ t = ast::ty_machine(ast::ty_i16);
} else if (eat_word(p, "i32")) {
- t = ast::ty_machine(common::ty_i32);
+ t = ast::ty_machine(ast::ty_i32);
} else if (eat_word(p, "i64")) {
- t = ast::ty_machine(common::ty_i64);
+ t = ast::ty_machine(ast::ty_i64);
} else if (eat_word(p, "u8")) {
- t = ast::ty_machine(common::ty_u8);
+ t = ast::ty_machine(ast::ty_u8);
} else if (eat_word(p, "u16")) {
- t = ast::ty_machine(common::ty_u16);
+ t = ast::ty_machine(ast::ty_u16);
} else if (eat_word(p, "u32")) {
- t = ast::ty_machine(common::ty_u32);
+ t = ast::ty_machine(ast::ty_u32);
} else if (eat_word(p, "u64")) {
- t = ast::ty_machine(common::ty_u64);
+ t = ast::ty_machine(ast::ty_u64);
} else if (eat_word(p, "f32")) {
- t = ast::ty_machine(common::ty_f32);
+ t = ast::ty_machine(ast::ty_f32);
} else if (eat_word(p, "f64")) {
- t = ast::ty_machine(common::ty_f64);
+ t = ast::ty_machine(ast::ty_f64);
} else if (p.peek() == token::LPAREN) {
p.bump();
alt (p.peek()) {
@@ -541,9 +545,7 @@ fn parse_ty(&parser p) -> @ast::ty {
hi = p.get_hi_pos();
expect(p, token::RBRACKET);
} else if (eat_word(p, "mutable")) {
- p.get_session().span_warn(p.get_span(),
- "ignoring deprecated 'mutable'"
- + " type constructor");
+ p.warn("ignoring deprecated 'mutable' type constructor");
auto typ = parse_ty(p);
t = typ.node;
hi = typ.span.hi;
@@ -585,7 +587,7 @@ fn parse_seq_to_end[T](token::token ket, option::t[token::token] sep,
fn parse_seq[T](token::token bra, token::token ket,
option::t[token::token] sep, fn(&parser) -> T f, &parser p)
- -> util::common::spanned[vec[T]] {
+ -> ast::spanned[vec[T]] {
auto lo = p.get_lo_pos();
expect(p, bra);
auto result = parse_seq_to_end[T](ket, sep, f, p);
@@ -764,8 +766,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
ex = ast::expr_lit(lit);
}
case (_) {
- p.get_session().span_unimpl(p.get_span(),
- "unique pointer creation");
+ p.fatal("unimplemented: unique pointer creation");
}
}
} else if (eat_word(p, "obj")) {
@@ -971,21 +972,21 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr {
* wish to use while bootstrapping. The eventual aim is to permit
* loading rust crates to process extensions.
*/
-fn expand_syntax_ext(&parser p, common::span sp, &ast::path path,
+fn expand_syntax_ext(&parser p, span sp, &ast::path path,
vec[@ast::expr] args, option::t[str] body) ->
ast::expr_ {
assert (vec::len(path.node.idents) > 0u);
auto extname = path.node.idents.(0);
alt (p.get_syntax_expanders().find(extname)) {
case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); }
- case (some(ext::normal(?ext))) {
- auto ext_cx = ext::mk_ctxt(p);
+ case (some(ex::normal(?ext))) {
+ auto ext_cx = ex::mk_ctxt(p.get_sess());
ret ast::expr_ext(path, args, body, ext(ext_cx, sp, args, body));
}
// because we have expansion inside parsing, new macros are only
// visible further down the file
- case (some(ext::macro_defining(?ext))) {
- auto ext_cx = ext::mk_ctxt(p);
+ case (some(ex::macro_defining(?ext))) {
+ auto ext_cx = ex::mk_ctxt(p.get_sess());
auto name_and_extension = ext(ext_cx, sp, args, body);
p.get_syntax_expanders().insert(name_and_extension._0,
name_and_extension._1);
@@ -1049,9 +1050,7 @@ fn parse_dot_or_call_expr_with(&parser p, @ast::expr e) -> @ast::expr {
fn parse_prefix_expr(&parser p) -> @ast::expr {
if (eat_word(p, "mutable")) {
- p.get_session().span_warn(p.get_span(),
- "ignoring deprecated 'mutable'"
- + " prefix operator");
+ p.warn("ignoring deprecated 'mutable' prefix operator");
}
auto lo = p.get_lo_pos();
auto hi = p.get_hi_pos();
@@ -1676,7 +1675,7 @@ fn parse_ty_params(&parser p) -> vec[ast::ty_param] {
}
fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
- let util::common::spanned[vec[ast::arg]] inputs =
+ let ast::spanned[vec[ast::arg]] inputs =
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
p);
let ty_or_bang rslt;
@@ -1784,7 +1783,7 @@ fn parse_item_obj(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
auto lo = p.get_last_lo_pos();
auto ident = parse_value_ident(p);
auto ty_params = parse_ty_params(p);
- let util::common::spanned[vec[ast::obj_field]] fields =
+ let ast::spanned[vec[ast::obj_field]] fields =
parse_seq[ast::obj_field](token::LPAREN, token::RPAREN,
some(token::COMMA), parse_obj_field, p);
let vec[@ast::method] meths = [];
@@ -2320,7 +2319,10 @@ fn parse_native_view(&parser p) -> vec[@ast::view_item] {
ret items;
}
-fn parse_crate_from_source_file(&parser p) -> @ast::crate {
+fn parse_crate_from_source_file(&str input, &ast::crate_cfg cfg,
+ &codemap::codemap cm) -> @ast::crate {
+ auto sess = @rec(cm=cm, mutable next_id=0);
+ auto p = new_parser(sess, cfg, input, 0u);
auto lo = p.get_lo_pos();
auto crate_attrs = parse_inner_attrs_and_next(p);
auto first_item_outer_attrs = crate_attrs._1;
@@ -2428,7 +2430,10 @@ fn parse_crate_directives(&parser p, token::token term,
ret cdirs;
}
-fn parse_crate_from_crate_file(&parser p) -> @ast::crate {
+fn parse_crate_from_crate_file(&str input, &ast::crate_cfg cfg,
+ &codemap::codemap cm) -> @ast::crate {
+ auto sess = @rec(cm=cm, mutable next_id=0);
+ auto p = new_parser(sess, cfg, input, 0u);
auto lo = p.get_lo_pos();
auto prefix = std::fs::dirname(p.get_filemap().name);
auto leading_attrs = parse_inner_attrs_and_next(p);
@@ -2436,14 +2441,12 @@ fn parse_crate_from_crate_file(&parser p) -> @ast::crate {
auto first_cdir_attr = leading_attrs._1;
auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
let vec[str] deps = [];
- auto cx =
- @rec(p=p,
- mode=eval::mode_parse,
- mutable deps=deps,
- sess=p.get_session(),
- mutable chpos=p.get_chpos(),
- mutable next_id=p.next_id(),
- cfg = p.get_cfg());
+ auto cx = @rec(p=p,
+ mode=eval::mode_parse,
+ mutable deps=deps,
+ sess=sess,
+ mutable chpos=p.get_chpos(),
+ cfg = p.get_cfg());
auto m =
eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
auto hi = p.get_hi_pos();
diff --git a/src/comp/front/token.rs b/src/comp/syntax/parse/token.rs
similarity index 97%
rename from src/comp/front/token.rs
rename to src/comp/syntax/parse/token.rs
index 664a5db5e82e..b8ea07d50db1 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -1,8 +1,8 @@
-import util::common::ty_mach;
-import util::common::ty_mach_to_str;
-import util::common::new_str_hash;
-import util::data::interner;
+import ast::ty_mach;
+import ast::ty_mach_to_str;
+import _std::new_str_hash;
+import util::interner;
import std::int;
import std::uint;
import std::str;
diff --git a/src/comp/pretty/pp.rs b/src/comp/syntax/print/pp.rs
similarity index 100%
rename from src/comp/pretty/pp.rs
rename to src/comp/syntax/print/pp.rs
diff --git a/src/comp/pretty/pprust.rs b/src/comp/syntax/print/pprust.rs
similarity index 82%
rename from src/comp/pretty/pprust.rs
rename to src/comp/syntax/print/pprust.rs
index 104362aa26ea..b146d703471e 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -5,12 +5,11 @@ import std::vec;
import std::str;
import std::io;
import std::option;
-import driver::session::session;
-import front::lexer;
-import front::codemap;
-import front::codemap::codemap;
-import front::ast;
-import util::common;
+import parse::lexer;
+import syntax::codemap::codemap;
+import ast;
+import _std::istr;
+import _std::uistr;
import option::some;
import option::none;
import pp::printer;
@@ -25,15 +24,63 @@ import pp::breaks;
import pp::consistent;
import pp::inconsistent;
import pp::eof;
-import ppaux::*;
-fn print_crate(session sess, @ast::crate crate, str filename,
+// The ps is stored here to prevent recursive type.
+// FIXME use a nominal tag instead
+tag ann_node {
+ node_block(ps, ast::block);
+ node_item(ps, @ast::item);
+ node_expr(ps, @ast::expr);
+ node_pat(ps, @ast::pat);
+}
+type pp_ann = rec(fn(&ann_node node) pre,
+ fn(&ann_node node) post);
+
+fn no_ann() -> pp_ann {
+ fn ignore(&ann_node node) {}
+ ret rec(pre=ignore, post=ignore);
+}
+
+type ps =
+ @rec(pp::printer s,
+ option::t[codemap] cm,
+ option::t[vec[lexer::cmnt]] comments,
+ option::t[vec[lexer::lit]] literals,
+ mutable uint cur_cmnt,
+ mutable uint cur_lit,
+ mutable vec[pp::breaks] boxes,
+ pp_ann ann);
+
+fn ibox(&ps s, uint u) {
+ vec::push(s.boxes, pp::inconsistent);
+ pp::ibox(s.s, u);
+}
+
+fn end(&ps s) { vec::pop(s.boxes); pp::end(s.s); }
+
+fn rust_printer(io::writer writer) -> ps {
+ let vec[pp::breaks] boxes = [];
+ ret @rec(s=pp::mk_printer(writer, default_columns),
+ cm=none[codemap],
+ comments=none[vec[lexer::cmnt]],
+ literals=none[vec[lexer::lit]],
+ mutable cur_cmnt=0u,
+ mutable cur_lit=0u,
+ mutable boxes=boxes,
+ ann=no_ann());
+}
+
+const uint indent_unit = 4u;
+
+const uint default_columns = 78u;
+
+fn print_crate(&codemap cm, @ast::crate crate, str filename,
io::writer out, &pp_ann ann) {
let vec[pp::breaks] boxes = [];
- auto r = lexer::gather_comments_and_literals(sess, filename);
+ auto r = lexer::gather_comments_and_literals(cm, filename);
auto s =
@rec(s=pp::mk_printer(out, default_columns),
- cm=some(sess.get_codemap()),
+ cm=some(cm),
comments=some(r.cmnts),
literals=some(r.lits),
mutable cur_cmnt=0u,
@@ -119,7 +166,7 @@ fn bopen(&ps s) {
}
-fn bclose(&ps s, common::span span) {
+fn bclose(&ps s, codemap::span span) {
maybe_print_comment(s, span.hi);
break_offset(s.s, 1u, -(indent_unit as int));
word(s.s, "}");
@@ -161,7 +208,7 @@ fn commasep[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op) {
}
fn commasep_cmnt[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op,
- fn(&IN) -> common::span get_span) {
+ fn(&IN) -> codemap::span get_span) {
box(s, 0u, b);
auto len = vec::len[IN](elts);
auto i = 0u;
@@ -180,7 +227,7 @@ fn commasep_cmnt[IN](&ps s, breaks b, vec[IN] elts, fn(&ps, &IN) op,
}
fn commasep_exprs(&ps s, breaks b, vec[@ast::expr] exprs) {
- fn expr_span(&@ast::expr expr) -> common::span { ret expr.span; }
+ fn expr_span(&@ast::expr expr) -> codemap::span { ret expr.span; }
commasep_cmnt(s, b, exprs, print_expr, expr_span);
}
@@ -208,7 +255,7 @@ fn print_type(&ps s, &ast::ty ty) {
case (ast::ty_int) { word(s.s, "int"); }
case (ast::ty_uint) { word(s.s, "uint"); }
case (ast::ty_float) { word(s.s, "float"); }
- case (ast::ty_machine(?tm)) { word(s.s, common::ty_mach_to_str(tm)); }
+ case (ast::ty_machine(?tm)) { word(s.s, ast::ty_mach_to_str(tm)); }
case (ast::ty_char) { word(s.s, "char"); }
case (ast::ty_str) { word(s.s, "str"); }
case (ast::ty_istr) { word(s.s, "istr"); }
@@ -257,7 +304,7 @@ fn print_type(&ps s, &ast::ty ty) {
word(s.s, f.node.ident);
end(s);
}
- fn get_span(&ast::ty_field f) -> common::span { ret f.span; }
+ fn get_span(&ast::ty_field f) -> codemap::span { ret f.span; }
commasep_cmnt(s, consistent, fields, print_field, get_span);
pclose(s);
}
@@ -435,7 +482,7 @@ fn print_item(&ps s, &@ast::item item) {
word(s.s, field.ident);
end(s);
}
- fn get_span(&ast::obj_field f) -> common::span { ret f.ty.span; }
+ fn get_span(&ast::obj_field f) -> codemap::span { ret f.ty.span; }
commasep_cmnt(s, consistent, _obj.fields, print_field, get_span);
pclose(s);
space(s.s);
@@ -517,7 +564,7 @@ fn print_stmt(&ps s, &ast::stmt st) {
print_expr(s, expr);
}
}
- if (front::parser::stmt_ends_with_semi(st)) { word(s.s, ";"); }
+ if (parse::parser::stmt_ends_with_semi(st)) { word(s.s, ";"); }
maybe_print_trailing_comment(s, st.span, none[uint]);
}
@@ -605,7 +652,7 @@ fn print_expr(&ps s, &@ast::expr expr) {
print_expr(s, elt.expr);
end(s);
}
- fn get_span(&ast::elt elt) -> common::span { ret elt.expr.span; }
+ fn get_span(&ast::elt elt) -> codemap::span { ret elt.expr.span; }
word(s.s, "tup");
popen(s);
commasep_cmnt(s, inconsistent, exprs, printElt, get_span);
@@ -620,7 +667,9 @@ fn print_expr(&ps s, &@ast::expr expr) {
print_expr(s, field.node.expr);
end(s);
}
- fn get_span(&ast::field field) -> common::span { ret field.span; }
+ fn get_span(&ast::field field) -> codemap::span {
+ ret field.span;
+ }
word(s.s, "rec");
popen(s);
commasep_cmnt(s, consistent, fields, print_field, get_span);
@@ -675,11 +724,11 @@ fn print_expr(&ps s, &@ast::expr expr) {
}
case (ast::expr_unary(?op, ?expr)) {
word(s.s, ast::unop_to_str(op));
- print_maybe_parens(s, expr, front::parser::unop_prec);
+ print_maybe_parens(s, expr, parse::parser::unop_prec);
}
case (ast::expr_lit(?lit)) { print_literal(s, lit); }
case (ast::expr_cast(?expr, ?ty)) {
- print_maybe_parens(s, expr, front::parser::as_prec);
+ print_maybe_parens(s, expr, parse::parser::as_prec);
space(s.s);
word_space(s, "as");
print_type(s, *ty);
@@ -1114,7 +1163,7 @@ 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()) {
+ for (parse::parser::op_spec spec in parse::parser::prec_table()) {
if (spec.op == op) { ret spec.prec; }
}
fail;
@@ -1127,10 +1176,10 @@ fn print_maybe_parens(&ps s, &@ast::expr expr, int outer_prec) {
add_them = operator_prec(op) < outer_prec;
}
case (ast::expr_cast(_, _)) {
- add_them = front::parser::as_prec < outer_prec;
+ add_them = parse::parser::as_prec < outer_prec;
}
case (ast::expr_ternary(_, _, _)) {
- add_them = front::parser::ternary_prec < outer_prec;
+ add_them = parse::parser::ternary_prec < outer_prec;
}
case (_) { add_them = false; }
}
@@ -1186,7 +1235,7 @@ fn print_ty_fn(&ps s, &ast::proto proto, &option::t[str] id,
end(s);
}
-fn maybe_print_trailing_comment(&ps s, common::span span,
+fn maybe_print_trailing_comment(&ps s, codemap::span span,
option::t[uint] next_pos) {
auto cm;
alt (s.cm) { case (some(?ccm)) { cm = ccm; } case (_) { ret; } }
@@ -1221,6 +1270,197 @@ fn in_cbox(&ps s) -> bool {
if (len == 0u) { ret false; }
ret s.boxes.(len - 1u) == pp::consistent;
}
+
+fn print_literal(&ps s, &@ast::lit lit) {
+ maybe_print_comment(s, lit.span.lo);
+ alt (next_lit(s)) {
+ case (some(?lt)) {
+ if (lt.pos == lit.span.lo) {
+ word(s.s, lt.lit);
+ s.cur_lit += 1u;
+ ret;
+ }
+ }
+ case (_) { }
+ }
+ alt (lit.node) {
+ case (ast::lit_str(?st, ?kind)) {
+ if (kind == ast::sk_unique) { word(s.s, "~"); }
+ print_string(s, st);
+ }
+ case (ast::lit_char(?ch)) {
+ word(s.s,
+ "'" + escape_str(str::from_bytes([ch as u8]), '\'') + "'");
+ }
+ case (ast::lit_int(?val)) { word(s.s, istr(val)); }
+ case (ast::lit_uint(?val)) { word(s.s, uistr(val) + "u"); }
+ case (ast::lit_float(?fstr)) { word(s.s, fstr); }
+ case (ast::lit_mach_int(?mach, ?val)) {
+ word(s.s, istr(val as int));
+ word(s.s, ast::ty_mach_to_str(mach));
+ }
+ case (ast::lit_mach_float(?mach, ?val)) {
+ // val is already a str
+ word(s.s, val);
+ word(s.s, ast::ty_mach_to_str(mach));
+ }
+ case (ast::lit_nil) { word(s.s, "()"); }
+ case (ast::lit_bool(?val)) {
+ if (val) { word(s.s, "true"); } else { word(s.s, "false"); }
+ }
+ }
+}
+
+fn lit_to_str(&@ast::lit l) -> str { be to_str(l, print_literal); }
+
+fn next_lit(&ps s) -> option::t[lexer::lit] {
+ alt (s.literals) {
+ case (some(?lits)) {
+ if (s.cur_lit < vec::len(lits)) {
+ ret some(lits.(s.cur_lit));
+ } else { ret none[lexer::lit]; }
+ }
+ case (_) { ret none[lexer::lit]; }
+ }
+}
+
+fn maybe_print_comment(&ps s, uint pos) {
+ while (true) {
+ alt (next_comment(s)) {
+ case (some(?cmnt)) {
+ if (cmnt.pos < pos) {
+ print_comment(s, cmnt);
+ s.cur_cmnt += 1u;
+ } else { break; }
+ }
+ case (_) { break; }
+ }
+ }
+}
+
+fn print_comment(&ps s, lexer::cmnt cmnt) {
+ alt (cmnt.style) {
+ case (lexer::mixed) {
+ assert (vec::len(cmnt.lines) == 1u);
+ zerobreak(s.s);
+ word(s.s, cmnt.lines.(0));
+ zerobreak(s.s);
+ }
+ case (lexer::isolated) {
+ pprust::hardbreak_if_not_bol(s);
+ for (str line in cmnt.lines) { word(s.s, line); hardbreak(s.s); }
+ }
+ case (lexer::trailing) {
+ word(s.s, " ");
+ if (vec::len(cmnt.lines) == 1u) {
+ word(s.s, cmnt.lines.(0));
+ hardbreak(s.s);
+ } else {
+ ibox(s, 0u);
+ for (str line in cmnt.lines) {
+ word(s.s, line);
+ hardbreak(s.s);
+ }
+ end(s);
+ }
+ }
+ case (lexer::blank_line) {
+ // We need to do at least one, possibly two hardbreaks.
+ pprust::hardbreak_if_not_bol(s);
+ hardbreak(s.s);
+ }
+ }
+}
+
+fn print_string(&ps s, &str st) {
+ word(s.s, "\"");
+ word(s.s, escape_str(st, '"'));
+ word(s.s, "\"");
+}
+
+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 += "\\"; }
+ // FIXME some (or all?) non-ascii things should be escaped
+
+ str::push_char(out, cur);
+ }
+ }
+ i += 1u;
+ }
+ ret out;
+}
+
+fn to_str[T](&T t, fn(&ps, &T) f) -> str {
+ auto writer = io::string_writer();
+ auto s = rust_printer(writer.get_writer());
+ f(s, t);
+ eof(s.s);
+ ret writer.get_str();
+}
+
+fn next_comment(&ps s) -> option::t[lexer::cmnt] {
+ alt (s.comments) {
+ case (some(?cmnts)) {
+ if (s.cur_cmnt < vec::len(cmnts)) {
+ ret some(cmnts.(s.cur_cmnt));
+ } else { ret none[lexer::cmnt]; }
+ }
+ case (_) { ret none[lexer::cmnt]; }
+ }
+}
+
+
+fn constr_args_to_str[T](fn(&T) -> str f,
+ &vec[@ast::constr_arg_general[T]] args) -> str {
+ auto comma = false;
+ auto s = "(";
+ for (@ast::constr_arg_general[T] a in args) {
+ if (comma) { s += ", "; } else { comma = true; }
+ s += constr_arg_to_str[T](f, a.node);
+ }
+ s += ")";
+ ret s;
+}
+
+fn constr_arg_to_str[T](fn(&T) -> str f, &ast::constr_arg_general_[T] c) ->
+ str {
+ alt (c) {
+ case (ast::carg_base) { ret "*"; }
+ case (ast::carg_ident(?i)) { ret f(i); }
+ case (ast::carg_lit(?l)) { ret lit_to_str(l); }
+ }
+}
+
+// needed b/c constr_args_to_str needs
+// something that takes an alias
+// (argh)
+fn uint_to_str(&uint i) -> str { ret uistr(i); }
+
+fn ast_constr_to_str(&@ast::constr c) -> str {
+ ret ast::path_to_str(c.node.path) +
+ constr_args_to_str(uint_to_str, c.node.args);
+}
+
+fn ast_constrs_str(&vec[@ast::constr] constrs) -> str {
+ auto s = "";
+ auto colon = true;
+ for (@ast::constr c in constrs) {
+ if (colon) { s += " : "; colon = false; } else { s += ", "; }
+ s += ast_constr_to_str(c);
+ }
+ ret s;
+}
+
//
// Local Variables:
// mode: rust
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
new file mode 100644
index 000000000000..e096b953a891
--- /dev/null
+++ b/src/comp/syntax/util/interner.rs
@@ -0,0 +1,35 @@
+// An "interner" is a data structure that associates values with uint tags and
+// allows bidirectional lookup; i.e. given a value, one can easily find the
+// type, and vice versa.
+import std::vec;
+import std::map;
+import std::map::hashmap;
+import std::map::hashfn;
+import std::map::eqfn;
+import std::option;
+import std::option::none;
+import std::option::some;
+
+type interner[T] =
+ rec(hashmap[T, uint] map,
+ mutable vec[T] vect,
+ hashfn[T] hasher,
+ eqfn[T] eqer);
+
+fn mk[T](hashfn[T] hasher, eqfn[T] eqer) -> interner[T] {
+ auto m = map::mk_hashmap[T, uint](hasher, eqer);
+ let vec[T] vect = [];
+ ret rec(map=m, mutable vect=vect, hasher=hasher, eqer=eqer);
+}
+fn intern[T](&interner[T] itr, &T val) -> uint {
+ alt (itr.map.find(val)) {
+ case (some(?idx)) { ret idx; }
+ case (none) {
+ auto new_idx = vec::len[T](itr.vect);
+ itr.map.insert(val, new_idx);
+ itr.vect += [val];
+ ret new_idx;
+ }
+ }
+}
+fn get[T](&interner[T] itr, uint idx) -> T { ret itr.vect.(idx); }
diff --git a/src/comp/middle/visit.rs b/src/comp/syntax/visit.rs
similarity index 99%
rename from src/comp/middle/visit.rs
rename to src/comp/syntax/visit.rs
index c87373c4ff86..a709814a9a32 100644
--- a/src/comp/middle/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -1,10 +1,9 @@
-import front::ast::*;
+import ast::*;
import std::option;
import std::option::some;
import std::option::none;
-import util::common::span;
-import util::common::respan;
+import codemap::span;
// Context-passing AST walker. Each overridden visit method has full control
diff --git a/src/comp/middle/walk.rs b/src/comp/syntax/walk.rs
similarity index 99%
rename from src/comp/middle/walk.rs
rename to src/comp/syntax/walk.rs
index 598c6d68f787..79e8ca6dca6b 100644
--- a/src/comp/middle/walk.rs
+++ b/src/comp/syntax/walk.rs
@@ -1,11 +1,11 @@
-import front::ast;
-import middle::ty::ty_param;
+import ast;
+import ast::ty_param;
+import ast::respan;
import std::option;
import std::option::some;
import std::option::none;
-import util::common::span;
-import util::common::respan;
+import codemap::span;
type ast_visitor =
rec(fn() -> bool keep_going,
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index 9eca5c1f9b52..cf50c2fbc733 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -7,70 +7,30 @@ import std::vec;
import std::option;
import std::option::none;
import std::option::some;
-import front::ast;
-import front::ast::ty;
-import front::ast::pat;
-import front::codemap::codemap;
-import front::ast::lit;
-import front::ast::path;
-import middle::walk;
+import syntax::ast;
+import ast::ty;
+import ast::pat;
+import syntax::codemap::codemap;
+import syntax::codemap::span;
+import ast::lit;
+import ast::path;
+import syntax::walk;
import std::io::stdout;
import std::io::str_writer;
import std::io::string_writer;
-import pretty::pprust::print_block;
-import pretty::pprust::print_item;
-import pretty::pprust::print_expr;
-import pretty::pprust::print_path;
-import pretty::pprust::print_decl;
-import pretty::pprust::print_fn;
-import pretty::pprust::print_type;
-import pretty::ppaux::print_literal;
-import pretty::pp::mk_printer;
-
-type filename = str;
-
-type span = rec(uint lo, uint hi);
-
-type spanned[T] = rec(T node, span span);
+import syntax::print;
+import print::pprust::print_block;
+import print::pprust::print_item;
+import print::pprust::print_expr;
+import print::pprust::print_path;
+import print::pprust::print_decl;
+import print::pprust::print_fn;
+import print::pprust::print_type;
+import print::pprust::print_literal;
+import print::pp::mk_printer;
type flag = hashmap[str, ()];
-tag ty_mach {
- ty_i8;
- ty_i16;
- ty_i32;
- ty_i64;
- ty_u8;
- ty_u16;
- ty_u32;
- ty_u64;
- ty_f32;
- ty_f64;
-}
-
-tag ty_or_bang[T] { a_ty(T); a_bang; }
-
-fn ty_mach_to_str(ty_mach tm) -> str {
- alt (tm) {
- case (ty_u8) { ret "u8"; }
- case (ty_u16) { ret "u16"; }
- case (ty_u32) { ret "u32"; }
- case (ty_u64) { ret "u64"; }
- case (ty_i8) { ret "i8"; }
- case (ty_i16) { ret "i16"; }
- case (ty_i32) { ret "i32"; }
- case (ty_i64) { ret "i64"; }
- case (ty_f32) { ret "f32"; }
- case (ty_f64) { ret "f64"; }
- }
-}
-
-fn new_str_hash[V]() -> std::map::hashmap[str, V] {
- let std::map::hashfn[str] hasher = std::str::hash;
- let std::map::eqfn[str] eqer = std::str::eq;
- ret std::map::mk_hashmap[str, V](hasher, eqer);
-}
-
fn def_eq(&ast::def_id a, &ast::def_id b) -> bool {
ret a._0 == b._0 && a._1 == b._1;
}
@@ -88,26 +48,6 @@ fn new_def_hash[V]() -> std::map::hashmap[ast::def_id, V] {
ret std::map::mk_hashmap[ast::def_id, V](hasher, eqer);
}
-fn new_int_hash[V]() -> std::map::hashmap[int, V] {
- fn hash_int(&int x) -> uint { ret x as uint; }
- fn eq_int(&int a, &int b) -> bool { ret a == b; }
- auto hasher = hash_int;
- auto eqer = eq_int;
- ret std::map::mk_hashmap[int, V](hasher, eqer);
-}
-
-fn new_uint_hash[V]() -> std::map::hashmap[uint, V] {
- fn hash_uint(&uint x) -> uint { ret x; }
- fn eq_uint(&uint a, &uint b) -> bool { ret a == b; }
- auto hasher = hash_uint;
- auto eqer = eq_uint;
- ret std::map::mk_hashmap[uint, V](hasher, eqer);
-}
-
-fn istr(int i) -> str { ret int::to_str(i, 10u); }
-
-fn uistr(uint i) -> str { ret uint::to_str(i, 10u); }
-
fn elt_expr(&ast::elt e) -> @ast::expr { ret e.expr; }
fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] {
@@ -122,31 +62,31 @@ fn field_exprs(vec[ast::field] fields) -> vec[@ast::expr] {
ret vec::map[ast::field, @ast::expr](f, fields);
}
-fn log_expr(&ast::expr e) { log pretty::pprust::expr_to_str(@e); }
+fn log_expr(&ast::expr e) { log print::pprust::expr_to_str(@e); }
-fn log_expr_err(&ast::expr e) { log_err pretty::pprust::expr_to_str(@e); }
+fn log_expr_err(&ast::expr e) { log_err print::pprust::expr_to_str(@e); }
-fn log_ty_err(&ty t) { log_err pretty::pprust::ty_to_str(t); }
+fn log_ty_err(&ty t) { log_err print::pprust::ty_to_str(t); }
-fn log_pat_err(&@pat p) { log_err pretty::pprust::pat_to_str(p); }
+fn log_pat_err(&@pat p) { log_err print::pprust::pat_to_str(p); }
-fn log_block(&ast::block b) { log pretty::pprust::block_to_str(b); }
+fn log_block(&ast::block b) { log print::pprust::block_to_str(b); }
-fn log_block_err(&ast::block b) { log_err pretty::pprust::block_to_str(b); }
+fn log_block_err(&ast::block b) { log_err print::pprust::block_to_str(b); }
-fn log_item_err(&@ast::item i) { log_err pretty::pprust::item_to_str(i); }
+fn log_item_err(&@ast::item i) { log_err print::pprust::item_to_str(i); }
fn log_fn(&ast::_fn f, str name, vec[ast::ty_param] params) {
- log pretty::pprust::fun_to_str(f, name, params);
+ log print::pprust::fun_to_str(f, name, params);
}
fn log_fn_err(&ast::_fn f, str name, vec[ast::ty_param] params) {
- log_err pretty::pprust::fun_to_str(f, name, params);
+ log_err print::pprust::fun_to_str(f, name, params);
}
-fn log_stmt(&ast::stmt st) { log pretty::pprust::stmt_to_str(st); }
+fn log_stmt(&ast::stmt st) { log print::pprust::stmt_to_str(st); }
-fn log_stmt_err(&ast::stmt st) { log_err pretty::pprust::stmt_to_str(st); }
+fn log_stmt_err(&ast::stmt st) { log_err print::pprust::stmt_to_str(st); }
fn has_nonlocal_exits(&ast::block b) -> bool {
auto has_exits = @mutable false;
@@ -232,27 +172,6 @@ fn lit_eq(&@ast::lit l, &@ast::lit m) -> bool {
}
}
-fn respan[T](&span sp, &T t) -> spanned[T] { ret rec(node=t, span=sp); }
-
-fn may_begin_ident(char c) -> bool { ret is_alpha(c) || c == '_'; }
-
-fn in_range(char c, char lo, char hi) -> bool { ret lo <= c && c <= hi; }
-
-fn is_alpha(char c) -> bool {
- ret in_range(c, 'a', 'z') || in_range(c, 'A', 'Z');
-}
-
-fn is_dec_digit(char c) -> bool { ret in_range(c, '0', '9'); }
-
-fn is_alnum(char c) -> bool { ret is_alpha(c) || is_dec_digit(c); }
-
-fn is_hex_digit(char c) -> bool {
- ret in_range(c, '0', '9') || in_range(c, 'a', 'f') ||
- in_range(c, 'A', 'F');
-}
-
-fn is_bin_digit(char c) -> bool { ret c == '0' || c == '1'; }
-
// FIXME move to vec
fn any[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
for (T t in v) {
diff --git a/src/comp/util/data.rs b/src/comp/util/data.rs
deleted file mode 100644
index 5ff3cf686780..000000000000
--- a/src/comp/util/data.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-
-
-// An "interner" is a data structure that associates values with uint tags and
-// allows bidirectional lookup; i.e. given a value, one can easily find the
-// type, and vice versa.
-import std::vec;
-import std::map;
-import std::map::hashmap;
-import std::map::hashfn;
-import std::map::eqfn;
-import std::option;
-import std::option::none;
-import std::option::some;
-
-mod interner {
- type interner[T] =
- rec(hashmap[T, uint] map,
- mutable vec[T] vect,
- hashfn[T] hasher,
- eqfn[T] eqer);
-
- fn mk[T](hashfn[T] hasher, eqfn[T] eqer) -> interner[T] {
- auto m = map::mk_hashmap[T, uint](hasher, eqer);
- let vec[T] vect = [];
- ret rec(map=m, mutable vect=vect, hasher=hasher, eqer=eqer);
- }
- fn intern[T](&interner[T] itr, &T val) -> uint {
- alt (itr.map.find(val)) {
- case (some(?idx)) { ret idx; }
- case (none) {
- auto new_idx = vec::len[T](itr.vect);
- itr.map.insert(val, new_idx);
- itr.vect += [val];
- ret new_idx;
- }
- }
- }
- fn get[T](&interner[T] itr, uint idx) -> T { ret itr.vect.(idx); }
-}
diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs
new file mode 100644
index 000000000000..4adc6c437db7
--- /dev/null
+++ b/src/comp/util/ppaux.rs
@@ -0,0 +1,182 @@
+import std::io;
+import std::vec;
+import std::str;
+import std::option;
+import std::option::none;
+import std::option::some;
+import middle::ty;
+import middle::ty::*;
+import syntax::print::pp;
+import syntax::print::pprust;
+import pp::word;
+import pp::eof;
+import pp::zerobreak;
+import pp::hardbreak;
+import syntax::_std::istr;
+import syntax::_std::uistr;
+import ast::ty_mach_to_str;
+import syntax::ast;
+
+fn mode_str(&ty::mode m) -> str {
+ alt (m) {
+ case (mo_val) { "" }
+ case (mo_alias(false)) { "&" }
+ case (mo_alias(true)) { "&mutable " }
+ }
+}
+
+fn mode_str_1(&ty::mode m) -> str {
+ alt (m) {
+ case (mo_val) { "val" }
+ case (_) { mode_str(m) }
+ }
+}
+
+fn fn_ident_to_string(ast::node_id id, &ast::fn_ident i) -> str {
+ ret alt (i) {
+ case (none) { "anon" + istr(id) }
+ case (some(?s)) { s }
+ };
+}
+
+fn ty_to_str(&ctxt cx, &t typ) -> str {
+ fn fn_input_to_str(&ctxt cx, &rec(middle::ty::mode mode, t ty) input) ->
+ str {
+ auto s = mode_str(input.mode);
+ ret s + ty_to_str(cx, input.ty);
+ }
+ fn fn_to_str(&ctxt cx, ast::proto proto, option::t[ast::ident] ident,
+ &arg[] inputs, t output, ast::controlflow cf,
+ &vec[@constr_def] constrs) -> str {
+ auto s;
+ alt (proto) {
+ case (ast::proto_iter) { s = "iter"; }
+ case (ast::proto_fn) { s = "fn"; }
+ }
+ alt (ident) { case (some(?i)) { s += " "; s += i; } case (_) { } }
+ s += "(";
+ auto strs = [];
+ for (arg a in inputs) { strs += [fn_input_to_str(cx, a)]; }
+ s += str::connect(strs, ", ");
+ s += ")";
+ if (struct(cx, output) != ty_nil) {
+ alt (cf) {
+ case (ast::noreturn) { s += " -> !"; }
+ case (ast::return) { s += " -> " + ty_to_str(cx, output); }
+ }
+ }
+ s += constrs_str(constrs);
+ ret s;
+ }
+ fn method_to_str(&ctxt cx, &method m) -> str {
+ ret fn_to_str(cx, m.proto, some[ast::ident](m.ident), m.inputs,
+ m.output, m.cf, m.constrs) + ";";
+ }
+ fn field_to_str(&ctxt cx, &field f) -> str {
+ ret mt_to_str(cx, f.mt) + " " + f.ident;
+ }
+ fn mt_to_str(&ctxt cx, &mt m) -> str {
+ auto mstr;
+ alt (m.mut) {
+ case (ast::mut) { mstr = "mutable "; }
+ case (ast::imm) { mstr = ""; }
+ case (ast::maybe_mut) { mstr = "mutable? "; }
+ }
+ ret mstr + ty_to_str(cx, m.ty);
+ }
+ alt (cname(cx, typ)) { case (some(?cs)) { ret cs; } case (_) { } }
+ auto s = "";
+ alt (struct(cx, typ)) {
+ case (ty_native(_)) { s += "native"; }
+ case (ty_nil) { s += "()"; }
+ case (ty_bot) { s += "_|_"; }
+ case (ty_bool) { s += "bool"; }
+ case (ty_int) { s += "int"; }
+ case (ty_float) { s += "float"; }
+ case (ty_uint) { s += "uint"; }
+ case (ty_machine(?tm)) { s += ty_mach_to_str(tm); }
+ case (ty_char) { s += "char"; }
+ case (ty_str) { s += "str"; }
+ case (ty_istr) { s += "istr"; }
+ case (ty_box(?tm)) { s += "@" + mt_to_str(cx, tm); }
+ case (ty_vec(?tm)) { s += "vec[" + mt_to_str(cx, tm) + "]"; }
+ case (ty_ivec(?tm)) { s += "ivec[" + mt_to_str(cx, tm) + "]"; }
+ case (ty_port(?t)) { s += "port[" + ty_to_str(cx, t) + "]"; }
+ case (ty_chan(?t)) { s += "chan[" + ty_to_str(cx, t) + "]"; }
+ case (ty_type) { s += "type"; }
+ case (ty_task) { s += "task"; }
+ case (ty_tup(?elems)) {
+ let vec[str] strs = [];
+ for (mt tm in elems) { strs += [mt_to_str(cx, tm)]; }
+ s += "tup(" + str::connect(strs, ",") + ")";
+ }
+ case (ty_rec(?elems)) {
+ let vec[str] strs = [];
+ for (field fld in elems) { strs += [field_to_str(cx, fld)]; }
+ s += "rec(" + str::connect(strs, ",") + ")";
+ }
+ case (ty_tag(?id, ?tps)) {
+ // The user should never see this if the cname is set properly!
+
+ s += "";
+ if (vec::len[t](tps) > 0u) {
+ auto f = bind ty_to_str(cx, _);
+ auto strs = vec::map[t, str](f, tps);
+ s += "[" + str::connect(strs, ",") + "]";
+ }
+ }
+ case (ty_fn(?proto, ?inputs, ?output, ?cf, ?constrs)) {
+ s += fn_to_str(cx, proto, none, inputs, output, cf, constrs);
+ }
+ case (ty_native_fn(_, ?inputs, ?output)) {
+ s += fn_to_str(cx, ast::proto_fn, none, inputs, output,
+ ast::return, []);
+ }
+ case (ty_obj(?meths)) {
+ auto f = bind method_to_str(cx, _);
+ auto m = vec::map[method, str](f, meths);
+ s += "obj {\n\t" + str::connect(m, "\n\t") + "\n}";
+ }
+ case (ty_res(?id, _, _)) {
+ s += "";
+ }
+ case (ty_var(?v)) { s += ""; }
+ case (ty_param(?id)) {
+ s += "'" + str::unsafe_from_bytes([('a' as u8) + (id as u8)]);
+ }
+ case (_) { s += ty_to_short_str(cx, typ); }
+ }
+ ret s;
+}
+
+fn ty_to_short_str(&ctxt cx, t typ) -> str {
+ auto f = def_to_str;
+ auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata::tyencode::ac_no_abbrevs);
+ auto s = metadata::tyencode::ty_str(ecx, typ);
+ if (str::byte_len(s) >= 32u) { s = str::substr(s, 0u, 32u); }
+ ret s;
+}
+
+fn constr_to_str(&@constr_def c) -> str {
+ ret ast::path_to_str(c.node.path) +
+ pprust::constr_args_to_str(pprust::uint_to_str, c.node.args);
+}
+
+fn constrs_str(&vec[@constr_def] constrs) -> str {
+ auto s = "";
+ auto colon = true;
+ for (@constr_def c in constrs) {
+ if (colon) { s += " : "; colon = false; } else { s += ", "; }
+ s += constr_to_str(c);
+ }
+ ret s;
+}
+
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
diff --git a/src/lib/int.rs b/src/lib/int.rs
index 2387d2587239..af2403cd4b01 100644
--- a/src/lib/int.rs
+++ b/src/lib/int.rs
@@ -47,6 +47,7 @@ fn to_str(int n, uint radix) -> str {
"-" + uint::to_str(-n as uint, radix)
} else { uint::to_str(n as uint, radix) };
}
+fn str(int i) -> str { ret to_str(i, 10u); }
fn pow(int base, uint exponent) -> int {
ret if (exponent == 0u) {
diff --git a/src/lib/map.rs b/src/lib/map.rs
index 90b2693bdcfd..95214bcbf262 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -1,6 +1,3 @@
-
-
-
/**
* At the moment, this is a partial hashmap implementation, not yet fit for
* use, but useful as a stress test for rustboot.
@@ -196,6 +193,31 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
let vec[mutable bucket[K, V]] bkts = make_buckets[K, V](initial_capacity);
ret hashmap[K, V](hasher, eqer, bkts, initial_capacity, 0u, load_factor);
}
+
+// Hash map constructors for basic types
+
+fn new_str_hash[V]() -> hashmap[str, V] {
+ let hashfn[str] hasher = str::hash;
+ let eqfn[str] eqer = str::eq;
+ ret mk_hashmap[str, V](hasher, eqer);
+}
+
+fn new_int_hash[V]() -> hashmap[int, V] {
+ fn hash_int(&int x) -> uint { ret x as uint; }
+ fn eq_int(&int a, &int b) -> bool { ret a == b; }
+ auto hasher = hash_int;
+ auto eqer = eq_int;
+ ret mk_hashmap[int, V](hasher, eqer);
+}
+
+fn new_uint_hash[V]() -> hashmap[uint, V] {
+ fn hash_uint(&uint x) -> uint { ret x; }
+ fn eq_uint(&uint a, &uint b) -> bool { ret a == b; }
+ auto hasher = hash_uint;
+ auto eqer = eq_uint;
+ ret mk_hashmap[uint, V](hasher, eqer);
+}
+
// Local Variables:
// mode: rust;
// fill-column: 78;
diff --git a/src/lib/uint.rs b/src/lib/uint.rs
index ca632914a459..6908aa6342a6 100644
--- a/src/lib/uint.rs
+++ b/src/lib/uint.rs
@@ -92,6 +92,8 @@ fn to_str(uint num, uint radix) -> str {
while (len != 0u) { len -= 1u; s1 += str::unsafe_from_byte(s.(len)); }
ret s1;
}
+fn str(uint i) -> str { ret to_str(i, 10u); }
+
// Local Variables:
// mode: rust;
// fill-column: 78;
diff --git a/src/lib/vec.rs b/src/lib/vec.rs
index cf7be9167229..2a0754779376 100644
--- a/src/lib/vec.rs
+++ b/src/lib/vec.rs
@@ -301,6 +301,19 @@ fn or(&vec[bool] v) -> bool {
ret vec::foldl[bool, bool](f, false, v);
}
+fn any[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
+ for (T t in v) {
+ if (f(t)) { ret true; }
+ }
+ ret false;
+}
+fn all[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
+ for (T t in v) {
+ if (!f(t)) { ret false; }
+ }
+ ret true;
+}
+
fn clone[T](&vec[T] v) -> vec[T] { ret slice[T](v, 0u, len[T](v)); }
fn plus_option[T](&mutable vec[T] v, &option::t[T] o) {