From e1dcbefe52d4c5877602a17270cf5a1b6882c232 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 29 Jul 2014 17:06:37 -0700 Subject: [PATCH] remove serialize::ebml, add librbml Our implementation of ebml has diverged from the standard in order to better serve the needs of the compiler, so it doesn't make much sense to call what we have ebml anyore. Furthermore, our implementation is pretty crufty, and should eventually be rewritten into a format that better suits the needs of the compiler. This patch factors out serialize::ebml into librbml, otherwise known as the Really Bad Markup Language. This is a stopgap library that shouldn't be used by end users, and will eventually be replaced by something better. [breaking-change] --- mk/crates.mk | 7 +- src/{libserialize/ebml.rs => librbml/lib.rs} | 52 +- src/librustc/lib.rs | 1 + src/librustc/metadata/csearch.rs | 6 +- src/librustc/metadata/decoder.rs | 118 +- src/librustc/metadata/encoder.rs | 1218 ++++++++--------- src/librustc/middle/astencode.rs | 301 ++-- src/librustc/middle/trans/base.rs | 2 +- src/libserialize/lib.rs | 1 - src/test/run-pass/auto-encode.rs | 46 +- .../run-pass/deriving-encodable-decodable.rs | 11 +- src/test/run-pass/issue-11881.rs | 9 +- 12 files changed, 895 insertions(+), 877 deletions(-) rename src/{libserialize/ebml.rs => librbml/lib.rs} (97%) diff --git a/mk/crates.mk b/mk/crates.mk index c95576f6252..5bc4505fb05 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -51,7 +51,7 @@ TARGET_CRATES := libc std green rustuv native flate arena glob term semver \ uuid serialize sync getopts collections num test time rand \ - url log regex graphviz core rlibc alloc debug rustrt \ + url log regex graphviz core rbml rlibc alloc debug rustrt \ unicode HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \ rustc_llvm rustc_back @@ -71,7 +71,7 @@ DEPS_green := std native:context_switch DEPS_rustuv := std native:uv native:uv_support DEPS_native := std DEPS_syntax := std term serialize log fmt_macros debug -DEPS_rustc := syntax flate arena serialize getopts \ +DEPS_rustc := syntax flate arena serialize getopts rbml \ time log graphviz debug rustc_llvm rustc_back DEPS_rustc_llvm := native:rustllvm libc std DEPS_rustc_back := std syntax rustc_llvm flate log libc @@ -82,6 +82,7 @@ DEPS_arena := std DEPS_graphviz := std DEPS_glob := std DEPS_serialize := std log +DEPS_rbml := std log serialize DEPS_term := std log DEPS_semver := std DEPS_uuid := std serialize @@ -91,7 +92,7 @@ DEPS_collections := core alloc unicode DEPS_fourcc := rustc syntax std DEPS_hexfloat := rustc syntax std DEPS_num := std -DEPS_test := std getopts serialize term time regex native:rust_test_helpers +DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers DEPS_time := std serialize DEPS_rand := core DEPS_url := std diff --git a/src/libserialize/ebml.rs b/src/librbml/lib.rs similarity index 97% rename from src/libserialize/ebml.rs rename to src/librbml/lib.rs index c3434466836..e54410b6a5d 100644 --- a/src/libserialize/ebml.rs +++ b/src/librbml/lib.rs @@ -8,16 +8,35 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +//! Really Bad Markup Language (rbml) is a temporary measure until we migrate +//! the rust object metadata to a better serialization format. It is not +//! intended to be used by users. +//! +//! It is loosely based on the Extensible Binary Markup Language (ebml): +//! http://www.matroska.org/technical/specs/rfc/index.html + +#![crate_name = "rbml"] +#![experimental] +#![crate_type = "rlib"] +#![crate_type = "dylib"] +#![license = "MIT/ASL2"] +#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", + html_favicon_url = "http://www.rust-lang.org/favicon.ico", + html_root_url = "http://doc.rust-lang.org/master/", + html_playground_url = "http://play.rust-lang.org/")] +#![feature(macro_rules, phase)] #![allow(missing_doc)] +extern crate serialize; + +#[phase(plugin, link)] extern crate log; +#[cfg(test)] extern crate test; + use std::io; use std::str; -// Simple Extensible Binary Markup Language (ebml) reader and writer on a -// cursor model. See the specification here: -// http://www.matroska.org/technical/specs/rfc/index.html -// Common data structures +/// Common data structures #[deriving(Clone)] pub struct Doc<'a> { pub data: &'a [u8], @@ -107,7 +126,7 @@ pub mod reader { Expected }; pub type DecodeResult = Result; - // ebml reading + // rbml reading macro_rules! try_or( ($e:expr, $r:expr) => ( @@ -637,7 +656,7 @@ pub mod writer { pub type EncodeResult = io::IoResult<()>; - // ebml writing + // rbml writing pub struct Encoder<'a, W> { pub writer: &'a mut W, size_positions: Vec, @@ -671,7 +690,7 @@ pub mod writer { }) } - // FIXME (#2741): Provide a function to write the standard ebml header. + // FIXME (#2741): Provide a function to write the standard rbml header. impl<'a, W: Writer + Seek> Encoder<'a, W> { pub fn new(w: &'a mut W) -> Encoder<'a, W> { Encoder { @@ -1018,10 +1037,8 @@ pub mod writer { #[cfg(test)] mod tests { - use super::Doc; - use ebml::reader; - use ebml::writer; - use {Encodable, Decodable}; + use super::{Doc, reader, writer}; + use serialize::{Encodable, Decodable}; use std::io::{IoError, IoResult, SeekStyle}; use std::io; @@ -1196,11 +1213,11 @@ mod tests { debug!("v == {}", v); let mut wr = SeekableMemWriter::new(); { - let mut ebml_w = writer::Encoder::new(&mut wr); - let _ = v.encode(&mut ebml_w); + let mut rbml_w = writer::Encoder::new(&mut wr); + let _ = v.encode(&mut rbml_w); } - let ebml_doc = Doc::new(wr.get_ref()); - let mut deser = reader::Decoder::new(ebml_doc); + let rbml_doc = Doc::new(wr.get_ref()); + let mut deser = reader::Decoder::new(rbml_doc); let v1 = Decodable::decode(&mut deser).unwrap(); debug!("v1 == {}", v1); assert_eq!(v, v1); @@ -1215,9 +1232,8 @@ mod tests { #[cfg(test)] mod bench { #![allow(non_snake_case_functions)] - extern crate test; - use self::test::Bencher; - use ebml::reader; + use test::Bencher; + use super::reader; #[bench] pub fn vuint_at_A_aligned(b: &mut Bencher) { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 82040f14159..5385c610350 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -44,6 +44,7 @@ extern crate libc; extern crate llvm = "rustc_llvm"; extern crate rustc_back = "rustc_back"; extern crate serialize; +extern crate rbml; extern crate time; #[phase(plugin, link)] extern crate log; #[phase(plugin, link)] extern crate syntax; diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index b1b366ec030..252d19bbb23 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -20,8 +20,8 @@ use middle::ty; use middle::typeck; use middle::subst::VecPerParamSpace; -use serialize::ebml; -use serialize::ebml::reader; +use rbml; +use rbml::reader; use std::rc::Rc; use syntax::ast; use syntax::ast_map; @@ -218,7 +218,7 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId, def: ast::DefId) -> ty::Polytype { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(class_id.krate); - let all_items = reader::get_doc(ebml::Doc::new(cdata.data()), tag_items); + let all_items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items); let class_doc = expect(tcx.sess.diagnostic(), decoder::maybe_find_item(class_id.node, all_items), || { diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index f7576ffb481..c9807a18383 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -37,8 +37,8 @@ use std::io; use std::collections::hashmap::HashMap; use std::rc::Rc; use std::u64; -use serialize::ebml::reader; -use serialize::ebml; +use rbml::reader; +use rbml; use serialize::Decodable; use syntax::ast_map; use syntax::attr; @@ -56,8 +56,8 @@ pub type Cmd<'a> = &'a crate_metadata; // what crate that's in and give us a def_id that makes sense for the current // build. -fn lookup_hash<'a>(d: ebml::Doc<'a>, eq_fn: |&[u8]| -> bool, - hash: u64) -> Option> { +fn lookup_hash<'a>(d: rbml::Doc<'a>, eq_fn: |&[u8]| -> bool, + hash: u64) -> Option> { let index = reader::get_doc(d, tag_index); let table = reader::get_doc(index, tag_index_table); let hash_pos = table.start + (hash % 256 * 4) as uint; @@ -80,7 +80,7 @@ fn lookup_hash<'a>(d: ebml::Doc<'a>, eq_fn: |&[u8]| -> bool, } pub fn maybe_find_item<'a>(item_id: ast::NodeId, - items: ebml::Doc<'a>) -> Option> { + items: rbml::Doc<'a>) -> Option> { fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool { return u64_from_be_bytes( bytes.slice(0u, 4u), 0u, 4u) as ast::NodeId @@ -91,17 +91,17 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId, hash::hash(&(item_id as i64))) } -fn find_item<'a>(item_id: ast::NodeId, items: ebml::Doc<'a>) -> ebml::Doc<'a> { +fn find_item<'a>(item_id: ast::NodeId, items: rbml::Doc<'a>) -> rbml::Doc<'a> { match maybe_find_item(item_id, items) { None => fail!("lookup_item: id not found: {}", item_id), Some(d) => d } } -// Looks up an item in the given metadata and returns an ebml doc pointing +// Looks up an item in the given metadata and returns an rbml doc pointing // to the item data. -fn lookup_item<'a>(item_id: ast::NodeId, data: &'a [u8]) -> ebml::Doc<'a> { - let items = reader::get_doc(ebml::Doc::new(data), tag_items); +fn lookup_item<'a>(item_id: ast::NodeId, data: &'a [u8]) -> rbml::Doc<'a> { + let items = reader::get_doc(rbml::Doc::new(data), tag_items); find_item(item_id, items) } @@ -127,7 +127,7 @@ enum Family { InheritedField // N } -fn item_family(item: ebml::Doc) -> Family { +fn item_family(item: rbml::Doc) -> Family { let fam = reader::get_doc(item, tag_items_data_item_family); match reader::doc_as_u8(fam) as char { 'c' => ImmStatic, @@ -152,7 +152,7 @@ fn item_family(item: ebml::Doc) -> Family { } } -fn item_visibility(item: ebml::Doc) -> ast::Visibility { +fn item_visibility(item: rbml::Doc) -> ast::Visibility { match reader::maybe_get_doc(item, tag_items_data_item_visibility) { None => ast::Public, Some(visibility_doc) => { @@ -165,7 +165,7 @@ fn item_visibility(item: ebml::Doc) -> ast::Visibility { } } -fn item_method_sort(item: ebml::Doc) -> char { +fn item_method_sort(item: rbml::Doc) -> char { let mut ret = 'r'; reader::tagged_docs(item, tag_item_trait_method_sort, |doc| { ret = doc.as_str_slice().as_bytes()[0] as char; @@ -174,11 +174,11 @@ fn item_method_sort(item: ebml::Doc) -> char { ret } -fn item_symbol(item: ebml::Doc) -> String { +fn item_symbol(item: rbml::Doc) -> String { reader::get_doc(item, tag_items_data_item_symbol).as_str().to_string() } -fn item_parent_item(d: ebml::Doc) -> Option { +fn item_parent_item(d: rbml::Doc) -> Option { let mut ret = None; reader::tagged_docs(d, tag_items_data_parent_item, |did| { ret = Some(reader::with_doc_data(did, parse_def_id)); @@ -188,60 +188,60 @@ fn item_parent_item(d: ebml::Doc) -> Option { } fn item_reqd_and_translated_parent_item(cnum: ast::CrateNum, - d: ebml::Doc) -> ast::DefId { + d: rbml::Doc) -> ast::DefId { let trait_did = item_parent_item(d).expect("item without parent"); ast::DefId { krate: cnum, node: trait_did.node } } -fn item_def_id(d: ebml::Doc, cdata: Cmd) -> ast::DefId { +fn item_def_id(d: rbml::Doc, cdata: Cmd) -> ast::DefId { let tagdoc = reader::get_doc(d, tag_def_id); return translate_def_id(cdata, reader::with_doc_data(tagdoc, parse_def_id)); } -fn get_provided_source(d: ebml::Doc, cdata: Cmd) -> Option { +fn get_provided_source(d: rbml::Doc, cdata: Cmd) -> Option { reader::maybe_get_doc(d, tag_item_method_provided_source).map(|doc| { translate_def_id(cdata, reader::with_doc_data(doc, parse_def_id)) }) } -fn each_reexport(d: ebml::Doc, f: |ebml::Doc| -> bool) -> bool { +fn each_reexport(d: rbml::Doc, f: |rbml::Doc| -> bool) -> bool { reader::tagged_docs(d, tag_items_data_item_reexport, f) } -fn variant_disr_val(d: ebml::Doc) -> Option { +fn variant_disr_val(d: rbml::Doc) -> Option { reader::maybe_get_doc(d, tag_disr_val).and_then(|val_doc| { reader::with_doc_data(val_doc, |data| u64::parse_bytes(data, 10u)) }) } -fn doc_type(doc: ebml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::t { +fn doc_type(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::t { let tp = reader::get_doc(doc, tag_items_data_item_type); parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, |_, did| translate_def_id(cdata, did)) } -fn doc_method_fty(doc: ebml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::BareFnTy { +fn doc_method_fty(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::BareFnTy { let tp = reader::get_doc(doc, tag_item_method_fty); parse_bare_fn_ty_data(tp.data, cdata.cnum, tp.start, tcx, |_, did| translate_def_id(cdata, did)) } -pub fn item_type(_item_id: ast::DefId, item: ebml::Doc, +pub fn item_type(_item_id: ast::DefId, item: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::t { doc_type(item, tcx, cdata) } -fn doc_trait_ref(doc: ebml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef { +fn doc_trait_ref(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef { parse_trait_ref_data(doc.data, cdata.cnum, doc.start, tcx, |_, did| translate_def_id(cdata, did)) } -fn item_trait_ref(doc: ebml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef { +fn item_trait_ref(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef { let tp = reader::get_doc(doc, tag_item_trait_ref); doc_trait_ref(tp, tcx, cdata) } -fn item_ty_param_defs(item: ebml::Doc, +fn item_ty_param_defs(item: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd, tag: uint) @@ -257,7 +257,7 @@ fn item_ty_param_defs(item: ebml::Doc, bounds } -fn item_region_param_defs(item_doc: ebml::Doc, cdata: Cmd) +fn item_region_param_defs(item_doc: rbml::Doc, cdata: Cmd) -> subst::VecPerParamSpace { let mut v = subst::VecPerParamSpace::empty(); @@ -285,7 +285,7 @@ fn item_region_param_defs(item_doc: ebml::Doc, cdata: Cmd) v } -fn enum_variant_ids(item: ebml::Doc, cdata: Cmd) -> Vec { +fn enum_variant_ids(item: rbml::Doc, cdata: Cmd) -> Vec { let mut ids: Vec = Vec::new(); let v = tag_items_data_item_variant; reader::tagged_docs(item, v, |p| { @@ -296,7 +296,7 @@ fn enum_variant_ids(item: ebml::Doc, cdata: Cmd) -> Vec { return ids; } -fn item_path(item_doc: ebml::Doc) -> Vec { +fn item_path(item_doc: rbml::Doc) -> Vec { let path_doc = reader::get_doc(item_doc, tag_path); let len_doc = reader::get_doc(path_doc, tag_path_len); @@ -319,7 +319,7 @@ fn item_path(item_doc: ebml::Doc) -> Vec { result } -fn item_name(intr: &IdentInterner, item: ebml::Doc) -> ast::Ident { +fn item_name(intr: &IdentInterner, item: rbml::Doc) -> ast::Ident { let name = reader::get_doc(item, tag_paths_data_name); let string = name.as_str_slice(); match intr.find_equiv(&string) { @@ -328,7 +328,7 @@ fn item_name(intr: &IdentInterner, item: ebml::Doc) -> ast::Ident { } } -fn item_to_def_like(item: ebml::Doc, did: ast::DefId, cnum: ast::CrateNum) +fn item_to_def_like(item: rbml::Doc, did: ast::DefId, cnum: ast::CrateNum) -> DefLike { let fam = item_family(item); match fam { @@ -463,7 +463,7 @@ pub enum DefLike { /// Iterates over the language items in the given crate. pub fn each_lang_item(cdata: Cmd, f: |ast::NodeId, uint| -> bool) -> bool { - let root = ebml::Doc::new(cdata.data()); + let root = rbml::Doc::new(cdata.data()); let lang_items = reader::get_doc(root, tag_lang_items); reader::tagged_docs(lang_items, tag_lang_items_item, |item_doc| { let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id); @@ -480,7 +480,7 @@ pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Rc; fn each_child_of_item_or_crate(intr: Rc, cdata: Cmd, - item_doc: ebml::Doc, + item_doc: rbml::Doc, get_crate_data: GetCrateDataCb, callback: |DefLike, ast::Ident, @@ -503,7 +503,7 @@ fn each_child_of_item_or_crate(intr: Rc, None => cdata }; - let other_crates_items = reader::get_doc(ebml::Doc::new(crate_data.data()), tag_items); + let other_crates_items = reader::get_doc(rbml::Doc::new(crate_data.data()), tag_items); // Get the item. match maybe_find_item(child_def_id.node, other_crates_items) { @@ -531,7 +531,7 @@ fn each_child_of_item_or_crate(intr: Rc, |inherent_impl_def_id_doc| { let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc, cdata); - let items = reader::get_doc(ebml::Doc::new(cdata.data()), tag_items); + let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items); match maybe_find_item(inherent_impl_def_id.node, items) { None => {} Some(inherent_impl_doc) => { @@ -596,7 +596,7 @@ fn each_child_of_item_or_crate(intr: Rc, None => cdata }; - let other_crates_items = reader::get_doc(ebml::Doc::new(crate_data.data()), tag_items); + let other_crates_items = reader::get_doc(rbml::Doc::new(crate_data.data()), tag_items); // Get the item. match maybe_find_item(child_def_id.node, other_crates_items) { @@ -623,7 +623,7 @@ pub fn each_child_of_item(intr: Rc, get_crate_data: GetCrateDataCb, callback: |DefLike, ast::Ident, ast::Visibility|) { // Find the item. - let root_doc = ebml::Doc::new(cdata.data()); + let root_doc = rbml::Doc::new(cdata.data()); let items = reader::get_doc(root_doc, tag_items); let item_doc = match maybe_find_item(id, items) { None => return, @@ -644,7 +644,7 @@ pub fn each_top_level_item_of_crate(intr: Rc, callback: |DefLike, ast::Ident, ast::Visibility|) { - let root_doc = ebml::Doc::new(cdata.data()); + let root_doc = rbml::Doc::new(cdata.data()); let misc_info_doc = reader::get_doc(root_doc, tag_misc_info); let crate_items_doc = reader::get_doc(misc_info_doc, tag_misc_info_crate_items); @@ -663,7 +663,7 @@ pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec { pub type DecodeInlinedItem<'a> = |cdata: Cmd, tcx: &ty::ctxt, path: Vec, - par_doc: ebml::Doc|: 'a + par_doc: rbml::Doc|: 'a -> Result >; pub fn maybe_get_item_ast(cdata: Cmd, tcx: &ty::ctxt, id: ast::NodeId, @@ -693,7 +693,7 @@ pub fn maybe_get_item_ast(cdata: Cmd, tcx: &ty::ctxt, id: ast::NodeId, pub fn get_enum_variants(intr: Rc, cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) -> Vec> { let data = cdata.data(); - let items = reader::get_doc(ebml::Doc::new(data), tag_items); + let items = reader::get_doc(rbml::Doc::new(data), tag_items); let item = find_item(id, items); let mut disr_val = 0; enum_variant_ids(item, cdata).iter().map(|did| { @@ -725,7 +725,7 @@ pub fn get_enum_variants(intr: Rc, cdata: Cmd, id: ast::NodeId, }).collect() } -fn get_explicit_self(item: ebml::Doc) -> ty::ExplicitSelfCategory { +fn get_explicit_self(item: rbml::Doc) -> ty::ExplicitSelfCategory { fn get_mutability(ch: u8) -> ast::Mutability { match ch as char { 'i' => ast::MutImmutable, @@ -965,7 +965,7 @@ pub fn get_item_attrs(cdata: Cmd, } pub fn get_struct_field_attrs(cdata: Cmd) -> HashMap> { - let data = ebml::Doc::new(cdata.data()); + let data = rbml::Doc::new(cdata.data()); let fields = reader::get_doc(data, tag_struct_fields); let mut map = HashMap::new(); reader::tagged_docs(fields, tag_struct_field, |field| { @@ -1023,7 +1023,7 @@ pub fn get_struct_fields(intr: Rc, cdata: Cmd, id: ast::NodeId) result } -fn get_meta_items(md: ebml::Doc) -> Vec> { +fn get_meta_items(md: rbml::Doc) -> Vec> { let mut items: Vec> = Vec::new(); reader::tagged_docs(md, tag_meta_item_word, |meta_item_doc| { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); @@ -1051,7 +1051,7 @@ fn get_meta_items(md: ebml::Doc) -> Vec> { return items; } -fn get_attributes(md: ebml::Doc) -> Vec { +fn get_attributes(md: rbml::Doc) -> Vec { let mut attrs: Vec = Vec::new(); match reader::maybe_get_doc(md, tag_attributes) { Some(attrs_d) => { @@ -1082,7 +1082,7 @@ fn get_attributes(md: ebml::Doc) -> Vec { return attrs; } -fn list_crate_attributes(md: ebml::Doc, hash: &Svh, +fn list_crate_attributes(md: rbml::Doc, hash: &Svh, out: &mut io::Writer) -> io::IoResult<()> { try!(write!(out, "=Crate Attributes ({})=\n", *hash)); @@ -1095,7 +1095,7 @@ fn list_crate_attributes(md: ebml::Doc, hash: &Svh, } pub fn get_crate_attributes(data: &[u8]) -> Vec { - get_attributes(ebml::Doc::new(data)) + get_attributes(rbml::Doc::new(data)) } #[deriving(Clone)] @@ -1107,10 +1107,10 @@ pub struct CrateDep { pub fn get_crate_deps(data: &[u8]) -> Vec { let mut deps: Vec = Vec::new(); - let cratedoc = ebml::Doc::new(data); + let cratedoc = rbml::Doc::new(data); let depsdoc = reader::get_doc(cratedoc, tag_crate_deps); let mut crate_num = 1; - fn docstr(doc: ebml::Doc, tag_: uint) -> String { + fn docstr(doc: rbml::Doc, tag_: uint) -> String { let d = reader::get_doc(doc, tag_); d.as_str_slice().to_string() } @@ -1138,27 +1138,27 @@ fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> { } pub fn maybe_get_crate_hash(data: &[u8]) -> Option { - let cratedoc = ebml::Doc::new(data); + let cratedoc = rbml::Doc::new(data); reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| { Svh::new(doc.as_str_slice()) }) } pub fn get_crate_hash(data: &[u8]) -> Svh { - let cratedoc = ebml::Doc::new(data); + let cratedoc = rbml::Doc::new(data); let hashdoc = reader::get_doc(cratedoc, tag_crate_hash); Svh::new(hashdoc.as_str_slice()) } pub fn maybe_get_crate_name(data: &[u8]) -> Option { - let cratedoc = ebml::Doc::new(data); + let cratedoc = rbml::Doc::new(data); reader::maybe_get_doc(cratedoc, tag_crate_crate_name).map(|doc| { doc.as_str_slice().to_string() }) } pub fn get_crate_triple(data: &[u8]) -> Option { - let cratedoc = ebml::Doc::new(data); + let cratedoc = rbml::Doc::new(data); let triple_doc = reader::maybe_get_doc(cratedoc, tag_crate_triple); triple_doc.map(|s| s.as_str().to_string()) } @@ -1169,7 +1169,7 @@ pub fn get_crate_name(data: &[u8]) -> String { pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Writer) -> io::IoResult<()> { let hash = get_crate_hash(bytes); - let md = ebml::Doc::new(bytes); + let md = rbml::Doc::new(bytes); try!(list_crate_attributes(md, &hash, out)); list_crate_deps(bytes, out) } @@ -1196,7 +1196,7 @@ pub fn translate_def_id(cdata: Cmd, did: ast::DefId) -> ast::DefId { } pub fn each_impl(cdata: Cmd, callback: |ast::DefId|) { - let impls_doc = reader::get_doc(ebml::Doc::new(cdata.data()), tag_impls); + let impls_doc = reader::get_doc(rbml::Doc::new(cdata.data()), tag_impls); let _ = reader::tagged_docs(impls_doc, tag_impls_impl, |impl_doc| { callback(item_def_id(impl_doc, cdata)); true @@ -1252,7 +1252,7 @@ pub fn get_trait_of_method(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) pub fn get_native_libraries(cdata: Cmd) -> Vec<(cstore::NativeLibaryKind, String)> { - let libraries = reader::get_doc(ebml::Doc::new(cdata.data()), + let libraries = reader::get_doc(rbml::Doc::new(cdata.data()), tag_native_libraries); let mut result = Vec::new(); reader::tagged_docs(libraries, tag_native_libraries_lib, |lib_doc| { @@ -1268,12 +1268,12 @@ pub fn get_native_libraries(cdata: Cmd) } pub fn get_plugin_registrar_fn(data: &[u8]) -> Option { - reader::maybe_get_doc(ebml::Doc::new(data), tag_plugin_registrar_fn) + reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn) .map(|doc| FromPrimitive::from_u32(reader::doc_as_u32(doc)).unwrap()) } pub fn get_exported_macros(data: &[u8]) -> Vec { - let macros = reader::get_doc(ebml::Doc::new(data), + let macros = reader::get_doc(rbml::Doc::new(data), tag_exported_macros); let mut result = Vec::new(); reader::tagged_docs(macros, tag_macro_def, |macro_doc| { @@ -1286,7 +1286,7 @@ pub fn get_exported_macros(data: &[u8]) -> Vec { pub fn get_dylib_dependency_formats(cdata: Cmd) -> Vec<(ast::CrateNum, cstore::LinkagePreference)> { - let formats = reader::get_doc(ebml::Doc::new(cdata.data()), + let formats = reader::get_doc(rbml::Doc::new(cdata.data()), tag_dylib_dependency_formats); let mut result = Vec::new(); @@ -1312,7 +1312,7 @@ pub fn get_dylib_dependency_formats(cdata: Cmd) pub fn get_missing_lang_items(cdata: Cmd) -> Vec { - let items = reader::get_doc(ebml::Doc::new(cdata.data()), tag_lang_items); + let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_lang_items); let mut result = Vec::new(); reader::tagged_docs(items, tag_lang_items_missing, |missing_doc| { let item: lang_items::LangItem = @@ -1340,7 +1340,7 @@ pub fn get_method_arg_names(cdata: Cmd, id: ast::NodeId) -> Vec { pub fn get_reachable_extern_fns(cdata: Cmd) -> Vec { let mut ret = Vec::new(); - let items = reader::get_doc(ebml::Doc::new(cdata.data()), + let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_reachable_extern_fns); reader::tagged_docs(items, tag_reachable_extern_fn_id, |doc| { ret.push(ast::DefId { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index dbda4f58d96..40da534bfab 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -52,7 +52,7 @@ use syntax::parse::token; use syntax::visit::Visitor; use syntax::visit; use syntax; -use writer = serialize::ebml::writer; +use rbml::writer; /// A borrowed version of ast::InlinedItem. pub enum InlinedItemRef<'a> { @@ -64,7 +64,7 @@ pub enum InlinedItemRef<'a> { pub type Encoder<'a> = writer::Encoder<'a, SeekableMemWriter>; pub type EncodeInlinedItem<'a> = |ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ii: InlinedItemRef|: 'a; pub struct EncodeParams<'a> { @@ -92,16 +92,16 @@ pub struct EncodeContext<'a> { pub reachable: &'a NodeSet, } -fn encode_name(ebml_w: &mut Encoder, name: Name) { - ebml_w.wr_tagged_str(tag_paths_data_name, token::get_name(name).get()); +fn encode_name(rbml_w: &mut Encoder, name: Name) { + rbml_w.wr_tagged_str(tag_paths_data_name, token::get_name(name).get()); } -fn encode_impl_type_basename(ebml_w: &mut Encoder, name: Ident) { - ebml_w.wr_tagged_str(tag_item_impl_type_basename, token::get_ident(name).get()); +fn encode_impl_type_basename(rbml_w: &mut Encoder, name: Ident) { + rbml_w.wr_tagged_str(tag_item_impl_type_basename, token::get_ident(name).get()); } -pub fn encode_def_id(ebml_w: &mut Encoder, id: DefId) { - ebml_w.wr_tagged_str(tag_def_id, def_to_string(id).as_slice()); +pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) { + rbml_w.wr_tagged_str(tag_def_id, def_to_string(id).as_slice()); } #[deriving(Clone)] @@ -110,7 +110,7 @@ struct entry { pos: u64 } -fn encode_trait_ref(ebml_w: &mut Encoder, +fn encode_trait_ref(rbml_w: &mut Encoder, ecx: &EncodeContext, trait_ref: &ty::TraitRef, tag: uint) { @@ -121,31 +121,31 @@ fn encode_trait_ref(ebml_w: &mut Encoder, abbrevs: &ecx.type_abbrevs }; - ebml_w.start_tag(tag); - tyencode::enc_trait_ref(ebml_w.writer, ty_str_ctxt, trait_ref); - ebml_w.end_tag(); + rbml_w.start_tag(tag); + tyencode::enc_trait_ref(rbml_w.writer, ty_str_ctxt, trait_ref); + rbml_w.end_tag(); } -fn encode_impl_vtables(ebml_w: &mut Encoder, +fn encode_impl_vtables(rbml_w: &mut Encoder, ecx: &EncodeContext, vtables: &typeck::vtable_res) { - ebml_w.start_tag(tag_item_impl_vtables); - astencode::encode_vtable_res(ecx, ebml_w, vtables); - ebml_w.end_tag(); + rbml_w.start_tag(tag_item_impl_vtables); + astencode::encode_vtable_res(ecx, rbml_w, vtables); + rbml_w.end_tag(); } // Item info table encoding -fn encode_family(ebml_w: &mut Encoder, c: char) { - ebml_w.start_tag(tag_items_data_item_family); - ebml_w.writer.write(&[c as u8]); - ebml_w.end_tag(); +fn encode_family(rbml_w: &mut Encoder, c: char) { + rbml_w.start_tag(tag_items_data_item_family); + rbml_w.writer.write(&[c as u8]); + rbml_w.end_tag(); } pub fn def_to_string(did: DefId) -> String { format!("{}:{}", did.krate, did.node) } -fn encode_ty_type_param_defs(ebml_w: &mut Encoder, +fn encode_ty_type_param_defs(rbml_w: &mut Encoder, ecx: &EncodeContext, params: &VecPerParamSpace, tag: uint) { @@ -156,61 +156,61 @@ fn encode_ty_type_param_defs(ebml_w: &mut Encoder, abbrevs: &ecx.type_abbrevs }; for param in params.iter() { - ebml_w.start_tag(tag); - tyencode::enc_type_param_def(ebml_w.writer, ty_str_ctxt, param); - ebml_w.end_tag(); + rbml_w.start_tag(tag); + tyencode::enc_type_param_def(rbml_w.writer, ty_str_ctxt, param); + rbml_w.end_tag(); } } -fn encode_region_param_defs(ebml_w: &mut Encoder, +fn encode_region_param_defs(rbml_w: &mut Encoder, params: &VecPerParamSpace) { for param in params.iter() { - ebml_w.start_tag(tag_region_param_def); + rbml_w.start_tag(tag_region_param_def); - ebml_w.start_tag(tag_region_param_def_ident); - encode_name(ebml_w, param.name); - ebml_w.end_tag(); + rbml_w.start_tag(tag_region_param_def_ident); + encode_name(rbml_w, param.name); + rbml_w.end_tag(); - ebml_w.wr_tagged_str(tag_region_param_def_def_id, + rbml_w.wr_tagged_str(tag_region_param_def_def_id, def_to_string(param.def_id).as_slice()); - ebml_w.wr_tagged_u64(tag_region_param_def_space, + rbml_w.wr_tagged_u64(tag_region_param_def_space, param.space.to_uint() as u64); - ebml_w.wr_tagged_u64(tag_region_param_def_index, + rbml_w.wr_tagged_u64(tag_region_param_def_index, param.index as u64); - ebml_w.end_tag(); + rbml_w.end_tag(); } } -fn encode_item_variances(ebml_w: &mut Encoder, +fn encode_item_variances(rbml_w: &mut Encoder, ecx: &EncodeContext, id: ast::NodeId) { let v = ty::item_variances(ecx.tcx, ast_util::local_def(id)); - ebml_w.start_tag(tag_item_variances); - v.encode(ebml_w); - ebml_w.end_tag(); + rbml_w.start_tag(tag_item_variances); + v.encode(rbml_w); + rbml_w.end_tag(); } -fn encode_bounds_and_type(ebml_w: &mut Encoder, +fn encode_bounds_and_type(rbml_w: &mut Encoder, ecx: &EncodeContext, pty: &ty::Polytype) { - encode_ty_type_param_defs(ebml_w, ecx, &pty.generics.types, + encode_ty_type_param_defs(rbml_w, ecx, &pty.generics.types, tag_items_data_item_ty_param_bounds); - encode_region_param_defs(ebml_w, &pty.generics.regions); - encode_type(ecx, ebml_w, pty.ty); + encode_region_param_defs(rbml_w, &pty.generics.regions); + encode_type(ecx, rbml_w, pty.ty); } -fn encode_variant_id(ebml_w: &mut Encoder, vid: DefId) { - ebml_w.start_tag(tag_items_data_item_variant); +fn encode_variant_id(rbml_w: &mut Encoder, vid: DefId) { + rbml_w.start_tag(tag_items_data_item_variant); let s = def_to_string(vid); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); } pub fn write_closure_type(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, closure_type: &ty::ClosureTy) { let ty_str_ctxt = &tyencode::ctxt { diag: ecx.diag, @@ -218,11 +218,11 @@ pub fn write_closure_type(ecx: &EncodeContext, tcx: ecx.tcx, abbrevs: &ecx.type_abbrevs }; - tyencode::enc_closure_ty(ebml_w.writer, ty_str_ctxt, closure_type); + tyencode::enc_closure_ty(rbml_w.writer, ty_str_ctxt, closure_type); } pub fn write_type(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, typ: ty::t) { let ty_str_ctxt = &tyencode::ctxt { diag: ecx.diag, @@ -230,21 +230,21 @@ pub fn write_type(ecx: &EncodeContext, tcx: ecx.tcx, abbrevs: &ecx.type_abbrevs }; - tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ); + tyencode::enc_ty(rbml_w.writer, ty_str_ctxt, typ); } fn encode_type(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, typ: ty::t) { - ebml_w.start_tag(tag_items_data_item_type); - write_type(ecx, ebml_w, typ); - ebml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_type); + write_type(ecx, rbml_w, typ); + rbml_w.end_tag(); } fn encode_method_fty(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, typ: &ty::BareFnTy) { - ebml_w.start_tag(tag_item_method_fty); + rbml_w.start_tag(tag_item_method_fty); let ty_str_ctxt = &tyencode::ctxt { diag: ecx.diag, @@ -252,66 +252,66 @@ fn encode_method_fty(ecx: &EncodeContext, tcx: ecx.tcx, abbrevs: &ecx.type_abbrevs }; - tyencode::enc_bare_fn_ty(ebml_w.writer, ty_str_ctxt, typ); + tyencode::enc_bare_fn_ty(rbml_w.writer, ty_str_ctxt, typ); - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_symbol(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, id: NodeId) { - ebml_w.start_tag(tag_items_data_item_symbol); + rbml_w.start_tag(tag_items_data_item_symbol); match ecx.item_symbols.borrow().find(&id) { Some(x) => { debug!("encode_symbol(id={:?}, str={})", id, *x); - ebml_w.writer.write(x.as_bytes()); + rbml_w.writer.write(x.as_bytes()); } None => { ecx.diag.handler().bug( format!("encode_symbol: id not found {}", id).as_slice()); } } - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_disr_val(_: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, disr_val: ty::Disr) { - ebml_w.start_tag(tag_disr_val); + rbml_w.start_tag(tag_disr_val); let s = disr_val.to_string(); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); } -fn encode_parent_item(ebml_w: &mut Encoder, id: DefId) { - ebml_w.start_tag(tag_items_data_parent_item); +fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) { + rbml_w.start_tag(tag_items_data_parent_item); let s = def_to_string(id); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); } -fn encode_struct_fields(ebml_w: &mut Encoder, +fn encode_struct_fields(rbml_w: &mut Encoder, fields: &[ty::field_ty], origin: DefId) { for f in fields.iter() { if f.name == special_idents::unnamed_field.name { - ebml_w.start_tag(tag_item_unnamed_field); + rbml_w.start_tag(tag_item_unnamed_field); } else { - ebml_w.start_tag(tag_item_field); - encode_name(ebml_w, f.name); + rbml_w.start_tag(tag_item_field); + encode_name(rbml_w, f.name); } - encode_struct_field_family(ebml_w, f.vis); - encode_def_id(ebml_w, f.id); - ebml_w.start_tag(tag_item_field_origin); + encode_struct_field_family(rbml_w, f.vis); + encode_def_id(rbml_w, f.id); + rbml_w.start_tag(tag_item_field_origin); let s = def_to_string(origin); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); + rbml_w.end_tag(); } } fn encode_enum_variant_info(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, id: NodeId, variants: &[P], index: &mut Vec>) { @@ -325,82 +325,82 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let def_id = local_def(variant.node.id); index.push(entry { val: variant.node.id as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); match variant.node.kind { - ast::TupleVariantKind(_) => encode_family(ebml_w, 'v'), - ast::StructVariantKind(_) => encode_family(ebml_w, 'V') + ast::TupleVariantKind(_) => encode_family(rbml_w, 'v'), + ast::StructVariantKind(_) => encode_family(rbml_w, 'V') } - encode_name(ebml_w, variant.node.name.name); - encode_parent_item(ebml_w, local_def(id)); - encode_visibility(ebml_w, variant.node.vis); - encode_attributes(ebml_w, variant.node.attrs.as_slice()); + encode_name(rbml_w, variant.node.name.name); + encode_parent_item(rbml_w, local_def(id)); + encode_visibility(rbml_w, variant.node.vis); + encode_attributes(rbml_w, variant.node.attrs.as_slice()); let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id)); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); match variant.node.kind { ast::TupleVariantKind(_) => {}, ast::StructVariantKind(_) => { let fields = ty::lookup_struct_fields(ecx.tcx, def_id); let idx = encode_info_for_struct(ecx, - ebml_w, + rbml_w, fields.as_slice(), index); - encode_struct_fields(ebml_w, fields.as_slice(), def_id); - encode_index(ebml_w, idx, write_i64); + encode_struct_fields(rbml_w, fields.as_slice(), def_id); + encode_index(rbml_w, idx, write_i64); } } if vi.get(i).disr_val != disr_val { - encode_disr_val(ecx, ebml_w, vi.get(i).disr_val); + encode_disr_val(ecx, rbml_w, vi.get(i).disr_val); disr_val = vi.get(i).disr_val; } - encode_bounds_and_type(ebml_w, ecx, + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(ecx.tcx, def_id)); - ecx.tcx.map.with_path(variant.node.id, |path| encode_path(ebml_w, path)); - ebml_w.end_tag(); + ecx.tcx.map.with_path(variant.node.id, |path| encode_path(rbml_w, path)); + rbml_w.end_tag(); disr_val += 1; i += 1; } } -fn encode_path + Clone>(ebml_w: &mut Encoder, +fn encode_path + Clone>(rbml_w: &mut Encoder, mut path: PI) { - ebml_w.start_tag(tag_path); - ebml_w.wr_tagged_u32(tag_path_len, path.clone().count() as u32); + rbml_w.start_tag(tag_path); + rbml_w.wr_tagged_u32(tag_path_len, path.clone().count() as u32); for pe in path { let tag = match pe { ast_map::PathMod(_) => tag_path_elem_mod, ast_map::PathName(_) => tag_path_elem_name }; - ebml_w.wr_tagged_str(tag, token::get_name(pe.name()).get()); + rbml_w.wr_tagged_str(tag, token::get_name(pe.name()).get()); } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_reexported_static_method(ebml_w: &mut Encoder, +fn encode_reexported_static_method(rbml_w: &mut Encoder, exp: &middle::resolve::Export2, method_def_id: DefId, method_ident: Ident) { debug!("(encode reexported static method) {}::{}", exp.name, token::get_ident(method_ident)); - ebml_w.start_tag(tag_items_data_item_reexport); - ebml_w.start_tag(tag_items_data_item_reexport_def_id); - ebml_w.wr_str(def_to_string(method_def_id).as_slice()); - ebml_w.end_tag(); - ebml_w.start_tag(tag_items_data_item_reexport_name); - ebml_w.wr_str(format!("{}::{}", + rbml_w.start_tag(tag_items_data_item_reexport); + rbml_w.start_tag(tag_items_data_item_reexport_def_id); + rbml_w.wr_str(def_to_string(method_def_id).as_slice()); + rbml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_reexport_name); + rbml_w.wr_str(format!("{}::{}", exp.name, token::get_ident(method_ident)).as_slice()); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.end_tag(); + rbml_w.end_tag(); } fn encode_reexported_static_base_methods(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, exp: &middle::resolve::Export2) -> bool { let impl_methods = ecx.tcx.impl_methods.borrow(); @@ -410,7 +410,7 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext, for &method_did in impl_methods.get(base_impl_did).iter() { let m = ty::method(ecx.tcx, method_did); if m.explicit_self == ty::StaticExplicitSelfCategory { - encode_reexported_static_method(ebml_w, exp, m.def_id, m.ident); + encode_reexported_static_method(rbml_w, exp, m.def_id, m.ident); } } } @@ -422,14 +422,14 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext, } fn encode_reexported_static_trait_methods(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, exp: &middle::resolve::Export2) -> bool { match ecx.tcx.trait_methods_cache.borrow().find(&exp.def_id) { Some(methods) => { for m in methods.iter() { if m.explicit_self == ty::StaticExplicitSelfCategory { - encode_reexported_static_method(ebml_w, exp, m.def_id, m.ident); + encode_reexported_static_method(rbml_w, exp, m.def_id, m.ident); } } @@ -440,7 +440,7 @@ fn encode_reexported_static_trait_methods(ecx: &EncodeContext, } fn encode_reexported_static_methods(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, mod_path: PathElems, exp: &middle::resolve::Export2) { match ecx.tcx.map.find(exp.def_id.node) { @@ -469,8 +469,8 @@ fn encode_reexported_static_methods(ecx: &EncodeContext, // but not yet for Foo. // if path_differs || original_name.get() != exp.name.as_slice() { - if !encode_reexported_static_base_methods(ecx, ebml_w, exp) { - if encode_reexported_static_trait_methods(ecx, ebml_w, exp) { + if !encode_reexported_static_base_methods(ecx, rbml_w, exp) { + if encode_reexported_static_trait_methods(ecx, rbml_w, exp) { debug!("(encode reexported static methods) {} \ [trait]", original_name); @@ -520,7 +520,7 @@ fn each_auxiliary_node_id(item: Gc, callback: |NodeId| -> bool) -> bool { } fn encode_reexports(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, id: NodeId, path: PathElems) { debug!("(encoding info for module) encoding reexports for {}", id); @@ -534,15 +534,15 @@ fn encode_reexports(ecx: &EncodeContext, exp.def_id.krate, exp.def_id.node, id); - ebml_w.start_tag(tag_items_data_item_reexport); - ebml_w.start_tag(tag_items_data_item_reexport_def_id); - ebml_w.wr_str(def_to_string(exp.def_id).as_slice()); - ebml_w.end_tag(); - ebml_w.start_tag(tag_items_data_item_reexport_name); - ebml_w.wr_str(exp.name.as_slice()); - ebml_w.end_tag(); - ebml_w.end_tag(); - encode_reexported_static_methods(ecx, ebml_w, path.clone(), exp); + rbml_w.start_tag(tag_items_data_item_reexport); + rbml_w.start_tag(tag_items_data_item_reexport_def_id); + rbml_w.wr_str(def_to_string(exp.def_id).as_slice()); + rbml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_reexport_name); + rbml_w.wr_str(exp.name.as_slice()); + rbml_w.end_tag(); + rbml_w.end_tag(); + encode_reexported_static_methods(ecx, rbml_w, path.clone(), exp); } } None => { @@ -553,30 +553,30 @@ fn encode_reexports(ecx: &EncodeContext, } fn encode_info_for_mod(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, md: &Mod, attrs: &[Attribute], id: NodeId, path: PathElems, name: Ident, vis: Visibility) { - 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.name); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, local_def(id)); + encode_family(rbml_w, 'm'); + encode_name(rbml_w, name.name); debug!("(encoding info for module) encoding info for module ID {}", id); // Encode info about all the module children. for item in md.items.iter() { - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(local_def(item.id)).as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(local_def(item.id)).as_slice()); + rbml_w.end_tag(); each_auxiliary_node_id(*item, |auxiliary_node_id| { - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(local_def( + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(local_def( auxiliary_node_id)).as_slice()); - ebml_w.end_tag(); + rbml_w.end_tag(); true }); @@ -588,100 +588,100 @@ fn encode_info_for_mod(ecx: &EncodeContext, token::get_ident(ident), did, ecx.tcx.map.node_to_string(did)); - ebml_w.start_tag(tag_mod_impl); - ebml_w.wr_str(def_to_string(local_def(did)).as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_mod_impl); + rbml_w.wr_str(def_to_string(local_def(did)).as_slice()); + rbml_w.end_tag(); } _ => {} } } - encode_path(ebml_w, path.clone()); - encode_visibility(ebml_w, vis); + encode_path(rbml_w, path.clone()); + encode_visibility(rbml_w, vis); let stab = stability::lookup(ecx.tcx, ast_util::local_def(id)); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); // Encode the reexports of this module, if this module is public. if vis == Public { debug!("(encoding info for module) encoding reexports for {}", id); - encode_reexports(ecx, ebml_w, id, path); + encode_reexports(ecx, rbml_w, id, path); } - encode_attributes(ebml_w, attrs); + encode_attributes(rbml_w, attrs); - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_struct_field_family(ebml_w: &mut Encoder, +fn encode_struct_field_family(rbml_w: &mut Encoder, visibility: Visibility) { - encode_family(ebml_w, match visibility { + encode_family(rbml_w, match visibility { Public => 'g', Inherited => 'N' }); } -fn encode_visibility(ebml_w: &mut Encoder, visibility: Visibility) { - ebml_w.start_tag(tag_items_data_item_visibility); +fn encode_visibility(rbml_w: &mut Encoder, visibility: Visibility) { + rbml_w.start_tag(tag_items_data_item_visibility); let ch = match visibility { Public => 'y', Inherited => 'i', }; - ebml_w.wr_str(ch.to_string().as_slice()); - ebml_w.end_tag(); + rbml_w.wr_str(ch.to_string().as_slice()); + rbml_w.end_tag(); } -fn encode_explicit_self(ebml_w: &mut Encoder, +fn encode_explicit_self(rbml_w: &mut Encoder, explicit_self: &ty::ExplicitSelfCategory) { - ebml_w.start_tag(tag_item_trait_method_explicit_self); + rbml_w.start_tag(tag_item_trait_method_explicit_self); // Encode the base self type. match *explicit_self { ty::StaticExplicitSelfCategory => { - ebml_w.writer.write(&[ 's' as u8 ]); + rbml_w.writer.write(&[ 's' as u8 ]); } ty::ByValueExplicitSelfCategory => { - ebml_w.writer.write(&[ 'v' as u8 ]); + rbml_w.writer.write(&[ 'v' as u8 ]); } ty::ByBoxExplicitSelfCategory => { - ebml_w.writer.write(&[ '~' as u8 ]); + rbml_w.writer.write(&[ '~' as u8 ]); } ty::ByReferenceExplicitSelfCategory(_, m) => { // FIXME(#4846) encode custom lifetime - ebml_w.writer.write(&['&' as u8]); - encode_mutability(ebml_w, m); + rbml_w.writer.write(&['&' as u8]); + encode_mutability(rbml_w, m); } } - ebml_w.end_tag(); + rbml_w.end_tag(); - fn encode_mutability(ebml_w: &mut Encoder, + fn encode_mutability(rbml_w: &mut Encoder, m: ast::Mutability) { match m { - MutImmutable => { ebml_w.writer.write(&[ 'i' as u8 ]); } - MutMutable => { ebml_w.writer.write(&[ 'm' as u8 ]); } + MutImmutable => { rbml_w.writer.write(&[ 'i' as u8 ]); } + MutMutable => { rbml_w.writer.write(&[ 'm' as u8 ]); } } } } -fn encode_method_sort(ebml_w: &mut Encoder, sort: char) { - ebml_w.start_tag(tag_item_trait_method_sort); - ebml_w.writer.write(&[ sort as u8 ]); - ebml_w.end_tag(); +fn encode_method_sort(rbml_w: &mut Encoder, sort: char) { + rbml_w.start_tag(tag_item_trait_method_sort); + rbml_w.writer.write(&[ sort as u8 ]); + rbml_w.end_tag(); } -fn encode_provided_source(ebml_w: &mut Encoder, +fn encode_provided_source(rbml_w: &mut Encoder, source_opt: Option) { for source in source_opt.iter() { - ebml_w.start_tag(tag_item_method_provided_source); + rbml_w.start_tag(tag_item_method_provided_source); let s = def_to_string(*source); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); } } /* Returns an index of items in this class */ fn encode_info_for_struct(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, fields: &[ty::field_ty], global_index: &mut Vec>) -> Vec> { @@ -695,86 +695,86 @@ fn encode_info_for_struct(ecx: &EncodeContext, let nm = field.name; let id = field.id.node; - index.push(entry {val: id as i64, pos: ebml_w.writer.tell().unwrap()}); + index.push(entry {val: id as i64, pos: rbml_w.writer.tell().unwrap()}); global_index.push(entry { val: id as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); - ebml_w.start_tag(tag_items_data_item); + rbml_w.start_tag(tag_items_data_item); debug!("encode_info_for_struct: doing {} {}", token::get_name(nm), id); - encode_struct_field_family(ebml_w, field.vis); - encode_name(ebml_w, nm); - encode_type(ecx, ebml_w, node_id_to_type(tcx, id)); - encode_def_id(ebml_w, local_def(id)); + encode_struct_field_family(rbml_w, field.vis); + encode_name(rbml_w, nm); + encode_type(ecx, rbml_w, node_id_to_type(tcx, id)); + encode_def_id(rbml_w, local_def(id)); let stab = stability::lookup(ecx.tcx, field.id); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); - ebml_w.end_tag(); + rbml_w.end_tag(); } index } fn encode_info_for_struct_ctor(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, name: ast::Ident, ctor_id: NodeId, index: &mut Vec>, struct_id: NodeId) { index.push(entry { val: ctor_id as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, local_def(ctor_id)); - encode_family(ebml_w, 'f'); - encode_bounds_and_type(ebml_w, ecx, + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, local_def(ctor_id)); + encode_family(rbml_w, 'f'); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(ecx.tcx, local_def(ctor_id))); - encode_name(ebml_w, name.name); - encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, ctor_id)); - ecx.tcx.map.with_path(ctor_id, |path| encode_path(ebml_w, path)); - encode_parent_item(ebml_w, local_def(struct_id)); + encode_name(rbml_w, name.name); + encode_type(ecx, rbml_w, node_id_to_type(ecx.tcx, ctor_id)); + ecx.tcx.map.with_path(ctor_id, |path| encode_path(rbml_w, path)); + encode_parent_item(rbml_w, local_def(struct_id)); if ecx.item_symbols.borrow().contains_key(&ctor_id) { - encode_symbol(ecx, ebml_w, ctor_id); + encode_symbol(ecx, rbml_w, ctor_id); } let stab = stability::lookup(ecx.tcx, ast_util::local_def(ctor_id)); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); // indicate that this is a tuple struct ctor, because downstream users will normally want // the tuple struct definition, but without this there is no way for them to tell that // they actually have a ctor rather than a normal function - ebml_w.start_tag(tag_items_data_item_is_tuple_struct_ctor); - ebml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_is_tuple_struct_ctor); + rbml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_method_ty_fields(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, method_ty: &ty::Method) { - encode_def_id(ebml_w, method_ty.def_id); - encode_name(ebml_w, method_ty.ident.name); - encode_ty_type_param_defs(ebml_w, ecx, &method_ty.generics.types, + encode_def_id(rbml_w, method_ty.def_id); + encode_name(rbml_w, method_ty.ident.name); + encode_ty_type_param_defs(rbml_w, ecx, &method_ty.generics.types, tag_item_method_tps); - encode_method_fty(ecx, ebml_w, &method_ty.fty); - encode_visibility(ebml_w, method_ty.vis); - encode_explicit_self(ebml_w, &method_ty.explicit_self); + encode_method_fty(ecx, rbml_w, &method_ty.fty); + encode_visibility(rbml_w, method_ty.vis); + encode_explicit_self(rbml_w, &method_ty.explicit_self); let fn_style = method_ty.fty.fn_style; match method_ty.explicit_self { ty::StaticExplicitSelfCategory => { - encode_family(ebml_w, fn_style_static_method_family(fn_style)); + encode_family(rbml_w, fn_style_static_method_family(fn_style)); } - _ => encode_family(ebml_w, style_fn_family(fn_style)) + _ => encode_family(rbml_w, style_fn_family(fn_style)) } - encode_provided_source(ebml_w, method_ty.provided_source); + encode_provided_source(rbml_w, method_ty.provided_source); } fn encode_info_for_method(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, m: &ty::Method, impl_path: PathElems, is_default_impl: bool, @@ -783,23 +783,23 @@ fn encode_info_for_method(ecx: &EncodeContext, debug!("encode_info_for_method: {:?} {}", m.def_id, token::get_ident(m.ident)); - ebml_w.start_tag(tag_items_data_item); + rbml_w.start_tag(tag_items_data_item); - encode_method_ty_fields(ecx, ebml_w, m); - encode_parent_item(ebml_w, local_def(parent_id)); + encode_method_ty_fields(ecx, rbml_w, m); + encode_parent_item(rbml_w, local_def(parent_id)); let stab = stability::lookup(ecx.tcx, m.def_id); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); // The type for methods gets encoded twice, which is unfortunate. let pty = lookup_item_type(ecx.tcx, m.def_id); - encode_bounds_and_type(ebml_w, ecx, &pty); + encode_bounds_and_type(rbml_w, ecx, &pty); let elem = ast_map::PathName(m.ident.name); - encode_path(ebml_w, impl_path.chain(Some(elem).move_iter())); + encode_path(rbml_w, impl_path.chain(Some(elem).move_iter())); match ast_method_opt { Some(ast_method) => { - encode_attributes(ebml_w, ast_method.attrs.as_slice()) + encode_attributes(rbml_w, ast_method.attrs.as_slice()) } None => () } @@ -807,41 +807,41 @@ fn encode_info_for_method(ecx: &EncodeContext, for &ast_method in ast_method_opt.iter() { let any_types = !pty.generics.types.is_empty(); if any_types || is_default_impl || should_inline(ast_method.attrs.as_slice()) { - encode_inlined_item(ecx, ebml_w, + encode_inlined_item(ecx, rbml_w, IIMethodRef(local_def(parent_id), false, &*ast_method)); } else { - encode_symbol(ecx, ebml_w, m.def_id.node); + encode_symbol(ecx, rbml_w, m.def_id.node); } - encode_method_argument_names(ebml_w, &*ast_method.pe_fn_decl()); + encode_method_argument_names(rbml_w, &*ast_method.pe_fn_decl()); } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_method_argument_names(ebml_w: &mut Encoder, +fn encode_method_argument_names(rbml_w: &mut Encoder, decl: &ast::FnDecl) { - ebml_w.start_tag(tag_method_argument_names); + rbml_w.start_tag(tag_method_argument_names); for arg in decl.inputs.iter() { - ebml_w.start_tag(tag_method_argument_name); + rbml_w.start_tag(tag_method_argument_name); match arg.pat.node { ast::PatIdent(_, ref path1, _) => { let name = token::get_ident(path1.node); - ebml_w.writer.write(name.get().as_bytes()); + rbml_w.writer.write(name.get().as_bytes()); } _ => {} } - ebml_w.end_tag(); + rbml_w.end_tag(); } - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_inlined_item(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ii: InlinedItemRef) { let mut eii = ecx.encode_inlined_item.borrow_mut(); let eii: &mut EncodeInlinedItem = &mut *eii; - (*eii)(ecx, ebml_w, ii) + (*eii)(ecx, rbml_w, ii) } fn style_fn_family(s: FnStyle) -> char { @@ -869,15 +869,15 @@ fn should_inline(attrs: &[Attribute]) -> bool { // Encodes the inherent implementations of a structure, enumeration, or trait. fn encode_inherent_implementations(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, def_id: DefId) { match ecx.tcx.inherent_impls.borrow().find(&def_id) { None => {} Some(implementations) => { for &impl_def_id in implementations.borrow().iter() { - ebml_w.start_tag(tag_items_data_item_inherent_impl); - encode_def_id(ebml_w, impl_def_id); - ebml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_inherent_impl); + encode_def_id(rbml_w, impl_def_id); + rbml_w.end_tag(); } } } @@ -885,41 +885,41 @@ fn encode_inherent_implementations(ecx: &EncodeContext, // Encodes the implementations of a trait defined in this crate. fn encode_extension_implementations(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, trait_def_id: DefId) { match ecx.tcx.trait_impls.borrow().find(&trait_def_id) { None => {} Some(implementations) => { for &impl_def_id in implementations.borrow().iter() { - ebml_w.start_tag(tag_items_data_item_extension_impl); - encode_def_id(ebml_w, impl_def_id); - ebml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_extension_impl); + encode_def_id(rbml_w, impl_def_id); + rbml_w.end_tag(); } } } } -fn encode_stability(ebml_w: &mut Encoder, stab_opt: Option) { +fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option) { stab_opt.map(|stab| { - ebml_w.start_tag(tag_items_data_item_stability); - stab.encode(ebml_w).unwrap(); - ebml_w.end_tag(); + rbml_w.start_tag(tag_items_data_item_stability); + stab.encode(rbml_w).unwrap(); + rbml_w.end_tag(); }); } fn encode_info_for_item(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, item: &Item, index: &mut Vec>, path: PathElems, vis: ast::Visibility) { let tcx = ecx.tcx; - fn add_to_index(item: &Item, ebml_w: &Encoder, + fn add_to_index(item: &Item, rbml_w: &Encoder, index: &mut Vec>) { index.push(entry { val: item.id as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); } @@ -931,52 +931,52 @@ fn encode_info_for_item(ecx: &EncodeContext, match item.node { ItemStatic(_, m, _) => { - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); if m == ast::MutMutable { - encode_family(ebml_w, 'b'); + encode_family(rbml_w, 'b'); } else { - encode_family(ebml_w, 'c'); + encode_family(rbml_w, 'c'); } - encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id)); - encode_symbol(ecx, ebml_w, item.id); - encode_name(ebml_w, item.ident.name); - encode_path(ebml_w, path); + encode_type(ecx, rbml_w, node_id_to_type(tcx, item.id)); + encode_symbol(ecx, rbml_w, item.id); + encode_name(rbml_w, item.ident.name); + encode_path(rbml_w, path); let inlineable = !ecx.non_inlineable_statics.borrow().contains(&item.id); if inlineable { - encode_inlined_item(ecx, ebml_w, IIItemRef(item)); + encode_inlined_item(ecx, rbml_w, IIItemRef(item)); } - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); - ebml_w.end_tag(); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); + rbml_w.end_tag(); } ItemFn(ref decl, fn_style, _, ref generics, _) => { - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, style_fn_family(fn_style)); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, style_fn_family(fn_style)); let tps_len = generics.ty_params.len(); - encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id)); - encode_name(ebml_w, item.ident.name); - encode_path(ebml_w, path); - encode_attributes(ebml_w, item.attrs.as_slice()); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); + encode_name(rbml_w, item.ident.name); + encode_path(rbml_w, path); + encode_attributes(rbml_w, item.attrs.as_slice()); if tps_len > 0u || should_inline(item.attrs.as_slice()) { - encode_inlined_item(ecx, ebml_w, IIItemRef(item)); + encode_inlined_item(ecx, rbml_w, IIItemRef(item)); } else { - encode_symbol(ecx, ebml_w, item.id); + encode_symbol(ecx, rbml_w, item.id); } - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); - encode_method_argument_names(ebml_w, &**decl); - ebml_w.end_tag(); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); + encode_method_argument_names(rbml_w, &**decl); + rbml_w.end_tag(); } ItemMod(ref m) => { - add_to_index(item, ebml_w, index); + add_to_index(item, rbml_w, index); encode_info_for_mod(ecx, - ebml_w, + rbml_w, m, item.attrs.as_slice(), item.id, @@ -985,60 +985,60 @@ fn encode_info_for_item(ecx: &EncodeContext, item.vis); } ItemForeignMod(ref fm) => { - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 'n'); - encode_name(ebml_w, item.ident.name); - encode_path(ebml_w, path); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 'n'); + encode_name(rbml_w, item.ident.name); + encode_path(rbml_w, path); // Encode all the items in this module. for foreign_item in fm.items.iter() { - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(local_def(foreign_item.id)).as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(local_def(foreign_item.id)).as_slice()); + rbml_w.end_tag(); } - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); - ebml_w.end_tag(); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); + rbml_w.end_tag(); } ItemTy(..) => { - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 'y'); - encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id)); - encode_name(ebml_w, item.ident.name); - encode_path(ebml_w, path); - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); - ebml_w.end_tag(); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 'y'); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); + encode_name(rbml_w, item.ident.name); + encode_path(rbml_w, path); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); + rbml_w.end_tag(); } ItemEnum(ref enum_definition, _) => { - add_to_index(item, ebml_w, index); + add_to_index(item, rbml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 't'); - encode_item_variances(ebml_w, ecx, item.id); - encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id)); - encode_name(ebml_w, item.ident.name); - encode_attributes(ebml_w, item.attrs.as_slice()); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 't'); + encode_item_variances(rbml_w, ecx, item.id); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); + encode_name(rbml_w, item.ident.name); + encode_attributes(rbml_w, item.attrs.as_slice()); for v in (*enum_definition).variants.iter() { - encode_variant_id(ebml_w, local_def(v.node.id)); + encode_variant_id(rbml_w, local_def(v.node.id)); } - encode_inlined_item(ecx, ebml_w, IIItemRef(item)); - encode_path(ebml_w, path); + encode_inlined_item(ecx, rbml_w, IIItemRef(item)); + encode_path(rbml_w, path); // Encode inherent implementations for this enumeration. - encode_inherent_implementations(ecx, ebml_w, def_id); + encode_inherent_implementations(ecx, rbml_w, def_id); - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); - ebml_w.end_tag(); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); + rbml_w.end_tag(); encode_enum_variant_info(ecx, - ebml_w, + rbml_w, item.id, (*enum_definition).variants.as_slice(), index); @@ -1051,44 +1051,44 @@ fn encode_info_for_item(ecx: &EncodeContext, the index, and the index needs to be in the item for the class itself */ let idx = encode_info_for_struct(ecx, - ebml_w, + rbml_w, fields.as_slice(), index); /* Index the class*/ - add_to_index(item, ebml_w, index); + add_to_index(item, rbml_w, index); /* Now, make an item for the class itself */ - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 'S'); - encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id)); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 'S'); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); - encode_item_variances(ebml_w, ecx, item.id); - encode_name(ebml_w, item.ident.name); - encode_attributes(ebml_w, item.attrs.as_slice()); - encode_path(ebml_w, path.clone()); - encode_stability(ebml_w, stab); - encode_visibility(ebml_w, vis); + encode_item_variances(rbml_w, ecx, item.id); + encode_name(rbml_w, item.ident.name); + encode_attributes(rbml_w, item.attrs.as_slice()); + encode_path(rbml_w, path.clone()); + encode_stability(rbml_w, stab); + encode_visibility(rbml_w, vis); /* Encode def_ids for each field and method for methods, write all the stuff get_trait_method needs to know*/ - encode_struct_fields(ebml_w, fields.as_slice(), def_id); + encode_struct_fields(rbml_w, fields.as_slice(), def_id); - encode_inlined_item(ecx, ebml_w, IIItemRef(item)); + encode_inlined_item(ecx, rbml_w, IIItemRef(item)); // Encode inherent implementations for this structure. - encode_inherent_implementations(ecx, ebml_w, def_id); + encode_inherent_implementations(ecx, rbml_w, def_id); /* Each class has its own index -- encode it */ - encode_index(ebml_w, idx, write_i64); - ebml_w.end_tag(); + encode_index(rbml_w, idx, write_i64); + rbml_w.end_tag(); // If this is a tuple-like struct, encode the type of the constructor. match struct_def.ctor_id { Some(ctor_id) => { - encode_info_for_struct_ctor(ecx, ebml_w, item.ident, + encode_info_for_struct_ctor(ecx, rbml_w, item.ident, ctor_id, index, def_id.node); } None => {} @@ -1100,38 +1100,38 @@ fn encode_info_for_item(ecx: &EncodeContext, let impl_methods = tcx.impl_methods.borrow(); let methods = impl_methods.get(&def_id); - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 'i'); - encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id)); - encode_name(ebml_w, item.ident.name); - encode_attributes(ebml_w, item.attrs.as_slice()); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 'i'); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id)); + encode_name(rbml_w, item.ident.name); + encode_attributes(rbml_w, item.attrs.as_slice()); match ty.node { ast::TyPath(ref path, ref bounds, _) if path.segments .len() == 1 => { let ident = path.segments.last().unwrap().identifier; assert!(bounds.is_none()); - encode_impl_type_basename(ebml_w, ident); + encode_impl_type_basename(rbml_w, ident); } _ => {} } for &method_def_id in methods.iter() { - ebml_w.start_tag(tag_item_impl_method); + rbml_w.start_tag(tag_item_impl_method); let s = def_to_string(method_def_id); - ebml_w.writer.write(s.as_bytes()); - ebml_w.end_tag(); + rbml_w.writer.write(s.as_bytes()); + rbml_w.end_tag(); } for ast_trait_ref in opt_trait.iter() { let trait_ref = ty::node_id_to_trait_ref( tcx, ast_trait_ref.ref_id); - encode_trait_ref(ebml_w, ecx, &*trait_ref, tag_item_trait_ref); + encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_trait_ref); let impl_vtables = ty::lookup_impl_vtables(tcx, def_id); - encode_impl_vtables(ebml_w, ecx, &impl_vtables); + encode_impl_vtables(rbml_w, ecx, &impl_vtables); } - encode_path(ebml_w, path.clone()); - encode_stability(ebml_w, stab); - ebml_w.end_tag(); + encode_path(rbml_w, path.clone()); + encode_stability(rbml_w, stab); + rbml_w.end_tag(); // Iterate down the methods, emitting them. We rely on the // assumption that all of the actually implemented methods @@ -1145,10 +1145,10 @@ fn encode_info_for_item(ecx: &EncodeContext, index.push(entry { val: method_def_id.node as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); encode_info_for_method(ecx, - ebml_w, + rbml_w, &*ty::method(tcx, method_def_id), path.clone(), false, @@ -1157,43 +1157,43 @@ fn encode_info_for_item(ecx: &EncodeContext, } } ItemTrait(_, _, ref super_traits, ref ms) => { - add_to_index(item, ebml_w, index); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, def_id); - encode_family(ebml_w, 'I'); - encode_item_variances(ebml_w, ecx, item.id); + add_to_index(item, rbml_w, index); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, def_id); + encode_family(rbml_w, 'I'); + encode_item_variances(rbml_w, ecx, item.id); let trait_def = ty::lookup_trait_def(tcx, def_id); - encode_ty_type_param_defs(ebml_w, ecx, + encode_ty_type_param_defs(rbml_w, ecx, &trait_def.generics.types, tag_items_data_item_ty_param_bounds); - encode_region_param_defs(ebml_w, &trait_def.generics.regions); - encode_trait_ref(ebml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref); - encode_name(ebml_w, item.ident.name); - encode_attributes(ebml_w, item.attrs.as_slice()); - encode_visibility(ebml_w, vis); - encode_stability(ebml_w, stab); + encode_region_param_defs(rbml_w, &trait_def.generics.regions); + encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref); + encode_name(rbml_w, item.ident.name); + encode_attributes(rbml_w, item.attrs.as_slice()); + encode_visibility(rbml_w, vis); + encode_stability(rbml_w, stab); for &method_def_id in ty::trait_method_def_ids(tcx, def_id).iter() { - ebml_w.start_tag(tag_item_trait_method); - encode_def_id(ebml_w, method_def_id); - ebml_w.end_tag(); + rbml_w.start_tag(tag_item_trait_method); + encode_def_id(rbml_w, method_def_id); + rbml_w.end_tag(); - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(method_def_id).as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(method_def_id).as_slice()); + rbml_w.end_tag(); } - encode_path(ebml_w, path.clone()); + encode_path(rbml_w, path.clone()); // FIXME(#8559): This should use the tcx's supertrait cache instead of // reading the AST's list, because the former has already filtered out // the builtin-kinds-as-supertraits. See corresponding fixme in decoder. for ast_trait_ref in super_traits.iter() { let trait_ref = ty::node_id_to_trait_ref(ecx.tcx, ast_trait_ref.ref_id); - encode_trait_ref(ebml_w, ecx, &*trait_ref, tag_item_super_trait_ref); + encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_super_trait_ref); } // Encode the implementations of this trait. - encode_extension_implementations(ecx, ebml_w, def_id); + encode_extension_implementations(ecx, rbml_w, def_id); - ebml_w.end_tag(); + rbml_w.end_tag(); // Now output the method info for each method. let r = ty::trait_method_def_ids(tcx, def_id); @@ -1204,32 +1204,32 @@ fn encode_info_for_item(ecx: &EncodeContext, index.push(entry { val: method_def_id.node as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); - ebml_w.start_tag(tag_items_data_item); + rbml_w.start_tag(tag_items_data_item); - encode_method_ty_fields(ecx, ebml_w, &*method_ty); - encode_parent_item(ebml_w, def_id); + encode_method_ty_fields(ecx, rbml_w, &*method_ty); + encode_parent_item(rbml_w, def_id); let stab = stability::lookup(tcx, method_def_id); - encode_stability(ebml_w, stab); + encode_stability(rbml_w, stab); let elem = ast_map::PathName(method_ty.ident.name); - encode_path(ebml_w, path.clone().chain(Some(elem).move_iter())); + encode_path(rbml_w, path.clone().chain(Some(elem).move_iter())); match method_ty.explicit_self { ty::StaticExplicitSelfCategory => { - encode_family(ebml_w, + encode_family(rbml_w, fn_style_static_method_family( method_ty.fty.fn_style)); let pty = ty::lookup_item_type(tcx, method_def_id); - encode_bounds_and_type(ebml_w, ecx, &pty); + encode_bounds_and_type(rbml_w, ecx, &pty); } _ => { - encode_family(ebml_w, + encode_family(rbml_w, style_fn_family( method_ty.fty.fn_style)); } @@ -1237,32 +1237,32 @@ fn encode_info_for_item(ecx: &EncodeContext, match ms.get(i) { &Required(ref tm) => { - encode_attributes(ebml_w, tm.attrs.as_slice()); - encode_method_sort(ebml_w, 'r'); - encode_method_argument_names(ebml_w, &*tm.decl); + encode_attributes(rbml_w, tm.attrs.as_slice()); + encode_method_sort(rbml_w, 'r'); + encode_method_argument_names(rbml_w, &*tm.decl); } &Provided(m) => { - encode_attributes(ebml_w, m.attrs.as_slice()); + encode_attributes(rbml_w, m.attrs.as_slice()); // If this is a static method, we've already encoded // this. if method_ty.explicit_self != ty::StaticExplicitSelfCategory { // FIXME: I feel like there is something funny going on. let pty = ty::lookup_item_type(tcx, method_def_id); - encode_bounds_and_type(ebml_w, ecx, &pty); + encode_bounds_and_type(rbml_w, ecx, &pty); } - encode_method_sort(ebml_w, 'p'); - encode_inlined_item(ecx, ebml_w, + encode_method_sort(rbml_w, 'p'); + encode_inlined_item(ecx, rbml_w, IIMethodRef(def_id, true, &*m)); - encode_method_argument_names(ebml_w, &*m.pe_fn_decl()); + encode_method_argument_names(rbml_w, &*m.pe_fn_decl()); } } - ebml_w.end_tag(); + rbml_w.end_tag(); } // Encode inherent implementations for this trait. - encode_inherent_implementations(ecx, ebml_w, def_id); + encode_inherent_implementations(ecx, rbml_w, def_id); } ItemMac(..) => { // macros are encoded separately @@ -1271,61 +1271,61 @@ fn encode_info_for_item(ecx: &EncodeContext, } fn encode_info_for_foreign_item(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, nitem: &ForeignItem, index: &mut Vec>, path: PathElems, abi: abi::Abi) { index.push(entry { val: nitem.id as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, local_def(nitem.id)); + rbml_w.start_tag(tag_items_data_item); + encode_def_id(rbml_w, local_def(nitem.id)); match nitem.node { ForeignItemFn(..) => { - encode_family(ebml_w, style_fn_family(NormalFn)); - encode_bounds_and_type(ebml_w, ecx, + encode_family(rbml_w, style_fn_family(NormalFn)); + encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(ecx.tcx,local_def(nitem.id))); - encode_name(ebml_w, nitem.ident.name); + encode_name(rbml_w, nitem.ident.name); if abi == abi::RustIntrinsic { - encode_inlined_item(ecx, ebml_w, IIForeignRef(nitem)); + encode_inlined_item(ecx, rbml_w, IIForeignRef(nitem)); } else { - encode_symbol(ecx, ebml_w, nitem.id); + encode_symbol(ecx, rbml_w, nitem.id); } } ForeignItemStatic(_, mutbl) => { if mutbl { - encode_family(ebml_w, 'b'); + encode_family(rbml_w, 'b'); } else { - encode_family(ebml_w, 'c'); + encode_family(rbml_w, 'c'); } - encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id)); - encode_symbol(ecx, ebml_w, nitem.id); - encode_name(ebml_w, nitem.ident.name); + encode_type(ecx, rbml_w, node_id_to_type(ecx.tcx, nitem.id)); + encode_symbol(ecx, rbml_w, nitem.id); + encode_name(rbml_w, nitem.ident.name); } } - encode_path(ebml_w, path); - ebml_w.end_tag(); + encode_path(rbml_w, path); + rbml_w.end_tag(); } fn my_visit_expr(_e: &Expr) { } fn my_visit_item(i: &Item, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ecx_ptr: *const int, index: &mut Vec>) { - let mut ebml_w = unsafe { ebml_w.unsafe_clone() }; + let mut rbml_w = unsafe { rbml_w.unsafe_clone() }; // See above let ecx: &EncodeContext = unsafe { mem::transmute(ecx_ptr) }; ecx.tcx.map.with_path(i.id, |path| { - encode_info_for_item(ecx, &mut ebml_w, i, index, path, i.vis); + encode_info_for_item(ecx, &mut rbml_w, i, index, path, i.vis); }); } fn my_visit_foreign_item(ni: &ForeignItem, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ecx_ptr:*const int, index: &mut Vec>) { // See above @@ -1334,19 +1334,19 @@ fn my_visit_foreign_item(ni: &ForeignItem, ecx.tcx.map.path_to_string(ni.id), token::get_ident(ni.ident)); - let mut ebml_w = unsafe { - ebml_w.unsafe_clone() + let mut rbml_w = unsafe { + rbml_w.unsafe_clone() }; let abi = ecx.tcx.map.get_foreign_abi(ni.id); ecx.tcx.map.with_path(ni.id, |path| { - encode_info_for_foreign_item(ecx, &mut ebml_w, + encode_info_for_foreign_item(ecx, &mut rbml_w, ni, index, path, abi); }); } struct EncodeVisitor<'a,'b> { - ebml_w_for_visit_item: &'a mut Encoder<'b>, + rbml_w_for_visit_item: &'a mut Encoder<'b>, ecx_ptr:*const int, index: &'a mut Vec>, } @@ -1359,31 +1359,31 @@ impl<'a,'b> visit::Visitor<()> for EncodeVisitor<'a,'b> { fn visit_item(&mut self, i: &Item, _: ()) { visit::walk_item(self, i, ()); my_visit_item(i, - self.ebml_w_for_visit_item, + self.rbml_w_for_visit_item, self.ecx_ptr, self.index); } fn visit_foreign_item(&mut self, ni: &ForeignItem, _: ()) { visit::walk_foreign_item(self, ni, ()); my_visit_foreign_item(ni, - self.ebml_w_for_visit_item, + self.rbml_w_for_visit_item, self.ecx_ptr, self.index); } } fn encode_info_for_items(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, krate: &Crate) -> Vec> { let mut index = Vec::new(); - ebml_w.start_tag(tag_items_data); + rbml_w.start_tag(tag_items_data); index.push(entry { val: CRATE_NODE_ID as i64, - pos: ebml_w.writer.tell().unwrap(), + pos: rbml_w.writer.tell().unwrap(), }); encode_info_for_mod(ecx, - ebml_w, + rbml_w, &krate.module, &[], CRATE_NODE_ID, @@ -1396,17 +1396,17 @@ fn encode_info_for_items(ecx: &EncodeContext, visit::walk_crate(&mut EncodeVisitor { index: &mut index, ecx_ptr: ecx_ptr, - ebml_w_for_visit_item: &mut *ebml_w, + rbml_w_for_visit_item: &mut *rbml_w, }, krate, ()); - ebml_w.end_tag(); + rbml_w.end_tag(); index } // Path and definition ID indexing -fn encode_index(ebml_w: &mut Encoder, index: Vec>, +fn encode_index(rbml_w: &mut Encoder, index: Vec>, write_fn: |&mut SeekableMemWriter, &T|) { let mut buckets: Vec>> = Vec::from_fn(256, |_| Vec::new()); for elt in index.move_iter() { @@ -1414,33 +1414,33 @@ fn encode_index(ebml_w: &mut Encoder, index: Vec>, buckets.get_mut(h % 256).push(elt); } - ebml_w.start_tag(tag_index); + rbml_w.start_tag(tag_index); let mut bucket_locs = Vec::new(); - ebml_w.start_tag(tag_index_buckets); + rbml_w.start_tag(tag_index_buckets); for bucket in buckets.iter() { - bucket_locs.push(ebml_w.writer.tell().unwrap()); - ebml_w.start_tag(tag_index_buckets_bucket); + bucket_locs.push(rbml_w.writer.tell().unwrap()); + rbml_w.start_tag(tag_index_buckets_bucket); for elt in bucket.iter() { - ebml_w.start_tag(tag_index_buckets_bucket_elt); + rbml_w.start_tag(tag_index_buckets_bucket_elt); assert!(elt.pos < 0xffff_ffff); { - let wr: &mut SeekableMemWriter = ebml_w.writer; + let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(elt.pos as u32); } - write_fn(ebml_w.writer, &elt.val); - ebml_w.end_tag(); + write_fn(rbml_w.writer, &elt.val); + rbml_w.end_tag(); } - ebml_w.end_tag(); + rbml_w.end_tag(); } - ebml_w.end_tag(); - ebml_w.start_tag(tag_index_table); + rbml_w.end_tag(); + rbml_w.start_tag(tag_index_table); for pos in bucket_locs.iter() { assert!(*pos < 0xffff_ffff); - let wr: &mut SeekableMemWriter = ebml_w.writer; + let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(*pos as u32); } - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.end_tag(); + rbml_w.end_tag(); } fn write_i64(writer: &mut SeekableMemWriter, &n: &i64) { @@ -1449,55 +1449,55 @@ fn write_i64(writer: &mut SeekableMemWriter, &n: &i64) { wr.write_be_u32(n as u32); } -fn encode_meta_item(ebml_w: &mut Encoder, mi: Gc) { +fn encode_meta_item(rbml_w: &mut Encoder, mi: Gc) { match mi.node { MetaWord(ref name) => { - ebml_w.start_tag(tag_meta_item_word); - ebml_w.start_tag(tag_meta_item_name); - ebml_w.writer.write(name.get().as_bytes()); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.start_tag(tag_meta_item_word); + rbml_w.start_tag(tag_meta_item_name); + rbml_w.writer.write(name.get().as_bytes()); + rbml_w.end_tag(); + rbml_w.end_tag(); } MetaNameValue(ref name, ref value) => { match value.node { LitStr(ref value, _) => { - ebml_w.start_tag(tag_meta_item_name_value); - ebml_w.start_tag(tag_meta_item_name); - ebml_w.writer.write(name.get().as_bytes()); - ebml_w.end_tag(); - ebml_w.start_tag(tag_meta_item_value); - ebml_w.writer.write(value.get().as_bytes()); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.start_tag(tag_meta_item_name_value); + rbml_w.start_tag(tag_meta_item_name); + rbml_w.writer.write(name.get().as_bytes()); + rbml_w.end_tag(); + rbml_w.start_tag(tag_meta_item_value); + rbml_w.writer.write(value.get().as_bytes()); + rbml_w.end_tag(); + rbml_w.end_tag(); } _ => {/* FIXME (#623): encode other variants */ } } } MetaList(ref name, ref items) => { - ebml_w.start_tag(tag_meta_item_list); - ebml_w.start_tag(tag_meta_item_name); - ebml_w.writer.write(name.get().as_bytes()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_meta_item_list); + rbml_w.start_tag(tag_meta_item_name); + rbml_w.writer.write(name.get().as_bytes()); + rbml_w.end_tag(); for inner_item in items.iter() { - encode_meta_item(ebml_w, *inner_item); + encode_meta_item(rbml_w, *inner_item); } - ebml_w.end_tag(); + rbml_w.end_tag(); } } } -fn encode_attributes(ebml_w: &mut Encoder, attrs: &[Attribute]) { - ebml_w.start_tag(tag_attributes); +fn encode_attributes(rbml_w: &mut Encoder, attrs: &[Attribute]) { + rbml_w.start_tag(tag_attributes); for attr in attrs.iter() { - ebml_w.start_tag(tag_attribute); - ebml_w.wr_tagged_u8(tag_attribute_is_sugared_doc, attr.node.is_sugared_doc as u8); - encode_meta_item(ebml_w, attr.node.value); - ebml_w.end_tag(); + rbml_w.start_tag(tag_attribute); + rbml_w.wr_tagged_u8(tag_attribute_is_sugared_doc, attr.node.is_sugared_doc as u8); + encode_meta_item(rbml_w, attr.node.value); + rbml_w.end_tag(); } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_crate_deps(ebml_w: &mut Encoder, cstore: &cstore::CStore) { +fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { fn get_ordered_deps(cstore: &cstore::CStore) -> Vec { // Pull the cnums and name,vers,hash out of cstore let mut deps = Vec::new(); @@ -1527,77 +1527,77 @@ fn encode_crate_deps(ebml_w: &mut Encoder, cstore: &cstore::CStore) { // the assumption that they are numbered 1 to n. // FIXME (#2166): 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); + rbml_w.start_tag(tag_crate_deps); let r = get_ordered_deps(cstore); for dep in r.iter() { - encode_crate_dep(ebml_w, (*dep).clone()); + encode_crate_dep(rbml_w, (*dep).clone()); } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut Encoder) { - ebml_w.start_tag(tag_lang_items); +fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { + rbml_w.start_tag(tag_lang_items); for (i, def_id) in ecx.tcx.lang_items.items() { for id in def_id.iter() { if id.krate == LOCAL_CRATE { - ebml_w.start_tag(tag_lang_items_item); + rbml_w.start_tag(tag_lang_items_item); - ebml_w.start_tag(tag_lang_items_item_id); + rbml_w.start_tag(tag_lang_items_item_id); { - let wr: &mut SeekableMemWriter = ebml_w.writer; + let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(i as u32); } - ebml_w.end_tag(); // tag_lang_items_item_id + rbml_w.end_tag(); // tag_lang_items_item_id - ebml_w.start_tag(tag_lang_items_item_node_id); + rbml_w.start_tag(tag_lang_items_item_node_id); { - let wr: &mut SeekableMemWriter = ebml_w.writer; + let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(id.node as u32); } - ebml_w.end_tag(); // tag_lang_items_item_node_id + rbml_w.end_tag(); // tag_lang_items_item_node_id - ebml_w.end_tag(); // tag_lang_items_item + rbml_w.end_tag(); // tag_lang_items_item } } } for i in ecx.tcx.lang_items.missing.iter() { - ebml_w.wr_tagged_u32(tag_lang_items_missing, *i as u32); + rbml_w.wr_tagged_u32(tag_lang_items_missing, *i as u32); } - ebml_w.end_tag(); // tag_lang_items + rbml_w.end_tag(); // tag_lang_items } -fn encode_native_libraries(ecx: &EncodeContext, ebml_w: &mut Encoder) { - ebml_w.start_tag(tag_native_libraries); +fn encode_native_libraries(ecx: &EncodeContext, rbml_w: &mut Encoder) { + rbml_w.start_tag(tag_native_libraries); for &(ref lib, kind) in ecx.tcx.sess.cstore.get_used_libraries() .borrow().iter() { match kind { cstore::NativeStatic => {} // these libraries are not propagated cstore::NativeFramework | cstore::NativeUnknown => { - ebml_w.start_tag(tag_native_libraries_lib); + rbml_w.start_tag(tag_native_libraries_lib); - ebml_w.start_tag(tag_native_libraries_kind); - ebml_w.writer.write_be_u32(kind as u32); - ebml_w.end_tag(); + rbml_w.start_tag(tag_native_libraries_kind); + rbml_w.writer.write_be_u32(kind as u32); + rbml_w.end_tag(); - ebml_w.start_tag(tag_native_libraries_name); - ebml_w.writer.write(lib.as_bytes()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_native_libraries_name); + rbml_w.writer.write(lib.as_bytes()); + rbml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.end_tag(); } } } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_plugin_registrar_fn(ecx: &EncodeContext, ebml_w: &mut Encoder) { +fn encode_plugin_registrar_fn(ecx: &EncodeContext, rbml_w: &mut Encoder) { match ecx.tcx.sess.plugin_registrar_fn.get() { - Some(id) => { ebml_w.wr_tagged_u32(tag_plugin_registrar_fn, id); } + Some(id) => { rbml_w.wr_tagged_u32(tag_plugin_registrar_fn, id); } None => {} } } @@ -1605,72 +1605,72 @@ fn encode_plugin_registrar_fn(ecx: &EncodeContext, ebml_w: &mut Encoder) { /// Given a span, write the text of that span into the output stream /// as an exported macro fn encode_macro_def(ecx: &EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, span: &syntax::codemap::Span) { let def = ecx.tcx.sess.codemap().span_to_snippet(*span) .expect("Unable to find source for macro"); - ebml_w.start_tag(tag_macro_def); - ebml_w.wr_str(def.as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_macro_def); + rbml_w.wr_str(def.as_slice()); + rbml_w.end_tag(); } /// Serialize the text of the exported macros fn encode_macro_defs(ecx: &EncodeContext, krate: &Crate, - ebml_w: &mut Encoder) { - ebml_w.start_tag(tag_exported_macros); + rbml_w: &mut Encoder) { + rbml_w.start_tag(tag_exported_macros); for item in krate.exported_macros.iter() { - encode_macro_def(ecx, ebml_w, &item.span); + encode_macro_def(ecx, rbml_w, &item.span); } - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_unboxed_closures<'a>( ecx: &'a EncodeContext, - ebml_w: &'a mut Encoder) { - ebml_w.start_tag(tag_unboxed_closures); + rbml_w: &'a mut Encoder) { + rbml_w.start_tag(tag_unboxed_closures); for (unboxed_closure_id, unboxed_closure_type) in ecx.tcx.unboxed_closure_types.borrow().iter() { if unboxed_closure_id.krate != LOCAL_CRATE { continue } - ebml_w.start_tag(tag_unboxed_closure); - encode_def_id(ebml_w, *unboxed_closure_id); - ebml_w.start_tag(tag_unboxed_closure_type); - write_closure_type(ecx, ebml_w, unboxed_closure_type); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.start_tag(tag_unboxed_closure); + encode_def_id(rbml_w, *unboxed_closure_id); + rbml_w.start_tag(tag_unboxed_closure_type); + write_closure_type(ecx, rbml_w, unboxed_closure_type); + rbml_w.end_tag(); + rbml_w.end_tag(); } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_struct_field_attrs(ebml_w: &mut Encoder, krate: &Crate) { +fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &Crate) { struct StructFieldVisitor<'a, 'b> { - ebml_w: &'a mut Encoder<'b>, + rbml_w: &'a mut Encoder<'b>, } impl<'a, 'b> Visitor<()> for StructFieldVisitor<'a, 'b> { fn visit_struct_field(&mut self, field: &ast::StructField, _: ()) { - self.ebml_w.start_tag(tag_struct_field); - self.ebml_w.wr_tagged_u32(tag_struct_field_id, field.node.id); - encode_attributes(self.ebml_w, field.node.attrs.as_slice()); - self.ebml_w.end_tag(); + self.rbml_w.start_tag(tag_struct_field); + self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id); + encode_attributes(self.rbml_w, field.node.attrs.as_slice()); + self.rbml_w.end_tag(); } } - ebml_w.start_tag(tag_struct_fields); + rbml_w.start_tag(tag_struct_fields); visit::walk_crate(&mut StructFieldVisitor { - ebml_w: ebml_w + rbml_w: rbml_w }, krate, ()); - ebml_w.end_tag(); + rbml_w.end_tag(); } struct ImplVisitor<'a,'b,'c> { ecx: &'a EncodeContext<'b>, - ebml_w: &'a mut Encoder<'c>, + rbml_w: &'a mut Encoder<'c>, } impl<'a,'b,'c> Visitor<()> for ImplVisitor<'a,'b,'c> { @@ -1685,9 +1685,9 @@ impl<'a,'b,'c> Visitor<()> for ImplVisitor<'a,'b,'c> { // or if the trait is not defined in this crate. if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() || def_id.krate != LOCAL_CRATE { - self.ebml_w.start_tag(tag_impls_impl); - encode_def_id(self.ebml_w, local_def(item.id)); - self.ebml_w.end_tag(); + self.rbml_w.start_tag(tag_impls_impl); + encode_def_id(self.rbml_w, local_def(item.id)); + self.rbml_w.end_tag(); } } _ => {} @@ -1708,55 +1708,55 @@ impl<'a,'b,'c> Visitor<()> for ImplVisitor<'a,'b,'c> { /// * Implementations of traits not defined in this crate. fn encode_impls<'a>(ecx: &'a EncodeContext, krate: &Crate, - ebml_w: &'a mut Encoder) { - ebml_w.start_tag(tag_impls); + rbml_w: &'a mut Encoder) { + rbml_w.start_tag(tag_impls); { let mut visitor = ImplVisitor { ecx: ecx, - ebml_w: ebml_w, + rbml_w: rbml_w, }; visit::walk_crate(&mut visitor, krate, ()); } - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_misc_info(ecx: &EncodeContext, krate: &Crate, - ebml_w: &mut Encoder) { - ebml_w.start_tag(tag_misc_info); - ebml_w.start_tag(tag_misc_info_crate_items); + rbml_w: &mut Encoder) { + rbml_w.start_tag(tag_misc_info); + rbml_w.start_tag(tag_misc_info_crate_items); for &item in krate.module.items.iter() { - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(local_def(item.id)).as_slice()); - ebml_w.end_tag(); + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(local_def(item.id)).as_slice()); + rbml_w.end_tag(); each_auxiliary_node_id(item, |auxiliary_node_id| { - ebml_w.start_tag(tag_mod_child); - ebml_w.wr_str(def_to_string(local_def( + rbml_w.start_tag(tag_mod_child); + rbml_w.wr_str(def_to_string(local_def( auxiliary_node_id)).as_slice()); - ebml_w.end_tag(); + rbml_w.end_tag(); true }); } // Encode reexports for the root module. - encode_reexports(ecx, ebml_w, 0, ast_map::Values([].iter()).chain(None)); + encode_reexports(ecx, rbml_w, 0, ast_map::Values([].iter()).chain(None)); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_reachable_extern_fns(ecx: &EncodeContext, ebml_w: &mut Encoder) { - ebml_w.start_tag(tag_reachable_extern_fns); +fn encode_reachable_extern_fns(ecx: &EncodeContext, rbml_w: &mut Encoder) { + rbml_w.start_tag(tag_reachable_extern_fns); for id in ecx.reachable.iter() { match ecx.tcx.map.find(*id) { Some(ast_map::NodeItem(i)) => { match i.node { ast::ItemFn(_, _, abi, _, _) if abi != abi::Rust => { - ebml_w.wr_tagged_u32(tag_reachable_extern_fn_id, *id); + rbml_w.wr_tagged_u32(tag_reachable_extern_fn_id, *id); } _ => {} } @@ -1765,41 +1765,41 @@ fn encode_reachable_extern_fns(ecx: &EncodeContext, ebml_w: &mut Encoder) { } } - ebml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_crate_dep(ebml_w: &mut Encoder, +fn encode_crate_dep(rbml_w: &mut Encoder, dep: decoder::CrateDep) { - ebml_w.start_tag(tag_crate_dep); - ebml_w.start_tag(tag_crate_dep_crate_name); - ebml_w.writer.write(dep.name.as_bytes()); - ebml_w.end_tag(); - ebml_w.start_tag(tag_crate_dep_hash); - ebml_w.writer.write(dep.hash.as_str().as_bytes()); - ebml_w.end_tag(); - ebml_w.end_tag(); + rbml_w.start_tag(tag_crate_dep); + rbml_w.start_tag(tag_crate_dep_crate_name); + rbml_w.writer.write(dep.name.as_bytes()); + rbml_w.end_tag(); + rbml_w.start_tag(tag_crate_dep_hash); + rbml_w.writer.write(dep.hash.as_str().as_bytes()); + rbml_w.end_tag(); + rbml_w.end_tag(); } -fn encode_hash(ebml_w: &mut Encoder, hash: &Svh) { - ebml_w.start_tag(tag_crate_hash); - ebml_w.writer.write(hash.as_str().as_bytes()); - ebml_w.end_tag(); +fn encode_hash(rbml_w: &mut Encoder, hash: &Svh) { + rbml_w.start_tag(tag_crate_hash); + rbml_w.writer.write(hash.as_str().as_bytes()); + rbml_w.end_tag(); } -fn encode_crate_name(ebml_w: &mut Encoder, crate_name: &str) { - ebml_w.start_tag(tag_crate_crate_name); - ebml_w.writer.write(crate_name.as_bytes()); - ebml_w.end_tag(); +fn encode_crate_name(rbml_w: &mut Encoder, crate_name: &str) { + rbml_w.start_tag(tag_crate_crate_name); + rbml_w.writer.write(crate_name.as_bytes()); + rbml_w.end_tag(); } -fn encode_crate_triple(ebml_w: &mut Encoder, triple: &str) { - ebml_w.start_tag(tag_crate_triple); - ebml_w.writer.write(triple.as_bytes()); - ebml_w.end_tag(); +fn encode_crate_triple(rbml_w: &mut Encoder, triple: &str) { + rbml_w.start_tag(tag_crate_triple); + rbml_w.writer.write(triple.as_bytes()); + rbml_w.end_tag(); } -fn encode_dylib_dependency_formats(ebml_w: &mut Encoder, ecx: &EncodeContext) { - ebml_w.start_tag(tag_dylib_dependency_formats); +fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) { + rbml_w.start_tag(tag_dylib_dependency_formats); match ecx.tcx.dependency_formats.borrow().find(&config::CrateTypeDylib) { Some(arr) => { let s = arr.iter().enumerate().filter_map(|(i, slot)| { @@ -1808,11 +1808,11 @@ fn encode_dylib_dependency_formats(ebml_w: &mut Encoder, ecx: &EncodeContext) { cstore::RequireStatic => "s", })).to_string()) }).collect::>(); - ebml_w.writer.write(s.connect(",").as_bytes()); + rbml_w.writer.write(s.connect(",").as_bytes()); } None => {} } - ebml_w.end_tag(); + rbml_w.end_tag(); } // NB: Increment this as you change the metadata encoding version. @@ -1885,79 +1885,79 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate: reachable: reachable, }; - let mut ebml_w = writer::Encoder::new(wr); + let mut rbml_w = writer::Encoder::new(wr); - encode_crate_name(&mut ebml_w, ecx.link_meta.crate_name.as_slice()); - encode_crate_triple(&mut ebml_w, + encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name.as_slice()); + encode_crate_triple(&mut rbml_w, tcx.sess .targ_cfg .target_strs .target_triple .as_slice()); - encode_hash(&mut ebml_w, &ecx.link_meta.crate_hash); - encode_dylib_dependency_formats(&mut ebml_w, &ecx); + encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash); + encode_dylib_dependency_formats(&mut rbml_w, &ecx); - let mut i = ebml_w.writer.tell().unwrap(); - encode_attributes(&mut ebml_w, krate.attrs.as_slice()); - stats.attr_bytes = ebml_w.writer.tell().unwrap() - i; + let mut i = rbml_w.writer.tell().unwrap(); + encode_attributes(&mut rbml_w, krate.attrs.as_slice()); + stats.attr_bytes = rbml_w.writer.tell().unwrap() - i; - i = ebml_w.writer.tell().unwrap(); - encode_crate_deps(&mut ebml_w, ecx.cstore); - stats.dep_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_crate_deps(&mut rbml_w, ecx.cstore); + stats.dep_bytes = rbml_w.writer.tell().unwrap() - i; // Encode the language items. - i = ebml_w.writer.tell().unwrap(); - encode_lang_items(&ecx, &mut ebml_w); - stats.lang_item_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_lang_items(&ecx, &mut rbml_w); + stats.lang_item_bytes = rbml_w.writer.tell().unwrap() - i; // Encode the native libraries used - i = ebml_w.writer.tell().unwrap(); - encode_native_libraries(&ecx, &mut ebml_w); - stats.native_lib_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_native_libraries(&ecx, &mut rbml_w); + stats.native_lib_bytes = rbml_w.writer.tell().unwrap() - i; // Encode the plugin registrar function - i = ebml_w.writer.tell().unwrap(); - encode_plugin_registrar_fn(&ecx, &mut ebml_w); - stats.plugin_registrar_fn_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_plugin_registrar_fn(&ecx, &mut rbml_w); + stats.plugin_registrar_fn_bytes = rbml_w.writer.tell().unwrap() - i; // Encode macro definitions - i = ebml_w.writer.tell().unwrap(); - encode_macro_defs(&ecx, krate, &mut ebml_w); - stats.macro_defs_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_macro_defs(&ecx, krate, &mut rbml_w); + stats.macro_defs_bytes = rbml_w.writer.tell().unwrap() - i; // Encode the types of all unboxed closures in this crate. - i = ebml_w.writer.tell().unwrap(); - encode_unboxed_closures(&ecx, &mut ebml_w); - stats.unboxed_closure_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_unboxed_closures(&ecx, &mut rbml_w); + stats.unboxed_closure_bytes = rbml_w.writer.tell().unwrap() - i; // Encode the def IDs of impls, for coherence checking. - i = ebml_w.writer.tell().unwrap(); - encode_impls(&ecx, krate, &mut ebml_w); - stats.impl_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_impls(&ecx, krate, &mut rbml_w); + stats.impl_bytes = rbml_w.writer.tell().unwrap() - i; // Encode miscellaneous info. - i = ebml_w.writer.tell().unwrap(); - encode_misc_info(&ecx, krate, &mut ebml_w); - encode_reachable_extern_fns(&ecx, &mut ebml_w); - stats.misc_bytes = ebml_w.writer.tell().unwrap() - i; + i = rbml_w.writer.tell().unwrap(); + encode_misc_info(&ecx, krate, &mut rbml_w); + encode_reachable_extern_fns(&ecx, &mut rbml_w); + stats.misc_bytes = rbml_w.writer.tell().unwrap() - i; // Encode and index the items. - ebml_w.start_tag(tag_items); - i = ebml_w.writer.tell().unwrap(); - let items_index = encode_info_for_items(&ecx, &mut ebml_w, krate); - stats.item_bytes = ebml_w.writer.tell().unwrap() - i; + rbml_w.start_tag(tag_items); + i = rbml_w.writer.tell().unwrap(); + let items_index = encode_info_for_items(&ecx, &mut rbml_w, krate); + stats.item_bytes = rbml_w.writer.tell().unwrap() - i; - i = ebml_w.writer.tell().unwrap(); - encode_index(&mut ebml_w, items_index, write_i64); - stats.index_bytes = ebml_w.writer.tell().unwrap() - i; - ebml_w.end_tag(); + i = rbml_w.writer.tell().unwrap(); + encode_index(&mut rbml_w, items_index, write_i64); + stats.index_bytes = rbml_w.writer.tell().unwrap() - i; + rbml_w.end_tag(); - encode_struct_field_attrs(&mut ebml_w, krate); + encode_struct_field_attrs(&mut rbml_w, krate); - stats.total_bytes = ebml_w.writer.tell().unwrap(); + stats.total_bytes = rbml_w.writer.tell().unwrap(); if tcx.sess.meta_stats() { - for e in ebml_w.writer.get_ref().iter() { + for e in rbml_w.writer.get_ref().iter() { if *e == 0 { stats.zero_bytes += 1; } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 9a587dd7741..98111c7c4cf 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -43,12 +43,11 @@ use std::io::Seek; use std::mem; use std::gc::GC; -use serialize::ebml::reader; -use serialize::ebml; +use rbml::{reader, writer}; +use rbml; use serialize; use serialize::{Encoder, Encodable, EncoderHelpers, DecoderHelpers}; use serialize::{Decoder, Decodable}; -use writer = serialize::ebml::writer; #[cfg(test)] use syntax::parse; #[cfg(test)] use syntax::print::pprust; @@ -79,7 +78,7 @@ pub type Encoder<'a> = writer::Encoder<'a, SeekableMemWriter>; // Top-level methods. pub fn encode_inlined_item(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ii: e::InlinedItemRef) { let id = match ii { e::IIItemRef(i) => i.id, @@ -88,26 +87,26 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext, }; debug!("> Encoding inlined item: {} ({})", ecx.tcx.map.path_to_string(id), - ebml_w.writer.tell()); + rbml_w.writer.tell()); let ii = simplify_ast(ii); let id_range = ast_util::compute_id_range_for_inlined_item(&ii); - ebml_w.start_tag(c::tag_ast as uint); - id_range.encode(ebml_w); - encode_ast(ebml_w, ii); - encode_side_tables_for_ii(ecx, ebml_w, &ii); - ebml_w.end_tag(); + rbml_w.start_tag(c::tag_ast as uint); + id_range.encode(rbml_w); + encode_ast(rbml_w, ii); + encode_side_tables_for_ii(ecx, rbml_w, &ii); + rbml_w.end_tag(); debug!("< Encoded inlined fn: {} ({})", ecx.tcx.map.path_to_string(id), - ebml_w.writer.tell()); + rbml_w.writer.tell()); } pub fn decode_inlined_item(cdata: &cstore::crate_metadata, tcx: &ty::ctxt, path: Vec, - par_doc: ebml::Doc) + par_doc: rbml::Doc) -> Result> { let dcx = &DecodeContext { cdata: cdata, @@ -294,10 +293,10 @@ impl, E> def_id_decoder_helpers for D { // We also have to adjust the spans: for now we just insert a dummy span, // but eventually we should add entries to the local codemap as required. -fn encode_ast(ebml_w: &mut Encoder, item: ast::InlinedItem) { - ebml_w.start_tag(c::tag_tree as uint); - item.encode(ebml_w); - ebml_w.end_tag(); +fn encode_ast(rbml_w: &mut Encoder, item: ast::InlinedItem) { + rbml_w.start_tag(c::tag_tree as uint); + item.encode(rbml_w); + rbml_w.end_tag(); } struct NestedItemsDropper; @@ -353,7 +352,7 @@ fn simplify_ast(ii: e::InlinedItemRef) -> ast::InlinedItem { } } -fn decode_ast(par_doc: ebml::Doc) -> ast::InlinedItem { +fn decode_ast(par_doc: rbml::Doc) -> ast::InlinedItem { let chi_doc = par_doc.get(c::tag_tree as uint); let mut d = reader::Decoder::new(chi_doc); Decodable::decode(&mut d).unwrap() @@ -401,7 +400,7 @@ fn renumber_and_map_ast(xcx: &ExtendedDecodeContext, // ______________________________________________________________________ // Encoding and decoding of ast::def -fn decode_def(xcx: &ExtendedDecodeContext, doc: ebml::Doc) -> def::Def { +fn decode_def(xcx: &ExtendedDecodeContext, doc: rbml::Doc) -> def::Def { let mut dsr = reader::Decoder::new(doc); let def: def::Def = Decodable::decode(&mut dsr).unwrap(); def.tr(xcx) @@ -526,16 +525,16 @@ impl tr for ty::TraitStore { // ______________________________________________________________________ // Encoding and decoding of freevar information -fn encode_freevar_entry(ebml_w: &mut Encoder, fv: &freevar_entry) { - (*fv).encode(ebml_w).unwrap(); +fn encode_freevar_entry(rbml_w: &mut Encoder, fv: &freevar_entry) { + (*fv).encode(rbml_w).unwrap(); } -trait ebml_decoder_helper { +trait rbml_decoder_helper { fn read_freevar_entry(&mut self, xcx: &ExtendedDecodeContext) -> freevar_entry; } -impl<'a> ebml_decoder_helper for reader::Decoder<'a> { +impl<'a> rbml_decoder_helper for reader::Decoder<'a> { fn read_freevar_entry(&mut self, xcx: &ExtendedDecodeContext) -> freevar_entry { let fv: freevar_entry = Decodable::decode(self).unwrap(); @@ -561,21 +560,21 @@ trait read_method_callee_helper { } fn encode_method_callee(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, adjustment: typeck::ExprAdjustment, method: &MethodCallee) { - ebml_w.emit_struct("MethodCallee", 4, |ebml_w| { - ebml_w.emit_struct_field("adjustment", 0u, |ebml_w| { - adjustment.encode(ebml_w) + rbml_w.emit_struct("MethodCallee", 4, |rbml_w| { + rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| { + adjustment.encode(rbml_w) }); - ebml_w.emit_struct_field("origin", 1u, |ebml_w| { - method.origin.encode(ebml_w) + rbml_w.emit_struct_field("origin", 1u, |rbml_w| { + method.origin.encode(rbml_w) }); - ebml_w.emit_struct_field("ty", 2u, |ebml_w| { - Ok(ebml_w.emit_ty(ecx, method.ty)) + rbml_w.emit_struct_field("ty", 2u, |rbml_w| { + Ok(rbml_w.emit_ty(ecx, method.ty)) }); - ebml_w.emit_struct_field("substs", 3u, |ebml_w| { - Ok(ebml_w.emit_substs(ecx, &method.substs)) + rbml_w.emit_struct_field("substs", 3u, |rbml_w| { + Ok(rbml_w.emit_substs(ecx, &method.substs)) }) }).unwrap(); } @@ -636,81 +635,81 @@ impl tr for MethodOrigin { // Encoding and decoding vtable_res fn encode_vtable_res_with_key(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, adjustment: typeck::ExprAdjustment, dr: &typeck::vtable_res) { - ebml_w.emit_struct("VtableWithKey", 2, |ebml_w| { - ebml_w.emit_struct_field("adjustment", 0u, |ebml_w| { - adjustment.encode(ebml_w) + rbml_w.emit_struct("VtableWithKey", 2, |rbml_w| { + rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| { + adjustment.encode(rbml_w) }); - ebml_w.emit_struct_field("vtable_res", 1u, |ebml_w| { - Ok(encode_vtable_res(ecx, ebml_w, dr)) + rbml_w.emit_struct_field("vtable_res", 1u, |rbml_w| { + Ok(encode_vtable_res(ecx, rbml_w, dr)) }) }).unwrap() } pub fn encode_vtable_res(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, dr: &typeck::vtable_res) { // can't autogenerate this code because automatic code of // ty::t doesn't work, and there is no way (atm) to have // hand-written encoding routines combine with auto-generated // ones. perhaps we should fix this. encode_vec_per_param_space( - ebml_w, dr, - |ebml_w, param_tables| encode_vtable_param_res(ecx, ebml_w, + rbml_w, dr, + |rbml_w, param_tables| encode_vtable_param_res(ecx, rbml_w, param_tables)) } pub fn encode_vtable_param_res(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, param_tables: &typeck::vtable_param_res) { - ebml_w.emit_from_vec(param_tables.as_slice(), |ebml_w, vtable_origin| { - Ok(encode_vtable_origin(ecx, ebml_w, vtable_origin)) + rbml_w.emit_from_vec(param_tables.as_slice(), |rbml_w, vtable_origin| { + Ok(encode_vtable_origin(ecx, rbml_w, vtable_origin)) }).unwrap() } pub fn encode_vtable_origin(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, vtable_origin: &typeck::vtable_origin) { - ebml_w.emit_enum("vtable_origin", |ebml_w| { + rbml_w.emit_enum("vtable_origin", |rbml_w| { match *vtable_origin { typeck::vtable_static(def_id, ref substs, ref vtable_res) => { - ebml_w.emit_enum_variant("vtable_static", 0u, 3u, |ebml_w| { - ebml_w.emit_enum_variant_arg(0u, |ebml_w| { - Ok(ebml_w.emit_def_id(def_id)) + rbml_w.emit_enum_variant("vtable_static", 0u, 3u, |rbml_w| { + rbml_w.emit_enum_variant_arg(0u, |rbml_w| { + Ok(rbml_w.emit_def_id(def_id)) }); - ebml_w.emit_enum_variant_arg(1u, |ebml_w| { - Ok(ebml_w.emit_substs(ecx, substs)) + rbml_w.emit_enum_variant_arg(1u, |rbml_w| { + Ok(rbml_w.emit_substs(ecx, substs)) }); - ebml_w.emit_enum_variant_arg(2u, |ebml_w| { - Ok(encode_vtable_res(ecx, ebml_w, vtable_res)) + rbml_w.emit_enum_variant_arg(2u, |rbml_w| { + Ok(encode_vtable_res(ecx, rbml_w, vtable_res)) }) }) } typeck::vtable_param(pn, bn) => { - ebml_w.emit_enum_variant("vtable_param", 1u, 3u, |ebml_w| { - ebml_w.emit_enum_variant_arg(0u, |ebml_w| { - pn.encode(ebml_w) + rbml_w.emit_enum_variant("vtable_param", 1u, 3u, |rbml_w| { + rbml_w.emit_enum_variant_arg(0u, |rbml_w| { + pn.encode(rbml_w) }); - ebml_w.emit_enum_variant_arg(1u, |ebml_w| { - ebml_w.emit_uint(bn) + rbml_w.emit_enum_variant_arg(1u, |rbml_w| { + rbml_w.emit_uint(bn) }) }) } typeck::vtable_unboxed_closure(def_id) => { - ebml_w.emit_enum_variant("vtable_unboxed_closure", + rbml_w.emit_enum_variant("vtable_unboxed_closure", 2u, 1u, - |ebml_w| { - ebml_w.emit_enum_variant_arg(0u, |ebml_w| { - Ok(ebml_w.emit_def_id(def_id)) + |rbml_w| { + rbml_w.emit_enum_variant_arg(0u, |rbml_w| { + Ok(rbml_w.emit_def_id(def_id)) }) }) } typeck::vtable_error => { - ebml_w.emit_enum_variant("vtable_error", 3u, 3u, |_ebml_w| { + rbml_w.emit_enum_variant("vtable_error", 3u, 3u, |_rbml_w| { Ok(()) }) } @@ -831,12 +830,12 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { // ___________________________________________________________________________ // -fn encode_vec_per_param_space(ebml_w: &mut Encoder, +fn encode_vec_per_param_space(rbml_w: &mut Encoder, v: &subst::VecPerParamSpace, f: |&mut Encoder, &T|) { for &space in subst::ParamSpace::all().iter() { - ebml_w.emit_from_vec(v.get_slice(space), - |ebml_w, n| Ok(f(ebml_w, n))).unwrap(); + rbml_w.emit_from_vec(v.get_slice(space), + |rbml_w, n| Ok(f(rbml_w, n))).unwrap(); } } @@ -858,7 +857,7 @@ impl<'a> get_ty_str_ctxt for e::EncodeContext<'a> { } } -trait ebml_writer_helpers { +trait rbml_writer_helpers { fn emit_closure_type(&mut self, ecx: &e::EncodeContext, closure_type: &ty::ClosureTy); @@ -874,7 +873,7 @@ trait ebml_writer_helpers { fn emit_auto_adjustment(&mut self, ecx: &e::EncodeContext, adj: &ty::AutoAdjustment); } -impl<'a> ebml_writer_helpers for Encoder<'a> { +impl<'a> rbml_writer_helpers for Encoder<'a> { fn emit_closure_type(&mut self, ecx: &e::EncodeContext, closure_type: &ty::ClosureTy) { @@ -980,34 +979,34 @@ impl<'a> write_tag_and_id for Encoder<'a> { struct SideTableEncodingIdVisitor<'a,'b> { ecx_ptr: *const libc::c_void, - new_ebml_w: &'a mut Encoder<'b>, + new_rbml_w: &'a mut Encoder<'b>, } impl<'a,'b> ast_util::IdVisitingOperation for SideTableEncodingIdVisitor<'a,'b> { fn visit_id(&self, id: ast::NodeId) { - // Note: this will cause a copy of ebml_w, which is bad as + // Note: this will cause a copy of rbml_w, which is bad as // it is mutable. But I believe it's harmless since we generate // balanced EBML. // // FIXME(pcwalton): Don't copy this way. - let mut new_ebml_w = unsafe { - self.new_ebml_w.unsafe_clone() + let mut new_rbml_w = unsafe { + self.new_rbml_w.unsafe_clone() }; // See above let ecx: &e::EncodeContext = unsafe { mem::transmute(self.ecx_ptr) }; - encode_side_tables_for_id(ecx, &mut new_ebml_w, id) + encode_side_tables_for_id(ecx, &mut new_rbml_w, id) } } fn encode_side_tables_for_ii(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, ii: &ast::InlinedItem) { - ebml_w.start_tag(c::tag_table as uint); - let mut new_ebml_w = unsafe { - ebml_w.unsafe_clone() + rbml_w.start_tag(c::tag_table as uint); + let mut new_rbml_w = unsafe { + rbml_w.unsafe_clone() }; // Because the ast visitor uses @IdVisitingOperation, I can't pass in @@ -1017,49 +1016,49 @@ fn encode_side_tables_for_ii(ecx: &e::EncodeContext, ecx_ptr: unsafe { mem::transmute(ecx) }, - new_ebml_w: &mut new_ebml_w, + new_rbml_w: &mut new_rbml_w, }); - ebml_w.end_tag(); + rbml_w.end_tag(); } fn encode_side_tables_for_id(ecx: &e::EncodeContext, - ebml_w: &mut Encoder, + rbml_w: &mut Encoder, id: ast::NodeId) { let tcx = ecx.tcx; debug!("Encoding side tables for id {}", id); for def in tcx.def_map.borrow().find(&id).iter() { - ebml_w.tag(c::tag_table_def, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| (*def).encode(ebml_w).unwrap()); + rbml_w.tag(c::tag_table_def, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| (*def).encode(rbml_w).unwrap()); }) } for &ty in tcx.node_types.borrow().find(&(id as uint)).iter() { - ebml_w.tag(c::tag_table_node_type, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_ty(ecx, *ty); + rbml_w.tag(c::tag_table_node_type, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_ty(ecx, *ty); }) }) } for &item_substs in tcx.item_substs.borrow().find(&id).iter() { - ebml_w.tag(c::tag_table_item_subst, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_substs(ecx, &item_substs.substs); + rbml_w.tag(c::tag_table_item_subst, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_substs(ecx, &item_substs.substs); }) }) } for &fv in tcx.freevars.borrow().find(&id).iter() { - ebml_w.tag(c::tag_table_freevars, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_from_vec(fv.as_slice(), |ebml_w, fv_entry| { - Ok(encode_freevar_entry(ebml_w, fv_entry)) + rbml_w.tag(c::tag_table_freevars, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_from_vec(fv.as_slice(), |rbml_w, fv_entry| { + Ok(encode_freevar_entry(rbml_w, fv_entry)) }); }) }) @@ -1067,38 +1066,38 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id }; for &pty in tcx.tcache.borrow().find(&lid).iter() { - ebml_w.tag(c::tag_table_tcache, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_polytype(ecx, pty.clone()); + rbml_w.tag(c::tag_table_tcache, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_polytype(ecx, pty.clone()); }) }) } for &type_param_def in tcx.ty_param_defs.borrow().find(&id).iter() { - ebml_w.tag(c::tag_table_param_defs, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_type_param_def(ecx, type_param_def) + rbml_w.tag(c::tag_table_param_defs, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_type_param_def(ecx, type_param_def) }) }) } let method_call = MethodCall::expr(id); for &method in tcx.method_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_method_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_method_callee(ecx, ebml_w, method_call.adjustment, method) + rbml_w.tag(c::tag_table_method_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_method_callee(ecx, rbml_w, method_call.adjustment, method) }) }) } for &dr in tcx.vtable_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_vtable_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_vtable_res_with_key(ecx, ebml_w, method_call.adjustment, dr); + rbml_w.tag(c::tag_table_vtable_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_vtable_res_with_key(ecx, rbml_w, method_call.adjustment, dr); }) }) } @@ -1109,20 +1108,20 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, for autoderef in range(0, adj.autoderefs) { let method_call = MethodCall::autoderef(id, autoderef); for &method in tcx.method_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_method_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_method_callee(ecx, ebml_w, + rbml_w.tag(c::tag_table_method_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_method_callee(ecx, rbml_w, method_call.adjustment, method) }) }) } for &dr in tcx.vtable_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_vtable_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_vtable_res_with_key(ecx, ebml_w, + rbml_w.tag(c::tag_table_vtable_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_vtable_res_with_key(ecx, rbml_w, method_call.adjustment, dr); }) }) @@ -1132,19 +1131,19 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, ty::AutoObject(..) => { let method_call = MethodCall::autoobject(id); for &method in tcx.method_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_method_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_method_callee(ecx, ebml_w, method_call.adjustment, method) + rbml_w.tag(c::tag_table_method_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_method_callee(ecx, rbml_w, method_call.adjustment, method) }) }) } for &dr in tcx.vtable_map.borrow().find(&method_call).iter() { - ebml_w.tag(c::tag_table_vtable_map, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - encode_vtable_res_with_key(ecx, ebml_w, method_call.adjustment, dr); + rbml_w.tag(c::tag_table_vtable_map, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + encode_vtable_res_with_key(ecx, rbml_w, method_call.adjustment, dr); }) }) } @@ -1152,10 +1151,10 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, _ => {} } - ebml_w.tag(c::tag_table_adjustments, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_auto_adjustment(ecx, adj); + rbml_w.tag(c::tag_table_adjustments, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_auto_adjustment(ecx, adj); }) }) } @@ -1164,10 +1163,10 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, .borrow() .find(&ast_util::local_def(id)) .iter() { - ebml_w.tag(c::tag_table_unboxed_closure_type, |ebml_w| { - ebml_w.id(id); - ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_closure_type(ecx, *unboxed_closure_type) + rbml_w.tag(c::tag_table_unboxed_closure_type, |rbml_w| { + rbml_w.id(id); + rbml_w.tag(c::tag_table_val, |rbml_w| { + rbml_w.emit_closure_type(ecx, *unboxed_closure_type) }) }) } @@ -1178,14 +1177,14 @@ trait doc_decoder_helpers { fn opt_child(&self, tag: c::astencode_tag) -> Option; } -impl<'a> doc_decoder_helpers for ebml::Doc<'a> { +impl<'a> doc_decoder_helpers for rbml::Doc<'a> { fn as_int(&self) -> int { reader::doc_as_u64(*self) as int } - fn opt_child(&self, tag: c::astencode_tag) -> Option> { + fn opt_child(&self, tag: c::astencode_tag) -> Option> { reader::maybe_get_doc(*self, tag as uint) } } -trait ebml_decoder_decoder_helpers { +trait rbml_decoder_decoder_helpers { fn read_ty(&mut self, xcx: &ExtendedDecodeContext) -> ty::t; fn read_tys(&mut self, xcx: &ExtendedDecodeContext) -> Vec; fn read_type_param_def(&mut self, xcx: &ExtendedDecodeContext) @@ -1214,7 +1213,7 @@ trait ebml_decoder_decoder_helpers { -> subst::Substs; } -impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { +impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> { fn read_ty_noxcx(&mut self, tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> ty::t { self.read_opaque(|_, doc| { @@ -1270,7 +1269,7 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { Ok(ty) }).unwrap(); - fn type_string(doc: ebml::Doc) -> String { + fn type_string(doc: rbml::Doc) -> String { let mut str = String::new(); for i in range(doc.start, doc.end) { str.push_char(doc.data[i] as char); @@ -1423,7 +1422,7 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { } fn decode_side_tables(xcx: &ExtendedDecodeContext, - ast_doc: ebml::Doc) { + ast_doc: rbml::Doc) { let dcx = xcx.dcx; let tbl_doc = ast_doc.get(c::tag_table as uint); reader::docs(tbl_doc, |tag, entry_doc| { @@ -1527,14 +1526,14 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext, // Testing of astencode_gen #[cfg(test)] -fn encode_item_ast(ebml_w: &mut Encoder, item: Gc) { - ebml_w.start_tag(c::tag_tree as uint); - (*item).encode(ebml_w); - ebml_w.end_tag(); +fn encode_item_ast(rbml_w: &mut Encoder, item: Gc) { + rbml_w.start_tag(c::tag_tree as uint); + (*item).encode(rbml_w); + rbml_w.end_tag(); } #[cfg(test)] -fn decode_item_ast(par_doc: ebml::Doc) -> Gc { +fn decode_item_ast(par_doc: rbml::Doc) -> Gc { let chi_doc = par_doc.get(c::tag_tree as uint); let mut d = reader::Decoder::new(chi_doc); box(GC) Decodable::decode(&mut d).unwrap() @@ -1576,11 +1575,11 @@ fn roundtrip(in_item: Option>) { let in_item = in_item.unwrap(); let mut wr = SeekableMemWriter::new(); { - let mut ebml_w = writer::Encoder::new(&mut wr); - encode_item_ast(&mut ebml_w, in_item); + let mut rbml_w = writer::Encoder::new(&mut wr); + encode_item_ast(&mut rbml_w, in_item); } - let ebml_doc = ebml::Doc::new(wr.get_ref()); - let out_item = decode_item_ast(ebml_doc); + let rbml_doc = rbml::Doc::new(wr.get_ref()); + let out_item = decode_item_ast(rbml_doc); assert!(in_item == out_item); } diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index ea301784c93..cbb337be838 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2593,7 +2593,7 @@ pub fn write_metadata(cx: &CrateContext, krate: &ast::Crate) -> Vec { } let encode_inlined_item: encoder::EncodeInlinedItem = - |ecx, ebml_w, ii| astencode::encode_inlined_item(ecx, ebml_w, ii); + |ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii); let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item); let metadata = encoder::encode_metadata(encode_parms, krate); diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 5cb272a19eb..5c35ad85233 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -39,6 +39,5 @@ mod serialize; mod collection_impls; pub mod base64; -pub mod ebml; pub mod hex; pub mod json; diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index d01cda79e22..b03feb8fc22 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -10,33 +10,33 @@ // ignore-test FIXME(#5121) - -extern crate time; +extern crate rbml; extern crate serialize; +extern crate time; // These tests used to be separate files, but I wanted to refactor all // the common code. use std::hashmap::{HashMap, HashSet}; -use EBReader = serialize::ebml::reader; -use EBWriter = serialize::ebml::writer; +use EBReader = rbml::reader; +use EBWriter = rbml::writer; use std::cmp::Eq; use std::cmp; use std::io; use serialize::{Decodable, Encodable}; -fn test_ebml<'a, 'b, A: +fn test_rbml<'a, 'b, A: Eq + Encodable> + Decodable> >(a1: &A) { let mut wr = std::io::MemWriter::new(); - let mut ebml_w = EBwriter::Encoder::new(&mut wr); - a1.encode(&mut ebml_w); + let mut rbml_w = EBwriter::Encoder::new(&mut wr); + a1.encode(&mut rbml_w); let bytes = wr.get_ref(); - let d: serialize::ebml::Doc<'a> = EBDoc::new(bytes); + let d: serialize::rbml::Doc<'a> = EBDoc::new(bytes); let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d); let a2: A = Decodable::decode(&mut decoder); assert!(*a1 == a2); @@ -133,40 +133,40 @@ enum CLike { A, B, C } pub fn main() { let a = &Plus(@Minus(@Val(3u), @Val(10u)), @Plus(@Val(22u), @Val(5u))); - test_ebml(a); + test_rbml(a); let a = &Spanned {lo: 0u, hi: 5u, node: 22u}; - test_ebml(a); + test_rbml(a); let a = &Point {x: 3u, y: 5u}; - test_ebml(a); + test_rbml(a); let a = &Top(22u); - test_ebml(a); + test_rbml(a); let a = &Bottom(222u); - test_ebml(a); + test_rbml(a); let a = &A; - test_ebml(a); + test_rbml(a); let a = &B; - test_ebml(a); + test_rbml(a); let a = &time::now(); - test_ebml(a); + test_rbml(a); - test_ebml(&1.0f32); - test_ebml(&1.0f64); - test_ebml(&'a'); + test_rbml(&1.0f32); + test_rbml(&1.0f64); + test_rbml(&'a'); let mut a = HashMap::new(); - test_ebml(&a); + test_rbml(&a); a.insert(1, 2); - test_ebml(&a); + test_rbml(&a); let mut a = HashSet::new(); - test_ebml(&a); + test_rbml(&a); a.insert(1); - test_ebml(&a); + test_rbml(&a); } diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index bf519056130..573b57fb44a 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -16,15 +16,16 @@ #![feature(struct_variant)] extern crate rand; +extern crate rbml; extern crate serialize; use std::io::MemWriter; use rand::{random, Rand}; +use rbml; +use rbml::Doc; +use rbml::writer::Encoder; +use rbml::reader::Decoder; use serialize::{Encodable, Decodable}; -use serialize::ebml; -use serialize::ebml::Doc; -use serialize::ebml::writer::Encoder; -use serialize::ebml::reader::Decoder; #[deriving(Encodable, Decodable, Eq, Rand)] struct A; @@ -61,7 +62,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable> + let mut w = MemWriter::new(); let mut e = Encoder::new(&mut w); obj.encode(&mut e); - let doc = ebml::Doc::new(@w.get_ref()); + let doc = rbml::Doc::new(@w.get_ref()); let mut dec = Decoder::new(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/issue-11881.rs b/src/test/run-pass/issue-11881.rs index d7f487b629b..799cea865a3 100644 --- a/src/test/run-pass/issue-11881.rs +++ b/src/test/run-pass/issue-11881.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +extern crate rbml; extern crate serialize; use std::io; @@ -16,7 +17,7 @@ use std::slice; use serialize::{Encodable, Encoder}; use serialize::json; -use serialize::ebml::writer; +use rbml::writer; static BUF_CAPACITY: uint = 128; @@ -144,7 +145,7 @@ struct Bar { enum WireProtocol { JSON, - EBML, + RBML, // ... } @@ -155,7 +156,7 @@ fn encode_json<'a, let mut encoder = json::Encoder::new(wr); val.encode(&mut encoder); } -fn encode_ebml<'a, +fn encode_rbml<'a, T: Encodable, std::io::IoError>>(val: &T, wr: &'a mut SeekableMemWriter) { @@ -169,6 +170,6 @@ pub fn main() { let proto = JSON; match proto { JSON => encode_json(&target, &mut wr), - EBML => encode_ebml(&target, &mut wr) + RBML => encode_rbml(&target, &mut wr) } }