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::sha1::sha1;
import std::sort; import std::sort;
import trans::crate_ctxt; import trans::crate_ctxt;
import front::ast; import syntax::ast;
import lib::llvm::llvm::ModuleRef; import lib::llvm::llvm::ModuleRef;
import lib::llvm::llvm::ValueRef; import lib::llvm::llvm::ValueRef;
import lib::llvm::mk_pass_manager; 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) -> fn mangle_internal_name_by_type_only(&@crate_ctxt ccx, &ty::t t, &str name) ->
str { 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); auto hash = get_symbol_hash(ccx, t);
ret mangle([name, s, hash]); 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::str;
import std::vec; import std::vec;
import std::os::target_os; import std::os::target_os;
import util::common::istr; import syntax::_std::istr;
fn get_module_asm() -> str { ret ""; } fn get_module_asm() -> str { ret ""; }

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

@ -2,19 +2,19 @@
// -*- rust -*- // -*- rust -*-
import metadata::creader; import metadata::creader;
import front::parser; import syntax::parse::parser;
import front::token; import syntax::parse::token;
import front::eval; import syntax::ast;
import front::ast; import syntax::codemap;
import front::attr; import front::attr;
import middle::trans; import middle::trans;
import middle::resolve; import middle::resolve;
import middle::ty; import middle::ty;
import middle::typeck; import middle::typeck;
import middle::tstate::ck; import middle::tstate::ck;
import pretty::pp; import syntax::print::pp;
import pretty::pprust; import syntax::print::pprust;
import pretty::ppaux; import util::ppaux;
import back::link; import back::link;
import lib::llvm; import lib::llvm;
import util::common; import util::common;
@ -76,12 +76,14 @@ fn parse_cfgspecs(&vec[str] cfgspecs) -> ast::crate_cfg {
ret vec::map(to_meta_word, cfgspecs); ret vec::map(to_meta_word, cfgspecs);
} }
fn parse_input(session::session sess, parser::parser p, str input) -> fn parse_input(session::session sess, &ast::crate_cfg cfg, str input)
@ast::crate { -> @ast::crate {
ret if (str::ends_with(input, ".rc")) { 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")) { } 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 }; } 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, fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
str output) { str output) {
auto time_passes = sess.get_opts().time_passes; auto time_passes = sess.get_opts().time_passes;
auto p = parser::new_parser(sess, cfg, input, 0u, 0);
auto crate = 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; } if (sess.get_opts().output_type == link::output_type_none) { ret; }
crate = time(time_passes, "configuration", crate = time(time_passes, "configuration",
bind front::config::strip_unconfigured_items(crate)); 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, fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
str input, pp_mode ppm) { 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) { alt (node) {
case (ppaux::node_expr(?s, ?expr)) { case (pprust::node_expr(?s, ?expr)) {
pprust::popen(s); pprust::popen(s);
} }
case (_) {} 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) { alt (node) {
case (ppaux::node_expr(?s, ?expr)) { case (pprust::node_expr(?s, ?expr)) {
pp::space(s.s); pp::space(s.s);
pp::word(s.s, "as"); pp::word(s.s, "as");
pp::space(s.s); pp::space(s.s);
@ -149,18 +150,18 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
case (_) {} case (_) {}
} }
} }
fn ann_identified_post(&ppaux::ann_node node) { fn ann_identified_post(&pprust::ann_node node) {
alt (node) { alt (node) {
case (ppaux::node_item(?s, ?item)) { case (pprust::node_item(?s, ?item)) {
pp::space(s.s); pp::space(s.s);
pprust::synth_comment(s, int::to_str(item.id, 10u)); 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); pp::space(s.s);
pprust::synth_comment(s, "block " + pprust::synth_comment(s, "block " +
int::to_str(blk.node.id, 10u)); int::to_str(blk.node.id, 10u));
} }
case (ppaux::node_expr(?s, ?expr)) { case (pprust::node_expr(?s, ?expr)) {
pp::space(s.s); pp::space(s.s);
pprust::synth_comment(s, int::to_str(expr.id, 10u)); pprust::synth_comment(s, int::to_str(expr.id, 10u));
pprust::pclose(s); 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, cfg, input);
auto crate = parse_input(sess, p, input);
auto ann; auto ann;
alt (ppm) { alt (ppm) {
case (ppm_typed) { case (ppm_typed) {
@ -186,10 +186,11 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
post=ann_identified_post); post=ann_identified_post);
} }
case (ppm_normal) { 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) { fn version(str argv0) {
@ -268,9 +269,9 @@ fn build_target_config() -> @session::config {
let @session::config target_cfg = let @session::config target_cfg =
@rec(os=get_os(triple), @rec(os=get_os(triple),
arch=get_arch(triple), arch=get_arch(triple),
int_type=common::ty_i32, int_type=ast::ty_i32,
uint_type=common::ty_u32, uint_type=ast::ty_u32,
float_type=common::ty_f64); float_type=ast::ty_f64);
ret target_cfg; 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 { fn build_session(@session::options sopts) -> session::session {
auto target_cfg = build_target_config(); 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 target_crate_num = 0;
auto sess = auto sess =
session::session(target_crate_num, target_cfg, sopts, crate_cache, [], session::session(target_crate_num, target_cfg, sopts, crate_cache, [],
[], [], front::codemap::new_codemap(), 0u); [], [], codemap::new_codemap(), 0u);
ret sess; ret sess;
} }

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

@ -1,10 +1,9 @@
import front::ast; import syntax::ast;
import front::codemap; import syntax::codemap;
import util::common::span; import codemap::span;
import util::common::ty_mach; import syntax::ast::ty_mach;
import std::uint; import std::uint;
import std::term;
import std::io; import std::io;
import std::map; import std::map;
import std::option; import std::option;
@ -42,30 +41,6 @@ type options =
type crate_metadata = rec(str name, vec[u8] data); 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, obj session(ast::crate_num cnum,
@config targ_cfg, @config targ_cfg,
@options opts, @options opts,
@ -80,20 +55,19 @@ obj session(ast::crate_num cnum,
fn get_targ_crate_num() -> ast::crate_num { ret cnum; } fn get_targ_crate_num() -> ast::crate_num { ret cnum; }
fn span_fatal(span sp, str msg) -> ! { fn span_fatal(span sp, str msg) -> ! {
// FIXME: Use constants, but rustboot doesn't know how to export them. // FIXME: Use constants, but rustboot doesn't know how to export them.
codemap::emit_error(some(sp), msg, cm);
emit_diagnostic(some(sp), msg, "error", 9u8, cm);
fail; fail;
} }
fn fatal(str msg) -> ! { fn fatal(str msg) -> ! {
emit_diagnostic(none[span], msg, "error", 9u8, cm); codemap::emit_error(none, msg, cm);
fail; fail;
} }
fn span_err(span sp, str msg) { 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; err_count += 1u;
} }
fn err(str msg) { fn err(str msg) {
emit_diagnostic(none, msg, "error", 9u8, cm); codemap::emit_error(none, msg, cm);
err_count += 1u; err_count += 1u;
} }
fn abort_if_errors() { fn abort_if_errors() {
@ -103,19 +77,17 @@ obj session(ast::crate_num cnum,
} }
fn span_warn(span sp, str msg) { fn span_warn(span sp, str msg) {
// FIXME: Use constants, but rustboot doesn't know how to export them. // FIXME: Use constants, but rustboot doesn't know how to export them.
codemap::emit_warning(some(sp), msg, cm);
emit_diagnostic(some(sp), msg, "warning", 11u8, cm);
} }
fn warn(str msg) { 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) { fn span_note(span sp, str msg) {
// FIXME: Use constants, but rustboot doesn't know how to export them. // FIXME: Use constants, but rustboot doesn't know how to export them.
codemap::emit_note(some(sp), msg, cm);
emit_diagnostic(some(sp), msg, "note", 10u8, cm);
} }
fn note(str msg) { fn note(str msg) {
emit_diagnostic(none, msg, "note", 10u8, cm); codemap::emit_note(none, msg, cm);
} }
fn span_bug(span sp, str msg) -> ! { fn span_bug(span sp, str msg) -> ! {
self.span_fatal(sp, #fmt("internal compiler error %s", 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 { fn lookup_pos(uint pos) -> codemap::loc {
ret codemap::lookup_pos(cm, pos); 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: // Local Variables:
// fill-column: 78; // fill-column: 78;

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

@ -2,7 +2,7 @@
import std::vec; import std::vec;
import std::option; import std::option;
import front::ast; import syntax::ast;
import util::common; import util::common;
export attr_metas; 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 { 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) { 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)) { if (eq(item, needle)) {
log "found it!"; log "found it!";
ret true; ret true;
@ -166,7 +168,7 @@ fn remove_meta_items_by_name(&vec[@ast::meta_item] items,
ret vec::filter_map(filter, 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)); 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::option;
import std::vec; import std::vec;
import ast; import syntax::ast;
import fold; import syntax::fold;
import attr; import attr;
export strip_unconfigured_items; 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 { 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 { fn hash(&TypeRef t) -> uint {
ret t as uint; ret t as uint;
@ -1519,7 +1519,7 @@ fn type_to_str_inner(type_names names,
case (6) { ret "Label"; } case (6) { ret "Label"; }
case (7) { case (7) {
ret "i" + util::common::istr(llvm::LLVMGetIntTypeWidth(ty) ret "i" + syntax::_std::istr(llvm::LLVMGetIntTypeWidth(ty)
as int); as int);
} }
@ -1558,7 +1558,7 @@ fn type_to_str_inner(type_names names,
i += 1u; i += 1u;
if (tout as int == ty as int) { if (tout as int == ty as int) {
let uint n = vec::len[TypeRef](outer0) - i; 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, ret "*" + type_to_str_inner(names, outer,

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

@ -1,14 +1,15 @@
// Extracting metadata from crate files // Extracting metadata from crate files
import driver::session; import driver::session;
import front::ast; import syntax::ast;
import lib::llvm::False; import lib::llvm::False;
import lib::llvm::llvm; import lib::llvm::llvm;
import lib::llvm::mk_object_file; import lib::llvm::mk_object_file;
import lib::llvm::mk_section_iter; import lib::llvm::mk_section_iter;
import front::attr; import front::attr;
import middle::resolve; import middle::resolve;
import middle::walk; import syntax::walk;
import syntax::codemap::span;
import back::x86; import back::x86;
import util::common; import util::common;
import std::str; import std::str;
@ -20,7 +21,7 @@ import std::option;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
import std::map::hashmap; import std::map::hashmap;
import pretty::pprust; import syntax::print::pprust;
import tags::*; import tags::*;
export read_crates; export read_crates;
@ -129,7 +130,7 @@ fn get_metadata_section(str filename) -> option::t[vec[u8]] {
ret option::none[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, &ast::ident ident, vec[@ast::meta_item] metas,
&vec[str] library_search_paths) { &vec[str] library_search_paths) {
alt (find_library_crate(sess, ident, metas, 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 = auto e =
@rec(sess=sess, @rec(sess=sess,
crate_map=crate_map, 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, library_search_paths=sess.get_opts().library_search_paths,
mutable next_crate_num=1); mutable next_crate_num=1);
auto v = auto v =

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

@ -2,7 +2,7 @@
import std::str; import std::str;
import middle::trans; import middle::trans;
import front::ast::crate; import syntax::ast::crate;
import back::x86; import back::x86;
import lib::llvm::llvm; import lib::llvm::llvm;
import lib::llvm::llvm::ValueRef; 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::str;
import std::io; import std::io;
import std::map::hashmap; import std::map::hashmap;
import front::ast; import syntax::ast;
import front::attr; import front::attr;
import middle::ty; import middle::ty;
import tags::*; import tags::*;
@ -14,7 +14,7 @@ import tydecode::parse_def_id;
import tydecode::parse_ty_data; import tydecode::parse_ty_data;
import driver::session; import driver::session;
import util::common; import util::common;
import pretty::pprust; import syntax::print::pprust;
export get_symbol; export get_symbol;
export get_tag_variants; 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::some;
import std::option::none; import std::option::none;
import std::ebml; import std::ebml;
import front::ast::*; import syntax::ast::*;
import tags::*; import tags::*;
import middle::trans::crate_ctxt; import middle::trans::crate_ctxt;
import middle::trans::node_id_type; 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;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
import front::ast; import syntax::ast;
import ast::respan;
import middle::ty; 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_def_id;
export parse_ty_data; export parse_ty_data;
@ -26,7 +23,7 @@ type str_def = fn(str) -> ast::def_id ;
type pstate = type pstate =
rec(vec[u8] data, int crate, mutable uint pos, uint len, ty::ctxt tcx); 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); } 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 { fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
alt (peek(st) as char) { alt (peek(st) as char) {
case ('!') { next(st); ret a_bang[ty::t]; } case ('!') { next(st); ret a_bang; }
case (_) { ret a_ty[ty::t](parse_ty(st, sd)); } 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 ('l') { ret ty::mk_float(st.tcx); }
case ('M') { case ('M') {
alt (next(st) as char) { alt (next(st) as char) {
case ('b') { ret ty::mk_mach(st.tcx, common::ty_u8); } case ('b') { ret ty::mk_mach(st.tcx, ast::ty_u8); }
case ('w') { ret ty::mk_mach(st.tcx, common::ty_u16); } case ('w') { ret ty::mk_mach(st.tcx, ast::ty_u16); }
case ('l') { ret ty::mk_mach(st.tcx, common::ty_u32); } case ('l') { ret ty::mk_mach(st.tcx, ast::ty_u32); }
case ('d') { ret ty::mk_mach(st.tcx, common::ty_u64); } case ('d') { ret ty::mk_mach(st.tcx, ast::ty_u64); }
case ('B') { ret ty::mk_mach(st.tcx, common::ty_i8); } case ('B') { ret ty::mk_mach(st.tcx, ast::ty_i8); }
case ('W') { ret ty::mk_mach(st.tcx, common::ty_i16); } case ('W') { ret ty::mk_mach(st.tcx, ast::ty_i16); }
case ('L') { ret ty::mk_mach(st.tcx, common::ty_i32); } case ('L') { ret ty::mk_mach(st.tcx, ast::ty_i32); }
case ('D') { ret ty::mk_mach(st.tcx, common::ty_i64); } case ('D') { ret ty::mk_mach(st.tcx, ast::ty_i64); }
case ('f') { ret ty::mk_mach(st.tcx, common::ty_f32); } case ('f') { ret ty::mk_mach(st.tcx, ast::ty_f32); }
case ('F') { ret ty::mk_mach(st.tcx, common::ty_f64); } case ('F') { ret ty::mk_mach(st.tcx, ast::ty_f64); }
} }
} }
case ('c') { ret ty::mk_char(st.tcx); } 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::some;
import std::option::none; import std::option::none;
import std::uint; import std::uint;
import front::ast::*; import syntax::ast::*;
import middle::ty; import middle::ty;
import pretty::ppaux::lit_to_str; import syntax::print::pprust::lit_to_str;
import util::common; import util::common;
export ctxt; 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_float) { w.write_char('l'); }
case (ty::ty_machine(?mach)) { case (ty::ty_machine(?mach)) {
alt (mach) { alt (mach) {
case (common::ty_u8) { w.write_str("Mb"); } case (ty_u8) { w.write_str("Mb"); }
case (common::ty_u16) { w.write_str("Mw"); } case (ty_u16) { w.write_str("Mw"); }
case (common::ty_u32) { w.write_str("Ml"); } case (ty_u32) { w.write_str("Ml"); }
case (common::ty_u64) { w.write_str("Md"); } case (ty_u64) { w.write_str("Md"); }
case (common::ty_i8) { w.write_str("MB"); } case (ty_i8) { w.write_str("MB"); }
case (common::ty_i16) { w.write_str("MW"); } case (ty_i16) { w.write_str("MW"); }
case (common::ty_i32) { w.write_str("ML"); } case (ty_i32) { w.write_str("ML"); }
case (common::ty_i64) { w.write_str("MD"); } case (ty_i64) { w.write_str("MD"); }
case (common::ty_f32) { w.write_str("Mf"); } case (ty_f32) { w.write_str("Mf"); }
case (common::ty_f64) { w.write_str("MF"); } case (ty_f64) { w.write_str("MF"); }
} }
} }
case (ty::ty_char) { w.write_char('c'); } 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)) { case (ty::ty_var(?id)) {
w.write_char('X'); w.write_char('X');
w.write_str(common::istr(id)); w.write_str(syntax::_std::istr(id));
} }
case (ty::ty_native(?def)) { case (ty::ty_native(?def)) {
w.write_char('E'); w.write_char('E');
@ -191,7 +191,7 @@ fn enc_sty(&io::writer w, &@ctxt cx, &ty::sty st) {
} }
case (ty::ty_param(?id)) { case (ty::ty_param(?id)) {
w.write_char('p'); 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_type) { w.write_char('Y'); }
case (ty::ty_task) { w.write_char('a'); } case (ty::ty_task) { w.write_char('a'); }

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

@ -1,10 +1,11 @@
import front::ast; import syntax::ast;
import front::ast::ident; import ast::ident;
import front::ast::fn_ident; import ast::fn_ident;
import front::ast::node_id; import ast::node_id;
import front::ast::def_id; import ast::def_id;
import util::common::span; import syntax::codemap::span;
import syntax::visit;
import visit::vt; import visit::vt;
import std::vec; import std::vec;
import std::str; import std::str;
@ -44,7 +45,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
// Stores information about object fields and function // Stores information about object fields and function
// arguments that's otherwise not easily available. // arguments that's otherwise not easily available.
local_map=util::common::new_int_hash()); local_map=syntax::_std::new_int_hash());
auto v = auto v =
@rec(visit_fn=bind visit_fn(cx, _, _, _, _, _, _, _), @rec(visit_fn=bind visit_fn(cx, _, _, _, _, _, _, _),
visit_item=bind visit_item(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 (ty::ty_istr) { /* no-op */ }
case (_) { case (_) {
cx.tcx.sess.span_unimpl(seq.span, "unknown seq type " + 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 = auto new_sc =

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

@ -1,6 +1,7 @@
import std::smallintmap; import std::smallintmap;
import std::option; import std::option;
import front::ast::*; import syntax::ast::*;
import syntax::visit;
import visit::vt; import visit::vt;
tag ast_node { tag ast_node {

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

@ -1,21 +1,22 @@
import front::ast; import syntax::ast;
import front::ast::ident; import ast::ident;
import front::ast::fn_ident; import ast::fn_ident;
import front::ast::def; import ast::def;
import front::ast::def_id; import ast::def_id;
import front::ast::node_id; import ast::node_id;
import front::ast::local_def; import ast::local_def;
import metadata::creader; import metadata::creader;
import metadata::decoder; import metadata::decoder;
import driver::session::session; import driver::session::session;
import util::common::new_def_hash; import util::common::new_def_hash;
import util::common::new_int_hash; import syntax::_std::new_int_hash;
import util::common::new_str_hash; import syntax::_std::new_str_hash;
import util::common::span; import syntax::codemap::span;
import util::common::respan; import syntax::ast::respan;
import middle::ty::constr_table; import middle::ty::constr_table;
import syntax::visit;
import visit::vt; import visit::vt;
import std::map::hashmap; import std::map::hashmap;
import std::list; 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::some;
import std::option::none; import std::option::none;
import std::fs; import std::fs;
import front::ast; import syntax::ast;
import syntax::walk;
import driver::session; import driver::session;
import middle::ty; import middle::ty;
import back::link; import back::link;
@ -32,14 +33,15 @@ import back::x86;
import back::abi; import back::abi;
import back::upcall; import back::upcall;
import middle::ty::pat_ty; import middle::ty::pat_ty;
import syntax::visit;
import visit::vt; import visit::vt;
import util::common; import util::common;
import util::common::istr; import syntax::_std::istr;
import util::common::new_def_hash; import util::common::new_def_hash;
import util::common::new_int_hash; import syntax::_std::new_int_hash;
import util::common::new_str_hash; import syntax::_std::new_str_hash;
import util::common::local_rhs_span; import util::common::local_rhs_span;
import util::common::span; import syntax::codemap::span;
import lib::llvm::llvm; import lib::llvm::llvm;
import lib::llvm::builder; import lib::llvm::builder;
import lib::llvm::target_data; import lib::llvm::target_data;
@ -65,10 +67,10 @@ import link::mangle_exported_name;
import metadata::tyencode; import metadata::tyencode;
import metadata::creader; import metadata::creader;
import metadata::decoder; import metadata::decoder;
import pretty::ppaux::ty_to_str; import util::ppaux::ty_to_str;
import pretty::ppaux::ty_to_short_str; import util::ppaux::ty_to_short_str;
import pretty::pprust::expr_to_str; import syntax::print::pprust::expr_to_str;
import pretty::pprust::path_to_str; import syntax::print::pprust::path_to_str;
obj namegen(mutable int i) { obj namegen(mutable int i) {
fn next(str prefix) -> str { i += 1; ret prefix + istr(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_uint) { llty = T_int(); }
case (ty::ty_machine(?tm)) { case (ty::ty_machine(?tm)) {
alt (tm) { alt (tm) {
case (common::ty_i8) { llty = T_i8(); } case (ast::ty_i8) { llty = T_i8(); }
case (common::ty_u8) { llty = T_i8(); } case (ast::ty_u8) { llty = T_i8(); }
case (common::ty_i16) { llty = T_i16(); } case (ast::ty_i16) { llty = T_i16(); }
case (common::ty_u16) { llty = T_i16(); } case (ast::ty_u16) { llty = T_i16(); }
case (common::ty_i32) { llty = T_i32(); } case (ast::ty_i32) { llty = T_i32(); }
case (common::ty_u32) { llty = T_i32(); } case (ast::ty_u32) { llty = T_i32(); }
case (common::ty_i64) { llty = T_i64(); } case (ast::ty_i64) { llty = T_i64(); }
case (common::ty_u64) { llty = T_i64(); } case (ast::ty_u64) { llty = T_i64(); }
case (common::ty_f32) { llty = T_f32(); } case (ast::ty_f32) { llty = T_f32(); }
case (common::ty_f64) { llty = T_f64(); } case (ast::ty_f64) { llty = T_f64(); }
} }
} }
case (ty::ty_char) { llty = T_char(); } 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 { } else {
// FIXME: compare obj, fn by pointer? // FIXME: compare obj, fn by pointer?
trans_fail(cx, none[common::span], trans_fail(cx, none[span],
"attempt to compare values of type " + "attempt to compare values of type " +
ty_to_str(cx.fcx.lcx.ccx.tcx, t)); 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_char) { ret f(unsigned_int); }
case (ty::ty_type) { case (ty::ty_type) {
trans_fail(cx, none[common::span], trans_fail(cx, none[span],
"attempt to compare values of type type"); "attempt to compare values of type type");
// This is a bit lame, because we return a dummy block to the // 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)); C_bool(false));
} }
case (ty::ty_native(_)) { case (ty::ty_native(_)) {
trans_fail(cx, none[common::span], trans_fail(cx, none[span],
"attempt to compare values of type native"); "attempt to compare values of type native");
ret rslt(new_sub_block_ctxt(cx, "after_fail_dummy"), ret rslt(new_sub_block_ctxt(cx, "after_fail_dummy"),
C_bool(false)); 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); ret iter_ivec(cx, av, bv, unit_tm.ty, f);
} }
case (ty::ty_istr) { 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); ret iter_ivec(cx, av, bv, unit_ty, f);
} }
case (_) { 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); ret iter_sequence_body(cx, v, elt.ty, f, false, false);
} }
case (ty::ty_str) { 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); ret iter_sequence_body(cx, v, et, f, true, false);
} }
case (ty::ty_ivec(?elt)) { case (ty::ty_ivec(?elt)) {
ret iter_sequence_body(cx, v, elt.ty, f, false, true); ret iter_sequence_body(cx, v, elt.ty, f, false, true);
} }
case (ty::ty_istr) { 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); ret iter_sequence_body(cx, v, et, f, true, true);
} }
case (_) { case (_) {
@ -3179,7 +3181,7 @@ fn duplicate_heap_parts_if_necessary(&@block_ctxt cx, ValueRef vptr,
} }
case (ty::ty_istr) { case (ty::ty_istr) {
ret ivec::duplicate_heap_part(cx, vptr, 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()); } 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 t = T_int();
auto s = True; auto s = True;
alt (tm) { alt (tm) {
case (common::ty_u8) { t = T_i8(); s = False; } case (ast::ty_u8) { t = T_i8(); s = False; }
case (common::ty_u16) { t = T_i16(); s = False; } case (ast::ty_u16) { t = T_i16(); s = False; }
case (common::ty_u32) { t = T_i32(); s = False; } case (ast::ty_u32) { t = T_i32(); s = False; }
case (common::ty_u64) { t = T_i64(); s = False; } case (ast::ty_u64) { t = T_i64(); s = False; }
case (common::ty_i8) { t = T_i8(); } case (ast::ty_i8) { t = T_i8(); }
case (common::ty_i16) { t = T_i16(); } case (ast::ty_i16) { t = T_i16(); }
case (common::ty_i32) { t = T_i32(); } case (ast::ty_i32) { t = T_i32(); }
case (common::ty_i64) { t = T_i64(); } case (ast::ty_i64) { t = T_i64(); }
} }
ret C_integral(t, i as uint, s); 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)) { case (ast::lit_mach_float(?tm, ?s)) {
auto t = T_float(); auto t = T_float();
alt (tm) { alt (tm) {
case (common::ty_f32) { t = T_f32(); } case (ast::ty_f32) { t = T_f32(); }
case (common::ty_f64) { t = T_f64(); } case (ast::ty_f64) { t = T_f64(); }
} }
ret C_floating(s, t); 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; this_cx = next_cx;
} }
auto default_cx = this_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"); "non-exhaustive match failure");
ret rslt(join_branches(cx, arm_results), C_nil()); 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); bcx.build.CondBr(bounds_check, next_cx.llbb, fail_cx.llbb);
// fail: bad bounds check. // 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; auto body;
alt (interior_len_and_data) { alt (interior_len_and_data) {
case (some(?lad)) { body = lad._1; } 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 TypeRef tr;
let bool is32bit = false; let bool is32bit = false;
alt (ty::struct(cx.fcx.lcx.ccx.tcx, e_ty)) { 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(); tr = T_f32();
is32bit = true; 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(); } case (_) { tr = T_float(); }
} }
if (is32bit) { 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 cond_res = trans_expr(cx, e);
auto expr_str = s + " " + expr_to_str(e) + " failed"; auto expr_str = s + " " + expr_to_str(e) + " failed";
auto fail_cx = new_sub_block_ctxt(cx, "fail"); 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"); auto next_cx = new_sub_block_ctxt(cx, "next");
cond_res.bcx.build.CondBr(cond_res.val, next_cx.llbb, fail_cx.llbb); cond_res.bcx.build.CondBr(cond_res.val, next_cx.llbb, fail_cx.llbb);
ret rslt(next_cx, C_nil()); 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) &option::t[@ast::expr] fail_expr)
-> result { -> result {
auto bcx = cx; 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 { -> result {
auto V_fail_str = C_cstr(cx.fcx.lcx.ccx, fail_str); auto V_fail_str = C_cstr(cx.fcx.lcx.ccx, fail_str);
ret trans_fail_value(cx, sp_opt, V_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) &ValueRef V_fail_str)
-> result { -> result {
auto V_filename; auto V_filename;

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

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

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

@ -3,11 +3,12 @@ import std::vec;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import front::ast::*; import syntax::ast::*;
import util::common::istr; import syntax::walk;
import util::common::uistr; import syntax::codemap::span;
import util::common::span; import syntax::_std::istr;
import util::common::new_str_hash; import syntax::_std::uistr;
import syntax::_std::new_str_hash;
import util::common::log_expr_err; import util::common::log_expr_err;
import util::common::log_block_err; import util::common::log_block_err;
import util::common::log_item_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::none;
import std::option::some; import std::option::some;
import std::option::maybe; import std::option::maybe;
import front::ast; import syntax::ast::*;
import front::ast::*; import syntax::codemap::span;
import util::common; import util::common;
import util::common::span;
import util::common::spanned;
import util::common::respan;
import util::common::log_block; import util::common::log_block;
import util::common::new_int_hash; import syntax::_std::new_int_hash;
import util::common::new_uint_hash; import syntax::_std::new_uint_hash;
import util::common::log_expr_err; import util::common::log_expr_err;
import util::common::istr; import syntax::_std::istr;
import util::common::uistr; import syntax::_std::uistr;
import util::common::lit_eq; 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;
import tstate::ann::pre_and_post_state; import tstate::ann::pre_and_post_state;
import tstate::ann::empty_ann; import tstate::ann::empty_ann;
@ -42,8 +39,8 @@ import tstate::ann::clear_in_poststate;
import tstate::ann::clear_in_poststate_; import tstate::ann::clear_in_poststate_;
import tritv::*; import tritv::*;
import pretty::ppaux::constr_args_to_str; import syntax::print::pprust::constr_args_to_str;
import pretty::ppaux::lit_to_str; import syntax::print::pprust::lit_to_str;
/* logging funs */ /* 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. easier to look up a specific instance.
Both types are in constrast with the constraint type defined in 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 gets generated by the parser. aux and ast share the same type
to represent predicate *arguments* however. This 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. 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) -> fn match_args(&fn_ctxt fcx, vec[pred_desc] occs, vec[@constr_arg_use] occ) ->
uint { uint {
log "match_args: looking at " + 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) { for (pred_desc pd in occs) {
log "match_args: candidate " + pred_desc_to_str(pd); log "match_args: candidate " + pred_desc_to_str(pd);
fn eq(&tup(ident, def_id) p, &tup(ident, def_id) q) -> bool { 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 { fn pred_desc_to_str(&pred_desc p) -> str {
ret "<" + uistr(p.node.bit_num) + ", " + ret "<" + uistr(p.node.bit_num) + ", " +
pretty::ppaux::constr_args_to_str(std::util::fst[ident, def_id], constr_args_to_str(std::util::fst[ident, def_id], p.node.args) + ">";
p.node.args) + ">";
} }
fn substitute_constr_args(&ty::ctxt cx, &vec[@expr] actuals, 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)]; 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 { @constr_arg_use {
auto num_actuals = vec::len(actuals); auto num_actuals = vec::len(actuals);
alt (a.node) { 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::option::*;
import std::vec; import std::vec;
import std::vec::len; import std::vec::len;

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

@ -1,25 +1,26 @@
import front::ast; import syntax::ast;
import front::ast::method; import ast::method;
import front::ast::item; import ast::item;
import front::ast::item_fn; import ast::item_fn;
import front::ast::_fn; import ast::_fn;
import front::ast::obj_field; import ast::obj_field;
import front::ast::_obj; import ast::_obj;
import front::ast::stmt; import ast::stmt;
import front::ast::ident; import ast::ident;
import front::ast::fn_ident; import ast::fn_ident;
import front::ast::node_id; import ast::node_id;
import front::ast::def_id; import ast::def_id;
import front::ast::local_def; import ast::local_def;
import front::ast::ty_param; import ast::ty_param;
import front::ast::crate; import ast::crate;
import front::ast::return; import ast::return;
import front::ast::noreturn; import ast::noreturn;
import front::ast::expr; import ast::expr;
import syntax::walk;
import syntax::codemap::span;
import middle::ty::type_is_nil; import middle::ty::type_is_nil;
import middle::ty::ret_ty_of_fn; import middle::ty::ret_ty_of_fn;
import util::common::span;
import tstate::ann::ts_ann; import tstate::ann::ts_ann;
import tstate::ann::empty_poststate; import tstate::ann::empty_poststate;
import tstate::ann::true_precond; import tstate::ann::true_precond;
@ -43,7 +44,7 @@ import std::option::t;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import aux::*; import aux::*;
import pretty::pprust::ty_to_str; import syntax::print::pprust::ty_to_str;
import util::common::log_stmt_err; import util::common::log_stmt_err;
import bitvectors::promises; import bitvectors::promises;
import annotate::annotate_crate; import annotate::annotate_crate;
@ -86,7 +87,7 @@ fn check_states_expr(&fn_ctxt fcx, &@expr e) {
s += s +=
"Unsatisfied precondition constraint (for example, " + diff + "Unsatisfied precondition constraint (for example, " + diff +
") for expression:\n"; ") for expression:\n";
s += pretty::pprust::expr_to_str(e); s += syntax::print::pprust::expr_to_str(e);
s += "\nPrecondition:\n"; s += "\nPrecondition:\n";
s += tritv_to_str(fcx, prec); s += tritv_to_str(fcx, prec);
s += "\nPrestate:\n"; s += "\nPrestate:\n";
@ -115,7 +116,7 @@ fn check_states_stmt(&fn_ctxt fcx, &@stmt s) {
ss += ss +=
"Unsatisfied precondition constraint (for example, " + diff + "Unsatisfied precondition constraint (for example, " + diff +
") for statement:\n"; ") for statement:\n";
ss += pretty::pprust::stmt_to_str(*s); ss += syntax::print::pprust::stmt_to_str(*s);
ss += "\nPrecondition:\n"; ss += "\nPrecondition:\n";
ss += tritv_to_str(fcx, prec); ss += tritv_to_str(fcx, prec);
ss += "\nPrestate: \n"; ss += "\nPrestate: \n";

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

@ -1,13 +1,14 @@
import std::vec; import std::vec;
import std::vec::plus_option; import std::vec::plus_option;
import front::ast; import syntax::ast::*;
import front::ast::*; import util::ppaux::fn_ident_to_string;
import pretty::ppaux::fn_ident_to_string;
import std::option::*; import std::option::*;
import middle::walk::walk_crate; import syntax::walk;
import middle::walk::walk_fn; import syntax::visit;
import middle::walk::ast_visitor; import walk::walk_crate;
import walk::walk_fn;
import walk::ast_visitor;
import aux::cinit; import aux::cinit;
import aux::ninit; import aux::ninit;
import aux::npred; import aux::npred;
@ -20,11 +21,11 @@ import aux::constr_map;
import aux::expr_to_constr; import aux::expr_to_constr;
import aux::constraints_expr; import aux::constraints_expr;
import aux::node_id_to_def_strict; 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::new_def_hash;
import util::common::uistr; import syntax::_std::uistr;
import util::common::span; import syntax::codemap::span;
import util::common::respan; import syntax::ast::respan;
type ctxt = rec(@mutable vec[aux::constr] cs, ty::ctxt tcx); 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) { 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) &span sp, &fn_ident i, node_id id)
-> ctxt { -> ctxt {
let ctxt cx = rec(cs=@mutable vec::alloc(0u), tcx=tcx); 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) -> fn add_constraint(&ty::ctxt tcx, aux::constr c, uint next, constr_map tbl) ->
uint { 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) { alt (c.node.c) {
case (ninit(?i)) { tbl.insert(c.node.id, cinit(next, c.span, i)); } case (ninit(?i)) { tbl.insert(c.node.id, cinit(next, c.span, i)); }
case (npred(?p, ?args)) { 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 /* builds a table mapping each local var defined in f
to a bit number in the precondition/postcondition vectors */ 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, &span f_sp, &fn_ident f_name,
node_id id) { node_id id) {
auto res_map = @new_int_hash[constraint](); 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::gen_poststate;
import bitvectors::relax_precond_block; import bitvectors::relax_precond_block;
import bitvectors::gen; import bitvectors::gen;
import front::ast::*; import syntax::ast::*;
import util::common::new_int_hash; import syntax::_std::new_int_hash;
import util::common::new_def_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_expr;
import util::common::log_fn; import util::common::log_fn;
import util::common::elt_exprs; 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_expr_err;
import util::common::log_block_err; import util::common::log_block_err;
import util::common::log_block; import util::common::log_block;
import util::common::span; import syntax::codemap::span;
import util::common::istr; import util::ppaux::fn_ident_to_string;
import pretty::ppaux::fn_ident_to_string;
fn find_pre_post_mod(&_mod m) -> _mod { fn find_pre_post_mod(&_mod m) -> _mod {
log "implement find_pre_post_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::kill_poststate;
import bitvectors::clear_in_poststate_ident; import bitvectors::clear_in_poststate_ident;
import bitvectors::intersect_states; import bitvectors::intersect_states;
import front::ast; import syntax::ast::*;
import front::ast::*;
import middle::ty::expr_ty; import middle::ty::expr_ty;
import middle::ty::type_is_nil; import middle::ty::type_is_nil;
import middle::ty::type_is_bot; import middle::ty::type_is_bot;
import util::common::new_def_hash; import util::common::new_def_hash;
import util::common::uistr; import syntax::_std::uistr;
import util::common::log_expr; import util::common::log_expr;
import util::common::log_block; import util::common::log_block;
import util::common::log_block_err; 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; 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 { &vec[@expr] es, controlflow cf) -> bool {
auto rs = seq_states(fcx, pres, es); auto rs = seq_states(fcx, pres, es);
auto changed = rs._0 | set_prestate_ann(fcx.ccx, id, pres); 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, 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 { &prestate pres) -> bool {
auto changed = set_prestate_ann(fcx.ccx, id, pres) | auto changed = set_prestate_ann(fcx.ccx, id, pres) |
find_pre_post_state_expr(fcx, pres, antec); 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::option::some;
import std::smallintmap; import std::smallintmap;
import driver::session; import driver::session;
import front::ast; import syntax::ast;
import front::ast::def_id; import ast::def_id;
import front::ast::constr_arg_general; import ast::constr_arg_general;
import front::ast::mutability; import ast::mutability;
import front::ast::controlflow; import ast::controlflow;
import front::ast::path_to_str; import ast::path_to_str;
import ast::spanned;
import syntax::codemap::span;
import metadata::creader; import metadata::creader;
import metadata::decoder; import metadata::decoder;
import util::common::*; import util::common::*;
import util::data::interner; import syntax::util::interner;
import pretty::ppaux::ty_to_str; import util::ppaux::ty_to_str;
import pretty::ppaux::mode_str_1; import util::ppaux::mode_str_1;
export node_id_to_monotype; export node_id_to_monotype;
@ -251,7 +253,7 @@ tag sty {
ty_int; ty_int;
ty_float; ty_float;
ty_uint; ty_uint;
ty_machine(ty_mach); ty_machine(ast::ty_mach);
ty_char; ty_char;
ty_str; ty_str;
ty_istr; ty_istr;
@ -360,16 +362,16 @@ fn populate_type_store(&ctxt cx) {
intern(cx, ty_int, none[str]); intern(cx, ty_int, none[str]);
intern(cx, ty_float, none[str]); intern(cx, ty_float, none[str]);
intern(cx, ty_uint, none[str]); intern(cx, ty_uint, none[str]);
intern(cx, ty_machine(ty_i8), none[str]); intern(cx, ty_machine(ast::ty_i8), none[str]);
intern(cx, ty_machine(ty_i16), none[str]); intern(cx, ty_machine(ast::ty_i16), none[str]);
intern(cx, ty_machine(ty_i32), none[str]); intern(cx, ty_machine(ast::ty_i32), none[str]);
intern(cx, ty_machine(ty_i64), none[str]); intern(cx, ty_machine(ast::ty_i64), none[str]);
intern(cx, ty_machine(ty_u8), none[str]); intern(cx, ty_machine(ast::ty_u8), none[str]);
intern(cx, ty_machine(ty_u16), none[str]); intern(cx, ty_machine(ast::ty_u16), none[str]);
intern(cx, ty_machine(ty_u32), none[str]); intern(cx, ty_machine(ast::ty_u32), none[str]);
intern(cx, ty_machine(ty_u64), none[str]); intern(cx, ty_machine(ast::ty_u64), none[str]);
intern(cx, ty_machine(ty_f32), none[str]); intern(cx, ty_machine(ast::ty_f32), none[str]);
intern(cx, ty_machine(ty_f64), none[str]); intern(cx, ty_machine(ast::ty_f64), none[str]);
intern(cx, ty_char, none[str]); intern(cx, ty_char, none[str]);
intern(cx, ty_str, none[str]); intern(cx, ty_str, none[str]);
intern(cx, ty_istr, 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_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) { alt (tm) {
case (ty_u8) { ret idx_u8; } case (ast::ty_u8) { ret idx_u8; }
case (ty_u16) { ret idx_u16; } case (ast::ty_u16) { ret idx_u16; }
case (ty_u32) { ret idx_u32; } case (ast::ty_u32) { ret idx_u32; }
case (ty_u64) { ret idx_u64; } case (ast::ty_u64) { ret idx_u64; }
case (ty_i8) { ret idx_i8; } case (ast::ty_i8) { ret idx_i8; }
case (ty_i16) { ret idx_i16; } case (ast::ty_i16) { ret idx_i16; }
case (ty_i32) { ret idx_i32; } case (ast::ty_i32) { ret idx_i32; }
case (ty_i64) { ret idx_i64; } case (ast::ty_i64) { ret idx_i64; }
case (ty_f32) { ret idx_f32; } case (ast::ty_f32) { ret idx_f32; }
case (ty_f64) { ret idx_f64; } 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 { fn sequence_element_type(&ctxt cx, &t ty) -> t {
alt (struct(cx, ty)) { alt (struct(cx, ty)) {
case (ty_str) { ret mk_mach(cx, ty_u8); } case (ty_str) { ret mk_mach(cx, ast::ty_u8); }
case (ty_istr) { ret mk_mach(cx, ty_u8); } case (ty_istr) { ret mk_mach(cx, ast::ty_u8); }
case (ty_vec(?mt)) { ret mt.ty; } case (ty_vec(?mt)) { ret mt.ty; }
case (ty_ivec(?mt)) { ret mt.ty; } case (ty_ivec(?mt)) { ret mt.ty; }
case (_) { case (_) {
@ -1135,14 +1137,14 @@ fn type_is_integral(&ctxt cx, &t ty) -> bool {
case (ty_uint) { ret true; } case (ty_uint) { ret true; }
case (ty_machine(?m)) { case (ty_machine(?m)) {
alt (m) { alt (m) {
case (ty_i8) { ret true; } case (ast::ty_i8) { ret true; }
case (ty_i16) { ret true; } case (ast::ty_i16) { ret true; }
case (ty_i32) { ret true; } case (ast::ty_i32) { ret true; }
case (ty_i64) { ret true; } case (ast::ty_i64) { ret true; }
case (ty_u8) { ret true; } case (ast::ty_u8) { ret true; }
case (ty_u16) { ret true; } case (ast::ty_u16) { ret true; }
case (ty_u32) { ret true; } case (ast::ty_u32) { ret true; }
case (ty_u64) { ret true; } case (ast::ty_u64) { ret true; }
case (_) { ret false; } case (_) { ret false; }
} }
} }
@ -1155,8 +1157,8 @@ fn type_is_fp(&ctxt cx, &t ty) -> bool {
alt (struct(cx, ty)) { alt (struct(cx, ty)) {
case (ty_machine(?tm)) { case (ty_machine(?tm)) {
alt (tm) { alt (tm) {
case (ty_f32) { ret true; } case (ast::ty_f32) { ret true; }
case (ty_f64) { ret true; } case (ast::ty_f64) { ret true; }
case (_) { ret false; } case (_) { ret false; }
} }
} }
@ -1170,10 +1172,10 @@ fn type_is_signed(&ctxt cx, &t ty) -> bool {
case (ty_int) { ret true; } case (ty_int) { ret true; }
case (ty_machine(?tm)) { case (ty_machine(?tm)) {
alt (tm) { alt (tm) {
case (ty_i8) { ret true; } case (ast::ty_i8) { ret true; }
case (ty_i16) { ret true; } case (ast::ty_i16) { ret true; }
case (ty_i32) { ret true; } case (ast::ty_i32) { ret true; }
case (ty_i64) { ret true; } case (ast::ty_i64) { ret true; }
case (_) { ret false; } case (_) { ret false; }
} }
} }
@ -1322,16 +1324,16 @@ fn hash_type_structure(&sty st) -> uint {
case (ty_uint) { ret 4u; } case (ty_uint) { ret 4u; }
case (ty_machine(?tm)) { case (ty_machine(?tm)) {
alt (tm) { alt (tm) {
case (ty_i8) { ret 5u; } case (ast::ty_i8) { ret 5u; }
case (ty_i16) { ret 6u; } case (ast::ty_i16) { ret 6u; }
case (ty_i32) { ret 7u; } case (ast::ty_i32) { ret 7u; }
case (ty_i64) { ret 8u; } case (ast::ty_i64) { ret 8u; }
case (ty_u8) { ret 9u; } case (ast::ty_u8) { ret 9u; }
case (ty_u16) { ret 10u; } case (ast::ty_u16) { ret 10u; }
case (ty_u32) { ret 11u; } case (ast::ty_u32) { ret 11u; }
case (ty_u64) { ret 12u; } case (ast::ty_u64) { ret 12u; }
case (ty_f32) { ret 13u; } case (ast::ty_f32) { ret 13u; }
case (ty_f64) { ret 14u; } case (ast::ty_f64) { ret 14u; }
} }
} }
case (ty_char) { ret 15u; } case (ty_char) { ret 15u; }
@ -2644,7 +2646,7 @@ mod unify {
alt (smallintmap::find[t](vb.types, i)) { alt (smallintmap::find[t](vb.types, i)) {
case (none[t]) { typespec = ""; } case (none[t]) { typespec = ""; }
case (some[t](?typ)) { 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); 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_bool) { tycat_bool }
case (ty_int) { tycat_int } case (ty_int) { tycat_int }
case (ty_uint) { tycat_int } case (ty_uint) { tycat_int }
case (ty_machine(ty_i8)) { tycat_int } case (ty_machine(ast::ty_i8)) { tycat_int }
case (ty_machine(ty_i16)) { tycat_int } case (ty_machine(ast::ty_i16)) { tycat_int }
case (ty_machine(ty_i32)) { tycat_int } case (ty_machine(ast::ty_i32)) { tycat_int }
case (ty_machine(ty_i64)) { tycat_int } case (ty_machine(ast::ty_i64)) { tycat_int }
case (ty_machine(ty_u8)) { tycat_int } case (ty_machine(ast::ty_u8)) { tycat_int }
case (ty_machine(ty_u16)) { tycat_int } case (ty_machine(ast::ty_u16)) { tycat_int }
case (ty_machine(ty_u32)) { tycat_int } case (ty_machine(ast::ty_u32)) { tycat_int }
case (ty_machine(ty_u64)) { tycat_int } case (ty_machine(ast::ty_u64)) { tycat_int }
case (ty_float) { tycat_float } case (ty_float) { tycat_float }
case (ty_machine(ty_f32)) { tycat_float } case (ty_machine(ast::ty_f32)) { tycat_float }
case (ty_machine(ty_f64)) { tycat_float } case (ty_machine(ast::ty_f64)) { tycat_float }
case (ty_char) { tycat_int } case (ty_char) { tycat_int }
case (ty_ptr(_)) { tycat_int } case (ty_ptr(_)) { tycat_int }
case (ty_str) { tycat_str } case (ty_str) { tycat_str }

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

@ -1,14 +1,15 @@
import front::ast; import syntax::ast;
import front::ast::mutability; import ast::mutability;
import front::ast::local_def; import ast::local_def;
import front::ast::path_to_str; import ast::path_to_str;
import ast::respan;
import syntax::walk;
import metadata::decoder; import metadata::decoder;
import driver::session; import driver::session;
import util::common; import util::common;
import util::common::span; import syntax::codemap::span;
import util::common::respan; import syntax::_std::new_int_hash;
import util::common::new_int_hash;
import util::common::new_def_hash; import util::common::new_def_hash;
import util::common::log_expr_err; import util::common::log_expr_err;
import middle::ty; import middle::ty;
@ -24,7 +25,7 @@ import middle::ty::mo_alias;
import middle::ty::node_type_table; import middle::ty::node_type_table;
import middle::ty::pat_ty; import middle::ty::pat_ty;
import middle::ty::ty_param_substs_opt_and_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_param_count_and_ty;
import middle::ty::ty_nil; import middle::ty::ty_nil;
import middle::ty::unify::ures_ok; import middle::ty::unify::ures_ok;
@ -537,7 +538,7 @@ mod collect {
} }
case (_) { case (_) {
cx.tcx.sess.fatal("internal error " + cx.tcx.sess.fatal("internal error " +
util::common::istr(id._1)); syntax::_std::istr(id._1));
} }
} }
ret tpt; 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) { fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
// fcx.ccx.tcx.sess.span_warn(expr.span, "typechecking 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 // A generic function to factor out common logic from call and bind
// expressions. // expressions.
@ -1545,7 +1546,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
} }
// Checks the compatibility // 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) { ty::t ty, ast::binop binop) {
auto resolved_t = resolve_type_vars_if_possible(fcx, ty); auto resolved_t = resolve_type_vars_if_possible(fcx, ty);
if (!ty::is_binopable(fcx.ccx.tcx, resolved_t, binop)) { 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)) { alt (structure_of(fcx, expr.span, ety)) {
case (ty::ty_vec(?vec_elt_ty)) { elt_ty = vec_elt_ty.ty; } case (ty::ty_vec(?vec_elt_ty)) { elt_ty = vec_elt_ty.ty; }
case (ty::ty_str) { 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_ivec(?vec_elt_ty)) { elt_ty = vec_elt_ty.ty; }
case (ty::ty_istr) { 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 (_) { case (_) {
fcx.ccx.tcx.sess.span_fatal(expr.span, 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); write::ty_only_fixup(fcx, id, mt.ty);
} }
case (ty::ty_str) { 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); write::ty_only_fixup(fcx, id, typ);
} }
case (ty::ty_istr) { 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); write::ty_only_fixup(fcx, id, typ);
} }
case (_) { 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 middle {
mod trans; mod trans;
mod ty; mod ty;
mod walk;
mod visit;
mod ast_map; mod ast_map;
mod resolve; mod resolve;
mod typeck; mod typeck;
@ -38,25 +36,36 @@ mod middle {
} }
mod pretty { mod syntax {
mod pprust; mod _std; // FIXME remove
mod pp; mod ast;
mod ppaux; 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 front {
mod ast;
mod attr; mod attr;
mod ext;
mod extfmt;
mod extenv;
mod extsimplext;
mod fold;
mod codemap;
mod lexer;
mod parser;
mod token;
mod eval;
mod config; mod config;
} }
@ -88,11 +97,9 @@ mod driver {
mod util { mod util {
mod common; 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::metadata = unsafe;
auth middle::trans = unsafe; auth middle::trans = unsafe;
auth lib::llvm = 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::option;
import std::str; import std::str;
import std::vec; import std::vec;
import util::common::span; import codemap::span;
import util::common::spanned; import codemap::filename;
import util::common::ty_mach;
import util::common::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; type ident = str;
// Functions may or may not have names. // Functions may or may not have names.
@ -342,6 +343,34 @@ type ty_arg = spanned[ty_arg_];
type ty_method = spanned[ty_method_]; 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_]; type ty = spanned[ty_];
tag ty_ { tag ty_ {
@ -357,7 +386,7 @@ tag ty_ {
ty_int; ty_int;
ty_uint; ty_uint;
ty_float; ty_float;
ty_machine(util::common::ty_mach); ty_machine(ty_mach);
ty_char; ty_char;
ty_str; ty_str;
ty_istr; // interior string ty_istr; // interior string
@ -604,7 +633,7 @@ fn ternary_to_if(&@expr e) -> @ast::expr {
fn path_to_str(&ast::path pth) -> str { fn path_to_str(&ast::path pth) -> str {
auto result = str::connect(pth.node.idents, "::"); auto result = str::connect(pth.node.idents, "::");
if (vec::len[@ast::ty](pth.node.types) > 0u) { 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 += "[";
result += str::connect(vec::map(f, pth.node.types), ","); result += str::connect(vec::map(f, pth.node.types), ",");
result += "]"; 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::vec;
import std::option; import std::option;
import std::map::hashmap; import std::map::hashmap;
import driver::session::session; import parse::parser::parse_sess;
import front::parser::parser; import codemap::span;
import util::common::span; import syntax::_std::new_str_hash;
import util::common::new_str_hash; import codemap;
type syntax_expander = type syntax_expander =
fn(&ext_ctxt, span, &vec[@ast::expr], option::t[str]) -> @ast::expr; fn(&ext_ctxt, span, &vec[@ast::expr], option::t[str]) -> @ast::expr;
@ -20,10 +20,10 @@ tag syntax_extension {
// AST nodes into full ASTs // AST nodes into full ASTs
fn syntax_expander_table() -> hashmap[str, syntax_extension] { fn syntax_expander_table() -> hashmap[str, syntax_extension] {
auto syntax_expanders = new_str_hash[syntax_extension](); auto syntax_expanders = new_str_hash[syntax_extension]();
syntax_expanders.insert("fmt", normal(extfmt::expand_syntax_ext)); syntax_expanders.insert("fmt", normal(ext::fmt::expand_syntax_ext));
syntax_expanders.insert("env", normal(extenv::expand_syntax_ext)); syntax_expanders.insert("env", normal(ext::env::expand_syntax_ext));
syntax_expanders.insert("macro", syntax_expanders.insert("macro",
macro_defining(extsimplext::add_new_extension)); macro_defining(ext::simplext::add_new_extension));
ret syntax_expanders; ret syntax_expanders;
} }
@ -39,18 +39,18 @@ type ext_ctxt =
span_msg_fn span_unimpl, span_msg_fn span_unimpl,
next_id_fn next_id); next_id_fn next_id);
fn mk_ctxt(parser parser) -> ext_ctxt { fn mk_ctxt(&parse_sess sess) -> ext_ctxt {
auto sess = parser.get_session(); fn ext_span_fatal_(&codemap::codemap cm, span sp, str msg) -> ! {
fn ext_span_fatal_(session sess, span sp, str msg) -> ! { codemap::emit_error(option::some(sp), msg, cm);
sess.span_fatal(sp, msg); fail;
} }
auto ext_span_fatal = bind ext_span_fatal_(sess, _, _); auto ext_span_fatal = bind ext_span_fatal_(sess.cm, _, _);
fn ext_span_unimpl_(session sess, span sp, str msg) -> ! { fn ext_span_unimpl_(&codemap::codemap cm, span sp, str msg) -> ! {
sess.span_unimpl(sp, msg); codemap::emit_error(option::some(sp), "unimplemented " + msg, cm);
fail;
} }
auto ext_span_unimpl = bind ext_span_unimpl_(sess, _, _); auto ext_span_unimpl = bind ext_span_unimpl_(sess.cm, _, _);
fn ext_next_id_(parser parser) -> ast::node_id { parser.get_id() } auto ext_next_id = bind parse::parser::next_node_id(sess);
auto ext_next_id = bind ext_next_id_(parser);
ret rec(span_fatal=ext_span_fatal, ret rec(span_fatal=ext_span_fatal,
span_unimpl=ext_span_unimpl, span_unimpl=ext_span_unimpl,
next_id=ext_next_id); 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 * should all get sucked into either the compiler syntax extension plugin
* interface. * interface.
*/ */
import util::common;
import std::str; import std::str;
import std::vec; import std::vec;
import std::option; import std::option;
import std::generic_os; import std::generic_os;
import ext::*; import base::*;
export expand_syntax_ext; 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 { option::t[str] body) -> @ast::expr {
if (vec::len[@ast::expr](args) != 1u) { if (vec::len[@ast::expr](args) != 1u) {
cx.span_fatal(sp, "malformed #env call"); 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); auto sp_lit = @rec(node=lit, span=sp);
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_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)); 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 * should all get sucked into either the standard library extfmt module or the
* compiler syntax extension plugin interface. * compiler syntax extension plugin interface.
*/ */
import util::common;
import std::str; import std::str;
import std::vec; import std::vec;
import std::option; import std::option;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
import std::extfmt::ct::*; import std::extfmt::ct::*;
import ext::*; import base::*;
import codemap::span;
export expand_syntax_ext; 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 { option::t[str] body) -> @ast::expr {
if (vec::len[@ast::expr](args) == 0u) { if (vec::len[@ast::expr](args) == 0u) {
cx.span_fatal(sp, "#fmt requires a format string"); 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; auto fmtspan = args.(0).span;
log "Format string:"; log "Format string:";
log fmt; 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); cx.span_fatal(sp, msg);
} }
auto parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _); 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 // FIXME: A lot of these functions for producing expressions can probably
// be factored out in common with other code that builds expressions. // be factored out in common with other code that builds expressions.
// FIXME: Cleanup the naming of these functions // 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 { 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 { @ast::expr {
auto sp_lit = @rec(node=lit, span=sp); auto sp_lit = @rec(node=lit, span=sp);
ret @rec(id=cx.next_id(), node=ast::expr_lit(sp_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); auto lit = ast::lit_str(s, ast::sk_rc);
ret make_new_lit(cx, sp, lit); 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); auto lit = ast::lit_int(i);
ret make_new_lit(cx, sp, lit); 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); auto lit = ast::lit_uint(u);
ret make_new_lit(cx, sp, lit); 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 { @ast::expr rhs) -> @ast::expr {
auto binexpr = ast::expr_binary(ast::add, lhs, rhs); auto binexpr = ast::expr_binary(ast::add, lhs, rhs);
ret @rec(id=cx.next_id(), node=binexpr, span=sp); 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 { -> @ast::expr {
let vec[@ast::ty] types = []; let vec[@ast::ty] types = [];
auto path = rec(idents=idents, types=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); auto pathexpr = ast::expr_path(sp_path);
ret @rec(id=cx.next_id(), node=pathexpr, span=sp); 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 { @ast::expr {
auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc); auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc);
ret @rec(id=cx.next_id(), node=vecexpr, span=sp); 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 { vec[@ast::expr] args) -> @ast::expr {
auto pathexpr = make_path_expr(cx, sp, fn_path); auto pathexpr = make_path_expr(cx, sp, fn_path);
auto callexpr = ast::expr_call(pathexpr, args); auto callexpr = ast::expr_call(pathexpr, args);
ret @rec(id=cx.next_id(), node=callexpr, span=sp); 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 { vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
let vec[ast::field] astfields = []; let vec[ast::field] astfields = [];
for (tup(ast::ident, @ast::expr) field in fields) { 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]; 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 { @ast::expr {
auto path = make_path_vec(ident); auto path = make_path_vec(ident);
ret make_path_expr(cx, sp, path); 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, // Produces an AST expression that represents a RT::conv record,
// which tells the RT::conv* functions how to perform the conversion // 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 { @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 { @ast::expr {
let vec[@ast::expr] flagexprs = []; let vec[@ast::expr] flagexprs = [];
for (flag f in flags) { 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); 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 { @ast::expr {
alt (cnt) { alt (cnt) {
case (count_implied) { 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; auto rt_type;
alt (t) { alt (t) {
case (ty_hex(?c)) { 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); 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 width_expr, @ast::expr precision_expr,
@ast::expr ty_expr) -> @ast::expr { @ast::expr ty_expr) -> @ast::expr {
ret make_rec_expr(cx, sp, 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, ret make_conv_rec(cx, sp, rt_conv_flags, rt_conv_width,
rt_conv_precision, rt_conv_ty); 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 { @ast::expr arg) -> @ast::expr {
auto fname = "conv_" + conv_type; auto fname = "conv_" + conv_type;
auto path = make_path_vec(fname); 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]; auto args = [cnv_expr, arg];
ret make_call(cx, arg.span, path, args); 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 { -> @ast::expr {
// FIXME: Extract all this validation into extfmt::ct // 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; use std;
import util::common::span; import codemap::span;
import std::vec; import std::vec;
import std::option; import std::option;
import vec::map; import vec::map;
@ -8,11 +8,11 @@ import vec::len;
import option::some; import option::some;
import option::none; import option::none;
import ext::syntax_extension; import base::syntax_extension;
import ext::ext_ctxt; import base::ext_ctxt;
import ext::normal; import base::normal;
import ext::expr_to_str; import base::expr_to_str;
import ext::expr_to_ident; import base::expr_to_ident;
import fold::*; import fold::*;
import ast::ident; 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 ast::*;
import std::vec; 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;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import driver::session; import syntax::ast;
import front::parser::parser; import syntax::parse::token;
import front::parser::new_parser; import syntax::parse::parser::parser;
import front::parser::parse_inner_attrs_and_next; import syntax::parse::parser::new_parser;
import front::parser::parse_mod_items; import syntax::parse::parser::parse_inner_attrs_and_next;
import syntax::parse::parser::parse_mod_items;
export eval_crate_directives_to_mod; export eval_crate_directives_to_mod;
export mode_parse; export mode_parse;
@ -19,9 +20,8 @@ type ctx =
@rec(parser p, @rec(parser p,
eval_mode mode, eval_mode mode,
mutable vec[str] deps, mutable vec[str] deps,
session::session sess, parser::parse_sess sess,
mutable uint chpos, mutable uint chpos,
mutable int next_id,
ast::crate_cfg cfg); ast::crate_cfg cfg);
fn eval_crate_directives(ctx cx, vec[@ast::crate_directive] cdirs, 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); eval_crate_directive(cx, cdir, prefix, view_items, items);
} }
case (_) { case (_) {
cx.sess.span_fatal(s.span, codemap::emit_warning
"unsupported stmt in crate-directive block"); (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; } if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; }
auto p0 = auto p0 =
new_parser(cx.sess, cx.cfg, full_path, cx.chpos, new_parser(cx.sess, cx.cfg, full_path, cx.chpos);
cx.next_id);
auto inner_attrs = parse_inner_attrs_and_next(p0); auto inner_attrs = parse_inner_attrs_and_next(p0);
auto mod_attrs = attrs + inner_attrs._0; auto mod_attrs = attrs + inner_attrs._0;
auto first_item_outer_attrs = inner_attrs._1; auto first_item_outer_attrs = inner_attrs._1;
auto m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs); 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, auto i = syntax::parse::parser::mk_item
id, ast::item_mod(m0), (p0, cdir.span.lo, cdir.span.hi, id, ast::item_mod(m0),
mod_attrs); mod_attrs);
// Thread defids and chpos through the parsers // Thread defids and chpos through the parsers
cx.chpos = p0.get_chpos(); cx.chpos = p0.get_chpos();
cx.next_id = p0.next_id();
vec::push[@ast::item](items, i); vec::push[@ast::item](items, i);
} }
case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs, ?attrs)) { 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 m0 = eval_crate_directives_to_mod(cx, cdirs, full_path);
auto i = @rec(ident=id, auto i = @rec(ident=id,
attrs=attrs, attrs=attrs,
id=cx.next_id, id=cx.sess.next_id,
node=ast::item_mod(m0), node=ast::item_mod(m0),
span=cdir.span); span=cdir.span);
cx.next_id += 1; cx.sess.next_id += 1;
vec::push[@ast::item](items, i); vec::push[@ast::item](items, i);
} }
case (ast::cdir_view_item(?vi)) { 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;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import driver::session::session; import util::interner;
import util::common; import util::interner::intern;
import util::common::*; import codemap;
import util::data::interner;
import util::data::interner::intern;
type reader = type reader =
obj { obj {
@ -31,9 +29,9 @@ type reader =
fn err(str) ; 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 { @interner::interner[str] itr) -> reader {
obj reader(session sess, obj reader(codemap::codemap cm,
str file, str file,
uint len, uint len,
mutable uint col, 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_interner() -> @interner::interner[str] { ret itr; }
fn get_col() -> uint { ret col; } fn get_col() -> uint { ret col; }
fn get_filemap() -> codemap::filemap { ret fm; } 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()); auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
let vec[str] strs = []; let vec[str] strs = [];
auto rd = 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); filemap.start_pos, filemap.start_pos, strs, filemap, itr);
rd.init(); rd.init();
ret rd; ret rd;
@ -101,6 +101,25 @@ fn is_whitespace(char c) -> bool {
ret c == ' ' || c == '\t' || c == '\r' || c == '\n'; 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) { fn consume_whitespace_and_comments(&reader rdr) {
while (is_whitespace(rdr.curr())) { rdr.bump(); } while (is_whitespace(rdr.curr())) { rdr.bump(); }
be consume_any_line_comment(rdr); be consume_any_line_comment(rdr);
@ -218,30 +237,30 @@ fn scan_number(char c, &reader rdr) -> token::token {
if (c == '8') { if (c == '8') {
rdr.bump(); rdr.bump();
if (signed) { if (signed) {
ret token::LIT_MACH_INT(common::ty_i8, accum_int); ret token::LIT_MACH_INT(ast::ty_i8, accum_int);
} else { ret token::LIT_MACH_INT(common::ty_u8, accum_int); } } else { ret token::LIT_MACH_INT(ast::ty_u8, accum_int); }
} }
n = rdr.next(); n = rdr.next();
if (c == '1' && n == '6') { if (c == '1' && n == '6') {
rdr.bump(); rdr.bump();
rdr.bump(); rdr.bump();
if (signed) { if (signed) {
ret token::LIT_MACH_INT(common::ty_i16, accum_int); ret token::LIT_MACH_INT(ast::ty_i16, accum_int);
} else { ret token::LIT_MACH_INT(common::ty_u16, accum_int); } } else { ret token::LIT_MACH_INT(ast::ty_u16, accum_int); }
} }
if (c == '3' && n == '2') { if (c == '3' && n == '2') {
rdr.bump(); rdr.bump();
rdr.bump(); rdr.bump();
if (signed) { if (signed) {
ret token::LIT_MACH_INT(common::ty_i32, accum_int); ret token::LIT_MACH_INT(ast::ty_i32, accum_int);
} else { ret token::LIT_MACH_INT(common::ty_u32, accum_int); } } else { ret token::LIT_MACH_INT(ast::ty_u32, accum_int); }
} }
if (c == '6' && n == '4') { if (c == '6' && n == '4') {
rdr.bump(); rdr.bump();
rdr.bump(); rdr.bump();
if (signed) { if (signed) {
ret token::LIT_MACH_INT(common::ty_i64, accum_int); ret token::LIT_MACH_INT(ast::ty_i64, accum_int);
} else { ret token::LIT_MACH_INT(common::ty_u64, accum_int); } } else { ret token::LIT_MACH_INT(ast::ty_u64, accum_int); }
} }
if (signed) { if (signed) {
ret token::LIT_INT(accum_int); ret token::LIT_INT(accum_int);
@ -272,13 +291,13 @@ fn scan_number(char c, &reader rdr) -> token::token {
if (c == '3' && n == '2') { if (c == '3' && n == '2') {
rdr.bump(); rdr.bump();
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(), intern(*rdr.get_interner(),
float_str)); float_str));
} else if (c == '6' && n == '4') { } else if (c == '6' && n == '4') {
rdr.bump(); rdr.bump();
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(), intern(*rdr.get_interner(),
float_str)); float_str));
/* FIXME: if this is out of range for either a 32-bit or /* 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); 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) { rec(vec[cmnt] cmnts, vec[lit] lits) {
auto srdr = io::file_reader(path); auto srdr = io::file_reader(path);
auto itr = @interner::mk[str](str::hash, str::eq); 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[cmnt] comments = [];
let vec[lit] literals = []; let vec[lit] literals = [];
let bool first_read = true; 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::either::right;
import std::map::hashmap; import std::map::hashmap;
import token::can_begin_expr; import token::can_begin_expr;
import driver::session; import ex=ext::base;
import util::common; import codemap::span;
import util::common::filename; import _std::new_str_hash;
import util::common::span; import util::interner;
import util::common::new_str_hash;
import util::data::interner;
import util::common::a_bang;
import util::common::a_ty;
tag restriction { UNRESTRICTED; RESTRICT_NO_CALL_EXPRS; } tag restriction { UNRESTRICTED; RESTRICT_NO_CALL_EXPRS; }
tag file_type { CRATE_FILE; SOURCE_FILE; } 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 = type parser =
obj { obj {
fn peek() -> token::token ; fn peek() -> token::token ;
fn bump() ; fn bump() ;
fn fatal(str) -> ! ; fn fatal(str) -> ! ;
fn warn(str);
fn restrict(restriction) ; fn restrict(restriction) ;
fn get_restriction() -> restriction ; fn get_restriction() -> restriction ;
fn get_file_type() -> file_type ; fn get_file_type() -> file_type ;
fn get_cfg() -> ast::crate_cfg; fn get_cfg() -> ast::crate_cfg;
fn get_session() -> session::session ; fn get_span() -> span ;
fn get_span() -> common::span ;
fn get_lo_pos() -> uint ; fn get_lo_pos() -> uint ;
fn get_hi_pos() -> uint ; fn get_hi_pos() -> uint ;
fn get_last_lo_pos() -> uint ; fn get_last_lo_pos() -> uint ;
@ -44,15 +49,15 @@ type parser =
fn get_reader() -> lexer::reader ; fn get_reader() -> lexer::reader ;
fn get_filemap() -> codemap::filemap ; fn get_filemap() -> codemap::filemap ;
fn get_bad_expr_words() -> hashmap[str, ()] ; 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_chpos() -> uint ;
fn get_id() -> ast::node_id ; 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, fn new_parser(parse_sess sess, ast::crate_cfg cfg,
str path, uint pos, ast::node_id next_id) -> parser { str path, uint pos) -> parser {
obj stdio_parser(session::session sess, obj stdio_parser(parse_sess sess,
ast::crate_cfg cfg, ast::crate_cfg cfg,
file_type ftype, file_type ftype,
mutable token::token tok, mutable token::token tok,
@ -62,9 +67,8 @@ fn new_parser(session::session sess, ast::crate_cfg cfg,
mutable restriction restr, mutable restriction restr,
lexer::reader rdr, lexer::reader rdr,
vec[op_spec] precs, vec[op_spec] precs,
mutable ast::node_id next_id_var,
hashmap[str, ()] bad_words, 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 peek() -> token::token { ret tok; }
fn bump() { fn bump() {
// log rdr.get_filename() // log rdr.get_filename()
@ -75,11 +79,16 @@ fn new_parser(session::session sess, ast::crate_cfg cfg,
lo = rdr.get_mark_chpos(); lo = rdr.get_mark_chpos();
hi = rdr.get_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 restrict(restriction r) { restr = r; }
fn get_restriction() -> restriction { ret restr; } fn get_restriction() -> restriction { ret restr; }
fn get_session() -> session::session { ret sess; } fn get_span() -> span { ret rec(lo=lo, hi=hi); }
fn get_span() -> common::span { ret rec(lo=lo, hi=hi); }
fn get_lo_pos() -> uint { ret lo; } fn get_lo_pos() -> uint { ret lo; }
fn get_hi_pos() -> uint { ret hi; } fn get_hi_pos() -> uint { ret hi; }
fn get_last_lo_pos() -> uint { ret last_lo; } 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_reader() -> lexer::reader { ret rdr; }
fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); } fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); }
fn get_bad_expr_words() -> hashmap[str, ()] { ret bad_words; } 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; ret syntax_expanders;
} }
fn get_chpos() -> uint { ret rdr.get_chpos(); } fn get_chpos() -> uint { ret rdr.get_chpos(); }
fn get_id() -> ast::node_id { fn get_id() -> ast::node_id { ret next_node_id(sess); }
auto rv = next_id_var; fn get_sess() -> parse_sess { ret sess; }
next_id_var += 1;
ret rv;
}
fn next_id() -> ast::node_id { ret next_id_var; }
} }
auto ftype = SOURCE_FILE; auto ftype = SOURCE_FILE;
if (str::ends_with(path, ".rc")) { ftype = CRATE_FILE; } if (str::ends_with(path, ".rc")) { ftype = CRATE_FILE; }
auto srdr = io::file_reader(path); auto srdr = io::file_reader(path);
auto filemap = codemap::new_filemap(path, pos); 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 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: // Make sure npos points at first actual token:
lexer::consume_whitespace_and_comments(rdr); lexer::consume_whitespace_and_comments(rdr);
auto npos = rdr.get_chpos(); auto npos = rdr.get_chpos();
ret stdio_parser(sess, cfg, ftype, lexer::next_token(rdr), ret stdio_parser(sess, cfg, ftype, lexer::next_token(rdr),
npos, npos, npos, UNRESTRICTED, rdr, npos, npos, npos, UNRESTRICTED, rdr,
prec_table(), next_id, bad_expr_word_table(), prec_table(), bad_expr_word_table(),
ext::syntax_expander_table()); ex::syntax_expander_table());
} }
// These are the words that shouldn't be allowed as value identifiers, // 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)); 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 { fn ident_index(&parser p, &vec[ast::arg] args, &ast::ident i) -> uint {
auto j = 0u; auto j = 0u;
for (ast::arg a in args) { if (a.ident == i) { ret j; } j += 1u; } for (ast::arg a in args) { if (a.ident == i) { ret j; } j += 1u; }
p.get_session().span_fatal(p.get_span(), p.fatal("Unbound variable " + i + " in constraint arg");
"Unbound variable " + i + " in constraint arg");
} }
fn parse_constr_arg(vec[ast::arg] args, &parser p) -> @ast::constr_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. // mentioned in a constraint to an arg index.
// Seems weird to do this in the parser, but I'm not sure how else to. // 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) -> 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 lo = p.get_lo_pos();
auto hi = p.get_hi_pos(); auto hi = p.get_hi_pos();
let vec[@ast::constr] constrs = []; 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 { fn parse_ty_or_bang(&parser p) -> ty_or_bang {
alt (p.peek()) { 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)); } case (_) { ret a_ty(parse_ty(p)); }
} }
} }
@ -460,25 +464,25 @@ fn parse_ty(&parser p) -> @ast::ty {
} else if (eat_word(p, "task")) { } else if (eat_word(p, "task")) {
t = ast::ty_task; t = ast::ty_task;
} else if (eat_word(p, "i8")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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")) { } 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) { } else if (p.peek() == token::LPAREN) {
p.bump(); p.bump();
alt (p.peek()) { alt (p.peek()) {
@ -541,9 +545,7 @@ fn parse_ty(&parser p) -> @ast::ty {
hi = p.get_hi_pos(); hi = p.get_hi_pos();
expect(p, token::RBRACKET); expect(p, token::RBRACKET);
} else if (eat_word(p, "mutable")) { } else if (eat_word(p, "mutable")) {
p.get_session().span_warn(p.get_span(), p.warn("ignoring deprecated 'mutable' type constructor");
"ignoring deprecated 'mutable'"
+ " type constructor");
auto typ = parse_ty(p); auto typ = parse_ty(p);
t = typ.node; t = typ.node;
hi = typ.span.hi; 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, fn parse_seq[T](token::token bra, token::token ket,
option::t[token::token] sep, fn(&parser) -> T f, &parser p) 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(); auto lo = p.get_lo_pos();
expect(p, bra); expect(p, bra);
auto result = parse_seq_to_end[T](ket, sep, f, p); 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); ex = ast::expr_lit(lit);
} }
case (_) { case (_) {
p.get_session().span_unimpl(p.get_span(), p.fatal("unimplemented: unique pointer creation");
"unique pointer creation");
} }
} }
} else if (eat_word(p, "obj")) { } 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 * wish to use while bootstrapping. The eventual aim is to permit
* loading rust crates to process extensions. * 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) -> vec[@ast::expr] args, option::t[str] body) ->
ast::expr_ { ast::expr_ {
assert (vec::len(path.node.idents) > 0u); assert (vec::len(path.node.idents) > 0u);
auto extname = path.node.idents.(0); auto extname = path.node.idents.(0);
alt (p.get_syntax_expanders().find(extname)) { alt (p.get_syntax_expanders().find(extname)) {
case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); } case (none) { p.fatal("unknown syntax expander: '" + extname + "'"); }
case (some(ext::normal(?ext))) { case (some(ex::normal(?ext))) {
auto ext_cx = ext::mk_ctxt(p); auto ext_cx = ex::mk_ctxt(p.get_sess());
ret ast::expr_ext(path, args, body, ext(ext_cx, sp, args, body)); ret ast::expr_ext(path, args, body, ext(ext_cx, sp, args, body));
} }
// because we have expansion inside parsing, new macros are only // because we have expansion inside parsing, new macros are only
// visible further down the file // visible further down the file
case (some(ext::macro_defining(?ext))) { case (some(ex::macro_defining(?ext))) {
auto ext_cx = ext::mk_ctxt(p); auto ext_cx = ex::mk_ctxt(p.get_sess());
auto name_and_extension = ext(ext_cx, sp, args, body); auto name_and_extension = ext(ext_cx, sp, args, body);
p.get_syntax_expanders().insert(name_and_extension._0, p.get_syntax_expanders().insert(name_and_extension._0,
name_and_extension._1); 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 { fn parse_prefix_expr(&parser p) -> @ast::expr {
if (eat_word(p, "mutable")) { if (eat_word(p, "mutable")) {
p.get_session().span_warn(p.get_span(), p.warn("ignoring deprecated 'mutable' prefix operator");
"ignoring deprecated 'mutable'"
+ " prefix operator");
} }
auto lo = p.get_lo_pos(); auto lo = p.get_lo_pos();
auto hi = p.get_hi_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 { 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, parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
p); p);
let ty_or_bang rslt; 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 lo = p.get_last_lo_pos();
auto ident = parse_value_ident(p); auto ident = parse_value_ident(p);
auto ty_params = parse_ty_params(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, parse_seq[ast::obj_field](token::LPAREN, token::RPAREN,
some(token::COMMA), parse_obj_field, p); some(token::COMMA), parse_obj_field, p);
let vec[@ast::method] meths = []; let vec[@ast::method] meths = [];
@ -2320,7 +2319,10 @@ fn parse_native_view(&parser p) -> vec[@ast::view_item] {
ret items; 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 lo = p.get_lo_pos();
auto crate_attrs = parse_inner_attrs_and_next(p); auto crate_attrs = parse_inner_attrs_and_next(p);
auto first_item_outer_attrs = crate_attrs._1; auto first_item_outer_attrs = crate_attrs._1;
@ -2428,7 +2430,10 @@ fn parse_crate_directives(&parser p, token::token term,
ret cdirs; 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 lo = p.get_lo_pos();
auto prefix = std::fs::dirname(p.get_filemap().name); auto prefix = std::fs::dirname(p.get_filemap().name);
auto leading_attrs = parse_inner_attrs_and_next(p); 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 first_cdir_attr = leading_attrs._1;
auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr); auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
let vec[str] deps = []; let vec[str] deps = [];
auto cx = auto cx = @rec(p=p,
@rec(p=p, mode=eval::mode_parse,
mode=eval::mode_parse, mutable deps=deps,
mutable deps=deps, sess=sess,
sess=p.get_session(), mutable chpos=p.get_chpos(),
mutable chpos=p.get_chpos(), cfg = p.get_cfg());
mutable next_id=p.next_id(),
cfg = p.get_cfg());
auto m = auto m =
eval::eval_crate_directives_to_mod(cx, cdirs, prefix); eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
auto hi = p.get_hi_pos(); 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 ast::ty_mach;
import util::common::ty_mach_to_str; import ast::ty_mach_to_str;
import util::common::new_str_hash; import _std::new_str_hash;
import util::data::interner; import util::interner;
import std::int; import std::int;
import std::uint; import std::uint;
import std::str; 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::str;
import std::io; import std::io;
import std::option; import std::option;
import driver::session::session; import parse::lexer;
import front::lexer; import syntax::codemap::codemap;
import front::codemap; import ast;
import front::codemap::codemap; import _std::istr;
import front::ast; import _std::uistr;
import util::common;
import option::some; import option::some;
import option::none; import option::none;
import pp::printer; import pp::printer;
@ -25,15 +24,63 @@ import pp::breaks;
import pp::consistent; import pp::consistent;
import pp::inconsistent; import pp::inconsistent;
import pp::eof; 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) { io::writer out, &pp_ann ann) {
let vec[pp::breaks] boxes = []; 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 = auto s =
@rec(s=pp::mk_printer(out, default_columns), @rec(s=pp::mk_printer(out, default_columns),
cm=some(sess.get_codemap()), cm=some(cm),
comments=some(r.cmnts), comments=some(r.cmnts),
literals=some(r.lits), literals=some(r.lits),
mutable cur_cmnt=0u, 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); maybe_print_comment(s, span.hi);
break_offset(s.s, 1u, -(indent_unit as int)); break_offset(s.s, 1u, -(indent_unit as int));
word(s.s, "}"); 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 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); box(s, 0u, b);
auto len = vec::len[IN](elts); auto len = vec::len[IN](elts);
auto i = 0u; 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 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); 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_int) { word(s.s, "int"); }
case (ast::ty_uint) { word(s.s, "uint"); } case (ast::ty_uint) { word(s.s, "uint"); }
case (ast::ty_float) { word(s.s, "float"); } 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_char) { word(s.s, "char"); }
case (ast::ty_str) { word(s.s, "str"); } case (ast::ty_str) { word(s.s, "str"); }
case (ast::ty_istr) { word(s.s, "istr"); } 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); word(s.s, f.node.ident);
end(s); 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); commasep_cmnt(s, consistent, fields, print_field, get_span);
pclose(s); pclose(s);
} }
@ -435,7 +482,7 @@ fn print_item(&ps s, &@ast::item item) {
word(s.s, field.ident); word(s.s, field.ident);
end(s); 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); commasep_cmnt(s, consistent, _obj.fields, print_field, get_span);
pclose(s); pclose(s);
space(s.s); space(s.s);
@ -517,7 +564,7 @@ fn print_stmt(&ps s, &ast::stmt st) {
print_expr(s, expr); 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]); 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); print_expr(s, elt.expr);
end(s); 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"); word(s.s, "tup");
popen(s); popen(s);
commasep_cmnt(s, inconsistent, exprs, printElt, get_span); 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); print_expr(s, field.node.expr);
end(s); 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"); word(s.s, "rec");
popen(s); popen(s);
commasep_cmnt(s, consistent, fields, print_field, get_span); 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)) { case (ast::expr_unary(?op, ?expr)) {
word(s.s, ast::unop_to_str(op)); 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_lit(?lit)) { print_literal(s, lit); }
case (ast::expr_cast(?expr, ?ty)) { 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); space(s.s);
word_space(s, "as"); word_space(s, "as");
print_type(s, *ty); 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 // FIXME: The fact that this builds up the table anew for every call is
// not good. Eventually, table should be a const. // not good. Eventually, table should be a const.
fn operator_prec(ast::binop op) -> int { 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; } if (spec.op == op) { ret spec.prec; }
} }
fail; fail;
@ -1127,10 +1176,10 @@ fn print_maybe_parens(&ps s, &@ast::expr expr, int outer_prec) {
add_them = operator_prec(op) < outer_prec; add_them = operator_prec(op) < outer_prec;
} }
case (ast::expr_cast(_, _)) { case (ast::expr_cast(_, _)) {
add_them = front::parser::as_prec < outer_prec; add_them = parse::parser::as_prec < outer_prec;
} }
case (ast::expr_ternary(_, _, _)) { case (ast::expr_ternary(_, _, _)) {
add_them = front::parser::ternary_prec < outer_prec; add_them = parse::parser::ternary_prec < outer_prec;
} }
case (_) { add_them = false; } case (_) { add_them = false; }
} }
@ -1186,7 +1235,7 @@ fn print_ty_fn(&ps s, &ast::proto proto, &option::t[str] id,
end(s); 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) { option::t[uint] next_pos) {
auto cm; auto cm;
alt (s.cm) { case (some(?ccm)) { cm = ccm; } case (_) { ret; } } 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; } if (len == 0u) { ret false; }
ret s.boxes.(len - 1u) == pp::consistent; 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: // Local Variables:
// mode: rust // 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;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import util::common::span; import codemap::span;
import util::common::respan;
// Context-passing AST walker. Each overridden visit method has full control // 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 ast;
import middle::ty::ty_param; import ast::ty_param;
import ast::respan;
import std::option; import std::option;
import std::option::some; import std::option::some;
import std::option::none; import std::option::none;
import util::common::span; import codemap::span;
import util::common::respan;
type ast_visitor = type ast_visitor =
rec(fn() -> bool keep_going, 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;
import std::option::none; import std::option::none;
import std::option::some; import std::option::some;
import front::ast; import syntax::ast;
import front::ast::ty; import ast::ty;
import front::ast::pat; import ast::pat;
import front::codemap::codemap; import syntax::codemap::codemap;
import front::ast::lit; import syntax::codemap::span;
import front::ast::path; import ast::lit;
import middle::walk; import ast::path;
import syntax::walk;
import std::io::stdout; import std::io::stdout;
import std::io::str_writer; import std::io::str_writer;
import std::io::string_writer; import std::io::string_writer;
import pretty::pprust::print_block; import syntax::print;
import pretty::pprust::print_item; import print::pprust::print_block;
import pretty::pprust::print_expr; import print::pprust::print_item;
import pretty::pprust::print_path; import print::pprust::print_expr;
import pretty::pprust::print_decl; import print::pprust::print_path;
import pretty::pprust::print_fn; import print::pprust::print_decl;
import pretty::pprust::print_type; import print::pprust::print_fn;
import pretty::ppaux::print_literal; import print::pprust::print_type;
import pretty::pp::mk_printer; import print::pprust::print_literal;
import print::pp::mk_printer;
type filename = str;
type span = rec(uint lo, uint hi);
type spanned[T] = rec(T node, span span);
type flag = hashmap[str, ()]; 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 { fn def_eq(&ast::def_id a, &ast::def_id b) -> bool {
ret a._0 == b._0 && a._1 == b._1; 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); 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_expr(&ast::elt e) -> @ast::expr { ret e.expr; }
fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::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); 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) { 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) { 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 { fn has_nonlocal_exits(&ast::block b) -> bool {
auto has_exits = @mutable false; 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 // FIXME move to vec
fn any[T](&fn(&T) -> bool f, &vec[T] v) -> bool { fn any[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
for (T t in v) { 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) "-" + uint::to_str(-n as uint, radix)
} else { 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 { fn pow(int base, uint exponent) -> int {
ret if (exponent == 0u) { 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 * At the moment, this is a partial hashmap implementation, not yet fit for
* use, but useful as a stress test for rustboot. * 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); 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); 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: // Local Variables:
// mode: rust; // mode: rust;
// fill-column: 78; // 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)); } while (len != 0u) { len -= 1u; s1 += str::unsafe_from_byte(s.(len)); }
ret s1; ret s1;
} }
fn str(uint i) -> str { ret to_str(i, 10u); }
// Local Variables: // Local Variables:
// mode: rust; // mode: rust;
// fill-column: 78; // 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); 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 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) { fn plus_option[T](&mutable vec[T] v, &option::t[T] o) {