squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Remove ebmlivec module

Browse source
This commit is contained in:
Brian Anderson 2011-08-11 22:58:14 -07:00
parent 674fb0911c
commit 0fed53921f
3 changed files with 221 additions and 222 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
// Decoding metadata from a single crate's metadata
import std::ebmlivec;
import std::ebml;
import std::ivec;
import std::option;
import std::str;
@ -35,65 +35,65 @@ export external_resolver;
// build.
type external_resolver = fn(&ast::def_id) -> ast::def_id ;
fn lookup_hash(d: &ebmlivec::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
[ebmlivec::doc] {
let index = ebmlivec::get_doc(d, tag_index);
let table = ebmlivec::get_doc(index, tag_index_table);
fn lookup_hash(d: &ebml::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
[ebml::doc] {
let index = ebml::get_doc(d, tag_index);
let table = ebml::get_doc(index, tag_index_table);
let hash_pos = table.start + hash % 256u * 4u;
let pos = ebmlivec::be_uint_from_bytes(d.data, hash_pos, 4u);
let bucket = ebmlivec::doc_at(d.data, pos);
let pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u);
let bucket = ebml::doc_at(d.data, pos);
// Awkward logic because we can't ret from foreach yet
let result: [ebmlivec::doc] = ~[];
let result: [ebml::doc] = ~[];
let belt = tag_index_buckets_bucket_elt;
for each elt: ebmlivec::doc in ebmlivec::tagged_docs(bucket, belt) {
let pos = ebmlivec::be_uint_from_bytes(elt.data, elt.start, 4u);
for each elt: ebml::doc in ebml::tagged_docs(bucket, belt) {
let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
if eq_fn(ivec::slice[u8](*elt.data, elt.start + 4u, elt.end)) {
result += ~[ebmlivec::doc_at(d.data, pos)];
result += ~[ebml::doc_at(d.data, pos)];
}
}
ret result;
}
fn maybe_find_item(item_id: int, items: &ebmlivec::doc) ->
option::t[ebmlivec::doc] {
fn maybe_find_item(item_id: int, items: &ebml::doc) ->
option::t[ebml::doc] {
fn eq_item(bytes: &[u8], item_id: int) -> bool {
ret ebmlivec::be_uint_from_bytes(@bytes, 0u, 4u) as int == item_id;
ret ebml::be_uint_from_bytes(@bytes, 0u, 4u) as int == item_id;
}
let eqer = bind eq_item(_, item_id);
let found = lookup_hash(items, eqer, hash_node_id(item_id));
if ivec::len(found) == 0u {
ret option::none[ebmlivec::doc];
} else { ret option::some[ebmlivec::doc](found.(0)); }
ret option::none[ebml::doc];
} else { ret option::some[ebml::doc](found.(0)); }
}
fn find_item(item_id: int, items: &ebmlivec::doc) -> ebmlivec::doc {
fn find_item(item_id: int, items: &ebml::doc) -> ebml::doc {
ret option::get(maybe_find_item(item_id, items));
}
// Looks up an item in the given metadata and returns an ebmlivec doc pointing
// Looks up an item in the given metadata and returns an ebml doc pointing
// to the item data.
fn lookup_item(item_id: int, data: &@[u8]) -> ebmlivec::doc {
let items = ebmlivec::get_doc(ebmlivec::new_doc(data), tag_items);
fn lookup_item(item_id: int, data: &@[u8]) -> ebml::doc {
let items = ebml::get_doc(ebml::new_doc(data), tag_items);
ret find_item(item_id, items);
}
fn item_family(item: &ebmlivec::doc) -> u8 {
let fam = ebmlivec::get_doc(item, tag_items_data_item_family);
ret ebmlivec::doc_as_uint(fam) as u8;
fn item_family(item: &ebml::doc) -> u8 {
let fam = ebml::get_doc(item, tag_items_data_item_family);
ret ebml::doc_as_uint(fam) as u8;
}
fn item_symbol(item: &ebmlivec::doc) -> str {
let sym = ebmlivec::get_doc(item, tag_items_data_item_symbol);
ret str::unsafe_from_bytes(ebmlivec::doc_data(sym));
fn item_symbol(item: &ebml::doc) -> str {
let sym = ebml::get_doc(item, tag_items_data_item_symbol);
ret str::unsafe_from_bytes(ebml::doc_data(sym));
}
fn variant_tag_id(d: &ebmlivec::doc) -> ast::def_id {
let tagdoc = ebmlivec::get_doc(d, tag_items_data_item_tag_id);
ret parse_def_id(ebmlivec::doc_data(tagdoc));
fn variant_tag_id(d: &ebml::doc) -> ast::def_id {
let tagdoc = ebml::get_doc(d, tag_items_data_item_tag_id);
ret parse_def_id(ebml::doc_data(tagdoc));
}
fn item_type(item: &ebmlivec::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
fn item_type(item: &ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
extres: &external_resolver) -> ty::t {
fn parse_external_def_id(this_cnum: ast::crate_num,
extres: &external_resolver, s: str) ->
@ -108,18 +108,18 @@ fn item_type(item: &ebmlivec::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
ret {crate: this_cnum, node: external_def_id.node};
} else { ret extres(external_def_id); }
}
let tp = ebmlivec::get_doc(item, tag_items_data_item_type);
let tp = ebml::get_doc(item, tag_items_data_item_type);
let def_parser = bind parse_external_def_id(this_cnum, extres, _);
ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
def_parser, tcx);
}
fn item_ty_param_kinds(item: &ebmlivec::doc) -> [ast::kind] {
fn item_ty_param_kinds(item: &ebml::doc) -> [ast::kind] {
let ks: [ast::kind] = ~[];
let tp = tag_items_data_item_ty_param_kinds;
for each p: ebmlivec::doc in ebmlivec::tagged_docs(item, tp) {
let dat : [u8] = ebmlivec::doc_data(p);
let vi = ebmlivec::vint_at(dat, 0u);
for each p: ebml::doc in ebml::tagged_docs(item, tp) {
let dat : [u8] = ebml::doc_data(p);
let vi = ebml::vint_at(dat, 0u);
let i = 0u;
while i < vi.val {
let k = alt dat.(vi.next + i) as char {
@ -134,12 +134,12 @@ fn item_ty_param_kinds(item: &ebmlivec::doc) -> [ast::kind] {
ret ks;
}
fn tag_variant_ids(item: &ebmlivec::doc, this_cnum: ast::crate_num) ->
fn tag_variant_ids(item: &ebml::doc, this_cnum: ast::crate_num) ->
[ast::def_id] {
let ids: [ast::def_id] = ~[];
let v = tag_items_data_item_variant;
for each p: ebmlivec::doc in ebmlivec::tagged_docs(item, v) {
let ext = parse_def_id(ebmlivec::doc_data(p));
for each p: ebml::doc in ebml::tagged_docs(item, v) {
let ext = parse_def_id(ebml::doc_data(p));
ids += ~[{crate: this_cnum, node: ext.node}];
}
ret ids;
@ -152,13 +152,13 @@ fn resolve_path(path: &[ast::ident], data: @[u8]) -> [ast::def_id] {
ret str::eq(str::unsafe_from_bytes(data), s);
}
let s = str::connect(path, "::");
let md = ebmlivec::new_doc(data);
let paths = ebmlivec::get_doc(md, tag_paths);
let md = ebml::new_doc(data);
let paths = ebml::get_doc(md, tag_paths);
let eqer = bind eq_item(_, s);
let result: [ast::def_id] = ~[];
for doc: ebmlivec::doc in lookup_hash(paths, eqer, hash_path(s)) {
let did_doc = ebmlivec::get_doc(doc, tag_def_id);
result += ~[parse_def_id(ebmlivec::doc_data(did_doc))];
for doc: ebml::doc in lookup_hash(paths, eqer, hash_path(s)) {
let did_doc = ebml::get_doc(doc, tag_def_id);
result += ~[parse_def_id(ebml::doc_data(did_doc))];
}
ret result;
}
@ -229,7 +229,7 @@ fn get_tag_variants(data: &@[u8], def: ast::def_id, tcx: &ty::ctxt,
let external_crate_id = def.crate;
let data =
cstore::get_crate_data(tcx.sess.get_cstore(), external_crate_id).data;
let items = ebmlivec::get_doc(ebmlivec::new_doc(data), tag_items);
let items = ebml::get_doc(ebml::new_doc(data), tag_items);
let item = find_item(def.node, items);
let infos: [ty::variant_info] = ~[];
let variant_ids = tag_variant_ids(item, external_crate_id);
@ -266,15 +266,15 @@ fn family_has_type_params(fam_ch: u8) -> bool {
};
}
fn read_path(d: &ebmlivec::doc) -> {path: str, pos: uint} {
let desc = ebmlivec::doc_data(d);
let pos = ebmlivec::be_uint_from_bytes(@desc, 0u, 4u);
fn read_path(d: &ebml::doc) -> {path: str, pos: uint} {
let desc = ebml::doc_data(d);
let pos = ebml::be_uint_from_bytes(@desc, 0u, 4u);
let pathbytes = ivec::slice[u8](desc, 4u, ivec::len[u8](desc));
let path = str::unsafe_from_bytes(pathbytes);
ret {path: path, pos: pos};
}
fn describe_def(items: &ebmlivec::doc, id: ast::def_id) -> str {
fn describe_def(items: &ebml::doc, id: ast::def_id) -> str {
if id.crate != ast::local_crate { ret "external"; }
ret item_family_to_str(item_family(find_item(id.node, items)));
}
@ -294,40 +294,40 @@ fn item_family_to_str(fam: u8) -> str {
}
}
fn get_meta_items(md: &ebmlivec::doc) -> [@ast::meta_item] {
fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
let items: [@ast::meta_item] = ~[];
for each meta_item_doc: ebmlivec::doc in
ebmlivec::tagged_docs(md, tag_meta_item_word) {
let nd = ebmlivec::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::unsafe_from_bytes(ebmlivec::doc_data(nd));
for each meta_item_doc: ebml::doc in
ebml::tagged_docs(md, tag_meta_item_word) {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::unsafe_from_bytes(ebml::doc_data(nd));
items += ~[attr::mk_word_item(n)];
}
for each meta_item_doc: ebmlivec::doc in
ebmlivec::tagged_docs(md, tag_meta_item_name_value) {
let nd = ebmlivec::get_doc(meta_item_doc, tag_meta_item_name);
let vd = ebmlivec::get_doc(meta_item_doc, tag_meta_item_value);
let n = str::unsafe_from_bytes(ebmlivec::doc_data(nd));
let v = str::unsafe_from_bytes(ebmlivec::doc_data(vd));
for each meta_item_doc: ebml::doc in
ebml::tagged_docs(md, tag_meta_item_name_value) {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
let n = str::unsafe_from_bytes(ebml::doc_data(nd));
let v = str::unsafe_from_bytes(ebml::doc_data(vd));
// FIXME (#611): Should be able to decode meta_name_value variants,
// but currently they can't be encoded
items += ~[attr::mk_name_value_item_str(n, v)];
}
for each meta_item_doc: ebmlivec::doc in
ebmlivec::tagged_docs(md, tag_meta_item_list) {
let nd = ebmlivec::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::unsafe_from_bytes(ebmlivec::doc_data(nd));
for each meta_item_doc: ebml::doc in
ebml::tagged_docs(md, tag_meta_item_list) {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
let n = str::unsafe_from_bytes(ebml::doc_data(nd));
let subitems = get_meta_items(meta_item_doc);
items += ~[attr::mk_list_item(n, subitems)];
}
ret items;
}
fn get_attributes(md: &ebmlivec::doc) -> [ast::attribute] {
fn get_attributes(md: &ebml::doc) -> [ast::attribute] {
let attrs: [ast::attribute] = ~[];
alt ebmlivec::maybe_get_doc(md, tag_attributes) {
alt ebml::maybe_get_doc(md, tag_attributes) {
option::some(attrs_d) {
for each attr_doc: ebmlivec::doc in
ebmlivec::tagged_docs(attrs_d, tag_attribute) {
for each attr_doc: ebml::doc in
ebml::tagged_docs(attrs_d, tag_attribute) {
let meta_items = get_meta_items(attr_doc);
// Currently it's only possible to have a single meta item on
// an attribute
@ -343,13 +343,13 @@ fn get_attributes(md: &ebmlivec::doc) -> [ast::attribute] {
ret attrs;
}
fn list_meta_items(meta_items: &ebmlivec::doc, out: io::writer) {
fn list_meta_items(meta_items: &ebml::doc, out: io::writer) {
for mi: @ast::meta_item in get_meta_items(meta_items) {
out.write_str(#fmt("%s\n", pprust::meta_item_to_str(*mi)));
}
}
fn list_crate_attributes(md: &ebmlivec::doc, out: io::writer) {
fn list_crate_attributes(md: &ebml::doc, out: io::writer) {
out.write_str("=Crate Attributes=\n");
for attr: ast::attribute in get_attributes(md) {
@ -360,19 +360,19 @@ fn list_crate_attributes(md: &ebmlivec::doc, out: io::writer) {
}
fn get_crate_attributes(data: @[u8]) -> [ast::attribute] {
ret get_attributes(ebmlivec::new_doc(data));
ret get_attributes(ebml::new_doc(data));
}
type crate_dep = {cnum: ast::crate_num, ident: str};
fn get_crate_deps(data: @[u8]) -> [crate_dep] {
let deps: [crate_dep] = ~[];
let cratedoc = ebmlivec::new_doc(data);
let depsdoc = ebmlivec::get_doc(cratedoc, tag_crate_deps);
let cratedoc = ebml::new_doc(data);
let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
let crate_num = 1;
for each depdoc: ebmlivec::doc in
ebmlivec::tagged_docs(depsdoc, tag_crate_dep) {
let depname = str::unsafe_from_bytes(ebmlivec::doc_data(depdoc));
for each depdoc: ebml::doc in
ebml::tagged_docs(depsdoc, tag_crate_dep) {
let depname = str::unsafe_from_bytes(ebml::doc_data(depdoc));
deps += ~[{cnum: crate_num, ident: depname}];
crate_num += 1;
}
@ -389,20 +389,20 @@ fn list_crate_deps(data: @[u8], out: io::writer) {
out.write_str("\n");
}
fn list_crate_items(bytes: &@[u8], md: &ebmlivec::doc, out: io::writer) {
fn list_crate_items(bytes: &@[u8], md: &ebml::doc, out: io::writer) {
out.write_str("=Items=\n");
let paths = ebmlivec::get_doc(md, tag_paths);
let items = ebmlivec::get_doc(md, tag_items);
let index = ebmlivec::get_doc(paths, tag_index);
let bs = ebmlivec::get_doc(index, tag_index_buckets);
for each bucket: ebmlivec::doc in
ebmlivec::tagged_docs(bs, tag_index_buckets_bucket) {
let paths = ebml::get_doc(md, tag_paths);
let items = ebml::get_doc(md, tag_items);
let index = ebml::get_doc(paths, tag_index);
let bs = ebml::get_doc(index, tag_index_buckets);
for each bucket: ebml::doc in
ebml::tagged_docs(bs, tag_index_buckets_bucket) {
let et = tag_index_buckets_bucket_elt;
for each elt: ebmlivec::doc in ebmlivec::tagged_docs(bucket, et) {
for each elt: ebml::doc in ebml::tagged_docs(bucket, et) {
let data = read_path(elt);
let def = ebmlivec::doc_at(bytes, data.pos);
let did_doc = ebmlivec::get_doc(def, tag_def_id);
let did = parse_def_id(ebmlivec::doc_data(did_doc));
let def = ebml::doc_at(bytes, data.pos);
let did_doc = ebml::get_doc(def, tag_def_id);
let did = parse_def_id(ebml::doc_data(did_doc));
out.write_str(#fmt("%s (%s)\n", data.path,
describe_def(items, did)));
}
@ -411,7 +411,7 @@ fn list_crate_items(bytes: &@[u8], md: &ebmlivec::doc, out: io::writer) {
}
fn list_crate_metadata(bytes: &@[u8], out: io::writer) {
let md = ebmlivec::new_doc(bytes);
let md = ebml::new_doc(bytes);
list_crate_attributes(md, out);
list_crate_deps(bytes, out);
list_crate_items(bytes, md, out);

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

@ -7,7 +7,7 @@ import std::io;
import std::option;
import std::option::some;
import std::option::none;
import std::ebmlivec;
import std::ebml;
import std::map;
import syntax::ast::*;
import common::*;
@ -24,32 +24,32 @@ type abbrev_map = map::hashmap[ty::t, tyencode::ty_abbrev];
type encode_ctxt = {ccx: @crate_ctxt, type_abbrevs: abbrev_map};
// Path table encoding
fn encode_name(ebml_w: &ebmlivec::writer, name: &str) {
ebmlivec::start_tag(ebml_w, tag_paths_data_name);
fn encode_name(ebml_w: &ebml::writer, name: &str) {
ebml::start_tag(ebml_w, tag_paths_data_name);
ebml_w.writer.write(str::bytes(name));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_def_id(ebml_w: &ebmlivec::writer, id: &def_id) {
ebmlivec::start_tag(ebml_w, tag_def_id);
fn encode_def_id(ebml_w: &ebml::writer, id: &def_id) {
ebml::start_tag(ebml_w, tag_def_id);
ebml_w.writer.write(str::bytes(def_to_str(id)));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
type entry[T] = {val: T, pos: uint};
fn encode_tag_variant_paths(ebml_w: &ebmlivec::writer, variants: &[variant],
fn encode_tag_variant_paths(ebml_w: &ebml::writer, variants: &[variant],
path: &[str], index: &mutable [entry[str]]) {
for variant: variant in variants {
add_to_index(ebml_w, path, index, variant.node.name);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, variant.node.name);
encode_def_id(ebml_w, local_def(variant.node.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
fn add_to_index(ebml_w: &ebmlivec::writer, path: &[str],
fn add_to_index(ebml_w: &ebml::writer, path: &[str],
index: &mutable [entry[str]], name: &str) {
let full_path = path + ~[name];
index +=
@ -57,126 +57,126 @@ fn add_to_index(ebml_w: &ebmlivec::writer, path: &[str],
pos: ebml_w.writer.tell()}];
}
fn encode_native_module_item_paths(ebml_w: &ebmlivec::writer,
fn encode_native_module_item_paths(ebml_w: &ebml::writer,
nmod: &native_mod, path: &[str],
index: &mutable [entry[str]]) {
for nitem: @native_item in nmod.items {
add_to_index(ebml_w, path, index, nitem.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, nitem.ident);
encode_def_id(ebml_w, local_def(nitem.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
fn encode_module_item_paths(ebml_w: &ebmlivec::writer, module: &_mod,
fn encode_module_item_paths(ebml_w: &ebml::writer, module: &_mod,
path: &[str], index: &mutable [entry[str]]) {
for it: @item in module.items {
if !is_exported(it.ident, module) { cont; }
alt it.node {
item_const(_, _) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_fn(_, tps) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_mod(_mod) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_mod);
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
encode_module_item_paths(ebml_w, _mod, path + ~[it.ident], index);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_native_mod(nmod) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_mod);
ebml::start_tag(ebml_w, tag_paths_data_mod);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
encode_native_module_item_paths(ebml_w, nmod, path + ~[it.ident],
index);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_ty(_, tps) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_res(_, _, tps, ctor_id) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(ctor_id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_tag(variants, tps) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
encode_tag_variant_paths(ebml_w, variants, path, index);
}
item_obj(_, tps, ctor_id) {
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(ctor_id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
add_to_index(ebml_w, path, index, it.ident);
ebmlivec::start_tag(ebml_w, tag_paths_data_item);
ebml::start_tag(ebml_w, tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
}
}
fn encode_item_paths(ebml_w: &ebmlivec::writer, crate: &@crate) ->
fn encode_item_paths(ebml_w: &ebml::writer, crate: &@crate) ->
[entry[str]] {
let index: [entry[str]] = ~[];
let path: [str] = ~[];
ebmlivec::start_tag(ebml_w, tag_paths);
ebml::start_tag(ebml_w, tag_paths);
encode_module_item_paths(ebml_w, crate.node.module, path, index);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
ret index;
}
// Item info table encoding
fn encode_family(ebml_w: &ebmlivec::writer, c: u8) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_family);
fn encode_family(ebml_w: &ebml::writer, c: u8) {
ebml::start_tag(ebml_w, tag_items_data_item_family);
ebml_w.writer.write(~[c]);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_inlineness(ebml_w: &ebmlivec::writer, c: u8) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_inlineness);
fn encode_inlineness(ebml_w: &ebml::writer, c: u8) {
ebml::start_tag(ebml_w, tag_items_data_item_inlineness);
ebml_w.writer.write(~[c]);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn def_to_str(did: &def_id) -> str { ret #fmt("%d:%d", did.crate, did.node); }
fn encode_type_param_kinds(ebml_w: &ebmlivec::writer, tps: &[ty_param]) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_ty_param_kinds);
ebmlivec::write_vint(ebml_w.writer, ivec::len[ty_param](tps));
fn encode_type_param_kinds(ebml_w: &ebml::writer, tps: &[ty_param]) {
ebml::start_tag(ebml_w, tag_items_data_item_ty_param_kinds);
ebml::write_vint(ebml_w.writer, ivec::len[ty_param](tps));
for tp: ty_param in tps {
let c = alt tp.kind {
kind_unique. { 'u' }
@ -185,52 +185,52 @@ fn encode_type_param_kinds(ebml_w: &ebmlivec::writer, tps: &[ty_param]) {
};
ebml_w.writer.write(~[c as u8]);
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_variant_id(ebml_w: &ebmlivec::writer, vid: &def_id) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_variant);
fn encode_variant_id(ebml_w: &ebml::writer, vid: &def_id) {
ebml::start_tag(ebml_w, tag_items_data_item_variant);
ebml_w.writer.write(str::bytes(def_to_str(vid)));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_type(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer, typ: &ty::t) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_type);
fn encode_type(ecx: &@encode_ctxt, ebml_w: &ebml::writer, typ: &ty::t) {
ebml::start_tag(ebml_w, tag_items_data_item_type);
let f = def_to_str;
let ty_str_ctxt =
@{ds: f,
tcx: ecx.ccx.tcx,
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
tyencode::enc_ty(io::new_writer_(ebml_w.writer), ty_str_ctxt, typ);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_symbol(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer, id: node_id) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_symbol);
fn encode_symbol(ecx: &@encode_ctxt, ebml_w: &ebml::writer, id: node_id) {
ebml::start_tag(ebml_w, tag_items_data_item_symbol);
ebml_w.writer.write(str::bytes(ecx.ccx.item_symbols.get(id)));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_discriminant(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer,
fn encode_discriminant(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
id: node_id) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_symbol);
ebml::start_tag(ebml_w, tag_items_data_item_symbol);
ebml_w.writer.write(str::bytes(ecx.ccx.discrim_symbols.get(id)));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_tag_id(ebml_w: &ebmlivec::writer, id: &def_id) {
ebmlivec::start_tag(ebml_w, tag_items_data_item_tag_id);
fn encode_tag_id(ebml_w: &ebml::writer, id: &def_id) {
ebml::start_tag(ebml_w, tag_items_data_item_tag_id);
ebml_w.writer.write(str::bytes(def_to_str(id)));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer,
fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
id: node_id, variants: &[variant],
index: &mutable [entry[int]],
ty_params: &[ty_param]) {
for variant: variant in variants {
index += ~[{val: variant.node.id, pos: ebml_w.writer.tell()}];
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(variant.node.id));
encode_family(ebml_w, 'v' as u8);
encode_tag_id(ebml_w, local_def(id));
@ -241,23 +241,23 @@ fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer,
}
encode_discriminant(ecx, ebml_w, variant.node.id);
encode_type_param_kinds(ebml_w, ty_params);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebmlivec::writer,
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebml::writer,
item: @item, index: &mutable [entry[int]]) {
alt item.node {
item_const(_, _) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'c' as u8);
encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
encode_symbol(ecx, ebml_w, item.id);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_fn(fd, tps) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w,
alt fd.decl.purity { pure_fn. { 'p' } impure_fn. { 'f' } }
@ -270,30 +270,30 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebmlivec::writer,
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
encode_symbol(ecx, ebml_w, item.id);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_mod(_) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'm' as u8);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_native_mod(_) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'n' as u8);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_ty(_, tps) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'y' as u8);
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_tag(variants, tps) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 't' as u8);
encode_type_param_kinds(ebml_w, tps);
@ -301,54 +301,54 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebmlivec::writer,
for v: variant in variants {
encode_variant_id(ebml_w, local_def(v.node.id));
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
encode_tag_variant_info(ecx, ebml_w, item.id, variants, index, tps);
}
item_res(_, _, tps, ctor_id) {
let fn_ty = node_id_to_monotype(ecx.ccx.tcx, ctor_id);
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(ctor_id));
encode_family(ebml_w, 'y' as u8);
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, ty::ty_fn_ret(ecx.ccx.tcx, fn_ty));
encode_symbol(ecx, ebml_w, item.id);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
index += ~[{val: ctor_id, pos: ebml_w.writer.tell()}];
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(ctor_id));
encode_family(ebml_w, 'f' as u8);
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, fn_ty);
encode_symbol(ecx, ebml_w, ctor_id);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
item_obj(_, tps, ctor_id) {
let fn_ty = node_id_to_monotype(ecx.ccx.tcx, ctor_id);
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'y' as u8);
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, ty::ty_fn_ret(ecx.ccx.tcx, fn_ty));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
index += ~[{val: ctor_id, pos: ebml_w.writer.tell()}];
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
encode_def_id(ebml_w, local_def(ctor_id));
encode_family(ebml_w, 'f' as u8);
encode_type_param_kinds(ebml_w, tps);
encode_type(ecx, ebml_w, fn_ty);
encode_symbol(ecx, ebml_w, ctor_id);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
}
fn encode_info_for_native_item(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer,
fn encode_info_for_native_item(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
nitem: &@native_item) {
ebmlivec::start_tag(ebml_w, tag_items_data_item);
ebml::start_tag(ebml_w, tag_items_data_item);
alt nitem.node {
native_item_ty. {
encode_def_id(ebml_w, local_def(nitem.id));
@ -364,13 +364,13 @@ fn encode_info_for_native_item(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer,
encode_symbol(ecx, ebml_w, nitem.id);
}
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer) ->
fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebml::writer) ->
[entry[int]] {
let index: [entry[int]] = ~[];
ebmlivec::start_tag(ebml_w, tag_items_data);
ebml::start_tag(ebml_w, tag_items_data);
for each kvp: @{key: node_id, val: middle::ast_map::ast_node} in
ecx.ccx.ast_map.items() {
alt kvp.val {
@ -385,7 +385,7 @@ fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebmlivec::writer) ->
_ { }
}
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
ret index;
}
@ -408,28 +408,28 @@ fn create_index[T](index: &[entry[T]], hash_fn: fn(&T) -> uint ) ->
ret buckets_frozen;
}
fn encode_index[T](ebml_w: &ebmlivec::writer, buckets: &[@[entry[T]]],
fn encode_index[T](ebml_w: &ebml::writer, buckets: &[@[entry[T]]],
write_fn: fn(&io::writer, &T) ) {
let writer = io::new_writer_(ebml_w.writer);
ebmlivec::start_tag(ebml_w, tag_index);
ebml::start_tag(ebml_w, tag_index);
let bucket_locs: [uint] = ~[];
ebmlivec::start_tag(ebml_w, tag_index_buckets);
ebml::start_tag(ebml_w, tag_index_buckets);
for bucket: @[entry[T]] in buckets {
bucket_locs += ~[ebml_w.writer.tell()];
ebmlivec::start_tag(ebml_w, tag_index_buckets_bucket);
ebml::start_tag(ebml_w, tag_index_buckets_bucket);
for elt: entry[T] in *bucket {
ebmlivec::start_tag(ebml_w, tag_index_buckets_bucket_elt);
ebml::start_tag(ebml_w, tag_index_buckets_bucket_elt);
writer.write_be_uint(elt.pos, 4u);
write_fn(writer, elt.val);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
ebmlivec::end_tag(ebml_w);
ebmlivec::start_tag(ebml_w, tag_index_table);
ebml::end_tag(ebml_w);
ebml::start_tag(ebml_w, tag_index_table);
for pos: uint in bucket_locs { writer.write_be_uint(pos, 4u); }
ebmlivec::end_tag(ebml_w);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn write_str(writer: &io::writer, s: &str) { writer.write_str(s); }
@ -438,51 +438,51 @@ fn write_int(writer: &io::writer, n: &int) {
writer.write_be_uint(n as uint, 4u);
}
fn encode_meta_item(ebml_w: &ebmlivec::writer, mi: &meta_item) {
fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
alt mi.node {
meta_word(name) {
ebmlivec::start_tag(ebml_w, tag_meta_item_word);
ebmlivec::start_tag(ebml_w, tag_meta_item_name);
ebml::start_tag(ebml_w, tag_meta_item_word);
ebml::start_tag(ebml_w, tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebmlivec::end_tag(ebml_w);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
meta_name_value(name, value) {
alt value.node {
lit_str(value, _) {
ebmlivec::start_tag(ebml_w, tag_meta_item_name_value);
ebmlivec::start_tag(ebml_w, tag_meta_item_name);
ebml::start_tag(ebml_w, tag_meta_item_name_value);
ebml::start_tag(ebml_w, tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebmlivec::end_tag(ebml_w);
ebmlivec::start_tag(ebml_w, tag_meta_item_value);
ebml::end_tag(ebml_w);
ebml::start_tag(ebml_w, tag_meta_item_value);
ebml_w.writer.write(str::bytes(value));
ebmlivec::end_tag(ebml_w);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
_ {/* FIXME (#611) */ }
}
}
meta_list(name, items) {
ebmlivec::start_tag(ebml_w, tag_meta_item_list);
ebmlivec::start_tag(ebml_w, tag_meta_item_name);
ebml::start_tag(ebml_w, tag_meta_item_list);
ebml::start_tag(ebml_w, tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
for inner_item: @meta_item in items {
encode_meta_item(ebml_w, *inner_item);
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
}
}
fn encode_attributes(ebml_w: &ebmlivec::writer, attrs: &[attribute]) {
ebmlivec::start_tag(ebml_w, tag_attributes);
fn encode_attributes(ebml_w: &ebml::writer, attrs: &[attribute]) {
ebml::start_tag(ebml_w, tag_attributes);
for attr: attribute in attrs {
ebmlivec::start_tag(ebml_w, tag_attribute);
ebml::start_tag(ebml_w, tag_attribute);
encode_meta_item(ebml_w, attr.node.value);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
// So there's a special crate attribute called 'link' which defines the
@ -536,7 +536,7 @@ fn synthesize_crate_attrs(ecx: &@encode_ctxt, crate: &@crate) -> [attribute] {
ret attrs;
}
fn encode_crate_deps(ebml_w: &ebmlivec::writer, cstore: &cstore::cstore) {
fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
fn get_ordered_names(cstore: &cstore::cstore) -> [str] {
type hashkv = @{key: crate_num, val: cstore::crate_metadata};
@ -572,13 +572,13 @@ fn encode_crate_deps(ebml_w: &ebmlivec::writer, cstore: &cstore::cstore) {
// that they are numbered 1 to n.
// FIXME: This is not nearly enough to support correct versioning
// but is enough to get transitive crate dependencies working.
ebmlivec::start_tag(ebml_w, tag_crate_deps);
ebml::start_tag(ebml_w, tag_crate_deps);
for cname: str in get_ordered_names(cstore) {
ebmlivec::start_tag(ebml_w, tag_crate_dep);
ebml::start_tag(ebml_w, tag_crate_dep);
ebml_w.writer.write(str::bytes(cname));
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
}
fn encode_metadata(cx: &@crate_ctxt, crate: &@crate) -> str {
@ -588,7 +588,7 @@ fn encode_metadata(cx: &@crate_ctxt, crate: &@crate) -> str {
let string_w = io::string_writer();
let buf_w = string_w.get_writer().get_buf_writer();
let ebml_w = ebmlivec::create_writer(buf_w);
let ebml_w = ebml::create_writer(buf_w);
let crate_attrs = synthesize_crate_attrs(ecx, crate);
encode_attributes(ebml_w, crate_attrs);
@ -597,18 +597,18 @@ fn encode_metadata(cx: &@crate_ctxt, crate: &@crate) -> str {
// Encode and index the paths.
ebmlivec::start_tag(ebml_w, tag_paths);
ebml::start_tag(ebml_w, tag_paths);
let paths_index = encode_item_paths(ebml_w, crate);
let paths_buckets = create_index(paths_index, hash_path);
encode_index(ebml_w, paths_buckets, write_str);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
// Encode and index the items.
ebmlivec::start_tag(ebml_w, tag_items);
ebml::start_tag(ebml_w, tag_items);
let items_index = encode_info_for_items(ecx, ebml_w);
let items_buckets = create_index(items_index, hash_node_id);
encode_index(ebml_w, items_buckets, write_int);
ebmlivec::end_tag(ebml_w);
ebml::end_tag(ebml_w);
// Pad this, since something (LLVM, presumably) is cutting off the
// remaining % 4 bytes.

1
src/lib/std.rc
View file

@ -92,7 +92,6 @@ mod smallintmap;
mod ptr;
mod test;
mod unsafe;
mod ebmlivec = "ebml.rs";
mod term;
// Local Variables: