bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Move everything syntax-related to syntax/, break deps on rest of compiler

Browse source 
src/comp/syntax is currently just a sub-module of rustc, but it will,
in the near future, be its own crate. This includes:

 - The AST data structure
 - The parser
 - The pretty-printer
 - Visit, walk, and fold
 - The syntax extension system
 - Some utility stuff that should be in the stdlib*

*) Stdlib extensions currently require a snapshot before they can be
   used, and the win build is very broken right now. This is temporary
   and will be cleaned up when one of those problems goes away.

A lot of code was moved by this patch, mostly towards a more organized
layout. Some package paths did get longer, and I guess the new layout
will take some getting used to. Sorry about that!

Please try not to re-introduce any dependencies in syntax/ on any of
the other src/comp/ subdirs.
This commit is contained in:
Marijn Haverbeke 2011-07-05 11:48:19 +02:00
parent c59ebf0f01
commit 6fd6fdea93
54 changed files with 1254 additions and 1203 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/comp/back/link.rs
View file

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

2
src/comp/back/x86.rs
View file

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

61
src/comp/driver/rustc.rs
View file

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

56
src/comp/driver/session.rs
View file

@ -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 = "<input>: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;

10
src/comp/front/attr.rs
View file

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

52
src/comp/front/codemap.rs
View file

@ -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:
//

4
src/comp/front/config.rs
View file

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

6
src/comp/lib/llvm.rs
View file

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

11
src/comp/metadata/creader.rs
View file

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

2
src/comp/metadata/cwriter.rs
View file

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

4
src/comp/metadata/decoder.rs
View file

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

2
src/comp/metadata/encoder.rs
View file

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

33
src/comp/metadata/tydecode.rs
View file

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

28
src/comp/metadata/tyencode.rs
View file

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

17
src/comp/middle/alias.rs
View file

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

3
src/comp/middle/ast_map.rs
View file

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

23
src/comp/middle/resolve.rs
View file

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

90
src/comp/middle/trans.rs
View file

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

1
src/comp/middle/tstate/ann.rs
View file

@ -1,5 +1,4 @@
import front::ast::ident;
import std::vec;
import tritv::*;

11
src/comp/middle/tstate/annotate.rs
View file

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

32
src/comp/middle/tstate/auxiliary.rs
View file

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

3
src/comp/middle/tstate/bitvectors.rs
View file

@ -1,5 +1,6 @@
import front::ast::*;
import syntax::ast::*;
import syntax::walk;
import std::option::*;
import std::vec;
import std::vec::len;

45
src/comp/middle/tstate/ck.rs
View file

@ -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";

27
src/comp/middle/tstate/collect_locals.rs
View file

@ -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]();

12
src/comp/middle/tstate/pre_post_conditions.rs
View file

@ -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!";

9
src/comp/middle/tstate/states.rs
View file

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

138
src/comp/middle/ty.rs
View file

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

31
src/comp/middle/typeck.rs
View file

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

433
src/comp/pretty/ppaux.rs
View file

@ -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 += "<tag#" + istr(id._0) + ":" + istr(id._1) + ">";
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 += "<resource#" + istr(id._0) + ":" + istr(id._1) + ">";
}
case (ty_var(?v)) { s += "<T" + istr(v) + ">"; }
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:
//

47
src/comp/rustc.rc
View file

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

29
src/comp/syntax/_std.rs Normal file
View file

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

41
src/comp/front/ast.rs → src/comp/syntax/ast.rs
View file

@ -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 += "]";

96
src/comp/syntax/codemap.rs Normal file
View file

@ -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 = "<input>: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:
//

34
src/comp/front/ext.rs → src/comp/syntax/ext/base.rs
View file

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

9
src/comp/front/extenv.rs → src/comp/syntax/ext/env.rs
View file

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

44
src/comp/front/extfmt.rs → src/comp/syntax/ext/fmt.rs
View file

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

12
src/comp/front/extsimplext.rs → src/comp/syntax/ext/simplext.rs
View file

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

2
src/comp/front/fold.rs → src/comp/syntax/fold.rs
View file

@ -1,4 +1,4 @@
import util::common::span;
import syntax::codemap::span;
import ast::*;
import std::vec;

33
src/comp/front/eval.rs → src/comp/syntax/parse/eval.rs
View file

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

61
src/comp/front/lexer.rs → src/comp/syntax/parse/lexer.rs
View file

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

149
src/comp/front/parser.rs → src/comp/syntax/parse/parser.rs
View file

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

8
src/comp/front/token.rs → src/comp/syntax/parse/token.rs
View file

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

0
src/comp/pretty/pp.rs → src/comp/syntax/print/pp.rs
View file

290
src/comp/pretty/pprust.rs → src/comp/syntax/print/pprust.rs
View file

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

35
src/comp/syntax/util/interner.rs Normal file
View file

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

5
src/comp/middle/visit.rs → src/comp/syntax/visit.rs
View file

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

8
src/comp/middle/walk.rs → src/comp/syntax/walk.rs
View file

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

139
src/comp/util/common.rs
View file

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

39
src/comp/util/data.rs
View file

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

182
src/comp/util/ppaux.rs Normal file
View file

@ -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 += "<tag#" + istr(id._0) + ":" + istr(id._1) + ">";
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 += "<resource#" + istr(id._0) + ":" + istr(id._1) + ">";
}
case (ty_var(?v)) { s += "<T" + istr(v) + ">"; }
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:

1
src/lib/int.rs
View file

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

28
src/lib/map.rs
View file

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

2
src/lib/uint.rs
View file

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

13
src/lib/vec.rs
View file

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