---

yaml
---
r: 6323
b: refs/heads/master
c: 25bc37c
h: refs/heads/master
i:
  6321: c60213e
  6319: 60e714d
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: b27a88e99c2ab011ebc2fcaa8a8943bcfc0b3065
+refs/heads/master: 25bc37cef9ac13b0fc8b51bd4a285ac1f54cbc1f

trunk/src/lib/ctypes.rs

@@ -4,11 +4,18 @@ Module: ctypes
 Definitions useful for C interop
 */
 
-/* Type: size_t */
+type c_int = i32;
+type long = int;
+type unsigned = u32;
+type ulong = uint;
+
+type intptr_t = uint;
+type uintptr_t = uint;
+type uint32_t = u32;
+
 type size_t = uint;
-/* Type: ssize_t */
 type ssize_t = int;
-/* Type: uint32_t */
-type uint32_t = u32;
-/* Type: uintptr_t */
-type uintptr_t = uint;
+type off_t = uint;
+
+type fd_t = i32;      // not actually a C type, but should be.
+type pid_t = i32;

trunk/src/lib/generic_os.rs

@@ -48,7 +48,7 @@ fn setenv(n: str, v: str) {
                         let _: () =
                             str::as_buf(v,
                                         {|vbuf|
-                                            os::libc::setenv(nbuf, vbuf, 1);
+                                            os::libc::setenv(nbuf, vbuf, 1i32);
                                         });
                     });
 }

trunk/src/lib/io.rs

@@ -1,3 +1,5 @@
+import ctypes::fd_t;
+import ctypes::c_int;
 
 #[abi = "cdecl"]
 native mod rustrt {
@@ -6,7 +8,6 @@ native mod rustrt {
     fn rust_get_stderr() -> os::libc::FILE;
 }
 
-
 // Reading
 
 // FIXME This is all buffered. We might need an unbuffered variant as well
@@ -49,8 +50,12 @@ type reader =
         fn tell() -> uint;
     };
 
-fn convert_whence(whence: seek_style) -> int {
-    ret alt whence { seek_set. { 0 } seek_cur. { 1 } seek_end. { 2 } };
+fn convert_whence(whence: seek_style) -> i32 {
+    ret alt whence {
+      seek_set. { 0i32 }
+      seek_cur. { 1i32 }
+      seek_end. { 2i32 }
+    };
 }
 
 resource FILE_res(f: os::libc::FILE) { os::libc::fclose(f); }
@@ -64,11 +69,11 @@ obj FILE_buf_reader(f: os::libc::FILE, res: option::t<@FILE_res>) {
         vec::unsafe::set_len::<u8>(buf, read);
         ret buf;
     }
-    fn read_byte() -> int { ret os::libc::fgetc(f); }
-    fn unread_byte(byte: int) { os::libc::ungetc(byte, f); }
-    fn eof() -> bool { ret os::libc::feof(f) != 0; }
+    fn read_byte() -> int { ret os::libc::fgetc(f) as int; }
+    fn unread_byte(byte: int) { os::libc::ungetc(byte as i32, f); }
+    fn eof() -> bool { ret os::libc::feof(f) != 0i32; }
     fn seek(offset: int, whence: seek_style) {
-        assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0);
+        assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0i32);
     }
     fn tell() -> uint { ret os::libc::ftell(f) as uint; }
 }
@@ -247,14 +252,14 @@ obj FILE_writer(f: os::libc::FILE, res: option::t<@FILE_res>) {
         if nout < 1u { log_err "error dumping buffer"; }
     }
     fn seek(offset: int, whence: seek_style) {
-        assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0);
+        assert (os::libc::fseek(f, offset, convert_whence(whence)) == 0i32);
     }
     fn tell() -> uint { ret os::libc::ftell(f) as uint; }
 }
 
-resource fd_res(fd: int) { os::libc::close(fd); }
+resource fd_res(fd: fd_t) { os::libc::close(fd); }
 
-obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
+obj fd_buf_writer(fd: fd_t, res: option::t<@fd_res>) {
     fn write(v: [u8]) unsafe {
         let len = vec::len::<u8>(v);
         let count = 0u;
@@ -282,7 +287,7 @@ obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
 
 fn file_buf_writer(path: str,
                    flags: [fileflag]) -> result::t<buf_writer, str> {
-    let fflags: int =
+    let fflags: i32 =
         os::libc_constants::O_WRONLY | os::libc_constants::O_BINARY;
     for f: fileflag in flags {
         alt f {
@@ -299,7 +304,7 @@ fn file_buf_writer(path: str,
                                        os::libc_constants::S_IRUSR |
                                            os::libc_constants::S_IWUSR)
                     });
-    ret if fd < 0 {
+    ret if fd < 0i32 {
         log_err sys::last_os_error();
         result::err("error opening " + path)
     } else {
@@ -385,9 +390,14 @@ fn buffered_file_buf_writer(path: str) -> result::t<buf_writer, str> {
 
 
 // FIXME it would be great if this could be a const
+<<<<<<< HEAD
 // Problem seems to be that new_writer is not pure
 fn stdout() -> writer { ret new_writer(fd_buf_writer(1, option::none)); }
 fn stderr() -> writer { ret new_writer(fd_buf_writer(2, option::none)); }
+=======
+fn stdout() -> writer { ret new_writer(fd_buf_writer(1i32, option::none)); }
+fn stderr() -> writer { ret new_writer(fd_buf_writer(2i32, option::none)); }
+>>>>>>> refactor all unix types
 
 fn print(s: str) { stdout().write_str(s); }
 fn println(s: str) { stdout().write_str(s + "\n"); }

trunk/src/lib/linux_os.rs

@@ -4,82 +4,90 @@ Module: os
 TODO: Restructure and document
 */
 
+import ctypes::*;
+
+export libc;
+export libc_constants;
+export pipe;
+export fd_FILE;
+export close;
+export fclose;
+export waitpid;
+export getcwd;
+export exec_suffix;
+export target_os;
+export dylib_filename;
+export get_exe_path;
+
 // FIXME Somehow merge stuff duplicated here and macosx_os.rs. Made difficult
 // by https://github.com/graydon/rust/issues#issue/268
+
 #[link_name = ""]
 #[abi = "cdecl"]
 native mod libc {
-    fn read(fd: int, buf: *u8, count: uint) -> int;
-    fn write(fd: int, buf: *u8, count: uint) -> int;
-    fn fread(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
-    fn fwrite(buf: *u8, size: uint, n: uint, f: libc::FILE) -> uint;
-    fn open(s: str::sbuf, flags: int, mode: uint) -> int;
-    fn close(fd: int) -> int;
+    fn read(fd: fd_t, buf: *u8, count: size_t) -> ssize_t;
+    fn write(fd: fd_t, buf: *u8, count: size_t) -> ssize_t;
+    fn fread(buf: *u8, size: size_t, n: size_t, f: libc::FILE) -> size_t;
+    fn fwrite(buf: *u8, size: size_t, n: size_t, f: libc::FILE) -> size_t;
+    fn open(s: str::sbuf, flags: c_int, mode: unsigned) -> fd_t;
+    fn close(fd: fd_t) -> int;
     type FILE;
     fn fopen(path: str::sbuf, mode: str::sbuf) -> FILE;
-    fn fdopen(fd: int, mode: str::sbuf) -> FILE;
+    fn fdopen(fd: fd_t, mode: str::sbuf) -> FILE;
     fn fclose(f: FILE);
-    fn fgetc(f: FILE) -> int;
-    fn ungetc(c: int, f: FILE);
-    fn feof(f: FILE) -> int;
-    fn fseek(f: FILE, offset: int, whence: int) -> int;
-    fn ftell(f: FILE) -> int;
+    fn fgetc(f: FILE) -> c_int;
+    fn ungetc(c: c_int, f: FILE);
+    fn feof(f: FILE) -> c_int;
+    fn fseek(f: FILE, offset: long, whence: c_int) -> c_int;
+    fn ftell(f: FILE) -> long;
     type dir;
     fn opendir(d: str::sbuf) -> dir;
-    fn closedir(d: dir) -> int;
+    fn closedir(d: dir) -> c_int;
     type dirent;
     fn readdir(d: dir) -> dirent;
     fn getenv(n: str::sbuf) -> str::sbuf;
-    fn setenv(n: str::sbuf, v: str::sbuf, overwrite: int) -> int;
-    fn unsetenv(n: str::sbuf) -> int;
-    fn pipe(buf: *mutable int) -> int;
-    fn waitpid(pid: int, &status: int, options: int) -> int;
-    fn readlink(path: str::sbuf, buf: str::sbuf,
-                bufsize: ctypes::size_t) -> ctypes::ssize_t;
+    fn setenv(n: str::sbuf, v: str::sbuf, overwrite: c_int) -> c_int;
+    fn unsetenv(n: str::sbuf) -> c_int;
+    fn pipe(buf: *mutable fd_t) -> c_int;
+    fn waitpid(pid: pid_t, &status: c_int, options: c_int) -> pid_t;
 }
 
 mod libc_constants {
-    const O_RDONLY: int = 0;
-    const O_WRONLY: int = 1;
-    const O_RDWR: int   = 2;
-    const O_APPEND: int = 1024;
-    const O_CREAT: int  = 64;
-    const O_EXCL: int   = 128;
-    const O_TRUNC: int  = 512;
-    const O_TEXT: int   = 0;     // nonexistent in linux libc
-    const O_BINARY: int = 0;     // nonexistent in linux libc
-
-    const S_IRUSR: uint = 256u;
-    const S_IWUSR: uint = 128u;
-}
+    const O_RDONLY: c_int = 0;
+    const O_WRONLY: c_int = 1;
+    const O_RDWR: c_int   = 2;
+    const O_APPEND: c_int = 1024;
+    const O_CREAT: c_int  = 64;
+    const O_EXCL: c_int   = 128;
+    const O_TRUNC: c_int  = 512;
+    const O_TEXT: c_int   = 0;     // nonexistent in linux libc
+    const O_BINARY: c_int = 0;     // nonexistent in linux libc
 
-// FIXME turn into constants
-fn exec_suffix() -> str { ret ""; }
-fn target_os() -> str { ret "linux"; }
-
-fn dylib_filename(base: str) -> str { ret "lib" + base + ".so"; }
+    const S_IRUSR: unsigned = 256u;
+    const S_IWUSR: unsigned = 128u;
+}
 
-fn pipe() -> {in: int, out: int} {
-    let fds = {mutable in: 0, mutable out: 0};
-    assert (os::libc::pipe(ptr::mut_addr_of(fds.in)) == 0);
+fn pipe() -> {in: fd_t, out: fd_t} {
+    let fds = {mutable in: 0i32, mutable out: 0i32};
+    assert (os::libc::pipe(ptr::mut_addr_of(fds.in)) == 0i32);
     ret {in: fds.in, out: fds.out};
 }
 
-fn fd_FILE(fd: int) -> libc::FILE {
+fn fd_FILE(fd: fd_t) -> libc::FILE {
     ret str::as_buf("r", {|modebuf| libc::fdopen(fd, modebuf) });
 }
 
-fn close(fd: int) -> int {
+fn close(fd: fd_t) -> int {
     libc::close(fd)
 }
 
 fn fclose(file: libc::FILE) {
     libc::fclose(file)
 }
 
-fn waitpid(pid: int) -> int {
-    let status = 0;
-    assert (os::libc::waitpid(pid, status, 0) != -1);
+fn waitpid(pid: pid_t) -> i32 {
+    let status = 0i32;
+    assert (os::libc::waitpid(pid, status, 0i32) != -1i32);
     ret status;
 }
 
@@ -90,6 +98,12 @@ native mod rustrt {
 
 fn getcwd() -> str { ret rustrt::rust_getcwd(); }
 
+fn exec_suffix() -> str { ret ""; }
+
+fn target_os() -> str { ret "linux"; }
+
+fn dylib_filename(base: str) -> str { ret "lib" + base + ".so"; }
+
 /// Returns the directory containing the running program
 /// followed by a path separator
 fn get_exe_path() -> option::t<fs::path> {