Remove ebmlivec module
This commit is contained in:
parent
674fb0911c
commit
0fed53921f
3 changed files with 221 additions and 222 deletions
|
@ -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);
|
||||
|
|
|
@ -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.
|
||||
|
||||
|
|
|
@ -92,7 +92,6 @@ mod smallintmap;
|
|||
mod ptr;
|
||||
mod test;
|
||||
mod unsafe;
|
||||
mod ebmlivec = "ebml.rs";
|
||||
mod term;
|
||||
|
||||
// Local Variables:
|
||||
|
|
Loading…
Reference in a new issue