diff options
Diffstat (limited to 'src/comp/front/creader.rs')
| -rw-r--r-- | src/comp/front/creader.rs | 462 |
1 files changed, 232 insertions, 230 deletions
diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs index 5ae56417..03b5cb1e 100644 --- a/src/comp/front/creader.rs +++ b/src/comp/front/creader.rs @@ -1,56 +1,56 @@ // -*- rust -*- -import driver.session; -import front.ast; -import lib.llvm.False; -import lib.llvm.llvm; -import lib.llvm.mk_object_file; -import lib.llvm.mk_section_iter; -import middle.fold; -import middle.metadata; -import middle.trans; -import middle.ty; -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 driver::session; +import front::ast; +import lib::llvm::False; +import lib::llvm::llvm; +import lib::llvm::mk_object_file; +import lib::llvm::mk_section_iter; +import middle::fold; +import middle::metadata; +import middle::trans; +import middle::ty; +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; // TODO: map to a real type here. type env = @rec( - session.session sess, + session::session sess, @hashmap[str, int] crate_cache, vec[str] library_search_paths, mutable int next_crate_num ); tag resolve_result { - rr_ok(ast.def_id); - rr_not_found(ast.ident); + rr_ok(ast::def_id); + rr_not_found(ast::ident); } // Type decoding -// Compact string representation for ty.t values. API ty_str & parse_from_str. +// Compact string representation for ty::t values. API ty_str & parse_from_str // (The second has to be authed pure.) Extra parameters are for converting // to/from def_ids in the data buffer. Whatever format you choose should not // contain pipe characters. -// Callback to translate defs to strs or back. -type str_def = fn(str) -> ast.def_id; +// Callback to translate defs to strs or back: +type str_def = fn(str) -> ast::def_id; type pstate = rec(vec[u8] data, int crate, - mutable uint pos, uint len, ty.ctxt tcx); + mutable uint pos, uint len, ty::ctxt tcx); fn peek(@pstate st) -> u8 { ret st.data.(st.pos); @@ -62,105 +62,105 @@ fn next(@pstate st) -> u8 { } fn parse_ty_data(vec[u8] data, int crate_num, uint pos, uint len, - str_def sd, ty.ctxt tcx) -> ty.t { + str_def sd, ty::ctxt tcx) -> ty::t { auto st = @rec(data=data, crate=crate_num, mutable pos=pos, len=len, tcx=tcx); auto result = parse_ty(st, sd); ret result; } -fn parse_ty(@pstate st, str_def sd) -> ty.t { +fn parse_ty(@pstate st, str_def sd) -> ty::t { alt (next(st) as char) { - case ('n') { ret ty.mk_nil(st.tcx); } - case ('b') { ret ty.mk_bool(st.tcx); } - case ('i') { ret ty.mk_int(st.tcx); } - case ('u') { ret ty.mk_uint(st.tcx); } - case ('l') { ret ty.mk_float(st.tcx); } + case ('n') { ret ty::mk_nil(st.tcx); } + case ('b') { ret ty::mk_bool(st.tcx); } + case ('i') { ret ty::mk_int(st.tcx); } + case ('u') { ret ty::mk_uint(st.tcx); } + case ('l') { ret ty::mk_float(st.tcx); } case ('M') { alt (next(st) as char) { - case ('b') { ret ty.mk_mach(st.tcx, common.ty_u8); } - case ('w') { ret ty.mk_mach(st.tcx, common.ty_u16); } - case ('l') { ret ty.mk_mach(st.tcx, common.ty_u32); } - case ('d') { ret ty.mk_mach(st.tcx, common.ty_u64); } - case ('B') { ret ty.mk_mach(st.tcx, common.ty_i8); } - case ('W') { ret ty.mk_mach(st.tcx, common.ty_i16); } - case ('L') { ret ty.mk_mach(st.tcx, common.ty_i32); } - case ('D') { ret ty.mk_mach(st.tcx, common.ty_i64); } - case ('f') { ret ty.mk_mach(st.tcx, common.ty_f32); } - case ('F') { ret ty.mk_mach(st.tcx, common.ty_f64); } + case ('b') { ret ty::mk_mach(st.tcx, common::ty_u8); } + case ('w') { ret ty::mk_mach(st.tcx, common::ty_u16); } + case ('l') { ret ty::mk_mach(st.tcx, common::ty_u32); } + case ('d') { ret ty::mk_mach(st.tcx, common::ty_u64); } + case ('B') { ret ty::mk_mach(st.tcx, common::ty_i8); } + case ('W') { ret ty::mk_mach(st.tcx, common::ty_i16); } + case ('L') { ret ty::mk_mach(st.tcx, common::ty_i32); } + case ('D') { ret ty::mk_mach(st.tcx, common::ty_i64); } + case ('f') { ret ty::mk_mach(st.tcx, common::ty_f32); } + case ('F') { ret ty::mk_mach(st.tcx, common::ty_f64); } } } - case ('c') { ret ty.mk_char(st.tcx); } - case ('s') { ret ty.mk_str(st.tcx); } + case ('c') { ret ty::mk_char(st.tcx); } + case ('s') { ret ty::mk_str(st.tcx); } case ('t') { assert (next(st) as char == '['); auto def = parse_def(st, sd); - let vec[ty.t] params = vec(); + let vec[ty::t] params = vec(); while (peek(st) as char != ']') { params += vec(parse_ty(st, sd)); } st.pos = st.pos + 1u; - ret ty.mk_tag(st.tcx, def, params); + ret ty::mk_tag(st.tcx, def, params); } - case ('p') { ret ty.mk_param(st.tcx, parse_int(st) as uint); } - case ('@') { ret ty.mk_box(st.tcx, parse_mt(st, sd)); } - case ('V') { ret ty.mk_vec(st.tcx, parse_mt(st, sd)); } - case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); } - case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); } + case ('p') { ret ty::mk_param(st.tcx, parse_int(st) as uint); } + case ('@') { ret ty::mk_box(st.tcx, parse_mt(st, sd)); } + case ('V') { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); } + case ('P') { ret ty::mk_port(st.tcx, parse_ty(st, sd)); } + case ('C') { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); } case ('T') { assert (next(st) as char == '['); - let vec[ty.mt] params = vec(); + let vec[ty::mt] params = vec(); while (peek(st) as char != ']') { params += vec(parse_mt(st, sd)); } st.pos = st.pos + 1u; - ret ty.mk_tup(st.tcx, params); + ret ty::mk_tup(st.tcx, params); } case ('R') { assert (next(st) as char == '['); - let vec[ty.field] fields = vec(); + let vec[ty::field] fields = vec(); 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))); } st.pos = st.pos + 1u; - ret ty.mk_rec(st.tcx, fields); + ret ty::mk_rec(st.tcx, fields); } case ('F') { auto func = parse_ty_fn(st, sd); - ret ty.mk_fn(st.tcx, ast.proto_fn, func._0, func._1); + ret ty::mk_fn(st.tcx, ast::proto_fn, func._0, func._1); } case ('W') { auto func = parse_ty_fn(st, sd); - ret ty.mk_fn(st.tcx, ast.proto_iter, func._0, func._1); + ret ty::mk_fn(st.tcx, ast::proto_iter, func._0, func._1); } case ('N') { auto abi; alt (next(st) as char) { - case ('r') { abi = ast.native_abi_rust; } - case ('i') { abi = ast.native_abi_rust_intrinsic; } - case ('c') { abi = ast.native_abi_cdecl; } - case ('l') { abi = ast.native_abi_llvm; } + case ('r') { abi = ast::native_abi_rust; } + case ('i') { abi = ast::native_abi_rust_intrinsic; } + case ('c') { abi = ast::native_abi_cdecl; } + case ('l') { abi = ast::native_abi_llvm; } } auto func = parse_ty_fn(st, sd); - ret ty.mk_native_fn(st.tcx,abi,func._0,func._1); + ret ty::mk_native_fn(st.tcx,abi,func._0,func._1); } case ('O') { assert (next(st) as char == '['); - let vec[ty.method] methods = vec(); + let vec[ty::method] methods = vec(); while (peek(st) as char != ']') { auto proto; alt (next(st) as char) { - case ('W') {proto = ast.proto_iter;} - case ('F') {proto = ast.proto_fn;} + case ('W') {proto = ast::proto_iter;} + case ('F') {proto = ast::proto_fn;} } 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, @@ -169,19 +169,19 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { output=func._1)); } st.pos += 1u; - ret ty.mk_obj(st.tcx, methods); + ret ty::mk_obj(st.tcx, methods); } - case ('X') { ret ty.mk_var(st.tcx, parse_int(st)); } - case ('E') { ret ty.mk_native(st.tcx); } - case ('Y') { ret ty.mk_type(st.tcx); } + case ('X') { ret ty::mk_var(st.tcx, parse_int(st)); } + case ('E') { ret ty::mk_native(st.tcx); } + case ('Y') { ret ty::mk_type(st.tcx); } case ('#') { auto pos = parse_hex(st); assert (next(st) as char == ':'); auto len = parse_hex(st); assert (next(st) as char == '#'); alt (st.tcx.rcache.find(tup(st.crate,pos,len))) { - case (some[ty.t](?tt)) { ret tt; } - case (none[ty.t]) { + case (some[ty::t](?tt)) { ret tt; } + case (none[ty::t]) { auto ps = @rec(pos=pos, len=len with *st); auto tt = parse_ty(ps, sd); st.tcx.rcache.insert(tup(st.crate,pos,len), tt); @@ -197,20 +197,20 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { } } -fn parse_mt(@pstate st, str_def sd) -> ty.mt { +fn parse_mt(@pstate st, str_def sd) -> ty::mt { auto mut; alt (peek(st) as char) { - case ('m') {next(st); mut = ast.mut;} - case ('?') {next(st); mut = ast.maybe_mut;} - case (_) {mut=ast.imm;} + case ('m') {next(st); mut = ast::mut;} + case ('?') {next(st); mut = ast::maybe_mut;} + case (_) {mut=ast::imm;} } ret rec(ty=parse_ty(st, sd), mut=mut); } -fn parse_def(@pstate st, str_def sd) -> ast.def_id { +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); @@ -245,13 +245,13 @@ fn parse_hex(@pstate st) -> uint { ret n; } -fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) { +fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t) { assert (next(st) as char == '['); - let vec[ty.arg] inputs = vec(); + let vec[ty::arg] inputs = vec(); while (peek(st) as char != ']') { - auto mode = ty.mo_val; + auto mode = ty::mo_val; if (peek(st) as char == '&') { - mode = ty.mo_alias; + mode = ty::mo_alias; st.pos = st.pos + 1u; } inputs += vec(rec(mode=mode, ty=parse_ty(st, sd))); @@ -263,9 +263,9 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) { // Rust metadata parsing -fn parse_def_id(vec[u8] buf) -> ast.def_id { +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,31 @@ 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 belt = metadata.tag_index_buckets_bucket_elt; - for each (EBML.doc elt in EBML.tagged_docs(bucket, belt)) { + 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)) { 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 (_) {} @@ -308,127 +309,127 @@ fn lookup_hash(&EBML.doc d, fn(vec[u8]) -> bool eq_fn, uint hash) // Given a path and serialized crate metadata, returns the ID of the // definition the path refers to. -fn resolve_path(vec[ast.ident] path, vec[u8] data) -> resolve_result { +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))); + 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.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)); + 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 +// 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 parse_external_def_id(int this_cnum, str s) -> ast.def_id { +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); + // metadata: + 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; + 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; } ret ty_param_count; } -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)); +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)); } ret ids; } -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]];} +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]];} 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 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)); + 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 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)); } - llvm.LLVMMoveToNextSection(si.llsi); + llvm::LLVMMoveToNextSection(si.llsi); } - ret Option.none[vec[u8]]; + ret option::none[vec[u8]]; } -fn load_crate(session.session sess, +fn load_crate(session::session sess, int cnum, - ast.ident ident, + ast::ident ident, vec[str] library_search_paths) { - auto filename = parser.default_native_name(sess, ident); + 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; } @@ -441,10 +442,10 @@ fn load_crate(session.session sess, fail; } -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) - -> @ast.view_item { +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) + -> @ast::view_item { auto cnum; if (!e.crate_cache.contains_key(ident)) { cnum = e.next_crate_num; @@ -455,23 +456,24 @@ fn fold_view_item_use(&env e, &span sp, &ast.ident ident, cnum = e.crate_cache.get(ident); } - auto viu = ast.view_item_use(ident, meta_items, id, some[int](cnum)); - ret @fold.respan[ast.view_item_](sp, viu); + auto viu = ast::view_item_use(ident, meta_items, id, some[int](cnum)); + ret @fold::respan[ast::view_item_](sp, viu); } // Reads external crates referenced by "use" directives. -fn read_crates(session.session sess, - @ast.crate crate) -> @ast.crate { +fn read_crates(session::session sess, + @ast::crate crate) -> @ast::crate { auto e = @rec( sess=sess, - [email protected]_str_hash[int](), + crate_cache=@common::new_str_hash[int](), library_search_paths=sess.get_opts().library_search_paths, mutable next_crate_num=1 ); auto f = fold_view_item_use; - auto fld = @rec(fold_view_item_use=f with *fold.new_identity_fold[env]()); - ret fold.fold_crate[env](e, fld, crate); + auto fld = @rec(fold_view_item_use=f + with *fold::new_identity_fold[env]()); + ret fold::fold_crate[env](e, fld, crate); } @@ -497,15 +499,15 @@ 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] { +fn lookup_def(session::session sess, int cnum, vec[ast::ident] path) + -> option::t[ast::def] { auto data = sess.get_external_crate(cnum).data; auto did; alt (resolve_path(path, data)) { case (rr_ok(?di)) { did = di; } case (rr_not_found(?name)) { - ret none[ast.def]; + ret none[ast::def]; } } @@ -516,31 +518,31 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path) // FIXME: It'd be great if we had u8 char literals. auto def; - if (kind_ch == ('c' as u8)) { def = ast.def_const(did); } - else if (kind_ch == ('f' as u8)) { def = ast.def_fn(did); } - else if (kind_ch == ('F' as u8)) { def = ast.def_native_fn(did); } - else if (kind_ch == ('y' as u8)) { def = ast.def_ty(did); } - else if (kind_ch == ('o' as u8)) { def = ast.def_obj(did); } - else if (kind_ch == ('T' as u8)) { def = ast.def_native_ty(did); } + if (kind_ch == ('c' as u8)) { def = ast::def_const(did); } + else if (kind_ch == ('f' as u8)) { def = ast::def_fn(did); } + else if (kind_ch == ('F' as u8)) { def = ast::def_native_fn(did); } + else if (kind_ch == ('y' as u8)) { def = ast::def_ty(did); } + else if (kind_ch == ('o' as u8)) { def = ast::def_obj(did); } + else if (kind_ch == ('T' as u8)) { def = ast::def_native_ty(did); } else if (kind_ch == ('t' as u8)) { // We treat references to tags as references to types. - def = ast.def_ty(did); - } else if (kind_ch == ('m' as u8)) { def = ast.def_mod(did); } - else if (kind_ch == ('n' as u8)) { def = ast.def_native_mod(did); } + def = ast::def_ty(did); + } else if (kind_ch == ('m' as u8)) { def = ast::def_mod(did); } + else if (kind_ch == ('n' as u8)) { def = ast::def_native_mod(did); } else if (kind_ch == ('v' as u8)) { auto tid = variant_tag_id(item); tid = tup(cnum, tid._1); - def = ast.def_variant(tid, did); + def = ast::def_variant(tid, did); } else { log_err #fmt("lookup_def(): unknown kind char: %d", kind_ch as int); fail; } - ret some[ast.def](def); + ret some[ast::def](def); } -fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def) - -> ty.ty_param_count_and_ty { +fn get_type(session::session sess, ty::ctxt tcx, ast::def_id def) + -> ty::ty_param_count_and_ty { auto external_crate_id = def._0; auto data = sess.get_external_crate(external_crate_id).data; auto item = lookup_item(def._1, data); @@ -558,29 +560,29 @@ fn get_type(session.session sess, ty.ctxt tcx, ast.def_id def) ret tup(tp_count, t); } -fn get_symbol(session.session sess, ast.def_id def) -> str { +fn get_symbol(session::session sess, ast::def_id def) -> str { auto external_crate_id = def._0; auto data = sess.get_external_crate(external_crate_id).data; auto item = lookup_item(def._1, data); ret item_symbol(item); } -fn get_tag_variants(session.session sess, ty.ctxt tcx, ast.def_id def) - -> vec[trans.variant_info] { +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(); + let vec[trans::variant_info] infos = vec(); auto variant_ids = tag_variant_ids(item, external_crate_id); - for (ast.def_id did in variant_ids) { + for (ast::def_id did in variant_ids) { auto item = find_item(did._1, items); auto ctor_ty = item_type(item, external_crate_id, tcx); - let vec[ty.t] arg_tys = vec(); - alt (ty.struct(tcx, ctor_ty)) { - case (ty.ty_fn(_, ?args, _)) { - for (ty.arg a in args) { + let vec[ty::t] arg_tys = vec(); + alt (ty::struct(tcx, ctor_ty)) { + case (ty::ty_fn(_, ?args, _)) { + for (ty::arg a in args) { arg_tys += vec(a.ty); } } @@ -594,46 +596,46 @@ 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)) { - auto et = metadata.tag_index_buckets_bucket_elt; - for each (EBML.doc elt in EBML.tagged_docs(bucket, et)) { +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)) { 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";} auto item = find_item(id._1, items); ret item_kind_to_str(item_kind(item)); |