---

yaml
---
r: 5004
b: refs/heads/master
c: 54691f9
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 7d70685eefc98668804c05428bb94f43933cca61
+refs/heads/master: 54691f9a6cb6a92152fe57e4ca4b9fb6298dac0e

trunk/src/comp/driver/rustc.rs

@@ -491,17 +491,18 @@ fn main(args: [str]) {
     } else if n_inputs > 1u {
         sess.fatal("Multiple input filenames provided.");
     }
-    let ifile = istr::to_estr(match.free[0]);
+    let ifile = match.free[0];
     let saved_out_filename: str = "";
-    let cfg = build_configuration(sess, binary, ifile);
+    let cfg = build_configuration(sess, binary,
+                                  istr::to_estr(ifile));
     let pretty =
         option::map::<istr,
                       pp_mode>(bind parse_pretty(sess, _),
                                getopts::opt_default(match, ~"pretty",
                                                     ~"normal"));
     alt pretty {
       some::<pp_mode>(ppm) {
-        pretty_print_input(sess, cfg, ifile, ppm);
+        pretty_print_input(sess, cfg, istr::to_estr(ifile), ppm);
         ret;
       }
       none::<pp_mode>. {/* continue */ }
@@ -519,8 +520,8 @@ fn main(args: [str]) {
         // have to make up a name
         // We want to toss everything after the final '.'
         let parts =
-            if !input_is_stdin(ifile) {
-                str::split(ifile, '.' as u8)
+            if !input_is_stdin(istr::to_estr(ifile)) {
+                istr::to_estrs(istr::split(ifile, '.' as u8))
             } else { ["default", "rs"] };
         vec::pop(parts);
         saved_out_filename = str::connect(parts, ".");
@@ -536,15 +537,15 @@ fn main(args: [str]) {
               }
             };
         let ofile = saved_out_filename + "." + suffix;
-        compile_input(sess, cfg, ifile, ofile);
+        compile_input(sess, cfg, istr::to_estr(ifile), ofile);
       }
       some(ofile) {
         let ofile = istr::to_estr(ofile);
         // FIXME: what about windows? This will create a foo.exe.o.
         saved_out_filename = ofile;
         let temp_filename =
             if !stop_after_codegen { ofile + ".o" } else { ofile };
-        compile_input(sess, cfg, ifile, temp_filename);
+        compile_input(sess, cfg, istr::to_estr(ifile), temp_filename);
       }
     }
 
@@ -596,23 +597,23 @@ fn main(args: [str]) {
     }
 
     let cstore = sess.get_cstore();
