user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename std modules to be camelcased

Browse source 
(Have fun mergining your stuff with this.)
This commit is contained in:
Marijn Haverbeke 2011-05-06 22:13:13 +02:00
parent 44c1621525
commit a3ec0b1f64
100 changed files with 2150 additions and 2151 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/comp/front/ast.rs
View file

@ -1,8 +1,8 @@
import std.map.hashmap;
import std.option;
import std._str;
import std._vec;
import std.Map.hashmap;
import std.Option;
import std.Str;
import std.Vec;
import util.common.span;
import util.common.spanned;
import util.common.ty_mach;
@ -24,8 +24,8 @@ type ty_param = ident;
tag ann {
ann_none;
ann_type(middle.ty.t,
option.t[vec[middle.ty.t]], /* ty param substs */
option.t[@ts_ann]); /* pre- and postcondition for typestate */
Option.t[vec[middle.ty.t]], /* ty param substs */
Option.t[@ts_ann]); /* pre- and postcondition for typestate */
}
tag def {
@ -79,8 +79,8 @@ tag crate_directive_ {
// and redirected to the use of const stmt_decls inside
// crate directive blocks.
cdir_let(ident, @expr, vec[@crate_directive]);
cdir_src_mod(ident, option.t[filename]);
cdir_dir_mod(ident, option.t[filename], vec[@crate_directive]);
cdir_src_mod(ident, Option.t[filename]);
cdir_dir_mod(ident, Option.t[filename], vec[@crate_directive]);
cdir_view_item(@view_item);
cdir_meta(vec[@meta_item]);
cdir_syntax(path);
@ -100,7 +100,7 @@ tag block_index_entry {
bie_tag_variant(@item /* tag item */, uint /* variant index */);
}
type block_ = rec(vec[@stmt] stmts,
option.t[@expr] expr,
Option.t[@expr] expr,
hashmap[ident,block_index_entry] index,
ann a); /* ann is only meaningful for the ts_ann field */
@ -111,7 +111,7 @@ tag pat_ {
pat_wild(ann);
pat_bind(ident, def_id, ann);
pat_lit(@lit, ann);
pat_tag(path, vec[@pat], option.t[variant_def], ann);
pat_tag(path, vec[@pat], Option.t[variant_def], ann);
}
tag mutability {
@ -226,10 +226,10 @@ tag init_op {
type initializer = rec(init_op op,
@expr expr);
type local = rec(option.t[@ty] ty,
type local = rec(Option.t[@ty] ty,
bool infer,
ident ident,
option.t[initializer] init,
Option.t[initializer] init,
def_id id,
ann ann);
@ -253,16 +253,16 @@ type expr = spanned[expr_];
tag expr_ {
expr_vec(vec[@expr], mutability, ann);
expr_tup(vec[elt], ann);
expr_rec(vec[field], option.t[@expr], ann);
expr_rec(vec[field], Option.t[@expr], ann);
expr_call(@expr, vec[@expr], ann);
expr_self_method(ident, ann);
expr_bind(@expr, vec[option.t[@expr]], ann);
expr_spawn(spawn_dom, option.t[str], @expr, vec[@expr], ann);
expr_bind(@expr, vec[Option.t[@expr]], ann);
expr_spawn(spawn_dom, Option.t[str], @expr, vec[@expr], ann);
expr_binary(binop, @expr, @expr, ann);
expr_unary(unop, @expr, ann);
expr_lit(@lit, ann);
expr_cast(@expr, @ty, ann);
expr_if(@expr, block, option.t[@expr], ann);
expr_if(@expr, block, Option.t[@expr], ann);
expr_while(@expr, block, ann);
expr_for(@decl, @expr, block, ann);
expr_for_each(@decl, @expr, block, ann);
@ -275,13 +275,13 @@ tag expr_ {
expr_recv(@expr /* TODO: @expr|is_lval */, @expr, ann);
expr_field(@expr, ident, ann);
expr_index(@expr, @expr, ann);
expr_path(path, option.t[def], ann);
expr_ext(path, vec[@expr], option.t[str], @expr, ann);
expr_path(path, Option.t[def], ann);
expr_ext(path, vec[@expr], Option.t[str], @expr, ann);
expr_fail(ann);
expr_break(ann);
expr_cont(ann);
expr_ret(option.t[@expr], ann);
expr_put(option.t[@expr], ann);
expr_ret(Option.t[@expr], ann);
expr_put(Option.t[@expr], ann);
expr_be(@expr, ann);
expr_log(int, @expr, ann);
/* just an assert, no significance to typestate */
@ -331,7 +331,7 @@ tag ty_ {
ty_rec(vec[ty_field]);
ty_fn(proto, vec[ty_arg], @ty);
ty_obj(vec[ty_method]);
ty_path(path, option.t[def]);
ty_path(path, Option.t[def]);
ty_type;
ty_constr(@ty, vec[@constr]);
}
@ -364,7 +364,7 @@ type method = spanned[method_];
type obj_field = rec(@ty ty, ident ident, def_id id, ann ann);
type _obj = rec(vec[obj_field] fields,
vec[@method] methods,
option.t[@method] dtor);
Option.t[@method] dtor);
tag mod_index_entry {
mie_view_item(@view_item);
@ -402,8 +402,8 @@ type variant = spanned[variant_];
type view_item = spanned[view_item_];
tag view_item_ {
view_item_use(ident, vec[@meta_item], def_id, option.t[int]);
view_item_import(ident, vec[ident], def_id, option.t[def]);
view_item_use(ident, vec[@meta_item], def_id, Option.t[int]);
view_item_import(ident, vec[ident], def_id, Option.t[def]);
view_item_export(ident);
}
@ -423,7 +423,7 @@ tag item_ {
type native_item = spanned[native_item_];
tag native_item_ {
native_item_ty(ident, def_id);
native_item_fn(ident, option.t[str],
native_item_fn(ident, Option.t[str],
fn_decl, vec[ty_param], def_id, ann);
}
@ -542,7 +542,7 @@ fn is_exported(ident i, _mod m) -> bool {
for (@ast.view_item vi in m.view_items) {
alt (vi.node) {
case (ast.view_item_export(?id)) {
if (_str.eq(i, id)) {
if (Str.eq(i, id)) {
ret true;
}
count += 1;
@ -574,7 +574,7 @@ fn is_constraint_arg(@expr e) -> bool {
case (expr_lit(_,_)) {
ret true;
}
case (expr_path(_, option.some[def](def_local(_)), _)) {
case (expr_path(_, Option.some[def](def_local(_)), _)) {
ret true;
}
case (_) {

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

@ -1,4 +1,4 @@
import std._vec;
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
@ -24,18 +24,18 @@ fn new_filemap(str filename, uint start_pos) -> filemap {
}
fn next_line(filemap file, uint pos) {
_vec.push[uint](file.lines, 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);
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);
a = 0u; b = Vec.len[uint](f.lines);
while (b - a > 1u) {
auto m = (a + b) / 2u;
if (f.lines.(m) > pos) { b = m; }

202
src/comp/front/creader.rs
View file

@ -14,17 +14,17 @@ import back.x86;
import util.common;
import util.common.span;
import std._str;
import std._uint;
import std._vec;
import std.ebml;
import std.fs;
import std.io;
import std.option;
import std.option.none;
import std.option.some;
import std.os;
import std.map.hashmap;
import std.Str;
import std.UInt;
import std.Vec;
import std.EBML;
import std.FS;
import std.IO;
import std.Option;
import std.Option.none;
import std.Option.some;
import std.OS;
import std.Map.hashmap;
// TODO: map to a real type here.
type env = @rec(
@ -122,7 +122,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
while (peek(st) as char != ']') {
auto name = "";
while (peek(st) as char != '=') {
name += _str.unsafe_from_byte(next(st));
name += Str.unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
@ -160,7 +160,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
}
auto name = "";
while (peek(st) as char != '[') {
name += _str.unsafe_from_byte(next(st));
name += Str.unsafe_from_byte(next(st));
}
auto func = parse_ty_fn(st, sd);
methods += vec(rec(proto=proto,
@ -210,7 +210,7 @@ fn parse_mt(@pstate st, str_def sd) -> ty.mt {
fn parse_def(@pstate st, str_def sd) -> ast.def_id {
auto def = "";
while (peek(st) as char != '|') {
def += _str.unsafe_from_byte(next(st));
def += Str.unsafe_from_byte(next(st));
}
st.pos = st.pos + 1u;
ret sd(def);
@ -265,7 +265,7 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
fn parse_def_id(vec[u8] buf) -> ast.def_id {
auto colon_idx = 0u;
auto len = _vec.len[u8](buf);
auto len = Vec.len[u8](buf);
while (colon_idx < len && buf.(colon_idx) != (':' as u8)) {
colon_idx += 1u;
}
@ -274,30 +274,30 @@ fn parse_def_id(vec[u8] buf) -> ast.def_id {
fail;
}
auto crate_part = _vec.slice[u8](buf, 0u, colon_idx);
auto def_part = _vec.slice[u8](buf, colon_idx + 1u, len);
auto crate_num = _uint.parse_buf(crate_part, 10u) as int;
auto def_num = _uint.parse_buf(def_part, 10u) as int;
auto crate_part = Vec.slice[u8](buf, 0u, colon_idx);
auto def_part = Vec.slice[u8](buf, colon_idx + 1u, len);
auto crate_num = UInt.parse_buf(crate_part, 10u) as int;
auto def_num = UInt.parse_buf(def_part, 10u) as int;
ret tup(crate_num, def_num);
}
fn lookup_hash(&ebml.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
-> option.t[ebml.doc] {
auto index = ebml.get_doc(d, metadata.tag_index);
auto table = ebml.get_doc(index, metadata.tag_index_table);
fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
-> Option.t[EBML.doc] {
auto index = EBML.get_doc(d, metadata.tag_index);
auto table = EBML.get_doc(index, metadata.tag_index_table);
auto hash_pos = table.start + (hash % 256u) * 4u;
auto pos = ebml.be_uint_from_bytes(d.data, hash_pos, 4u);
auto bucket = ebml.doc_at(d.data, pos);
auto pos = EBML.be_uint_from_bytes(d.data, hash_pos, 4u);
auto bucket = EBML.doc_at(d.data, pos);
// Awkward logic because we can't ret from foreach yet
auto result = option.none[ebml.doc];
auto result = Option.none[EBML.doc];
auto belt = metadata.tag_index_buckets_bucket_elt;
for each (ebml.doc elt in ebml.tagged_docs(bucket, belt)) {
for each (EBML.doc elt in EBML.tagged_docs(bucket, belt)) {
alt (result) {
case (option.none[ebml.doc]) {
auto pos = ebml.be_uint_from_bytes(elt.data, elt.start, 4u);
if (eq_fn(_vec.slice[u8](elt.data, elt.start+4u, elt.end))) {
result = option.some[ebml.doc](ebml.doc_at(d.data, pos));
case (Option.none[EBML.doc]) {
auto pos = EBML.be_uint_from_bytes(elt.data, elt.start, 4u);
if (eq_fn(Vec.slice[u8](elt.data, elt.start+4u, elt.end))) {
result = Option.some[EBML.doc](EBML.doc_at(d.data, pos));
}
}
case (_) {}
@ -310,113 +310,113 @@ fn lookup_hash(&ebml.doc d, fn(vec[u8]) -> bool eq_fn, uint hash)
// definition the path refers to.
fn resolve_path(vec[ast.ident] path, vec[u8] data) -> resolve_result {
fn eq_item(vec[u8] data, str s) -> bool {
ret _str.eq(_str.unsafe_from_bytes(data), s);
ret Str.eq(Str.unsafe_from_bytes(data), s);
}
auto s = _str.connect(path, ".");
auto md = ebml.new_doc(data);
auto paths = ebml.get_doc(md, metadata.tag_paths);
auto s = Str.connect(path, ".");
auto md = EBML.new_doc(data);
auto paths = EBML.get_doc(md, metadata.tag_paths);
auto eqer = bind eq_item(_, s);
alt (lookup_hash(paths, eqer, metadata.hash_path(s))) {
case (option.some[ebml.doc](?d)) {
auto did_doc = ebml.get_doc(d, metadata.tag_def_id);
ret rr_ok(parse_def_id(ebml.doc_data(did_doc)));
case (Option.some[EBML.doc](?d)) {
auto did_doc = EBML.get_doc(d, metadata.tag_def_id);
ret rr_ok(parse_def_id(EBML.doc_data(did_doc)));
}
case (option.none[ebml.doc]) {
case (Option.none[EBML.doc]) {
ret rr_not_found(s);
}
}
}
fn maybe_find_item(int item_id, &ebml.doc items) -> option.t[ebml.doc] {
fn maybe_find_item(int item_id, &EBML.doc items) -> Option.t[EBML.doc] {
fn eq_item(vec[u8] bytes, int item_id) -> bool {
ret ebml.be_uint_from_bytes(bytes, 0u, 4u) as int == item_id;
ret EBML.be_uint_from_bytes(bytes, 0u, 4u) as int == item_id;
}
auto eqer = bind eq_item(_, item_id);
ret lookup_hash(items, eqer, metadata.hash_def_num(item_id));
}
fn find_item(int item_id, &ebml.doc items) -> ebml.doc {
fn find_item(int item_id, &EBML.doc items) -> EBML.doc {
alt (maybe_find_item(item_id, items)) {
case (option.some[ebml.doc](?d)) {ret d;}
case (Option.some[EBML.doc](?d)) {ret d;}
}
}
// Looks up an item in the given metadata and returns an EBML doc pointing
// to the item data.
fn lookup_item(int item_id, vec[u8] data) -> ebml.doc {
auto items = ebml.get_doc(ebml.new_doc(data), metadata.tag_items);
fn lookup_item(int item_id, vec[u8] data) -> EBML.doc {
auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items);
ret find_item(item_id, items);
}
fn item_kind(&ebml.doc item) -> u8 {
auto kind = ebml.get_doc(item, metadata.tag_items_data_item_kind);
ret ebml.doc_as_uint(kind) as u8;
fn item_kind(&EBML.doc item) -> u8 {
auto kind = EBML.get_doc(item, metadata.tag_items_data_item_kind);
ret EBML.doc_as_uint(kind) as u8;
}
fn item_symbol(&ebml.doc item) -> str {
auto sym = ebml.get_doc(item, metadata.tag_items_data_item_symbol);
ret _str.unsafe_from_bytes(ebml.doc_data(sym));
fn item_symbol(&EBML.doc item) -> str {
auto sym = EBML.get_doc(item, metadata.tag_items_data_item_symbol);
ret Str.unsafe_from_bytes(EBML.doc_data(sym));
}
fn variant_tag_id(&ebml.doc d) -> ast.def_id {
auto tagdoc = ebml.get_doc(d, metadata.tag_items_data_item_tag_id);
ret parse_def_id(ebml.doc_data(tagdoc));
fn variant_tag_id(&EBML.doc d) -> ast.def_id {
auto tagdoc = EBML.get_doc(d, metadata.tag_items_data_item_tag_id);
ret parse_def_id(EBML.doc_data(tagdoc));
}
fn item_type(&ebml.doc item, int this_cnum, ty.ctxt tcx) -> ty.t {
fn item_type(&EBML.doc item, int this_cnum, ty.ctxt tcx) -> ty.t {
fn parse_external_def_id(int this_cnum, str s) -> ast.def_id {
// FIXME: This is completely wrong when linking against a crate
// that, in turn, links against another crate. We need a mapping
// from crate ID to crate "meta" attributes as part of the crate
// metadata.
auto buf = _str.bytes(s);
auto buf = Str.bytes(s);
auto external_def_id = parse_def_id(buf);
ret tup(this_cnum, external_def_id._1);
}
auto tp = ebml.get_doc(item, metadata.tag_items_data_item_type);
auto s = _str.unsafe_from_bytes(ebml.doc_data(tp));
auto tp = EBML.get_doc(item, metadata.tag_items_data_item_type);
auto s = Str.unsafe_from_bytes(EBML.doc_data(tp));
ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
bind parse_external_def_id(this_cnum, _), tcx);
}
fn item_ty_param_count(&ebml.doc item, int this_cnum) -> uint {
fn item_ty_param_count(&EBML.doc item, int this_cnum) -> uint {
let uint ty_param_count = 0u;
auto tp = metadata.tag_items_data_item_ty_param_count;
for each (ebml.doc p in ebml.tagged_docs(item, tp)) {
ty_param_count = ebml.vint_at(ebml.doc_data(p), 0u)._0;
for each (EBML.doc p in EBML.tagged_docs(item, tp)) {
ty_param_count = EBML.vint_at(EBML.doc_data(p), 0u)._0;
}
ret ty_param_count;
}
fn tag_variant_ids(&ebml.doc item, int this_cnum) -> vec[ast.def_id] {
fn tag_variant_ids(&EBML.doc item, int this_cnum) -> vec[ast.def_id] {
let vec[ast.def_id] ids = vec();
auto v = metadata.tag_items_data_item_variant;
for each (ebml.doc p in ebml.tagged_docs(item, v)) {
auto ext = parse_def_id(ebml.doc_data(p));
_vec.push[ast.def_id](ids, tup(this_cnum, ext._1));
for each (EBML.doc p in EBML.tagged_docs(item, v)) {
auto ext = parse_def_id(EBML.doc_data(p));
Vec.push[ast.def_id](ids, tup(this_cnum, ext._1));
}
ret ids;
}
fn get_metadata_section(str filename) -> option.t[vec[u8]] {
fn get_metadata_section(str filename) -> Option.t[vec[u8]] {
auto mb = llvm.LLVMRustCreateMemoryBufferWithContentsOfFile
(_str.buf(filename));
if (mb as int == 0) {ret option.none[vec[u8]];}
(Str.buf(filename));
if (mb as int == 0) {ret Option.none[vec[u8]];}
auto of = mk_object_file(mb);
auto si = mk_section_iter(of.llof);
while (llvm.LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False) {
auto name_buf = llvm.LLVMGetSectionName(si.llsi);
auto name = _str.str_from_cstr(name_buf);
if (_str.eq(name, x86.get_meta_sect_name())) {
auto name = Str.str_from_cstr(name_buf);
if (Str.eq(name, x86.get_meta_sect_name())) {
auto cbuf = llvm.LLVMGetSectionContents(si.llsi);
auto csz = llvm.LLVMGetSectionSize(si.llsi);
auto cvbuf = cbuf as _vec.vbuf;
ret option.some[vec[u8]](_vec.vec_from_vbuf[u8](cvbuf, csz));
auto cvbuf = cbuf as Vec.vbuf;
ret Option.some[vec[u8]](Vec.vec_from_vbuf[u8](cvbuf, csz));
}
llvm.LLVMMoveToNextSection(si.llsi);
}
ret option.none[vec[u8]];
ret Option.none[vec[u8]];
}
@ -426,9 +426,9 @@ fn load_crate(session.session sess,
vec[str] library_search_paths) {
auto filename = parser.default_native_name(sess, ident);
for (str library_search_path in library_search_paths) {
auto path = fs.connect(library_search_path, filename);
auto path = FS.connect(library_search_path, filename);
alt (get_metadata_section(path)) {
case (option.some[vec[u8]](?cvec)) {
case (Option.some[vec[u8]](?cvec)) {
sess.set_external_crate(cnum, rec(name=ident, data=cvec));
ret;
}
@ -442,7 +442,7 @@ fn load_crate(session.session sess,
}
fn fold_view_item_use(&env e, &span sp, ast.ident ident,
vec[@ast.meta_item] meta_items, ast.def_id id, option.t[int] cnum_opt)
vec[@ast.meta_item] meta_items, ast.def_id id, Option.t[int] cnum_opt)
-> @ast.view_item {
auto cnum;
if (!e.crate_cache.contains_key(ident)) {
@ -497,7 +497,7 @@ fn kind_has_type_params(u8 kind_ch) -> bool {
// Crate metadata queries
fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
-> option.t[ast.def] {
-> Option.t[ast.def] {
auto data = sess.get_external_crate(cnum).data;
auto did;
@ -568,7 +568,7 @@ fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def)
-> vec[trans.variant_info] {
auto external_crate_id = def._0;
auto data = sess.get_external_crate(external_crate_id).data;
auto items = ebml.get_doc(ebml.new_doc(data), metadata.tag_items);
auto items = EBML.get_doc(EBML.new_doc(data), metadata.tag_items);
auto item = find_item(def._1, items);
let vec[trans.variant_info] infos = vec();
@ -593,52 +593,52 @@ fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def)
ret infos;
}
fn list_file_metadata(str path, io.writer out) {
fn list_file_metadata(str path, IO.writer out) {
alt (get_metadata_section(path)) {
case (option.some[vec[u8]](?bytes)) {
case (Option.some[vec[u8]](?bytes)) {
list_crate_metadata(bytes, out);
}
case (option.none[vec[u8]]) {
case (Option.none[vec[u8]]) {
out.write_str("Could not find metadata in " + path + ".\n");
}
}
}
fn read_path(&ebml.doc d) -> tup(str, uint) {
auto desc = ebml.doc_data(d);
auto pos = ebml.be_uint_from_bytes(desc, 0u, 4u);
auto pathbytes = _vec.slice[u8](desc, 4u, _vec.len[u8](desc));
auto path = _str.unsafe_from_bytes(pathbytes);
fn read_path(&EBML.doc d) -> tup(str, uint) {
auto desc = EBML.doc_data(d);
auto pos = EBML.be_uint_from_bytes(desc, 0u, 4u);
auto pathbytes = Vec.slice[u8](desc, 4u, Vec.len[u8](desc));
auto path = Str.unsafe_from_bytes(pathbytes);
ret tup(path, pos);
}
fn list_crate_metadata(vec[u8] bytes, io.writer out) {
auto md = ebml.new_doc(bytes);
auto paths = ebml.get_doc(md, metadata.tag_paths);
auto items = ebml.get_doc(md, metadata.tag_items);
auto index = ebml.get_doc(paths, metadata.tag_index);
auto bs = ebml.get_doc(index, metadata.tag_index_buckets);
for each (ebml.doc bucket in
ebml.tagged_docs(bs, metadata.tag_index_buckets_bucket)) {
fn list_crate_metadata(vec[u8] bytes, IO.writer out) {
auto md = EBML.new_doc(bytes);
auto paths = EBML.get_doc(md, metadata.tag_paths);
auto items = EBML.get_doc(md, metadata.tag_items);
auto index = EBML.get_doc(paths, metadata.tag_index);
auto bs = EBML.get_doc(index, metadata.tag_index_buckets);
for each (EBML.doc bucket in
EBML.tagged_docs(bs, metadata.tag_index_buckets_bucket)) {
auto et = metadata.tag_index_buckets_bucket_elt;
for each (ebml.doc elt in ebml.tagged_docs(bucket, et)) {
for each (EBML.doc elt in EBML.tagged_docs(bucket, et)) {
auto data = read_path(elt);
auto def = ebml.doc_at(bytes, data._1);
auto did_doc = ebml.get_doc(def, metadata.tag_def_id);
auto did = parse_def_id(ebml.doc_data(did_doc));
auto def = EBML.doc_at(bytes, data._1);
auto did_doc = EBML.get_doc(def, metadata.tag_def_id);
auto did = parse_def_id(EBML.doc_data(did_doc));
out.write_str(#fmt("%s (%s)\n", data._0,
describe_def(items, did)));
}
}
}
fn describe_def(&ebml.doc items, ast.def_id id) -> str {
fn describe_def(&EBML.doc items, ast.def_id id) -> str {
if (id._0 != 0) {ret "external";}
alt (maybe_find_item(id._1 as int, items)) {
case (option.some[ebml.doc](?item)) {
case (Option.some[EBML.doc](?item)) {
ret item_kind_to_str(item_kind(item));
}
case (option.none[ebml.doc]) {
case (Option.none[EBML.doc]) {
ret "??"; // Native modules don't seem to get item entries.
}
}

30
src/comp/front/eval.rs
View file

@ -1,9 +1,9 @@
import std._vec;
import std._str;
import std.option;
import std.option.some;
import std.option.none;
import std.map.hashmap;
import std.Vec;
import std.Str;
import std.Option;
import std.Option.some;
import std.Option.none;
import std.Map.hashmap;
import driver.session;
import ast.ident;
@ -91,7 +91,7 @@ fn val_as_str(val v) -> str {
fn lookup(session.session sess, env e, span sp, ident i) -> val {
for (tup(ident, val) pair in e) {
if (_str.eq(i, pair._0)) {
if (Str.eq(i, pair._0)) {
ret pair._1;
}
}
@ -114,8 +114,8 @@ fn eval_lit(ctx cx, span sp, @ast.lit lit) -> val {
fn eval_expr(ctx cx, env e, @ast.expr x) -> val {
alt (x.node) {
case (ast.expr_path(?pth, _, _)) {
if (_vec.len[ident](pth.node.idents) == 1u &&
_vec.len[@ast.ty](pth.node.types) == 0u) {
if (Vec.len[ident](pth.node.idents) == 1u &&
Vec.len[@ast.ty](pth.node.types) == 0u) {
ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
}
cx.sess.span_err(x.span, "evaluating structured path-name");
@ -224,7 +224,7 @@ fn val_eq(session.session sess, span sp, val av, val bv) -> bool {
ret val_as_int(av) == val_as_int(bv);
}
if (val_is_str(av) && val_is_str(bv)) {
ret _str.eq(val_as_str(av),
ret Str.eq(val_as_str(av),
val_as_str(bv));
}
sess.span_err(sp, "bad types in comparison");
@ -388,7 +388,7 @@ fn eval_crate_directive(ctx cx,
case (none[filename]) {}
}
auto full_path = prefix + std.fs.path_sep() + file_path;
auto full_path = prefix + std.FS.path_sep() + file_path;
if (cx.mode == mode_depend) {
cx.deps += vec(full_path);
@ -405,7 +405,7 @@ fn eval_crate_directive(ctx cx,
auto im = ast.item_mod(id, m0, next_id);
auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
ast.index_item(index, i);
_vec.push[@ast.item](items, i);
Vec.push[@ast.item](items, i);
}
case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
@ -418,16 +418,16 @@ fn eval_crate_directive(ctx cx,
case (none[filename]) {}
}
auto full_path = prefix + std.fs.path_sep() + path;
auto full_path = prefix + std.FS.path_sep() + path;
auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
auto im = ast.item_mod(id, m0, cx.p.next_def_id());
auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
ast.index_item(index, i);
_vec.push[@ast.item](items, i);
Vec.push[@ast.item](items, i);
}
case (ast.cdir_view_item(?vi)) {
_vec.push[@ast.view_item](view_items, vi);
Vec.push[@ast.view_item](view_items, vi);
ast.index_view_item(index, vi);
}

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

@ -6,9 +6,9 @@
import util.common;
import std._str;
import std._vec;
import std.option;
import std.Str;
import std.Vec;
import std.Option;
import std.GenericOS;
export expand_syntax_ext;
@ -17,9 +17,9 @@ export expand_syntax_ext;
fn expand_syntax_ext(parser.parser p,
common.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) {
p.err("malformed #env call");
}

36
src/comp/front/extfmt.rs
View file

@ -6,11 +6,11 @@
import util.common;
import std._str;
import std._vec;
import std.option;
import std.option.none;
import std.option.some;
import std.Str;
import std.Vec;
import std.Option;
import std.Option.none;
import std.Option.some;
import std.ExtFmt.CT.signedness;
import std.ExtFmt.CT.signed;
@ -47,9 +47,9 @@ export expand_syntax_ext;
// FIXME: Need to thread parser through here to handle errors correctly
fn expand_syntax_ext(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) {
log_err "malformed #fmt call";
fail;
}
@ -60,8 +60,8 @@ fn expand_syntax_ext(vec[@ast.expr] args,
// log fmt;
auto pieces = parse_fmt_string(fmt);
auto args_len = _vec.len[@ast.expr](args);
auto fmt_args = _vec.slice[@ast.expr](args, 1u, args_len - 1u);
auto args_len = Vec.len[@ast.expr](args);
auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u);
ret pieces_to_expr(pieces, args);
}
@ -148,7 +148,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
auto recexpr = ast.expr_rec(astfields,
option.none[@ast.expr],
Option.none[@ast.expr],
ast.ann_none);
auto sp_recexpr = @rec(node=recexpr, span=sp);
ret sp_recexpr;
@ -196,7 +196,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
// FIXME: 0-length vectors can't have their type inferred
// through the rec that these flags are a member of, so
// this is a hack placeholder flag
if (_vec.len[@ast.expr](flagexprs) == 0u) {
if (Vec.len[@ast.expr](flagexprs) == 0u) {
flagexprs += vec(make_rt_path_expr(sp, "flag_none"));
}
@ -303,7 +303,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
auto unsupported = "conversion not supported in #fmt string";
alt (cnv.param) {
case (option.none[int]) {
case (Option.none[int]) {
}
case (_) {
log_err unsupported;
@ -398,7 +398,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
fn log_conv(conv c) {
alt (c.param) {
case (some[int](?p)) {
log "param: " + std._int.to_str(p, 10u);
log "param: " + std.Int.to_str(p, 10u);
}
case (_) {
log "param: none";
@ -425,10 +425,10 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
alt (c.width) {
case (count_is(?i)) {
log "width: count is " + std._int.to_str(i, 10u);
log "width: count is " + std.Int.to_str(i, 10u);
}
case (count_is_param(?i)) {
log "width: count is param " + std._int.to_str(i, 10u);
log "width: count is param " + std.Int.to_str(i, 10u);
}
case (count_is_next_param) {
log "width: count is next param";
@ -439,10 +439,10 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
}
alt (c.precision) {
case (count_is(?i)) {
log "prec: count is " + std._int.to_str(i, 10u);
log "prec: count is " + std.Int.to_str(i, 10u);
}
case (count_is_param(?i)) {
log "prec: count is param " + std._int.to_str(i, 10u);
log "prec: count is param " + std.Int.to_str(i, 10u);
}
case (count_is_next_param) {
log "prec: count is next param";
@ -498,7 +498,7 @@ fn pieces_to_expr(vec[piece] pieces, vec[@ast.expr] args) -> @ast.expr {
tmp_expr = make_add_expr(sp, tmp_expr, s_expr);
}
case (piece_conv(?conv)) {
if (n >= _vec.len[@ast.expr](args)) {
if (n >= Vec.len[@ast.expr](args)) {
log_err "too many conversions in #fmt string";
fail;
}

80
src/comp/front/lexer.rs
View file

@ -1,12 +1,12 @@
import std.io;
import std._str;
import std._vec;
import std._int;
import std.map;
import std.map.hashmap;
import std.option;
import std.option.some;
import std.option.none;
import std.IO;
import std.Str;
import std.Vec;
import std.Int;
import std.Map;
import std.Map.hashmap;
import std.Option;
import std.Option.some;
import std.Option.none;
import util.common;
import util.common.new_str_hash;
@ -24,7 +24,7 @@ state type reader = state obj {
fn get_filemap() -> codemap.filemap;
};
fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
fn new_reader(IO.reader rdr, str filename, codemap.filemap filemap)
-> reader {
state obj reader(str file,
uint len,
@ -49,13 +49,13 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
}
fn next() -> char {
if (pos < len) {ret _str.char_at(file, pos);}
if (pos < len) {ret Str.char_at(file, pos);}
else {ret -1 as char;}
}
fn init() {
if (pos < len) {
auto next = _str.char_range_at(file, pos);
auto next = Str.char_range_at(file, pos);
pos = next._1;
ch = next._0;
}
@ -67,7 +67,7 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
if (ch == '\n') {
codemap.next_line(fm, chpos);
}
auto next = _str.char_range_at(file, pos);
auto next = Str.char_range_at(file, pos);
pos = next._1;
ch = next._0;
} else {
@ -87,8 +87,8 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
ret fm;
}
}
auto file = _str.unsafe_from_bytes(rdr.read_whole_stream());
auto rd = reader(file, _str.byte_len(file), 0u, -1 as char,
auto file = Str.unsafe_from_bytes(rdr.read_whole_stream());
auto rd = reader(file, Str.byte_len(file), 0u, -1 as char,
filemap.start_pos, filemap.start_pos,
keyword_table(),
reserved_word_table(),
@ -97,7 +97,7 @@ fn new_reader(io.reader rdr, str filename, codemap.filemap filemap)
ret rd;
}
fn keyword_table() -> std.map.hashmap[str, token.token] {
fn keyword_table() -> std.Map.hashmap[str, token.token] {
auto keywords = new_str_hash[token.token]();
keywords.insert("mod", token.MOD);
@ -205,7 +205,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
ret keywords;
}
fn reserved_word_table() -> std.map.hashmap[str, ()] {
fn reserved_word_table() -> std.Map.hashmap[str, ()] {
auto reserved = new_str_hash[()]();
reserved.insert("f16", ()); // IEEE 754-2008 'binary16' interchange fmt
reserved.insert("f80", ()); // IEEE 754-1985 'extended'
@ -341,20 +341,20 @@ fn digits_to_string(str s) -> int {
ret accum_int;
}
fn scan_exponent(reader rdr) -> option.t[str] {
fn scan_exponent(reader rdr) -> Option.t[str] {
auto c = rdr.curr();
auto res = "";
if (c == 'e' || c == 'E') {
res += _str.from_bytes(vec(c as u8));
res += Str.from_bytes(vec(c as u8));
rdr.bump();
c = rdr.curr();
if (c == '-' || c == '+') {
res += _str.from_bytes(vec(c as u8));
res += Str.from_bytes(vec(c as u8));
rdr.bump();
}
auto exponent = scan_dec_digits(rdr);
if (_str.byte_len(exponent) > 0u) {
if (Str.byte_len(exponent) > 0u) {
ret(some(res + exponent));
}
else {
@ -374,7 +374,7 @@ fn scan_dec_digits(reader rdr) -> str {
while (is_dec_digit (c) || c == '_') {
if (c != '_') {
res += _str.from_bytes(vec(c as u8));
res += Str.from_bytes(vec(c as u8));
}
rdr.bump();
c = rdr.curr();
@ -574,12 +574,12 @@ fn next_token(reader rdr) -> token.token {
if (is_alpha(c) || c == '_') {
while (is_alnum(c) || c == '_') {
_str.push_char(accum_str, c);
Str.push_char(accum_str, c);
rdr.bump();
c = rdr.curr();
}
if (_str.eq(accum_str, "_")) {
if (Str.eq(accum_str, "_")) {
ret token.UNDERSCORE;
}
@ -738,37 +738,37 @@ fn next_token(reader rdr) -> token.token {
alt (rdr.next()) {
case ('n') {
rdr.bump();
_str.push_byte(accum_str, '\n' as u8);
Str.push_byte(accum_str, '\n' as u8);
}
case ('r') {
rdr.bump();
_str.push_byte(accum_str, '\r' as u8);
Str.push_byte(accum_str, '\r' as u8);
}
case ('t') {
rdr.bump();
_str.push_byte(accum_str, '\t' as u8);
Str.push_byte(accum_str, '\t' as u8);
}
case ('\\') {
rdr.bump();
_str.push_byte(accum_str, '\\' as u8);
Str.push_byte(accum_str, '\\' as u8);
}
case ('"') {
rdr.bump();
_str.push_byte(accum_str, '"' as u8);
Str.push_byte(accum_str, '"' as u8);
}
case ('x') {
_str.push_char(accum_str,
Str.push_char(accum_str,
scan_numeric_escape(rdr));
}
case ('u') {
_str.push_char(accum_str,
Str.push_char(accum_str,
scan_numeric_escape(rdr));
}
case ('U') {
_str.push_char(accum_str,
Str.push_char(accum_str,
scan_numeric_escape(rdr));
}
@ -780,7 +780,7 @@ fn next_token(reader rdr) -> token.token {
}
}
case (_) {
_str.push_char(accum_str, rdr.curr());
Str.push_char(accum_str, rdr.curr());
}
}
rdr.bump();
@ -870,7 +870,7 @@ fn read_line_comment(reader rdr) -> cmnt {
while (rdr.curr() == ' ') {rdr.bump();}
auto val = "";
while (rdr.curr() != '\n' && !rdr.is_eof()) {
_str.push_char(val, rdr.curr());
Str.push_char(val, rdr.curr());
rdr.bump();
}
ret rec(val=cmnt_line(val),
@ -887,7 +887,7 @@ fn read_block_comment(reader rdr) -> cmnt {
auto level = 1;
while (true) {
if (rdr.curr() == '\n') {
_vec.push[str](lines, val);
Vec.push[str](lines, val);
val = "";
consume_whitespace(rdr);
} else {
@ -895,13 +895,13 @@ fn read_block_comment(reader rdr) -> cmnt {
level -= 1;
if (level == 0) {
rdr.bump(); rdr.bump();
_vec.push[str](lines, val);
Vec.push[str](lines, val);
break;
}
} else if (rdr.curr() == '/' && rdr.next() == '*') {
level += 1;
}
_str.push_char(val, rdr.curr());
Str.push_char(val, rdr.curr());
rdr.bump();
}
if (rdr.is_eof()) {fail;}
@ -912,16 +912,16 @@ fn read_block_comment(reader rdr) -> cmnt {
}
fn gather_comments(str path) -> vec[cmnt] {
auto srdr = io.file_reader(path);
auto srdr = IO.file_reader(path);
auto rdr = new_reader(srdr, path, codemap.new_filemap(path, 0u));
let vec[cmnt] comments = vec();
while (!rdr.is_eof()) {
while (true) {
consume_whitespace(rdr);
if (rdr.curr() == '/' && rdr.next() == '/') {
_vec.push[cmnt](comments, read_line_comment(rdr));
Vec.push[cmnt](comments, read_line_comment(rdr));
} else if (rdr.curr() == '/' && rdr.next() == '*') {
_vec.push[cmnt](comments, read_block_comment(rdr));
Vec.push[cmnt](comments, read_block_comment(rdr));
} else { break; }
}
next_token(rdr);

74
src/comp/front/parser.rs
View file

@ -1,10 +1,10 @@
import std.io;
import std._vec;
import std._str;
import std.option;
import std.option.some;
import std.option.none;
import std.map.hashmap;
import std.IO;
import std.Vec;
import std.Str;
import std.Option;
import std.Option.some;
import std.Option.none;
import std.Map.hashmap;
import driver.session;
import util.common;
@ -118,12 +118,12 @@ fn new_parser(session.session sess,
fn get_chpos() -> uint {ret rdr.get_chpos();}
}
auto ftype = SOURCE_FILE;
if (_str.ends_with(path, ".rc")) {
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);
_vec.push[codemap.filemap](sess.get_codemap().files, filemap);
Vec.push[codemap.filemap](sess.get_codemap().files, filemap);
auto rdr = lexer.new_reader(srdr, path, filemap);
// Make sure npos points at first actual token.
lexer.consume_any_whitespace(rdr);
@ -320,7 +320,7 @@ fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] {
case (token.IDENT(_)) {
auto constr = parse_ty_constr(p);
hi = constr.span.hi;
_vec.push[@ast.constr](constrs, constr);
Vec.push[@ast.constr](constrs, constr);
if (p.peek() == token.COMMA) {
p.bump();
more = false;
@ -496,7 +496,7 @@ fn parse_arg(parser p) -> ast.arg {
}
fn parse_seq_to_end[T](token.token ket,
option.t[token.token] sep,
Option.t[token.token] sep,
(fn(parser) -> T) f,
uint hi,
parser p) -> vec[T] {
@ -525,7 +525,7 @@ fn parse_seq_to_end[T](token.token ket,
fn parse_seq[T](token.token bra,
token.token ket,
option.t[token.token] sep,
Option.t[token.token] sep,
(fn(parser) -> T) f,
parser p) -> util.common.spanned[vec[T]] {
auto lo = p.get_lo_pos();
@ -764,7 +764,7 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
case (token.BIND) {
p.bump();
auto e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
fn parse_expr_opt(parser p) -> option.t[@ast.expr] {
fn parse_expr_opt(parser p) -> Option.t[@ast.expr] {
alt (p.peek()) {
case (token.UNDERSCORE) {
p.bump();
@ -777,7 +777,7 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
}
auto pf = parse_expr_opt;
auto es = parse_seq[option.t[@ast.expr]](token.LPAREN,
auto es = parse_seq[Option.t[@ast.expr]](token.LPAREN,
token.RPAREN,
some(token.COMMA),
pf, p);
@ -939,18 +939,18 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
fn expand_syntax_ext(parser p, ast.span sp,
&ast.path path, vec[@ast.expr] args,
option.t[str] body) -> ast.expr_ {
Option.t[str] body) -> ast.expr_ {
assert (_vec.len[ast.ident](path.node.idents) > 0u);
assert (Vec.len[ast.ident](path.node.idents) > 0u);
auto extname = path.node.idents.(0);
if (_str.eq(extname, "fmt")) {
if (Str.eq(extname, "fmt")) {
auto expanded = extfmt.expand_syntax_ext(args, body);
auto newexpr = ast.expr_ext(path, args, body,
expanded,
ast.ann_none);
ret newexpr;
} else if (_str.eq(extname, "env")) {
} else if (Str.eq(extname, "env")) {
auto expanded = extenv.expand_syntax_ext(p, sp, args, body);
auto newexpr = ast.expr_ext(path, args, body,
expanded,
@ -968,7 +968,7 @@ fn extend_expr_by_ident(parser p, uint lo, uint hi,
auto e_ = e.node;
alt (e.node) {
case (ast.expr_path(?pth, ?def, ?ann)) {
if (_vec.len[@ast.ty](pth.node.types) == 0u) {
if (Vec.len[@ast.ty](pth.node.types) == 0u) {
auto idents_ = pth.node.idents;
idents_ += vec(i);
auto tys = parse_ty_args(p, hi);
@ -1238,7 +1238,7 @@ fn parse_if_expr(parser p) -> @ast.expr {
auto cond = parse_expr(p);
expect(p, token.RPAREN);
auto thn = parse_block(p);
let option.t[@ast.expr] els = none[@ast.expr];
let Option.t[@ast.expr] els = none[@ast.expr];
auto hi = thn.span.hi;
alt (p.peek()) {
case (token.ELSE) {
@ -1398,7 +1398,7 @@ fn parse_spawn_expr(parser p) -> @ast.expr {
pf, p);
auto hi = es.span.hi;
auto spawn_expr = ast.expr_spawn(ast.dom_implicit,
option.none[str],
Option.none[str],
fn_expr,
es.node,
ast.ann_none);
@ -1449,7 +1449,7 @@ fn parse_expr_inner(parser p) -> @ast.expr {
}
}
fn parse_initializer(parser p) -> option.t[ast.initializer] {
fn parse_initializer(parser p) -> Option.t[ast.initializer] {
alt (p.peek()) {
case (token.EQ) {
p.bump();
@ -1521,7 +1521,7 @@ fn parse_pat(parser p) -> @ast.pat {
ret @spanned(lo, hi, pat);
}
fn parse_local_full(&option.t[@ast.ty] tyopt,
fn parse_local_full(&Option.t[@ast.ty] tyopt,
parser p) -> @ast.local {
auto ident = parse_ident(p);
auto init = parse_initializer(p);
@ -1607,7 +1607,7 @@ fn parse_source_stmt(parser p) -> @ast.stmt {
fail;
}
fn index_block(vec[@ast.stmt] stmts, option.t[@ast.expr] expr) -> ast.block_ {
fn index_block(vec[@ast.stmt] stmts, Option.t[@ast.expr] expr) -> ast.block_ {
auto index = new_str_hash[ast.block_index_entry]();
for (@ast.stmt s in stmts) {
ast.index_stmt(index, s);
@ -1634,7 +1634,7 @@ fn index_arm(@ast.pat pat) -> hashmap[ast.ident,ast.def_id] {
ret index;
}
fn stmt_to_expr(@ast.stmt stmt) -> option.t[@ast.expr] {
fn stmt_to_expr(@ast.stmt stmt) -> Option.t[@ast.expr] {
alt (stmt.node) {
case (ast.stmt_expr(?e,_)) { ret some[@ast.expr](e); }
case (_) { /* fall through */ }
@ -1697,7 +1697,7 @@ fn parse_block(parser p) -> ast.block {
auto lo = p.get_lo_pos();
let vec[@ast.stmt] stmts = vec();
let option.t[@ast.expr] expr = none[@ast.expr];
let Option.t[@ast.expr] expr = none[@ast.expr];
expect(p, token.LBRACE);
while (p.peek() != token.RBRACE) {
@ -1871,7 +1871,7 @@ fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
pf, p);
let vec[@ast.method] meths = vec();
let option.t[@ast.method] dtor = none[@ast.method];
let Option.t[@ast.method] dtor = none[@ast.method];
expect(p, token.LBRACE);
while (p.peek() != token.RBRACE) {
@ -1880,7 +1880,7 @@ fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
dtor = some[@ast.method](parse_dtor(p));
}
case (_) {
_vec.push[@ast.method](meths,
Vec.push[@ast.method](meths,
parse_method(p));
}
}
@ -2020,12 +2020,12 @@ fn parse_item_native_mod(parser p) -> @ast.item {
auto abi = ast.native_abi_cdecl;
if (p.peek() != token.MOD) {
auto t = parse_str_lit_or_env_ident(p);
if (_str.eq(t, "cdecl")) {
} else if (_str.eq(t, "rust")) {
if (Str.eq(t, "cdecl")) {
} else if (Str.eq(t, "rust")) {
abi = ast.native_abi_rust;
} else if (_str.eq(t, "llvm")) {
} else if (Str.eq(t, "llvm")) {
abi = ast.native_abi_llvm;
} else if (_str.eq(t, "rust-intrinsic")) {
} else if (Str.eq(t, "rust-intrinsic")) {
abi = ast.native_abi_rust_intrinsic;
} else {
p.err("unsupported abi: " + t);
@ -2264,7 +2264,7 @@ fn parse_use(parser p) -> @ast.view_item {
}
fn parse_rest_import_name(parser p, ast.ident first,
option.t[ast.ident] def_ident)
Option.t[ast.ident] def_ident)
-> @ast.view_item {
auto lo = p.get_lo_pos();
let vec[ast.ident] identifiers = vec(first);
@ -2281,7 +2281,7 @@ fn parse_rest_import_name(parser p, ast.ident first,
defined_id = i;
}
case (_) {
auto len = _vec.len[ast.ident](identifiers);
auto len = Vec.len[ast.ident](identifiers);
defined_id = identifiers.(len - 1u);
}
}
@ -2506,7 +2506,7 @@ fn parse_crate_directives(parser p, token.token term)
while (p.peek() != term) {
auto cdir = @parse_crate_directive(p);
_vec.push[@ast.crate_directive](cdirs, cdir);
Vec.push[@ast.crate_directive](cdirs, cdir);
}
ret cdirs;
@ -2514,7 +2514,7 @@ fn parse_crate_directives(parser p, token.token term)
fn parse_crate_from_crate_file(parser p) -> @ast.crate {
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 cdirs = parse_crate_directives(p, token.EOF);
let vec[str] deps = vec();
auto cx = @rec(p=p,

18
src/comp/front/token.rs
View file

@ -1,9 +1,9 @@
import util.common.ty_mach;
import util.common.ty_mach_to_str;
import util.common.new_str_hash;
import std._int;
import std._uint;
import std._str;
import std.Int;
import std.UInt;
import std.Str;
tag binop {
PLUS;
@ -295,10 +295,10 @@ fn to_str(token t) -> str {
case (JOIN) { ret "join"; }
/* Literals */
case (LIT_INT(?i)) { ret _int.to_str(i, 10u); }
case (LIT_UINT(?u)) { ret _uint.to_str(u, 10u); }
case (LIT_INT(?i)) { ret Int.to_str(i, 10u); }
case (LIT_UINT(?u)) { ret UInt.to_str(u, 10u); }
case (LIT_MACH_INT(?tm, ?i)) {
ret _int.to_str(i, 10u)
ret Int.to_str(i, 10u)
+ "_" + ty_mach_to_str(tm);
}
case (LIT_FLOAT(?s)) { ret s; }
@ -309,8 +309,8 @@ fn to_str(token t) -> str {
case (LIT_CHAR(?c)) {
// FIXME: escape.
auto tmp = "'";
_str.push_char(tmp, c);
_str.push_byte(tmp, '\'' as u8);
Str.push_char(tmp, c);
Str.push_byte(tmp, '\'' as u8);
ret tmp;
}
@ -320,7 +320,7 @@ fn to_str(token t) -> str {
/* Name components */
case (IDENT(?s)) { auto si = "ident:"; si += s; ret si; }
case (IDX(?i)) { ret "_" + _int.to_str(i, 10u); }
case (IDX(?i)) { ret "_" + Int.to_str(i, 10u); }
case (UNDERSCORE) { ret "_"; }
/* Reserved type names */