---

yaml
---
r: 6867
b: refs/heads/master
c: 56ec9cb
h: refs/heads/master
i:
  6865: c47a1ee
  6863: 3d007a5
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: b957916e06ea70b70aef1e404b089292aad42d7b
+refs/heads/master: 56ec9cb2789a7ece225cf224a2713618e2078172

trunk/src/comp/back/rpath.rs

@@ -3,6 +3,7 @@ import std::fs;
 import std::os_fs;
 import vec;
 import std::map;
+import std::math;
 import str;
 import uint;
 import metadata::cstore;
@@ -128,7 +129,7 @@ fn get_relative_to(abs1: fs::path, abs2: fs::path) -> fs::path {
     assert len1 > 0u;
     assert len2 > 0u;
 
-    let max_common_path = float::min(len1, len2) - 1u;
+    let max_common_path = math::min(len1, len2) - 1u;
     let start_idx = 0u;
     while start_idx < max_common_path
         && split1[start_idx] == split2[start_idx] {

trunk/src/comp/middle/ty.rs

@@ -4,6 +4,7 @@ import uint;
 import std::ufind;
 import std::map;
 import std::map::hashmap;
+import std::math;
 import option;
 import option::none;
 import option::some;
@@ -1753,7 +1754,7 @@ mod unify {
     // Unifies two sets.
     fn union(cx: @ctxt, set_a: uint, set_b: uint,
              variance: variance) -> union_result {
-        ufind::grow(cx.vb.sets, float::max(set_a, set_b) + 1u);
+        ufind::grow(cx.vb.sets, math::max(set_a, set_b) + 1u);
         let root_a = ufind::find(cx.vb.sets, set_a);
         let root_b = ufind::find(cx.vb.sets, set_b);
 

trunk/src/comp/util/common.rs

@@ -1,5 +1,5 @@
 import core::{str, option};
-import core::float::{max, min};
+import std::math::{max, min};
 import std::map::hashmap;
 import option::{some};
 import syntax::ast;

trunk/src/fuzzer/fuzzer.rs

@@ -1,5 +1,5 @@
 import core::{vec, str, int, uint, option, result};
-import std::{fs, io};
+import std::{fs, io, math};
 
 import rustc::syntax::{ast, ast_util, fold, visit, codemap};
 import rustc::syntax::parse::parser;
@@ -241,9 +241,9 @@ fn check_variants_T<copy T>(
     let L = vec::len(things);
 
     if L < 100u {
-        under(float::min(L, 20u)) {|i|
+        under(math::min(L, 20u)) {|i|
             log_err "Replacing... #" + uint::str(i);
-            under(float::min(L, 30u)) {|j|
+            under(math::min(L, 30u)) {|j|
                 log_err "With... " + stringifier(@things[j]);
                 let crate2 = @replacer(crate, i, things[j], cx.mode);
                 // It would be best to test the *crate* for stability, but testing the

trunk/src/libstd/cmath.rs

@@ -0,0 +1,71 @@
+import ctypes::c_int;
+
+#[link_name = "m"]
+#[abi = "cdecl"]
+native mod f64 {
+
+    // Alpabetically sorted by link_name
+
+    pure fn acos(n: f64) -> f64;
+    pure fn asin(n: f64) -> f64;
+    pure fn atan(n: f64) -> f64;
+    pure fn atan2(a: f64, b: f64) -> f64;
+    pure fn ceil(n: f64) -> f64;
+    pure fn cos(n: f64) -> f64;
+    pure fn cosh(n: f64) -> f64;
+    pure fn exp(n: f64) -> f64;
+    #[link_name="fabs"] pure fn abs(n: f64) -> f64;
+    pure fn floor(n: f64) -> f64;
+    pure fn fmod(x: f64, y: f64) -> f64;
+    pure fn frexp(n: f64, &value: c_int) -> f64;
+    pure fn ldexp(x: f64, n: c_int) -> f64;
+    #[link_name="log"] pure fn ln(n: f64) -> f64;
+    #[link_name="log1p"] pure fn ln1p(n: f64) -> f64;
+    pure fn log10(n: f64) -> f64;
+    pure fn log2(n: f64) -> f64;
+    pure fn modf(n: f64, iptr: *f64) -> f64;
+    pure fn pow(n: f64, e: f64) -> f64;
+    pure fn rint(n: f64) -> f64;
+    pure fn round(n: f64) -> f64;
+    pure fn sin(n: f64) -> f64;
+    pure fn sinh(n: f64) -> f64;
+    pure fn sqrt(n: f64) -> f64;
+    pure fn tan(n: f64) -> f64;
+    pure fn tanh(n: f64) -> f64;
+    pure fn trunc(n: f64) -> f64;
+}
+
+#[link_name = "m"]
+#[abi = "cdecl"]
+native mod f32 {
+
+    // Alpabetically sorted by link_name
+
+    #[link_name="acosf"] pure fn acos(n: f32) -> f32;
+    #[link_name="asinf"] pure fn asin(n: f32) -> f32;
+    #[link_name="atanf"] pure fn atan(n: f32) -> f32;
+    #[link_name="atan2f"] pure fn atan2(a: f32, b: f32) -> f32;
+    #[link_name="ceilf"] pure fn ceil(n: f32) -> f32;
+    #[link_name="cosf"] pure fn cos(n: f32) -> f32;
+    #[link_name="coshf"] pure fn cosh(n: f32) -> f32;
+    #[link_name="expf"] pure fn exp(n: f32) -> f32;
+    #[link_name="fabsf"] pure fn abs(n: f32) -> f32;
+    #[link_name="floorf"] pure fn floor(n: f32) -> f32;
+    #[link_name="frexpf"] pure fn frexp(n: f64, &value: c_int) -> f32;
+    #[link_name="fmodf"] pure fn fmod(x: f32, y: f32) -> f32;
+    #[link_name="ldexpf"] pure fn ldexp(x: f32, n: c_int) -> f32;
+    #[link_name="logf"] pure fn ln(n: f32) -> f32;
+    #[link_name="log1p"] pure fn ln1p(n: f64) -> f64;
+    #[link_name="log2f"] pure fn log2(n: f32) -> f32;
+    #[link_name="log10f"] pure fn log10(n: f32) -> f32;
+    #[link_name="modff"] pure fn modf(n: f32, iptr: *f32) -> f32;
+    #[link_name="powf"] pure fn pow(n: f32, e: f32) -> f32;
+    #[link_name="rintf"] pure fn rint(n: f32) -> f32;
+    #[link_name="roundf"] pure fn round(n: f32) -> f32;
+    #[link_name="sinf"] pure fn sin(n: f32) -> f32;
+    #[link_name="sinhf"] pure fn sinh(n: f32) -> f32;
+    #[link_name="sqrtf"] pure fn sqrt(n: f32) -> f32;
+    #[link_name="tanf"] pure fn tan(n: f32) -> f32;
+    #[link_name="tanhf"] pure fn tanh(n: f32) -> f32;
+    #[link_name="truncf"] pure fn trunc(n: f32) -> f32;
+}

trunk/src/libstd/ctypes.rs

@@ -0,0 +1,146 @@
+/*
+Module: ctypes
+
+Definitions useful for C interop
+*/
+
+/*
+FIXME: Add a test that uses some native code to verify these sizes,
+which are not obviously correct for all potential platforms.
+*/
+
+/*
+Type: c_int
+
+A signed integer with the same size as a C `int`
+*/
+type c_int = i32;
+
+/*
+Type: c_uint
+
+An unsigned integer with the same size as a C `unsigned int`
+*/
+type c_uint = u32;
+
+/*
+Type: long
+
+A signed integer with the same size as a C `long`
+*/
+type long = int;
+
+/*
+Type: unsigned
+
+An unsigned integer with the same size as a C `unsigned int`
+*/
+type unsigned = u32;
+
+/*
+Type: ulong
+
+An unsigned integer with the same size as a C `unsigned long`
+*/
+type ulong = uint;
+
+/*
+Type: intptr_t
+
+A signed integer with the same size as a pointer. This is
+guaranteed to always be the same type as a Rust `int`
+*/
+type intptr_t = uint; // FIXME: int
+
+/*
+Type: uintptr_t
+
+An unsigned integer with the same size as a pointer. This is
+guaranteed to always be the same type as a Rust `uint`.
+*/
+type uintptr_t = uint;
+type uint32_t = u32;
+
+/*
+Type: void
+
+A type, a pointer to which can be used as C `void *`
+
+Note that this does not directly correspond to the C `void` type,
+which is an incomplete type. Using pointers to this type
+when interoperating with C void pointers can help in documentation.
+*/
+type void = int;
+
+// machine type equivalents of rust int, uint, float
+
+/*
+Type: m_int
+
+FIXME: What C type does this represent?
+*/
+#[cfg(target_arch="x86")]
+type m_int = i32;
+#[cfg(target_arch="x86_64")]
+type m_int = i64;
+
+/*
+Type: m_uint
+
+FIXME: What C type does this represent?
+*/
+#[cfg(target_arch="x86")]
+type m_uint = u32;
+#[cfg(target_arch="x86_64")]
+type m_uint = u64;
+
+// This *must* match with "import m_float = fXX" in std::math per arch
+/*
+Type: m_float
+
+FIXME: What C type does this represent?
+*/
+type m_float = f64;
+
+/*
+Type: size_t
+
+An unsigned integer corresponding to the C `size_t`
+*/
+type size_t = uint;
+
+/*
+Type: ssize_t
+
+A signed integer correpsonding to the C `ssize_t`
+*/
+type ssize_t = int;
+
+/*
+Type: off_t
+
+An unsigned integer corresponding to the C `off_t`
+*/
+type off_t = uint;
+
+/*
+Type: fd_t
+
+A type that can be used for C file descriptors
+*/
+type fd_t = i32;      // not actually a C type, but should be.
+
+/*
+Type: pid_t
+
+A type for representing process ID's, corresponding to C `pid_t`
+*/
+type pid_t = i32;
+
+// enum is implementation-defined, but is 32-bits in practice
+/*
+Type: enum
+
+An unsigned integer with the same size as a C enum
+*/
+type enum = u32;