-    for cratepath: str in cstore::get_used_crate_files(cstore) {
-        if str::ends_with(cratepath, ".rlib") {
-            gcc_args += [istr::from_estr(cratepath)];
+    for cratepath: istr in cstore::get_used_crate_files(cstore) {
+        if istr::ends_with(cratepath, ~".rlib") {
+            gcc_args += [cratepath];
             cont;
         }
-        let cratepath = istr::from_estr(cratepath);
+        let cratepath = cratepath;
         let dir = fs::dirname(cratepath);
         if dir != ~"" { gcc_args += [~"-L" + dir]; }
         let libarg = unlib(sess.get_targ_cfg(), fs::basename(cratepath));
         gcc_args += [~"-l" + libarg];
     }
 
     let ula = cstore::get_used_link_args(cstore);
-    for arg: str in ula { gcc_args += [istr::from_estr(arg)]; }
+    for arg: istr in ula { gcc_args += [arg]; }
 
     let used_libs = cstore::get_used_libraries(cstore);
-    for l: str in used_libs { gcc_args += [~"-l" + istr::from_estr(l)]; }
+    for l: istr in used_libs { gcc_args += [~"-l" + l]; }
 
     if sopts.library {
         gcc_args += [istr::from_estr(lib_cmd)];

trunk/src/comp/metadata/creader.rs

@@ -35,7 +35,8 @@ fn read_crates(sess: session::session, crate: &ast::crate) {
     let e =
         @{sess: sess,
           crate_cache: @std::map::new_str_hash::<int>(),
-          library_search_paths: sess.get_opts().library_search_paths,
+          library_search_paths:
+          istr::from_estrs(sess.get_opts().library_search_paths),
           mutable next_crate_num: 1};
     let v =
         visit::mk_simple_visitor(@{visit_view_item:
@@ -48,7 +49,7 @@ fn read_crates(sess: session::session, crate: &ast::crate) {
 type env =
     @{sess: session::session,
       crate_cache: @hashmap<istr, int>,
-      library_search_paths: [str],
+      library_search_paths: [istr],
       mutable next_crate_num: ast::crate_num};
 
 fn visit_view_item(e: env, i: &@ast::view_item) {
@@ -69,12 +70,12 @@ fn visit_item(e: env, i: &@ast::item) {
         }
         let cstore = e.sess.get_cstore();
         if !cstore::add_used_library(cstore,
-                                     istr::to_estr(m.native_name)) { ret; }
+                                     m.native_name) { ret; }
         for a: ast::attribute in
             attr::find_attrs_by_name(i.attrs, ~"link_args") {
             alt attr::get_meta_item_value_str(attr::attr_meta(a)) {
               some(linkarg) {
-                cstore::add_used_link_args(cstore, istr::to_estr(linkarg));
+                cstore::add_used_link_args(cstore, linkarg);
               }
               none. {/* fallthrough */ }
             }
@@ -85,12 +86,12 @@ fn visit_item(e: env, i: &@ast::item) {
 }
 
 // A diagnostic function for dumping crate metadata to an output stream
-fn list_file_metadata(path: str, out: io::writer) {
+fn list_file_metadata(path: &istr, out: io::writer) {
     alt get_metadata_section(path) {
       option::some(bytes) { decoder::list_crate_metadata(bytes, out); }
       option::none. {
         out.write_str(
-            istr::from_estr("Could not find metadata in " + path + ".\n"));
+            ~"Could not find metadata in " + path + ~".\n");
       }
     }
 }
@@ -112,18 +113,18 @@ fn metadata_matches(crate_data: &@[u8], metas: &[@ast::meta_item]) -> bool {
 }
 
 fn default_native_lib_naming(sess: session::session, static: bool) ->
-   {prefix: str, suffix: str} {
-    if static { ret {prefix: "lib", suffix: ".rlib"}; }
+   {prefix: istr, suffix: istr} {
+    if static { ret {prefix: ~"lib", suffix: ~".rlib"}; }
     alt sess.get_targ_cfg().os {
-      session::os_win32. { ret {prefix: "", suffix: ".dll"}; }
-      session::os_macos. { ret {prefix: "lib", suffix: ".dylib"}; }
-      session::os_linux. { ret {prefix: "lib", suffix: ".so"}; }
+      session::os_win32. { ret {prefix: ~"", suffix: ~".dll"}; }
+      session::os_macos. { ret {prefix: ~"lib", suffix: ~".dylib"}; }
+      session::os_linux. { ret {prefix: ~"lib", suffix: ~".so"}; }
     }
 }
 
 fn find_library_crate(sess: &session::session, ident: &ast::ident,
-                      metas: &[@ast::meta_item], library_search_paths: &[str])
-   -> option::t<{ident: str, data: @[u8]}> {
+                      metas: &[@ast::meta_item], library_search_paths: &[istr])
+   -> option::t<{ident: istr, data: @[u8]}> {
 
     attr::require_unique_names(sess, metas);
 
@@ -145,48 +146,49 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
 
     let nn = default_native_lib_naming(sess, sess.get_opts().static);
     let x =
-        find_library_crate_aux(nn, istr::to_estr(crate_name),
+        find_library_crate_aux(nn, crate_name,
                                metas, library_search_paths);
     if x != none || sess.get_opts().static { ret x; }
     let nn2 = default_native_lib_naming(sess, true);
-    ret find_library_crate_aux(nn2, istr::to_estr(crate_name),
+    ret find_library_crate_aux(nn2, crate_name,
                                metas, library_search_paths);
 }
 
-fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
+fn find_library_crate_aux(nn: &{prefix: istr, suffix: istr},
+                          crate_name: &istr,
                           metas: &[@ast::meta_item],
-                          library_search_paths: &[str]) ->
-   option::t<{ident: str, data: @[u8]}> {
-    let prefix: istr = istr::from_estr(nn.prefix + crate_name);
-    let suffix: istr = istr::from_estr(nn.suffix);
+                          library_search_paths: &[istr]) ->
+   option::t<{ident: istr, data: @[u8]}> {
+    let prefix: istr = nn.prefix + crate_name;
+    let suffix: istr = nn.suffix;
     // FIXME: we could probably use a 'glob' function in std::fs but it will
     // be much easier to write once the unsafe module knows more about FFI
     // tricks. Currently the glob(3) interface is a bit more than we can
     // stomach from here, and writing a C++ wrapper is more work than just
     // manually filtering fs::list_dir here.
 
-    for library_search_path: str in library_search_paths {
-        log #fmt["searching %s", library_search_path];
-        let library_search_path = istr::from_estr(library_search_path);
+    for library_search_path: istr in library_search_paths {
+        log #fmt["searching %s", istr::to_estr(library_search_path)];
         for path: istr in fs::list_dir(library_search_path) {
             log #fmt["searching %s", istr::to_estr(path)];
             let f: istr = fs::basename(path);
-            let path = istr::to_estr(path);
             if !(istr::starts_with(f, prefix) && istr::ends_with(f, suffix))
                {
                 log #fmt["skipping %s, doesn't look like %s*%s",
-                         path,
+                         istr::to_estr(path),
                          istr::to_estr(prefix),
                          istr::to_estr(suffix)];
                 cont;
             }
             alt get_metadata_section(path) {
               option::some(cvec) {
                 if !metadata_matches(cvec, metas) {
-                    log #fmt["skipping %s, metadata doesn't match", path];
+                    log #fmt["skipping %s, metadata doesn't match",
+                             istr::to_estr(path)];
                     cont;
                 }
-                log #fmt["found %s with matching metadata", path];
+                log #fmt["found %s with matching metadata",
+                         istr::to_estr(path)];
                 ret some({ident: path, data: cvec});
               }
               _ { }
@@ -196,8 +198,8 @@ fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
     ret none;
 }
 
-fn get_metadata_section(filename: str) -> option::t<@[u8]> {
-    let mb = istr::as_buf(istr::from_estr(filename), { |buf|
+fn get_metadata_section(filename: &istr) -> option::t<@[u8]> {
+    let mb = istr::as_buf(filename, { |buf|
         llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
     });
     if mb as int == 0 { ret option::none::<@[u8]>; }
@@ -218,8 +220,9 @@ fn get_metadata_section(filename: str) -> option::t<@[u8]> {
 }
 
 fn load_library_crate(sess: &session::session, span: span, ident: &ast::ident,
-                      metas: &[@ast::meta_item], library_search_paths: &[str])
-   -> {ident: str, data: @[u8]} {
+                      metas: &[@ast::meta_item],
+                      library_search_paths: &[istr])
+   -> {ident: istr, data: @[u8]} {
 
 
     alt find_library_crate(sess, ident, metas, library_search_paths) {
@@ -249,12 +252,13 @@ fn resolve_crate(e: env, ident: &ast::ident, metas: [@ast::meta_item],
         // Now resolve the crates referenced by this crate
         let cnum_map = resolve_crate_deps(e, cdata);
 
-        let cmeta = {name: istr::to_estr(ident),
+        let cmeta = {name: ident,
                      data: cdata, cnum_map: cnum_map};
 
         let cstore = e.sess.get_cstore();
         cstore::set_crate_data(cstore, cnum, cmeta);
-        cstore::add_used_crate_file(cstore, cfilename);
+        cstore::add_used_crate_file(cstore,
+                                    cfilename);
         ret cnum;
     } else { ret e.crate_cache.get(ident); }
 }
@@ -268,19 +272,19 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
     for dep: decoder::crate_dep in decoder::get_crate_deps(cdata) {
         let extrn_cnum = dep.cnum;
         let cname = dep.ident;
-        log #fmt["resolving dep %s", cname];
-        if e.crate_cache.contains_key(istr::from_estr(cname)) {
+        log #fmt["resolving dep %s", istr::to_estr(cname)];
+        if e.crate_cache.contains_key(cname) {
             log "already have it";
             // We've already seen this crate
-            let local_cnum = e.crate_cache.get(istr::from_estr(cname));
+            let local_cnum = e.crate_cache.get(cname);
             cnum_map.insert(extrn_cnum, local_cnum);
         } else {
             log "need to load it";
             // This is a new one so we've got to load it
             // FIXME: Need better error reporting than just a bogus span
             let fake_span = ast_util::dummy_sp();
             let local_cnum = resolve_crate(e,
-                                           istr::from_estr(cname),
+                                           cname,
                                            [], fake_span);
             cnum_map.insert(extrn_cnum, local_cnum);
         }

trunk/src/comp/metadata/csearch.rs

@@ -11,7 +11,7 @@ export lookup_defs;
 export get_tag_variants;
 export get_type;
 
-fn get_symbol(cstore: &cstore::cstore, def: ast::def_id) -> str {
+fn get_symbol(cstore: &cstore::cstore, def: ast::def_id) -> istr {
     let cdata = cstore::get_crate_data(cstore, def.crate).data;
     ret decoder::get_symbol(cdata, def.node);
 }

trunk/src/comp/metadata/cstore.rs

@@ -4,6 +4,7 @@
 import std::vec;
 import std::map;
 import std::str;
+import std::istr;
 import syntax::ast;
 
 export cstore;
@@ -29,7 +30,7 @@ export get_use_stmt_cnum;
 // own crate numbers.
 type cnum_map = map::hashmap<ast::crate_num, ast::crate_num>;
 
-type crate_metadata = {name: str, data: @[u8], cnum_map: cnum_map};
+type crate_metadata = {name: istr, data: @[u8], cnum_map: cnum_map};
 
 // This is a bit of an experiment at encapsulating the data in cstore. By
 // keeping all the data in a non-exported tag variant, it's impossible for
@@ -41,9 +42,9 @@ tag cstore { private(cstore_private); }
 type cstore_private =
     @{metas: map::hashmap<ast::crate_num, crate_metadata>,
       use_crate_map: use_crate_map,
-      mutable used_crate_files: [str],
-      mutable used_libraries: [str],
-      mutable used_link_args: [str]};
+      mutable used_crate_files: [istr],
+      mutable used_libraries: [istr],
+      mutable used_link_args: [istr]};
 
 // Map from node_id's of local use statements to crate numbers
 type use_crate_map = map::hashmap<ast::node_id, ast::crate_num>;
@@ -82,34 +83,34 @@ iter iter_crate_data(cstore: &cstore) ->
     }
 }
 
-fn add_used_crate_file(cstore: &cstore, lib: &str) {
+fn add_used_crate_file(cstore: &cstore, lib: &istr) {
     if !vec::member(lib, p(cstore).used_crate_files) {
         p(cstore).used_crate_files += [lib];
     }
 }
 
-fn get_used_crate_files(cstore: &cstore) -> [str] {
+fn get_used_crate_files(cstore: &cstore) -> [istr] {
     ret p(cstore).used_crate_files;
 }
 
-fn add_used_library(cstore: &cstore, lib: &str) -> bool {
-    if lib == "" { ret false; }
+fn add_used_library(cstore: &cstore, lib: &istr) -> bool {
+    if lib == ~"" { ret false; }
 
     if vec::member(lib, p(cstore).used_libraries) { ret false; }
 
     p(cstore).used_libraries += [lib];
     ret true;
 }
 
-fn get_used_libraries(cstore: &cstore) -> [str] {
+fn get_used_libraries(cstore: &cstore) -> [istr] {
     ret p(cstore).used_libraries;
 }
 
-fn add_used_link_args(cstore: &cstore, args: &str) {
-    p(cstore).used_link_args += str::split(args, ' ' as u8);
+fn add_used_link_args(cstore: &cstore, args: &istr) {
+    p(cstore).used_link_args += istr::split(args, ' ' as u8);
 }
 
-fn get_used_link_args(cstore: &cstore) -> [str] {
+fn get_used_link_args(cstore: &cstore) -> [istr] {
     ret p(cstore).used_link_args;
 }