librustc: De-export back, lib, and util. rs=deexporting

Author: pcwalton

src/librustc/back/abi.rs

@@ -11,72 +11,72 @@
 
 
 
-const rc_base_field_refcnt: uint = 0u;
+pub const rc_base_field_refcnt: uint = 0u;
 
-const task_field_refcnt: uint = 0u;
+pub const task_field_refcnt: uint = 0u;
 
-const task_field_stk: uint = 2u;
+pub const task_field_stk: uint = 2u;
 
-const task_field_runtime_sp: uint = 3u;
+pub const task_field_runtime_sp: uint = 3u;
 
-const task_field_rust_sp: uint = 4u;
+pub const task_field_rust_sp: uint = 4u;
 
-const task_field_gc_alloc_chain: uint = 5u;
+pub const task_field_gc_alloc_chain: uint = 5u;
 
-const task_field_dom: uint = 6u;
+pub const task_field_dom: uint = 6u;
 
-const n_visible_task_fields: uint = 7u;
+pub const n_visible_task_fields: uint = 7u;
 
-const dom_field_interrupt_flag: uint = 1u;
+pub const dom_field_interrupt_flag: uint = 1u;
 
-const frame_glue_fns_field_mark: uint = 0u;
+pub const frame_glue_fns_field_mark: uint = 0u;
 
-const frame_glue_fns_field_drop: uint = 1u;
+pub const frame_glue_fns_field_drop: uint = 1u;
 
-const frame_glue_fns_field_reloc: uint = 2u;
+pub const frame_glue_fns_field_reloc: uint = 2u;
 
-const box_field_refcnt: uint = 0u;
-const box_field_tydesc: uint = 1u;
-const box_field_prev: uint = 2u;
-const box_field_next: uint = 3u;
-const box_field_body: uint = 4u;
+pub const box_field_refcnt: uint = 0u;
+pub const box_field_tydesc: uint = 1u;
+pub const box_field_prev: uint = 2u;
+pub const box_field_next: uint = 3u;
+pub const box_field_body: uint = 4u;
 
-const general_code_alignment: uint = 16u;
+pub const general_code_alignment: uint = 16u;
 
-const tydesc_field_size: uint = 0u;
-const tydesc_field_align: uint = 1u;
-const tydesc_field_take_glue: uint = 2u;
-const tydesc_field_drop_glue: uint = 3u;
-const tydesc_field_free_glue: uint = 4u;
-const tydesc_field_visit_glue: uint = 5u;
-const tydesc_field_shape: uint = 6u;
-const tydesc_field_shape_tables: uint = 7u;
-const n_tydesc_fields: uint = 8u;
+pub const tydesc_field_size: uint = 0u;
+pub const tydesc_field_align: uint = 1u;
+pub const tydesc_field_take_glue: uint = 2u;
+pub const tydesc_field_drop_glue: uint = 3u;
+pub const tydesc_field_free_glue: uint = 4u;
+pub const tydesc_field_visit_glue: uint = 5u;
+pub const tydesc_field_shape: uint = 6u;
+pub const tydesc_field_shape_tables: uint = 7u;
+pub const n_tydesc_fields: uint = 8u;
 
 // The two halves of a closure: code and environment.
-const fn_field_code: uint = 0u;
-const fn_field_box: uint = 1u;
+pub const fn_field_code: uint = 0u;
+pub const fn_field_box: uint = 1u;
 
-const vec_elt_fill: uint = 0u;
+pub const vec_elt_fill: uint = 0u;
 
-const vec_elt_alloc: uint = 1u;
+pub const vec_elt_alloc: uint = 1u;
 
-const vec_elt_elems: uint = 2u;
+pub const vec_elt_elems: uint = 2u;
 
-const slice_elt_base: uint = 0u;
-const slice_elt_len: uint = 1u;
+pub const slice_elt_base: uint = 0u;
+pub const slice_elt_len: uint = 1u;
 
-const worst_case_glue_call_args: uint = 7u;
+pub const worst_case_glue_call_args: uint = 7u;
 
-const abi_version: uint = 1u;
+pub const abi_version: uint = 1u;
 
-fn memcpy_glue_name() -> ~str { return ~"rust_memcpy_glue"; }
+pub fn memcpy_glue_name() -> ~str { return ~"rust_memcpy_glue"; }
 
-fn bzero_glue_name() -> ~str { return ~"rust_bzero_glue"; }
+pub fn bzero_glue_name() -> ~str { return ~"rust_bzero_glue"; }
 
-fn yield_glue_name() -> ~str { return ~"rust_yield_glue"; }
+pub fn yield_glue_name() -> ~str { return ~"rust_yield_glue"; }
 
-fn no_op_type_glue_name() -> ~str { return ~"rust_no_op_type_glue"; }
+pub fn no_op_type_glue_name() -> ~str { return ~"rust_no_op_type_glue"; }
 //
 // Local Variables:
 // mode: rust

src/librustc/back/arm.rs

@@ -13,7 +13,7 @@ use driver::session;
 use session::sess_os_to_meta_os;
 use metadata::loader::meta_section_name;
 
-fn get_target_strs(target_os: session::os) -> target_strs::t {
+pub fn get_target_strs(target_os: session::os) -> target_strs::t {
     return {
         module_asm: ~"",
 

src/librustc/back/link.rs

@@ -43,7 +43,8 @@ use syntax::ast_map::{path, path_mod, path_name};
 use syntax::attr;
 use syntax::print::pprust;
 
-enum output_type {
+#[deriving_eq]
+pub enum output_type {
     output_type_none,
     output_type_bitcode,
     output_type_assembly,
@@ -52,13 +53,6 @@ enum output_type {
     output_type_exe,
 }
 
-impl output_type : cmp::Eq {
-    pure fn eq(&self, other: &output_type) -> bool {
-        ((*self) as uint) == ((*other) as uint)
-    }
-    pure fn ne(&self, other: &output_type) -> bool { !(*self).eq(other) }
-}
-
 pub fn llvm_err(sess: Session, +msg: ~str) -> ! {
     unsafe {
         let cstr = llvm::LLVMRustGetLastError();
@@ -170,15 +164,15 @@ pub mod jit {
     }
 }
 
-mod write {
+pub mod write {
     use back::link::jit;
-    use back::link::{ModuleRef, WriteOutputFile, output_type};
+    use back::link::{WriteOutputFile, output_type};
     use back::link::{output_type_assembly, output_type_bitcode};
     use back::link::{output_type_exe, output_type_llvm_assembly};
     use back::link::{output_type_object};
     use driver::session;
     use lib::llvm::llvm;
-    use lib::llvm::{False, True, mk_pass_manager, mk_target_data};
+    use lib::llvm::{False, True, ModuleRef, mk_pass_manager, mk_target_data};
     use lib;
     use session::Session;
 
@@ -456,7 +450,7 @@ mod write {
  *
  */
 
-fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
+pub fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
                    symbol_hasher: &hash::State) -> link_meta {
 
     type provided_metas =
@@ -575,15 +569,15 @@ fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
     return {name: name, vers: vers, extras_hash: extras_hash};
 }
 
-fn truncated_hash_result(symbol_hasher: &hash::State) -> ~str {
+pub fn truncated_hash_result(symbol_hasher: &hash::State) -> ~str {
     unsafe {
         symbol_hasher.result_str()
     }
 }
 
 
 // This calculates STH for a symbol, as defined above
-fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
+pub fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
                link_meta: link_meta) -> @str {
     // NB: do *not* use abbrevs here as we want the symbol names
     // to be independent of one another in the crate.
@@ -601,7 +595,7 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
     hash.to_managed()
 }
 
-fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> @str {
+pub fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> @str {
     match ccx.type_hashcodes.find(t) {
       Some(h) => h,
       None => {
@@ -615,7 +609,7 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> @str {
 
 // Name sanitation. LLVM will happily accept identifiers with weird names, but
 // gas doesn't!
-fn sanitize(s: ~str) -> ~str {
+pub fn sanitize(s: ~str) -> ~str {
     let mut result = ~"";
     for str::chars_each(s) |c| {
         match c {
@@ -648,7 +642,7 @@ fn sanitize(s: ~str) -> ~str {
     return result;
 }
 
-fn mangle(sess: Session, ss: path) -> ~str {
+pub fn mangle(sess: Session, ss: path) -> ~str {
     // Follow C++ namespace-mangling style
 
     let mut n = ~"_ZN"; // Begin name-sequence.
@@ -663,26 +657,26 @@ fn mangle(sess: Session, ss: path) -> ~str {
     n
 }
 
-fn exported_name(sess: Session,
-                 +path: path,
-                 hash: &str,
-                 vers: &str) -> ~str {
+pub fn exported_name(sess: Session,
+                     +path: path,
+                     hash: &str,
+                     vers: &str) -> ~str {
     return mangle(sess,
             vec::append_one(
             vec::append_one(path, path_name(sess.ident_of(hash.to_owned()))),
             path_name(sess.ident_of(vers.to_owned()))));
 }
 
-fn mangle_exported_name(ccx: @crate_ctxt, +path: path, t: ty::t) -> ~str {
+pub fn mangle_exported_name(ccx: @crate_ctxt, +path: path, t: ty::t) -> ~str {
     let hash = get_symbol_hash(ccx, t);
     return exported_name(ccx.sess, path,
                          hash,
                          ccx.link_meta.vers);
 }
 
-fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
-                                     t: ty::t,
-                                     name: &str) -> ~str {
+pub fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
+                                         t: ty::t,
+                                         name: &str) -> ~str {
     let s = ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
     return mangle(ccx.sess,
@@ -691,23 +685,23 @@ fn mangle_internal_name_by_type_only(ccx: @crate_ctxt,
           path_name(ccx.sess.ident_of(hash.to_owned()))]);
 }
 
-fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt,
-                                        +path: path,
-                                        +flav: ~str) -> ~str {
+pub fn mangle_internal_name_by_path_and_seq(ccx: @crate_ctxt,
+                                            +path: path,
+                                            +flav: ~str) -> ~str {
     return mangle(ccx.sess,
                   vec::append_one(path, path_name((ccx.names)(flav))));
 }
 
-fn mangle_internal_name_by_path(ccx: @crate_ctxt, +path: path) -> ~str {
+pub fn mangle_internal_name_by_path(ccx: @crate_ctxt, +path: path) -> ~str {
     return mangle(ccx.sess, path);
 }
 
-fn mangle_internal_name_by_seq(ccx: @crate_ctxt, +flav: ~str) -> ~str {
+pub fn mangle_internal_name_by_seq(ccx: @crate_ctxt, +flav: ~str) -> ~str {
     return fmt!("%s_%u", flav, (ccx.names)(flav).repr);
 }
 
 
-fn output_dll_filename(os: session::os, lm: link_meta) -> ~str {
+pub fn output_dll_filename(os: session::os, lm: link_meta) -> ~str {
     let libname = fmt!("%s-%s-%s", lm.name, lm.extras_hash, lm.vers);
     let (dll_prefix, dll_suffix) = match os {
         session::os_win32 => (win32::DLL_PREFIX, win32::DLL_SUFFIX),
@@ -722,10 +716,10 @@ fn output_dll_filename(os: session::os, lm: link_meta) -> ~str {
 
 // If the user wants an exe generated we need to invoke
 // cc to link the object file with some libs
-fn link_binary(sess: Session,
-               obj_filename: &Path,
-               out_filename: &Path,
-               lm: link_meta) {
+pub fn link_binary(sess: Session,
+                   obj_filename: &Path,
+                   out_filename: &Path,
+                   lm: link_meta) {
     // Converts a library file-stem into a cc -l argument
     fn unlib(config: @session::config, +stem: ~str) -> ~str {
         if stem.starts_with("lib") &&

src/librustc/back/rpath.rs

@@ -21,22 +21,15 @@ use core::vec;
 use std::map::HashMap;
 use std::map;
 
-export get_absolute_rpath;
-export get_install_prefix_rpath;
-export get_relative_to;
-export get_rpath_flags;
-export get_rpath_relative_to_output;
-export minimize_rpaths;
-export rpaths_to_flags;
-
 pure fn not_win32(os: session::os) -> bool {
   match os {
       session::os_win32 => false,
       _ => true
   }
 }
 
-fn get_rpath_flags(sess: session::Session, out_filename: &Path) -> ~[~str] {
+pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
+                    -> ~[~str] {
     let os = sess.targ_cfg.os;
 
     // No rpath on windows
@@ -63,7 +56,7 @@ fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path {
     sess.filesearch.sysroot().push_rel(&r).push(os::dll_filename("rustrt"))
 }
 
-fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
+pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
     vec::map(rpaths, |rpath| fmt!("-Wl,-rpath,%s",rpath.to_str()))
 }
 
@@ -120,10 +113,10 @@ fn get_rpaths_relative_to_output(os: session::os,
     })
 }
 
-fn get_rpath_relative_to_output(os: session::os,
-                                output: &Path,
-                                lib: &Path)
-                             -> Path {
+pub fn get_rpath_relative_to_output(os: session::os,
+                                    output: &Path,
+                                    lib: &Path)
+                                 -> Path {
     use core::os;
 
     assert not_win32(os);
@@ -141,7 +134,7 @@ fn get_rpath_relative_to_output(os: session::os,
 }
 
 // Find the relative path from one file to another
-fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
+pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     assert abs1.is_absolute;
     assert abs2.is_absolute;
     let abs1 = abs1.normalize();
@@ -178,11 +171,11 @@ fn get_absolute_rpaths(libs: &[Path]) -> ~[Path] {
     vec::map(libs, |a| get_absolute_rpath(a) )
 }
 
-fn get_absolute_rpath(lib: &Path) -> Path {
+pub fn get_absolute_rpath(lib: &Path) -> Path {
     os::make_absolute(lib).dir_path()
 }
 
-fn get_install_prefix_rpath(target_triple: &str) -> Path {
+pub fn get_install_prefix_rpath(target_triple: &str) -> Path {
     let install_prefix = env!("CFG_PREFIX");
 
     if install_prefix == ~"" {
@@ -193,7 +186,7 @@ fn get_install_prefix_rpath(target_triple: &str) -> Path {
     os::make_absolute(&Path(install_prefix).push_rel(&tlib))
 }
 
-fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
+pub fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
     let set = map::HashMap();
     let mut minimized = ~[];
     for rpaths.each |rpath| {

src/librustc/back/target_strs.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-type t = {
+pub type t = {
     module_asm: ~str,
     meta_sect_name: ~str,
     data_layout: ~str,