---

yaml
---
r: 44390
b: refs/heads/master
c: 1d82d8d
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2180fe25520727a747c5a73b4d582a120ad116bd
+refs/heads/master: 1d82d8dd5def0713a78f864f47a4c9a65f8bf6cc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/os.rs

@@ -62,10 +62,11 @@ extern mod rustrt {
     unsafe fn rust_path_exists(path: *libc::c_char) -> c_int;
     unsafe fn rust_list_files2(&&path: ~str) -> ~[~str];
     unsafe fn rust_process_wait(handle: c_int) -> c_int;
+    unsafe fn last_os_error() -> ~str;
     unsafe fn rust_set_exit_status(code: libc::intptr_t);
 }
 
-pub const TMPBUF_SZ : uint = 1000u;
+pub const tmpbuf_sz : uint = 1000u;
 
 pub fn getcwd() -> Path {
     unsafe {
@@ -79,7 +80,7 @@ pub fn as_c_charp<T>(s: &str, f: fn(*c_char) -> T) -> T {
 
 pub fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
     -> Option<~str> {
-    let buf = vec::cast_to_mut(vec::from_elem(TMPBUF_SZ, 0u8 as c_char));
+    let buf = vec::cast_to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
     do vec::as_mut_buf(buf) |b, sz| {
         if f(b, sz as size_t) {
             unsafe {
@@ -98,19 +99,19 @@ pub mod win32 {
     use str;
     use option::{None, Option};
     use option;
-    use os::TMPBUF_SZ;
+    use os::tmpbuf_sz;
     use libc::types::os::arch::extra::DWORD;
 
     pub fn fill_utf16_buf_and_decode(f: fn(*mut u16, DWORD) -> DWORD)
         -> Option<~str> {
         unsafe {
-            let mut n = TMPBUF_SZ as DWORD;
+            let mut n = tmpbuf_sz as DWORD;
             let mut res = None;
             let mut done = false;
             while !done {
                 let buf = vec::cast_to_mut(vec::from_elem(n as uint, 0u16));
                 do vec::as_mut_buf(buf) |b, _sz| {
-                    let k : DWORD = f(b, TMPBUF_SZ as DWORD);
+                    let k : DWORD = f(b, tmpbuf_sz as DWORD);
                     if k == (0 as DWORD) {
                         done = true;
                     } else if (k == n &&
@@ -386,11 +387,11 @@ pub fn self_exe_path() -> Option<Path> {
         unsafe {
             use libc::funcs::posix01::unistd::readlink;
 
-            let mut path_str = str::with_capacity(TMPBUF_SZ);
+            let mut path_str = str::with_capacity(tmpbuf_sz);
             let len = do str::as_c_str(path_str) |buf| {
                 let buf = buf as *mut c_char;
                 do as_c_charp("/proc/self/exe") |proc_self_buf| {
-                    readlink(proc_self_buf, buf, TMPBUF_SZ as size_t)
+                    readlink(proc_self_buf, buf, tmpbuf_sz as size_t)
                 }
             };
             if len == -1 {
@@ -765,136 +766,11 @@ pub fn remove_file(p: &Path) -> bool {
     }
 }
 
-#[cfg(unix)]
-pub fn errno() -> int {
-    #[cfg(target_os = "macos")]
-    #[cfg(target_os = "freebsd")]
-    fn errno_location() -> *c_int {
-        #[nolink]
-        extern {
-            unsafe fn __error() -> *c_int;
-        }
-        unsafe {
-            __error()
-        }
-    }
-
-    #[cfg(target_os = "linux")]
-    #[cfg(target_os = "android")]
-    fn errno_location() -> *c_int {
-        #[nolink]
-        extern {
-            unsafe fn __errno_location() -> *c_int;
-        }
-        unsafe {
-            __errno_location()
-        }
-    }
-
-    unsafe {
-        (*errno_location()) as int
-    }
-}
-
-#[cfg(windows)]
-pub fn errno() -> uint {
-    use libc::types::os::arch::extra::DWORD;
-
-    #[link_name = "kernel32"]
-    #[abi = "stdcall"]
-    extern {
-        unsafe fn GetLastError() -> DWORD;
-    }
-
-    unsafe {
-        GetLastError() as uint
-    }
-}
-
 /// Get a string representing the platform-dependent last error
 pub fn last_os_error() -> ~str {
-    #[cfg(unix)]
-    fn strerror() -> ~str {
-        #[cfg(target_os = "macos")]
-        #[cfg(target_os = "android")]
-        #[cfg(target_os = "freebsd")]
-        fn strerror_r(errnum: c_int, buf: *c_char, buflen: size_t) -> c_int {
-            #[nolink]
-            extern {
-                unsafe fn strerror_r(errnum: c_int, buf: *c_char,
-                                     buflen: size_t) -> c_int;
-            }
-            unsafe {
-                strerror_r(errnum, buf, buflen)
-            }
-        }
-
-        // GNU libc provides a non-compliant version of strerror_r by default
-        // and requires macros to instead use the POSIX compliant variant.
-        // So we just use __xpg_strerror_r which is always POSIX compliant
-        #[cfg(target_os = "linux")]
-        fn strerror_r(errnum: c_int, buf: *c_char, buflen: size_t) -> c_int {
-            #[nolink]
-            extern {
-                unsafe fn __xpg_strerror_r(errnum: c_int, buf: *c_char,
-                                           buflen: size_t) -> c_int;
-            }
-            unsafe {
-                __xpg_strerror_r(errnum, buf, buflen)
-            }
-        }
-
-        let mut buf = [0 as c_char, ..TMPBUF_SZ];
-        unsafe {
-            let err = strerror_r(errno() as c_int, &buf[0],
-                                 TMPBUF_SZ as size_t);
-            if err < 0 {
-                die!(~"strerror_r failure");
-            }
-
-            str::raw::from_c_str(&buf[0])
-        }
-    }
-
-    #[cfg(windows)]
-    fn strerror() -> ~str {
-        use libc::types::os::arch::extra::DWORD;
-        use libc::types::os::arch::extra::LPSTR;
-        use libc::types::os::arch::extra::LPVOID;
-
-        #[link_name = "kernel32"]
-        #[abi = "stdcall"]
-        extern {
-            unsafe fn FormatMessageA(flags: DWORD, lpSrc: LPVOID,
-                                     msgId: DWORD, langId: DWORD,
-                                     buf: LPSTR, nsize: DWORD,
-                                     args: *c_void) -> DWORD;
-        }
-
-        const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
-        const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
-
-        let mut buf = [0 as c_char, ..TMPBUF_SZ];
-
-        // This value is calculated from the macro
-        // MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT)
-        let langId = 0x0800 as DWORD;
-        let err = errno() as DWORD;
-        unsafe {
-            let res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
-                                     FORMAT_MESSAGE_IGNORE_INSERTS,
-                                     ptr::mut_null(), err, langId,
-                                     &mut buf[0], TMPBUF_SZ as DWORD,
-                                     ptr::null());
-            if res == 0 {
-                die!(fmt!("[%?] FormatMessage failure", errno()));
-            }
-
-            str::raw::from_c_str(&buf[0])
-        }
+    unsafe {
+        rustrt::last_os_error()
     }
-
-    strerror()
 }
 
 /**

trunk/src/librustc/metadata/common.rs

@@ -153,7 +153,5 @@ pub const tag_lang_items_item: uint = 0x73;
 pub const tag_lang_items_item_id: uint = 0x74;
 pub const tag_lang_items_item_node_id: uint = 0x75;
 
-pub const tag_item_unnamed_field: uint = 0x76;
-
 pub type link_meta = {name: @str, vers: @str, extras_hash: @str};
 

trunk/src/librustc/metadata/csearch.rs

@@ -166,9 +166,8 @@ pub fn get_item_attrs(cstore: @mut cstore::CStore,
     decoder::get_item_attrs(cdata, def_id.node, f)
 }
 
-pub fn get_struct_fields(cstore: @mut cstore::CStore,
-                         def: ast::def_id)
-                      -> ~[ty::field_ty] {
+pub fn get_struct_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
+    let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_struct_fields(cstore.intr, cdata, def.node)
 }

trunk/src/librustc/metadata/decoder.rs

@@ -42,7 +42,7 @@ use std::serialize::Decodable;
 use syntax::ast_map;
 use syntax::attr;
 use syntax::diagnostic::span_handler;
-use syntax::parse::token::{ident_interner, special_idents};
+use syntax::parse::token::ident_interner;
 use syntax::print::pprust;
 use syntax::{ast, ast_util};
 use syntax::codemap;
@@ -231,9 +231,7 @@ pub fn item_type(item_id: ast::def_id, item: ebml::Doc,
     let t = doc_type(item, tcx, cdata);
     if family_names_type(item_family(item)) {
         ty::mk_with_id(tcx, t, item_id)
-    } else {
-        t
-    }
+    } else { t }
 }
 
 fn item_impl_traits(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
@@ -663,12 +661,11 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
     rslt
 }
 
-pub fn get_impls_for_mod(intr: @ident_interner,
-                         cdata: cmd,
-                         m_id: ast::node_id,
-                         name: Option<ast::ident>,
-                         get_cdata: &fn(ast::crate_num) -> cmd)
+pub fn get_impls_for_mod(intr: @ident_interner, cdata: cmd,
+                         m_id: ast::node_id, name: Option<ast::ident>,
+                         get_cdata: fn(ast::crate_num) -> cmd)
                       -> @~[@_impl] {
+
     let data = cdata.data;
     let mod_item = lookup_item(m_id, data);
     let mut result = ~[];
@@ -890,15 +887,6 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
             });
         }
     }
-    for reader::tagged_docs(item, tag_item_unnamed_field) |an_item| {
-        let did = item_def_id(an_item, cdata);
-        result.push(ty::field_ty {
-            ident: special_idents::unnamed_field,
-            id: did,
-            vis: ast::inherited,
-            mutability: ast::struct_immutable,
-        });
-    }
     result
 }
 

trunk/src/librustc/metadata/encoder.rs

@@ -46,7 +46,6 @@ use syntax::ast_map;
 use syntax::ast_util::*;
 use syntax::attr;
 use syntax::diagnostic::span_handler;
-use syntax::parse::token::special_idents;
 use syntax::print::pprust;
 use syntax::{ast_util, visit};
 use syntax;
@@ -329,7 +328,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: writer::Encoder,
     // Encode info about all the module children.
     for md.items.each |item| {
         match item.node {
-            item_impl(*) => {
+            item_impl(*) | item_struct(*) => {
                 let (ident, did) = (item.ident, item.id);
                 debug!("(encoding info for module) ... encoding impl %s \
                         (%?/%?)",
@@ -433,28 +432,25 @@ fn encode_info_for_struct(ecx: @encode_ctxt, ebml_w: writer::Encoder,
      /* We encode both private and public fields -- need to include
         private fields to get the offsets right */
     for fields.each |field| {
-        let (nm, mt, vis) = match field.node.kind {
-            named_field(nm, mt, vis) => (nm, mt, vis),
-            unnamed_field => (
-                special_idents::unnamed_field,
-                struct_immutable,
-                inherited
-            )
-        };
-
-        let id = field.node.id;
-        index.push({val: id, pos: ebml_w.writer.tell()});
-        global_index.push({val: id, pos: ebml_w.writer.tell()});
-        ebml_w.start_tag(tag_items_data_item);
-        debug!("encode_info_for_struct: doing %s %d",
-               tcx.sess.str_of(nm), id);
-        encode_visibility(ebml_w, vis);
-        encode_name(ecx, ebml_w, nm);
-        encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
-        encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
-        encode_mutability(ebml_w, mt);
-        encode_def_id(ebml_w, local_def(id));
-        ebml_w.end_tag();
+        match field.node.kind {
+            named_field(nm, mt, vis) => {
+                let id = field.node.id;
+                index.push({val: id, pos: ebml_w.writer.tell()});
+                global_index.push({val: id,
+                                    pos: ebml_w.writer.tell()});
+                ebml_w.start_tag(tag_items_data_item);
+                debug!("encode_info_for_struct: doing %s %d",
+                       tcx.sess.str_of(nm), id);
+                encode_visibility(ebml_w, vis);
+                encode_name(ecx, ebml_w, nm);
+                encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
+                encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
+                encode_mutability(ebml_w, mt);
+                encode_def_id(ebml_w, local_def(id));
+                ebml_w.end_tag();
+            }
+            unnamed_field => {}
+        }
     }
     /*bad*/copy *index
 }
@@ -677,24 +673,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Encoder,
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'S');
         encode_type_param_bounds(ebml_w, ecx, tps);
-
-        // If this is a tuple- or enum-like struct, encode the type of the
-        // constructor. Otherwise, encode the type of the struct.
-        if struct_def.fields.len() > 0 &&
-                struct_def.fields[0].node.kind == ast::unnamed_field {
-            // Tuple- or enum-like struct.
-            let ctor_id = match struct_def.ctor_id {
-                Some(ctor_id) => ctor_id,
-                None => ecx.tcx.sess.bug(~"struct def didn't have ctor id"),
-            };
-            encode_type(ecx, ebml_w, node_id_to_type(tcx, ctor_id));
-
-            // Also encode the symbol.
-            encode_symbol(ecx, ebml_w, ctor_id);
-        } else {
-            encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
-        }
-
+        encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_name(ecx, ebml_w, item.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         encode_region_param(ecx, ebml_w, item);
@@ -718,11 +697,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                    encode_def_id(ebml_w, local_def(f.node.id));
                    ebml_w.end_tag();
                 }
-                unnamed_field => {
-                    ebml_w.start_tag(tag_item_unnamed_field);
-                    encode_def_id(ebml_w, local_def(f.node.id));
-                    ebml_w.end_tag();
-                }
+                unnamed_field => {}
             }
         }