Machine types are different from int/uint, etc (Issue #2187)

Author: eholk

src/libcore/comm.rs

@@ -25,6 +25,7 @@ io::println(comm::recv(p));
 "];
 
 import either::either;
+import libc::size_t;
 
 export port::{};
 export chan::{};
@@ -66,7 +67,7 @@ enum chan<T: send> {
 
 #[doc = "Constructs a port"]
 fn port<T: send>() -> port<T> {
-    port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
+    port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>() as size_t)))
 }
 
 impl methods<T: send> for port<T> {
@@ -109,7 +110,7 @@ resource port_ptr<T: send>(po: *rust_port) unsafe {
         rustrt::rust_port_end_detach(po);
 
         // Drain the port so that all the still-enqueued items get dropped
-        while rustrt::rust_port_size(po) > 0u {
+        while rustrt::rust_port_size(po) > 0u as size_t {
             recv_::<T>(po);
         }
         rustrt::del_port(po);

src/libcore/f64.rs

@@ -76,6 +76,10 @@ pure fn ge(x: f64, y: f64) -> bool { ret x >= y; }
 
 pure fn gt(x: f64, y: f64) -> bool { ret x > y; }
 
+pure fn sqrt(x: f64) -> f64 {
+    cmath::c_double::sqrt(x as libc::c_double) as f64
+}
+
 #[doc = "
 Returns true if `x` is a positive number, including +0.0f640 and +Infinity.
 "]

src/libcore/float.rs

@@ -27,6 +27,57 @@ export j0, j1, jn, y0, y1, yn;
 import m_float = f64;
 import f64::*;
 
+const NaN: float = 0.0/0.0;
+
+const infinity: float = 1.0/0.0;
+
+const neg_infinity: float = -1.0/0.0;
+
+/* Module: consts */
+mod consts {
+
+    // FIXME replace with mathematical constants from cmath
+    // (requires Issue #1433 to fix)
+    #[doc = "Archimedes' constant"]
+    const pi: float = 3.14159265358979323846264338327950288;
+
+    #[doc = "pi/2.0"]
+    const frac_pi_2: float = 1.57079632679489661923132169163975144;
+
+    #[doc = "pi/4.0"]
+    const frac_pi_4: float = 0.785398163397448309615660845819875721;
+
+    #[doc = "1.0/pi"]
+    const frac_1_pi: float = 0.318309886183790671537767526745028724;
+
+    #[doc = "2.0/pi"]
+    const frac_2_pi: float = 0.636619772367581343075535053490057448;
+
+    #[doc = "2.0/sqrt(pi)"]
+    const frac_2_sqrtpi: float = 1.12837916709551257389615890312154517;
+
+    #[doc = "sqrt(2.0)"]
+    const sqrt2: float = 1.41421356237309504880168872420969808;
+
+    #[doc = "1.0/sqrt(2.0)"]
+    const frac_1_sqrt2: float = 0.707106781186547524400844362104849039;
+
+    #[doc = "Euler's number"]
+    const e: float = 2.71828182845904523536028747135266250;
+
+    #[doc = "log2(e)"]
+    const log2_e: float = 1.44269504088896340735992468100189214;
+
+    #[doc = "log10(e)"]
+    const log10_e: float = 0.434294481903251827651128918916605082;
+
+    #[doc = "ln(2.0)"]
+    const ln_2: float = 0.693147180559945309417232121458176568;
+
+    #[doc = "ln(10.0)"]
+    const ln_10: float = 2.30258509299404568401799145468436421;
+}
+
 /**
  * Section: String Conversions
  */
@@ -178,11 +229,11 @@ where `n` is the floating-point number represented by `[num]`.
 "]
 fn from_str(num: str) -> option<float> {
    if num == "inf" {
-       ret some(infinity);
+       ret some(infinity as float);
    } else if num == "-inf" {
-       ret some(neg_infinity);
+       ret some(neg_infinity as float);
    } else if num == "NaN" {
-       ret some(NaN);
+       ret some(NaN as float);
    }
 
    let mut pos = 0u;               //Current byte position in the string.
@@ -322,25 +373,40 @@ Compute the exponentiation of an integer by another integer as a float
 `NaN` if both `x` and `pow` are `0u`, otherwise `x^pow`
 "]
 fn pow_with_uint(base: uint, pow: uint) -> float {
-   if base == 0u {
-      if pow == 0u {
-        ret NaN;
-      }
-       ret 0.;
-   }
-   let mut my_pow     = pow;
-   let mut total      = 1f;
-   let mut multiplier = base as float;
-   while (my_pow > 0u) {
-     if my_pow % 2u == 1u {
-       total = total * multiplier;
-     }
-     my_pow     /= 2u;
-     multiplier *= multiplier;
-   }
-   ret total;
+    if base == 0u {
+        if pow == 0u {
+            ret NaN as float;
+        }
+        ret 0.;
+    }
+    let mut my_pow     = pow;
+    let mut total      = 1f;
+    let mut multiplier = base as float;
+    while (my_pow > 0u) {
+        if my_pow % 2u == 1u {
+            total = total * multiplier;
+        }
+        my_pow     /= 2u;
+        multiplier *= multiplier;
+    }
+    ret total;
 }
 
+fn is_positive(x: float) -> bool { f64::is_positive(x as f64) }
+fn is_negative(x: float) -> bool { f64::is_negative(x as f64) }
+fn is_nonpositive(x: float) -> bool { f64::is_nonpositive(x as f64) }
+fn is_nonnegative(x: float) -> bool { f64::is_nonnegative(x as f64) }
+fn is_zero(x: float) -> bool { f64::is_zero(x as f64) }
+fn is_infinite(x: float) -> bool { f64::is_infinite(x as f64) }
+fn is_finite(x: float) -> bool { f64::is_finite(x as f64) }
+fn is_NaN(x: float) -> bool { f64::is_NaN(x as f64) }
+
+fn abs(x: float) -> float { f64::abs(x as f64) as float }
+fn sqrt(x: float) -> float { f64::sqrt(x as f64) as float }
+fn atan(x: float) -> float { f64::atan(x as f64) as float }
+fn sin(x: float) -> float { f64::sin(x as f64) as float }
+fn cos(x: float) -> float { f64::cos(x as f64) as float }
+fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
 #[test]
 fn test_from_str() {

src/libcore/io.rs

@@ -7,7 +7,7 @@ Basic input/output
 import result::result;
 
 import dvec::{dvec, extensions};
-import libc::{c_int, c_uint, c_void, size_t, ssize_t};
+import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
 import libc::consts::os::posix88::*;
 import libc::consts::os::extra::*;
 
@@ -196,17 +196,17 @@ impl of reader for *libc::FILE {
         let mut buf : [mut u8] = [mut];
         vec::reserve(buf, len);
         vec::as_mut_buf(buf) {|b|
-            let read = libc::fread(b as *mut c_void, 1u,
-                                   len, self);
-            vec::unsafe::set_len(buf, read);
+            let read = libc::fread(b as *mut c_void, 1u as size_t,
+                                   len as size_t, self);
+            vec::unsafe::set_len(buf, read as uint);
         }
         ret vec::from_mut(buf);
     }
     fn read_byte() -> int { ret libc::fgetc(self) as int; }
     fn unread_byte(byte: int) { libc::ungetc(byte as c_int, self); }
     fn eof() -> bool { ret libc::feof(self) != 0 as c_int; }
     fn seek(offset: int, whence: seek_style) {
-        assert libc::fseek(self, offset, convert_whence(whence))
+        assert libc::fseek(self, offset as c_long, convert_whence(whence))
             == 0 as c_int;
     }
     fn tell() -> uint { ret libc::ftell(self) as uint; }
@@ -332,7 +332,8 @@ impl <T: writer, C> of writer for {base: T, cleanup: C} {
 impl of writer for *libc::FILE {
     fn write(v: [const u8]/&) unsafe {
         vec::unpack_const_slice(v) {|vbuf, len|
-            let nout = libc::fwrite(vbuf as *c_void, len, 1u, self);
+            let nout = libc::fwrite(vbuf as *c_void, len as size_t,
+                                    1u as size_t, self);
             if nout < 1 as size_t {
                 #error("error writing buffer");
                 log(error, os::last_os_error());
@@ -341,7 +342,7 @@ impl of writer for *libc::FILE {
         }
     }
     fn seek(offset: int, whence: seek_style) {
-        assert libc::fseek(self, offset, convert_whence(whence))
+        assert libc::fseek(self, offset as c_long, convert_whence(whence))
             == 0 as c_int;
     }
     fn tell() -> uint { libc::ftell(self) as uint }
@@ -362,7 +363,7 @@ impl of writer for fd_t {
         vec::unpack_const_slice(v) {|vbuf, len|
             while count < len {
                 let vb = ptr::const_offset(vbuf, count) as *c_void;
-                let nout = libc::write(self, vb, len);
+                let nout = libc::write(self, vb, len as size_t);
                 if nout < 0 as ssize_t {
                     #error("error writing buffer");
                     log(error, os::last_os_error());

src/libcore/libc.rs

@@ -185,8 +185,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i32;
-                type uintptr_t = u32;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i32;
@@ -229,8 +229,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i64;
-                type uintptr_t = u64;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i64;
@@ -276,8 +276,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i64;
-                type uintptr_t = u64;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i64;
@@ -323,8 +323,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i32;
-                type uintptr_t = u32;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i32;
@@ -397,8 +397,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i32;
-                type uintptr_t = u32;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i64;
@@ -441,8 +441,8 @@ mod types {
             mod c99 {
                 type c_longlong = i64;
                 type c_ulonglong = u64;
-                type intptr_t = i64;
-                type uintptr_t = u64;
+                type intptr_t = int;
+                type uintptr_t = uint;
             }
             mod posix88 {
                 type off_t = i64;

src/libcore/os.rs

@@ -90,11 +90,11 @@ mod win32 {
         import libc::funcs::extra::kernel32::*;
         import libc::consts::os::extra::*;
 
-        let mut n = tmpbuf_sz;
+        let mut n = tmpbuf_sz as dword;
         let mut res = none;
         let mut done = false;
         while !done {
-            let buf = vec::to_mut(vec::from_elem(n, 0u16));
+            let buf = vec::to_mut(vec::from_elem(n as uint, 0u16));
             vec::as_mut_buf(buf) {|b|
                 let k : dword = f(b, tmpbuf_sz as dword);
                 if k == (0 as dword) {
@@ -412,7 +412,7 @@ fn self_exe_path() -> option<path> {
         import libc::funcs::extra::kernel32::*;
         import win32::*;
         fill_utf16_buf_and_decode() {|buf, sz|
-            GetModuleFileNameW(0u, buf, sz)
+            GetModuleFileNameW(0u as dword, buf, sz)
         }
     }
 
@@ -692,16 +692,19 @@ fn copy_file(from: path, to: path) -> bool {
         let mut ok = true;
         while !done {
           vec::as_mut_buf(buf) {|b|
-            let nread = libc::fread(b as *mut c_void, 1u, bufsize, istream);
+              let nread = libc::fread(b as *mut c_void, 1u as size_t,
+                                      bufsize as size_t,
+                                      istream);
               if nread > 0 as size_t {
-                 if libc::fwrite(b as *c_void, 1u, nread, ostream) != nread {
-                    ok = false;
-                    done = true;
-                 }
+                  if libc::fwrite(b as *c_void, 1u as size_t, nread,
+                                  ostream) != nread {
+                      ok = false;
+                      done = true;
+                  }
               } else {
-                    done = true;
+                  done = true;
               }
-           }
+          }
         }
         fclose(istream);
         fclose(ostream);
@@ -988,8 +991,9 @@ mod tests {
       let s = "hello";
       let mut buf = vec::to_mut(str::bytes(s) + [0 as u8]);
       vec::as_mut_buf(buf) {|b|
-         assert (libc::fwrite(b as *c_void, 1u, str::len(s) + 1u, ostream) ==
-                 buf.len())};
+          assert (libc::fwrite(b as *c_void, 1u as size_t,
+                               (str::len(s) + 1u) as size_t, ostream)
+                  == buf.len() as size_t)};
       assert (libc::fclose(ostream) == (0u as c_int));
       let rs = os::copy_file(in, out);
       if (!os::path_exists(in)) {

src/libcore/ptr.rs

@@ -14,7 +14,7 @@ export buf_len;
 export position;
 export extensions;
 
-import libc::c_void;
+import libc::{c_void, size_t};
 
 #[nolink]
 #[abi = "cdecl"]
@@ -93,7 +93,7 @@ and destination may not overlap.
 #[inline(always)]
 unsafe fn memcpy<T>(dst: *T, src: *T, count: uint) {
     let n = count * sys::size_of::<T>();
-    libc_::memcpy(dst as *c_void, src as *c_void, n);
+    libc_::memcpy(dst as *c_void, src as *c_void, n as size_t);
 }
 
 #[doc = "
@@ -105,7 +105,7 @@ and destination may overlap.
 #[inline(always)]
 unsafe fn memmove<T>(dst: *T, src: *T, count: uint)  {
     let n = count * sys::size_of::<T>();
-    libc_::memmove(dst as *c_void, src as *c_void, n);
+    libc_::memmove(dst as *c_void, src as *c_void, n as size_t);
 }
 
 #[doc = "Extension methods for pointers"]

src/libcore/str.rs

@@ -7,6 +7,8 @@ for efficiency, but UTF-8 unsafe operations should be avoided.  For
 some heavy-duty uses, try std::rope.
 "];
 
+import libc::size_t;
+
 export
    // Creating a string
    from_bytes,
@@ -1596,7 +1598,7 @@ capacity, then no action is taken.
 "]
 fn reserve(&s: str, n: uint) {
     if capacity(s) < n {
-        rustrt::str_reserve_shared(s, n);
+        rustrt::str_reserve_shared(s, n as size_t);
     }
 }