mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2db4259b35
rust/src/rustc/metadata/encoder.rs
Niko Matsakis 825fd1808e lots of work to make iface/impls parameterized by regions 
- paths can now take region parameters, replacing the dirty hack
  I was doing before of abusing vstores.  vstores are now a bit
  of a hack though.

- fix various small bugs:
  - we never checked that iface types were compatible when casting
    to an iface with `as`
  - we allowed nonsense like int<int>
  - and more! (actually that may be it)
2012-04-25 19:26:56 -07:00

1044 lines
37 KiB
Rust
Raw Blame History

// Metadata encoding
import std::{ebml, map, list};
import std::map::hashmap;
import io::writer_util;
import ebml::writer;
import syntax::ast::*;
import syntax::print::pprust;
import syntax::{ast_util, visit};
import syntax::ast_util::local_def;
import common::*;
import middle::trans::common::crate_ctxt;
import middle::ty;
import middle::ty::node_id_to_type;
import middle::ast_map;
import syntax::attr;
import driver::session::session;
import std::serialization::serializer;
import std::ebml::serializer;
export encode_metadata;
export encoded_ty;
export reachable;
// used by astencode:
export def_to_str;
export encode_ctxt;
export write_type;
export encode_def_id;
type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>;
type encode_ctxt = {ccx: @crate_ctxt,
type_abbrevs: abbrev_map};
fn reachable(ecx: @encode_ctxt, id: node_id) -> bool {
ecx.ccx.reachable.contains_key(id)
}
// Path table encoding
fn encode_name(ebml_w: ebml::writer, name: str) {
ebml_w.wr_tagged_str(tag_paths_data_name, name);
}
fn encode_def_id(ebml_w: ebml::writer, id: def_id) {
ebml_w.wr_tagged_str(tag_def_id, def_to_str(id));
}
fn encode_region_param(ebml_w: ebml::writer, rp: region_param) {
ebml_w.wr_tag(tag_region_param) {||
serialize_region_param(ebml_w, rp)
}
}
fn encode_named_def_id(ebml_w: ebml::writer, name: str, id: def_id) {
ebml_w.wr_tag(tag_paths_data_item) {||
encode_name(ebml_w, name);
encode_def_id(ebml_w, id);
}
}
fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {
ebml_w.wr_tag(tag_class_mut) {||
ebml_w.writer.write([alt mt { class_immutable { 'i' }
class_mutable { 'm' } } as u8]/&);
}
}
type entry<T> = {val: T, pos: uint};
fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: [variant],
path: [str], &index: [entry<str>]) {
for variants.each {|variant|
add_to_index(ebml_w, path, index, variant.node.name);
ebml_w.wr_tag(tag_paths_data_item) {||
encode_name(ebml_w, variant.node.name);
encode_def_id(ebml_w, local_def(variant.node.id));
}
}
}
fn add_to_index(ebml_w: ebml::writer, path: [str], &index: [entry<str>],
name: str) {
let full_path = path + [name];
index +=
[{val: str::connect(full_path, "::"), pos: ebml_w.writer.tell()}];
}
fn encode_native_module_item_paths(ebml_w: ebml::writer, nmod: native_mod,
path: [str], &index: [entry<str>]) {
for nmod.items.each {|nitem|
add_to_index(ebml_w, path, index, nitem.ident);
encode_named_def_id(ebml_w, nitem.ident, local_def(nitem.id));
}
}
fn encode_class_item_paths(ebml_w: ebml::writer,
items: [@class_member], path: [str], &index: [entry<str>]) {
for items.each {|it|
alt ast_util::class_member_privacy(it) {
priv { cont; }
pub {
let (id, ident) = alt it.node {
instance_var(v, _, _, vid, _) { (vid, v) }
class_method(it) { (it.id, it.ident) }
};
add_to_index(ebml_w, path, index, ident);
encode_named_def_id(ebml_w, ident, local_def(id));
}
}
}
}
fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
module: _mod, path: [str], &index: [entry<str>]) {
// FIXME factor out add_to_index/start/encode_name/encode_def_id/end ops
for module.items.each {|it|
if !reachable(ecx, it.id) ||
!ast_util::is_exported(it.ident, module) { cont; }
alt it.node {
item_const(_, _) {
add_to_index(ebml_w, path, index, it.ident);
encode_named_def_id(ebml_w, it.ident, local_def(it.id));
}
item_fn(_, tps, _) {
add_to_index(ebml_w, path, index, it.ident);
encode_named_def_id(ebml_w, it.ident, local_def(it.id));
}
item_mod(_mod) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(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, ecx, _mod, path + [it.ident],
index);
ebml_w.end_tag();
}
item_native_mod(nmod) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(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);
ebml_w.end_tag();
}
item_ty(_, tps, _) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebml_w.end_tag();
}
item_res(_, tps, _, _, ctor_id, _) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(ctor_id));
ebml_w.end_tag();
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebml_w.end_tag();
}
item_class(_, _, items, ctor, _) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebml_w.end_tag();
ebml_w.start_tag(tag_paths);
add_to_index(ebml_w, path, index, it.ident);
#debug("ctor id: %d", ctor.node.id);
encode_named_def_id(ebml_w, it.ident, local_def(ctor.node.id));
encode_class_item_paths(ebml_w, items, path + [it.ident],
index);
ebml_w.end_tag();
}
item_enum(variants, _, _) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebml_w.end_tag();
encode_enum_variant_paths(ebml_w, variants, path, index);
}
item_iface(*) {
add_to_index(ebml_w, path, index, it.ident);
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, it.ident);
encode_def_id(ebml_w, local_def(it.id));
ebml_w.end_tag();
}
item_impl(*) {}
}
}
}
fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate)
-> [entry<str>] {
let mut index: [entry<str>] = [];
let mut path: [str] = [];
ebml_w.start_tag(tag_paths);
encode_module_item_paths(ebml_w, ecx, crate.node.module, path, index);
encode_reexport_paths(ebml_w, ecx, index);
ebml_w.end_tag();
ret index;
}
fn encode_reexport_paths(ebml_w: ebml::writer,
ecx: @encode_ctxt, &index: [entry<str>]) {
let tcx = ecx.ccx.tcx;
for ecx.ccx.exp_map.each {|exp_id, defs|
for defs.each {|def|
if !def.reexp { cont; }
let path = alt check tcx.items.get(exp_id) {
ast_map::node_export(_, path) { ast_map::path_to_str(*path) }
};
index += [{val: path, pos: ebml_w.writer.tell()}];
ebml_w.start_tag(tag_paths_data_item);
encode_name(ebml_w, path);
encode_def_id(ebml_w, def.id);
ebml_w.end_tag();
}
}
}
// Item info table encoding
fn encode_family(ebml_w: ebml::writer, c: char) {
ebml_w.start_tag(tag_items_data_item_family);
ebml_w.writer.write([c as u8]/&);
ebml_w.end_tag();
}
fn def_to_str(did: def_id) -> str { ret #fmt["%d:%d", did.crate, did.node]; }
fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
params: [ty_param]) {
let ty_str_ctxt = @{ds: def_to_str,
tcx: ecx.ccx.tcx,
reachable: reachable(ecx, _),
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
for params.each {|param|
ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
let bs = ecx.ccx.tcx.ty_param_bounds.get(param.id);
tyencode::enc_bounds(ebml_w.writer, ty_str_ctxt, bs);
ebml_w.end_tag();
}
}
fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
ebml_w.start_tag(tag_items_data_item_variant);
ebml_w.writer.write(str::bytes(def_to_str(vid)));
ebml_w.end_tag();
}
fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
let ty_str_ctxt =
@{ds: def_to_str,
tcx: ecx.ccx.tcx,
reachable: reachable(ecx, _),
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
}
fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
ebml_w.start_tag(tag_items_data_item_type);
write_type(ecx, ebml_w, typ);
ebml_w.end_tag();
}
fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
ebml_w.start_tag(tag_items_data_item_symbol);
let sym = alt ecx.ccx.item_symbols.find(id) {
some(x) { x }
none { ecx.ccx.tcx.sess.bug(#fmt("encode_symbol: \
id not found %d", id)); }
};
ebml_w.writer.write(str::bytes(sym));
ebml_w.end_tag();
}
fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
ebml_w.start_tag(tag_items_data_item_symbol);
ebml_w.writer.write(str::bytes(ecx.ccx.discrim_symbols.get(id)));
ebml_w.end_tag();
}
fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: int) {
ebml_w.start_tag(tag_disr_val);
ebml_w.writer.write(str::bytes(int::to_str(disr_val,10u)));
ebml_w.end_tag();
}
fn encode_parent_item(ebml_w: ebml::writer, id: def_id) {
ebml_w.start_tag(tag_items_data_parent_item);
ebml_w.writer.write(str::bytes(def_to_str(id)));
ebml_w.end_tag();
}
fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, variants: [variant],
path: ast_map::path, index: @mut [entry<int>],
ty_params: [ty_param]) {
let mut disr_val = 0;
let mut i = 0;
let vi = ty::enum_variants(ecx.ccx.tcx, {crate: local_crate, node: id});
for variants.each {|variant|
*index += [{val: variant.node.id, pos: ebml_w.writer.tell()}];
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(variant.node.id));
encode_family(ebml_w, 'v');
encode_name(ebml_w, variant.node.name);
encode_parent_item(ebml_w, local_def(id));
encode_type(ecx, ebml_w,
node_id_to_type(ecx.ccx.tcx, variant.node.id));
if vec::len(variant.node.args) > 0u && ty_params.len() == 0u {
encode_symbol(ecx, ebml_w, variant.node.id);
}
encode_discriminant(ecx, ebml_w, variant.node.id);
if vi[i].disr_val != disr_val {
encode_disr_val(ecx, ebml_w, vi[i].disr_val);
disr_val = vi[i].disr_val;
}
encode_type_param_bounds(ebml_w, ecx, ty_params);
encode_path(ebml_w, path, ast_map::path_name(variant.node.name));
ebml_w.end_tag();
disr_val += 1;
i += 1;
}
}
fn encode_path(ebml_w: ebml::writer,
path: ast_map::path,
name: ast_map::path_elt) {
fn encode_path_elt(ebml_w: ebml::writer, elt: ast_map::path_elt) {
let (tag, name) = alt elt {
ast_map::path_mod(name) { (tag_path_elt_mod, name) }
ast_map::path_name(name) { (tag_path_elt_name, name) }
};
ebml_w.wr_tagged_str(tag, name);
}
ebml_w.wr_tag(tag_path) {||
ebml_w.wr_tagged_u32(tag_path_len, (vec::len(path) + 1u) as u32);
vec::iter(path) {|pe| encode_path_elt(ebml_w, pe); }
encode_path_elt(ebml_w, name);
}
}
fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
id: node_id, path: ast_map::path, name: ident) {
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(id));
encode_family(ebml_w, 'm');
encode_name(ebml_w, name);
alt ecx.ccx.maps.impl_map.get(id) {
list::cons(impls, @list::nil) {
for vec::each(*impls) {|i|
if ast_util::is_exported(i.ident, md) {
ebml_w.wr_tagged_str(tag_mod_impl, def_to_str(i.did));
}
}
}
_ { ecx.ccx.tcx.sess.bug(#fmt("encode_info_for_mod: empty impl_map \
entry for %?", path)); }
}
encode_path(ebml_w, path, ast_map::path_mod(name));
ebml_w.end_tag();
}
fn encode_privacy(ebml_w: ebml::writer, privacy: privacy) {
encode_family(ebml_w, alt privacy {
pub { 'g' } priv { 'j' }});
}
/* Returns an index of items in this class */
fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, path: ast_map::path,
class_tps: [ty_param],
items: [@class_member],
global_index: @mut[entry<int>])
-> [entry<int>] {
let index = @mut [];
let tcx = ecx.ccx.tcx;
for items.each {|ci|
/* We encode both private and public fields -- need to include
private fields to get the offsets right */
alt ci.node {
instance_var(nm, _, mt, id, pr) {
*index += [{val: id, pos: ebml_w.writer.tell()}];
ebml_w.start_tag(tag_items_data_item);
#debug("encode_info_for_class: doing %s %d", nm, id);
encode_privacy(ebml_w, pr);
encode_name(ebml_w, nm);
encode_path(ebml_w, path, ast_map::path_name(nm));
encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
encode_mutability(ebml_w, mt);
encode_def_id(ebml_w, local_def(id));
ebml_w.end_tag();
}
class_method(m) {
alt m.privacy {
pub {
*index += [{val: m.id, pos: ebml_w.writer.tell()}];
/* Not sure whether we really need to have two indices,
but it works for now -- tjc */
*global_index += [{val: m.id, pos: ebml_w.writer.tell()}];
let impl_path = path + [ast_map::path_name(m.ident)];
#debug("encode_info_for_class: doing %s %d", m.ident, m.id);
encode_info_for_method(ecx, ebml_w, impl_path,
should_inline(m.attrs), id, m,
class_tps + m.tps);
}
_ { /* don't encode private methods */ }
}
}
}
};
*index
}
fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
id: node_id, ident: ident, path: ast_map::path,
item: option<inlined_item>, tps: [ty_param],
decl: fn_decl) {
ebml_w.start_tag(tag_items_data_item);
encode_name(ebml_w, ident);
encode_def_id(ebml_w, local_def(id));
encode_family(ebml_w, purity_fn_family(decl.purity));
encode_type_param_bounds(ebml_w, ecx, tps);
let its_ty = node_id_to_type(ecx.ccx.tcx, id);
#debug("fn name = %s ty = %s", ident,
util::ppaux::ty_to_str(ecx.ccx.tcx, its_ty));
encode_type(ecx, ebml_w, its_ty);
encode_path(ebml_w, path, ast_map::path_name(ident));
alt item {
some(it) {
astencode::encode_inlined_item(ecx, ebml_w, path, it);
}
none {
encode_symbol(ecx, ebml_w, id);
}
}
ebml_w.end_tag();
}
fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
impl_path: ast_map::path, should_inline: bool,
parent_id: node_id,
m: @method, all_tps: [ty_param]) {
#debug("encode_info_for_method: %d %s %u", m.id, m.ident, all_tps.len());
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(m.id));
encode_family(ebml_w, purity_fn_family(m.decl.purity));
encode_type_param_bounds(ebml_w, ecx, all_tps);
encode_type(ecx, ebml_w, node_id_to_type(ecx.ccx.tcx, m.id));
encode_name(ebml_w, m.ident);
encode_path(ebml_w, impl_path, ast_map::path_name(m.ident));
if all_tps.len() > 0u || should_inline {
astencode::encode_inlined_item(
ecx, ebml_w, impl_path,
ii_method(local_def(parent_id), m));
} else {
encode_symbol(ecx, ebml_w, m.id);
}
ebml_w.end_tag();
}
fn purity_fn_family(p: purity) -> char {
alt p {
unsafe_fn { 'u' }
pure_fn { 'p' }
impure_fn { 'f' }
crust_fn { 'c' }
}
}
fn should_inline(attrs: [attribute]) -> bool {
alt attr::find_inline_attr(attrs) {
attr::ia_none { false }
attr::ia_hint | attr::ia_always { true }
}
}
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
index: @mut [entry<int>], path: ast_map::path) {
let tcx = ecx.ccx.tcx;
let must_write =
alt item.node { item_enum(_, _, _) { true } _ { false } };
if !must_write && !reachable(ecx, item.id) { ret; }
fn add_to_index_(item: @item, ebml_w: ebml::writer,
index: @mut [entry<int>]) {
*index += [{val: item.id, pos: ebml_w.writer.tell()}];
}
let add_to_index = bind add_to_index_(item, ebml_w, index);
alt item.node {
item_const(_, _) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'c');
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_symbol(ecx, ebml_w, item.id);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
item_fn(decl, tps, _) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, purity_fn_family(decl.purity));
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_path(ebml_w, path, ast_map::path_name(item.ident));
if tps.len() > 0u || should_inline(item.attrs) {
astencode::encode_inlined_item(ecx, ebml_w, path, ii_item(item));
} else {
encode_symbol(ecx, ebml_w, item.id);
}
ebml_w.end_tag();
}
item_mod(m) {
add_to_index();
encode_info_for_mod(ecx, ebml_w, m, item.id, path, item.ident);
}
item_native_mod(_) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'n');
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
item_ty(_, tps, rp) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'y');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ebml_w, rp);
ebml_w.end_tag();
}
item_enum(variants, tps, rp) {
add_to_index();
ebml_w.wr_tag(tag_items_data_item) {||
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 't');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
for variants.each {|v|
encode_variant_id(ebml_w, local_def(v.node.id));
}
astencode::encode_inlined_item(ecx, ebml_w, path, ii_item(item));
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ebml_w, rp);
}
encode_enum_variant_info(ecx, ebml_w, item.id, variants,
path, index, tps);
}
item_class(tps, _ifaces, items, ctor, rp) {
/* First, encode the fields and methods
These come first because we need to write them to make
the index, and the index needs to be in the item for the
class itself */
let idx = encode_info_for_class(ecx, ebml_w, item.id, path, tps,
items, index);
/* Index the class*/
add_to_index();
/* Now, make an item for the class itself */
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'C');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ebml_w, rp);
/* FIXME: encode ifaces */
/* Encode def_ids for each field and method
for methods, write all the stuff get_iface_method
needs to know*/
let (fs,ms) = ast_util::split_class_items(items);
for fs.each {|f|
ebml_w.start_tag(tag_item_field);
encode_privacy(ebml_w, f.privacy);
encode_name(ebml_w, f.ident);
encode_def_id(ebml_w, local_def(f.id));
ebml_w.end_tag();
}
for ms.each {|m|
alt m.privacy {
priv { /* do nothing */ }
pub {
ebml_w.start_tag(tag_item_method);
#debug("Writing %s %d", m.ident, m.id);
encode_family(ebml_w, purity_fn_family(m.decl.purity));
encode_name(ebml_w, m.ident);
encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
encode_def_id(ebml_w, local_def(m.id));
ebml_w.end_tag();
}
}
}
/* Each class has its own index -- encode it */
let bkts = create_index(idx, hash_node_id);
encode_index(ebml_w, bkts, write_int);
ebml_w.end_tag();
}
item_res(_, tps, _, _, ctor_id, rp) {
add_to_index();
let fn_ty = node_id_to_type(tcx, ctor_id);
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(ctor_id));
encode_family(ebml_w, 'y');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, ty::ty_fn_ret(fn_ty));
encode_name(ebml_w, item.ident);
astencode::encode_inlined_item(ecx, ebml_w, path, ii_item(item));
if (tps.len() == 0u) {
encode_symbol(ecx, ebml_w, item.id);
}
encode_path(ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ebml_w, rp);
ebml_w.end_tag();
*index += [{val: ctor_id, pos: ebml_w.writer.tell()}];
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(ctor_id));
encode_family(ebml_w, 'f');
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, fn_ty);
encode_parent_item(ebml_w, local_def(item.id));
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
item_impl(tps, rp, ifce, _, methods) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'i');
encode_region_param(ebml_w, rp);
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
for methods.each {|m|
ebml_w.start_tag(tag_item_method);
ebml_w.writer.write(str::bytes(def_to_str(local_def(m.id))));
ebml_w.end_tag();
}
alt ifce {
some(t) {
let i_ty = ty::node_id_to_type(tcx, t.id);
ebml_w.start_tag(tag_impl_iface);
write_type(ecx, ebml_w, i_ty);
ebml_w.end_tag();
}
_ {}
}
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
let impl_path = path + [ast_map::path_name(item.ident)];
for methods.each {|m|
*index += [{val: m.id, pos: ebml_w.writer.tell()}];
encode_info_for_method(ecx, ebml_w, impl_path,
should_inline(m.attrs), item.id, m, tps + m.tps);
}
}
item_iface(tps, rp, ms) {
add_to_index();
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(item.id));
encode_family(ebml_w, 'I');
encode_region_param(ebml_w, rp);
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
encode_name(ebml_w, item.ident);
let mut i = 0u;
for vec::each(*ty::iface_methods(tcx, local_def(item.id))) {|mty|
ebml_w.start_tag(tag_item_method);
encode_name(ebml_w, mty.ident);
encode_type_param_bounds(ebml_w, ecx, ms[i].tps);
encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty));
encode_family(ebml_w, purity_fn_family(mty.purity));
ebml_w.end_tag();
i += 1u;
}
encode_path(ebml_w, path, ast_map::path_name(item.ident));
ebml_w.end_tag();
}
}
}
fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
nitem: @native_item,
index: @mut [entry<int>],
path: ast_map::path, abi: native_abi) {
if !reachable(ecx, nitem.id) { ret; }
*index += [{val: nitem.id, pos: ebml_w.writer.tell()}];
ebml_w.start_tag(tag_items_data_item);
alt nitem.node {
native_item_fn(fn_decl, tps) {
encode_def_id(ebml_w, local_def(nitem.id));
encode_family(ebml_w, purity_fn_family(fn_decl.purity));
encode_type_param_bounds(ebml_w, ecx, tps);
encode_type(ecx, ebml_w, node_id_to_type(ecx.ccx.tcx, nitem.id));
if abi == native_abi_rust_intrinsic {
astencode::encode_inlined_item(ecx, ebml_w, path,
ii_native(nitem));
} else {
encode_symbol(ecx, ebml_w, nitem.id);
}
encode_path(ebml_w, path, ast_map::path_name(nitem.ident));
}
}
ebml_w.end_tag();
}
fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
crate: @crate) -> [entry<int>] {
let index = @mut [];
ebml_w.start_tag(tag_items_data);
*index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
encode_info_for_mod(ecx, ebml_w, crate.node.module,
crate_node_id, [], "");
visit::visit_crate(*crate, (), visit::mk_vt(@{
visit_expr: {|_e, _cx, _v|},
visit_item: {|i, cx, v|
visit::visit_item(i, cx, v);
alt check ecx.ccx.tcx.items.get(i.id) {
ast_map::node_item(_, pt) {
encode_info_for_item(ecx, ebml_w, i, index, *pt);
/* encode ctor, then encode items */
alt i.node {
item_class(tps, _, _, ctor, _) {
/* this is assuming that ctors aren't inlined...
probably shouldn't assume that */
#debug("encoding info for ctor %s %d", i.ident,
ctor.node.id);
*index += [{val: ctor.node.id, pos: ebml_w.writer.tell()}];
encode_info_for_fn(ecx, ebml_w, ctor.node.id, i.ident,
*pt, if tps.len() > 0u {
some(ii_ctor(ctor, i.ident, tps,
local_def(i.id))) }
else { none }, tps, ctor.node.dec)
}
_ {}
}
}
}
},
visit_native_item: {|ni, cx, v|
visit::visit_native_item(ni, cx, v);
alt check ecx.ccx.tcx.items.get(ni.id) {
ast_map::node_native_item(_, abi, pt) {
encode_info_for_native_item(ecx, ebml_w, ni, index, *pt, abi);
}
}
}
with *visit::default_visitor()
}));
ebml_w.end_tag();
ret *index;
}
// Path and definition ID indexing
fn create_index<T: copy>(index: [entry<T>], hash_fn: fn@(T) -> uint) ->
[@[entry<T>]] {
let mut buckets: [@mut [entry<T>]] = [];
uint::range(0u, 256u) {|_i| buckets += [@mut []]; };
for index.each {|elt|
let h = hash_fn(elt.val);
*buckets[h % 256u] += [elt];
}
let mut buckets_frozen = [];
for buckets.each {|bucket|
buckets_frozen += [@*bucket];
}
ret buckets_frozen;
}
fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
write_fn: fn(io::writer, T)) {
let writer = ebml_w.writer;
ebml_w.start_tag(tag_index);
let mut bucket_locs: [uint] = [];
ebml_w.start_tag(tag_index_buckets);
for buckets.each {|bucket|
bucket_locs += [ebml_w.writer.tell()];
ebml_w.start_tag(tag_index_buckets_bucket);
for vec::each(*bucket) {|elt|
ebml_w.start_tag(tag_index_buckets_bucket_elt);
writer.write_be_uint(elt.pos, 4u);
write_fn(writer, elt.val);
ebml_w.end_tag();
}
ebml_w.end_tag();
}
ebml_w.end_tag();
ebml_w.start_tag(tag_index_table);
for bucket_locs.each {|pos| writer.write_be_uint(pos, 4u); }
ebml_w.end_tag();
ebml_w.end_tag();
}
fn write_str(writer: io::writer, &&s: str) { writer.write_str(s); }
fn write_int(writer: io::writer, &&n: int) {
writer.write_be_uint(n as uint, 4u);
}
fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
alt mi.node {
meta_word(name) {
ebml_w.start_tag(tag_meta_item_word);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
ebml_w.end_tag();
}
meta_name_value(name, value) {
alt value.node {
lit_str(value) {
ebml_w.start_tag(tag_meta_item_name_value);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
ebml_w.start_tag(tag_meta_item_value);
ebml_w.writer.write(str::bytes(value));
ebml_w.end_tag();
ebml_w.end_tag();
}
_ {/* FIXME (#611) */ }
}
}
meta_list(name, items) {
ebml_w.start_tag(tag_meta_item_list);
ebml_w.start_tag(tag_meta_item_name);
ebml_w.writer.write(str::bytes(name));
ebml_w.end_tag();
for items.each {|inner_item|
encode_meta_item(ebml_w, *inner_item);
}
ebml_w.end_tag();
}
}
}
fn encode_attributes(ebml_w: ebml::writer, attrs: [attribute]) {
ebml_w.start_tag(tag_attributes);
for attrs.each {|attr|
ebml_w.start_tag(tag_attribute);
encode_meta_item(ebml_w, attr.node.value);
ebml_w.end_tag();
}
ebml_w.end_tag();
}
// So there's a special crate attribute called 'link' which defines the
// metadata that Rust cares about for linking crates. This attribute requires
// 'name' and 'vers' items, so if the user didn't provide them we will throw
// them in anyway with default values.
fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> [attribute] {
fn synthesize_link_attr(ecx: @encode_ctxt, items: [@meta_item]) ->
attribute {
assert (ecx.ccx.link_meta.name != "");
assert (ecx.ccx.link_meta.vers != "");
let name_item =
attr::mk_name_value_item_str("name", ecx.ccx.link_meta.name);
let vers_item =
attr::mk_name_value_item_str("vers", ecx.ccx.link_meta.vers);
let other_items =
{
let tmp = attr::remove_meta_items_by_name(items, "name");
attr::remove_meta_items_by_name(tmp, "vers")
};
let meta_items = [name_item, vers_item] + other_items;
let link_item = attr::mk_list_item("link", meta_items);
ret attr::mk_attr(link_item);
}
let mut attrs: [attribute] = [];
let mut found_link_attr = false;
for crate.node.attrs.each {|attr|
attrs +=
if attr::get_attr_name(attr) != "link" {
[attr]
} else {
alt attr.node.value.node {
meta_list(n, l) {
found_link_attr = true;;
[synthesize_link_attr(ecx, l)]
}
_ { [attr] }
}
};
}
if !found_link_attr { attrs += [synthesize_link_attr(ecx, [])]; }
ret attrs;
}
fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
fn get_ordered_deps(cstore: cstore::cstore) -> [decoder::crate_dep] {
type hashkv = @{key: crate_num, val: cstore::crate_metadata};
type numdep = decoder::crate_dep;
// Pull the cnums and name,vers,hash out of cstore
let mut deps: [mut numdep] = [mut];
cstore::iter_crate_data(cstore) {|key, val|
let dep = {cnum: key, name: val.name,
vers: decoder::get_crate_vers(val.data),
hash: decoder::get_crate_hash(val.data)};
deps += [mut dep];
};
// Sort by cnum
fn lteq(kv1: numdep, kv2: numdep) -> bool { kv1.cnum <= kv2.cnum }
std::sort::quick_sort(lteq, deps);
// Sanity-check the crate numbers
let mut expected_cnum = 1;
for deps.each {|n|
assert (n.cnum == expected_cnum);
expected_cnum += 1;
}
// mut -> immutable hack for vec::map
ret vec::slice(deps, 0u, vec::len(deps));
}
// We're just going to write a list of crate 'name-hash-version's, with
// the assumption 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.
ebml_w.start_tag(tag_crate_deps);
for get_ordered_deps(cstore).each {|dep|
encode_crate_dep(ebml_w, dep);
}
ebml_w.end_tag();
}
fn encode_crate_dep(ebml_w: ebml::writer, dep: decoder::crate_dep) {
ebml_w.start_tag(tag_crate_dep);
ebml_w.start_tag(tag_crate_dep_name);
ebml_w.writer.write(str::bytes(dep.name));
ebml_w.end_tag();
ebml_w.start_tag(tag_crate_dep_vers);
ebml_w.writer.write(str::bytes(dep.vers));
ebml_w.end_tag();
ebml_w.start_tag(tag_crate_dep_hash);
ebml_w.writer.write(str::bytes(dep.hash));
ebml_w.end_tag();
ebml_w.end_tag();
}
fn encode_hash(ebml_w: ebml::writer, hash: str) {
ebml_w.start_tag(tag_crate_hash);
ebml_w.writer.write(str::bytes(hash));
ebml_w.end_tag();
}
fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> [u8] {
let ecx = @{ccx: cx, type_abbrevs: ty::new_ty_hash()};
let buf = io::mem_buffer();
let buf_w = io::mem_buffer_writer(buf);
let ebml_w = ebml::writer(buf_w);
encode_hash(ebml_w, cx.link_meta.extras_hash);
let crate_attrs = synthesize_crate_attrs(ecx, crate);
encode_attributes(ebml_w, crate_attrs);
encode_crate_deps(ebml_w, cx.sess.cstore);
// Encode and index the paths.
ebml_w.start_tag(tag_paths);
let paths_index = encode_item_paths(ebml_w, ecx, crate);
let paths_buckets = create_index(paths_index, hash_path);
encode_index(ebml_w, paths_buckets, write_str);
ebml_w.end_tag();
// Encode and index the items.
ebml_w.start_tag(tag_items);
let items_index = encode_info_for_items(ecx, ebml_w, crate);
let items_buckets = create_index(items_index, hash_node_id);
encode_index(ebml_w, items_buckets, write_int);
ebml_w.end_tag();
// Pad this, since something (LLVM, presumably) is cutting off the
// remaining % 4 bytes.
buf_w.write([0u8, 0u8, 0u8, 0u8]/&);
io::mem_buffer_buf(buf)
}
// Get the encoded string for a type
fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> str {
let cx = @{ds: def_to_str,
tcx: tcx,
reachable: {|_id| false},
abbrevs: tyencode::ac_no_abbrevs};
let buf = io::mem_buffer();
tyencode::enc_ty(io::mem_buffer_writer(buf), cx, t);
ret io::mem_buffer_str(buf);
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
Reference in New Issue View Git Blame Copy Permalink