---

yaml
---
r: 28275
b: refs/heads/try
c: 4370738
h: refs/heads/master
i:
  28273: 8f249b6
  28271: 59d9743
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: ff4b754958cc3acc32dcb9231aafceff692a4f95
+refs/heads/try: 437073868e590ff8d1aae7a6fad1d8c49056f0b0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/src/libcore/at_vec.rs

@@ -1,6 +1,6 @@
 //! Shared Vectors
 
-import ptr::addr_of;
+use ptr::addr_of;
 
 export init_op;
 export capacity;

branches/try/src/libcore/bool.rs

@@ -6,7 +6,7 @@
 
 //! Boolean logic
 
-import cmp::Eq;
+use cmp::Eq;
 
 export not, and, or, xor, implies;
 export eq, ne, is_true, is_false;

branches/try/src/libcore/box.rs

@@ -4,7 +4,7 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-import cmp::{Eq, Ord};
+use cmp::{Eq, Ord};
 
 export ptr_eq;
 

branches/try/src/libcore/char.rs

@@ -4,7 +4,7 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-import cmp::Eq;
+use cmp::Eq;
 
 /*
     Lu  Uppercase_Letter    an uppercase letter
@@ -47,9 +47,9 @@ export is_alphabetic,
        to_digit, cmp,
        escape_default, escape_unicode;
 
-import is_alphabetic = unicode::derived_property::Alphabetic;
-import is_XID_start = unicode::derived_property::XID_Start;
-import is_XID_continue = unicode::derived_property::XID_Continue;
+use is_alphabetic = unicode::derived_property::Alphabetic;
+use is_XID_start = unicode::derived_property::XID_Start;
+use is_XID_continue = unicode::derived_property::XID_Continue;
 
 
 /**

branches/try/src/libcore/cmath.rs

@@ -12,9 +12,9 @@ export c_double;
 export c_float_targ_consts;
 export c_double_targ_consts;
 
-import libc::c_int;
-import libc::c_float;
-import libc::c_double;
+use libc::c_int;
+use libc::c_float;
+use libc::c_double;
 
 // function names are almost identical to C's libmath, a few have been
 // renamed, grep for "rename:"
@@ -65,6 +65,9 @@ extern mod c_double {
     // renamed: to be consitent with log as ln
     #[link_name="log1p"] pure fn ln1p(n: c_double) -> c_double;
     pure fn log10(n: c_double) -> c_double;
+    #[cfg(target_os="linux")]
+    #[cfg(target_os="macos")]
+    #[cfg(target_os="win32")]
     pure fn log2(n: c_double) -> c_double;
     #[link_name="ilogb"] pure fn ilog_radix(n: c_double) -> c_int;
     pure fn modf(n: c_double, &iptr: c_double) -> c_double;
@@ -140,6 +143,9 @@ extern mod c_float {
     #[link_name="logf"] pure fn ln(n: c_float) -> c_float;
     #[link_name="logbf"] pure fn log_radix(n: c_float) -> c_float;
     #[link_name="log1pf"] pure fn ln1p(n: c_float) -> c_float;
+    #[cfg(target_os="linux")]
+    #[cfg(target_os="macos")]
+    #[cfg(target_os="win32")]
     #[link_name="log2f"] pure fn log2(n: c_float) -> c_float;
     #[link_name="log10f"] pure fn log10(n: c_float) -> c_float;
     #[link_name="ilogbf"] pure fn ilog_radix(n: c_float) -> c_int;

branches/try/src/libcore/comm.rs

@@ -27,8 +27,8 @@
  * ~~~
  */
 
-import either::Either;
-import libc::size_t;
+use either::Either;
+use libc::size_t;
 
 export Port;
 export Chan;

branches/try/src/libcore/core.rs

@@ -2,28 +2,28 @@
 
 // Export various ubiquitous types, constructors, methods.
 
-import option::{Some, None};
-import Option = option::Option;
+use option::{Some, None};
+use Option = option::Option;
 // XXX: snapshot rustc is generating code that wants lower-case option
 #[cfg(stage0)]
-import option = option::Option;
+use option = option::Option;
 
-import result::{Result, Ok, Err};
+use result::{Result, Ok, Err};
 
-import Path = path::Path;
-import GenericPath = path::GenericPath;
-import WindowsPath = path::WindowsPath;
-import PosixPath = path::PosixPath;
+use Path = path::Path;
+use GenericPath = path::GenericPath;
+use WindowsPath = path::WindowsPath;
+use PosixPath = path::PosixPath;
 
-import tuple::{TupleOps, ExtendedTupleOps};
-import str::{StrSlice, UniqueStr};
-import vec::{ConstVector, CopyableVector, ImmutableVector};
-import vec::{ImmutableEqVector, ImmutableCopyableVector};
-import iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
-import iter::{CopyableOrderedIter, Times, TimesIx};
-import num::Num;
-import ptr::Ptr;
-import to_str::ToStr;
+use tuple::{TupleOps, ExtendedTupleOps};
+use str::{StrSlice, UniqueStr};
+use vec::{ConstVector, CopyableVector, ImmutableVector};
+use vec::{ImmutableEqVector, ImmutableCopyableVector};
+use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+use iter::{CopyableOrderedIter, Times, TimesIx};
+use num::Num;
+use ptr::Ptr;
+use to_str::ToStr;
 
 export Path, WindowsPath, PosixPath, GenericPath;
 export Option, Some, None, unreachable;
@@ -44,11 +44,11 @@ export ToStr;
 // The compiler has special knowlege of these so we must not duplicate them
 // when compiling for testing
 #[cfg(notest)]
-import ops::{Const, Copy, Send, Owned};
+use ops::{Const, Copy, Send, Owned};
 #[cfg(notest)]
-import ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
+use ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
 #[cfg(notest)]
-import ops::{Shl, Shr, Index};
+use ops::{Shl, Shr, Index};
 
 #[cfg(notest)]
 export Const, Copy, Send, Owned;
@@ -61,11 +61,11 @@ export Shl, Shr, Index;
 use coreops(name = "core", vers = "0.4");
 
 #[cfg(test)]
-import coreops::ops::{Const, Copy, Send, Owned};
+use coreops::ops::{Const, Copy, Send, Owned};
 #[cfg(test)]
-import coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
+use coreops::ops::{Add, Sub, Mul, Div, Modulo, Neg, BitAnd, BitOr, BitXor};
 #[cfg(test)]
-import coreops::ops::{Shl, Shr, Index};
+use coreops::ops::{Shl, Shr, Index};
 
 
 // Export the log levels as global constants. Higher levels mean

branches/try/src/libcore/dvec.rs

@@ -9,8 +9,8 @@
 //
 // Note that recursive use is not permitted.
 
-import unsafe::reinterpret_cast;
-import ptr::null;
+use unsafe::reinterpret_cast;
+use ptr::null;
 
 export DVec;
 export from_elem;

branches/try/src/libcore/either.rs

@@ -4,8 +4,8 @@
 
 //! A type that represents one of two alternatives
 
-import cmp::Eq;
-import result::Result;
+use cmp::Eq;
+use result::Result;
 
 /// The either type
 enum Either<T, U> {

branches/try/src/libcore/extfmt.rs

@@ -26,8 +26,8 @@ debug!("hello, %s!", "world");
 
 */
 
-import cmp::Eq;
-import option::{Some, None};
+use cmp::Eq;
+use option::{Some, None};
 
 
 /*

branches/try/src/libcore/f32.rs

@@ -6,8 +6,8 @@
 
 // PORT
 
-import cmath::c_float::*;
-import cmath::c_float_targ_consts::*;
+use cmath::c_float::*;
+use cmath::c_float_targ_consts::*;
 
 export add, sub, mul, div, rem, lt, le, eq, ne, ge, gt;
 export is_positive, is_negative, is_nonpositive, is_nonnegative;
@@ -152,10 +152,25 @@ pure fn signbit(x: f32) -> int {
     if is_negative(x) { return 1; } else { return 0; }
 }
 
+#[cfg(target_os="linux")]
+#[cfg(target_os="macos")]
+#[cfg(target_os="win32")]
 pure fn logarithm(n: f32, b: f32) -> f32 {
     return log2(n) / log2(b);
 }
 
+#[cfg(target_os="freebsd")]
+pure fn logarithm(n: f32, b: f32) -> f32 {
+    // FIXME (#2000): check if it is good to use log2 instead of ln here;
+    // in theory should be faster since the radix is 2
+    return ln(n) / ln(b);
+}
+
+#[cfg(target_os="freebsd")]
+pure fn log2(n: f32) -> f32 {
+    return ln(n) / consts::ln_2;
+}
+
 impl f32: num::Num {
     pure fn add(&&other: f32)    -> f32 { return self + other; }
     pure fn sub(&&other: f32)    -> f32 { return self - other; }

branches/try/src/libcore/f64.rs

@@ -6,8 +6,8 @@
 
 // PORT
 
-import cmath::c_double::*;
-import cmath::c_double_targ_consts::*;
+use cmath::c_double::*;
+use cmath::c_double_targ_consts::*;
 
 // Even though this module exports everything defined in it,
 // because it contains re-exports, we also have to explicitly
@@ -179,10 +179,25 @@ pure fn signbit(x: f64) -> int {
     if is_negative(x) { return 1; } else { return 0; }
 }
 
+#[cfg(target_os="linux")]
+#[cfg(target_os="macos")]
+#[cfg(target_os="win32")]
 pure fn logarithm(n: f64, b: f64) -> f64 {
     return log2(n) / log2(b);
 }
 
+#[cfg(target_os="freebsd")]
+pure fn logarithm(n: f64, b: f64) -> f64 {
+    // FIXME (#2000): check if it is good to use log2 instead of ln here; in
+    // theory should be faster since the radix is 2
+    return ln(n) / ln(b);
+}
+
+#[cfg(target_os="freebsd")]
+pure fn log2(n: f64) -> f64 {
+    return ln(n) / consts::ln_2;
+}
+
 impl f64: num::Num {
     pure fn add(&&other: f64)    -> f64 { return self + other; }
     pure fn sub(&&other: f64)    -> f64 { return self - other; }

branches/try/src/libcore/flate.rs

@@ -1,4 +1,4 @@
-import libc::{c_void, size_t, c_int};
+use libc::{c_void, size_t, c_int};
 
 extern mod rustrt {
 

branches/try/src/libcore/float.rs

@@ -30,19 +30,19 @@ export j0, j1, jn, y0, y1, yn;
 
 // PORT this must match in width according to architecture
 
-import m_float = f64;
-
-import f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
-import f64::logarithm;
-import f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
-import f64::{erf, erfc, exp, expm1, exp2, abs_sub};
-import f64::{mul_add, fmax, fmin, nextafter, frexp, hypot, ldexp};
-import f64::{lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix};
-import f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
-import f64::signbit;
-import f64::{j0, j1, jn, y0, y1, yn};
-import cmp::{Eq, Ord};
-import num::from_int;
+use m_float = f64;
+
+use f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
+use f64::logarithm;
+use f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
+use f64::{erf, erfc, exp, expm1, exp2, abs_sub};
+use f64::{mul_add, fmax, fmin, nextafter, frexp, hypot, ldexp};
+use f64::{lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix};
+use f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
+use f64::signbit;
+use f64::{j0, j1, jn, y0, y1, yn};
+use cmp::{Eq, Ord};
+use num::from_int;
 
 const NaN: float = 0.0/0.0;
 

branches/try/src/libcore/future.rs

@@ -15,9 +15,9 @@
  * ~~~
  */
 
-import either::Either;
-import pipes::recv;
-import unsafe::copy_lifetime;
+use either::Either;
+use pipes::recv;
+use unsafe::copy_lifetime;
 
 export Future;
 export extensions;

branches/try/src/libcore/hash.rs

@@ -13,9 +13,9 @@
  * CPRNG like rand::rng.
  */
 
-import io::Writer;
-import io::WriterUtil;
-import to_bytes::IterBytes;
+use io::Writer;
+use io::WriterUtil;
+use to_bytes::IterBytes;
 
 export Streaming, State, Hash, HashUtil;
 export default_state;

branches/try/src/libcore/int-template.rs

@@ -2,10 +2,10 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-import T = inst::T;
-import cmp::{Eq, Ord};
-import from_str::FromStr;
-import num::from_int;
+use T = inst::T;
+use cmp::{Eq, Ord};
+use from_str::FromStr;
+use num::from_int;
 
 export min_value, max_value;
 export min, max;

branches/try/src/libcore/io.rs

@@ -4,13 +4,13 @@ Module: io
 Basic input/output
 */
 
-import result::Result;
+use result::Result;
 
-import cmp::Eq;
-import dvec::DVec;
-import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
-import libc::consts::os::posix88::*;
-import libc::consts::os::extra::*;
+use cmp::Eq;
+use dvec::DVec;
+use libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
+use libc::consts::os::posix88::*;
+use libc::consts::os::extra::*;
 
 #[allow(non_camel_case_types)] // not sure what to do about this
 type fd_t = c_int;

branches/try/src/libcore/iter-trait.rs

@@ -2,8 +2,8 @@
 // workaround our lack of traits and lack of macros.  See core.{rc,rs} for
 // how this file is used.
 
-import cmp::{Eq, Ord};
-import inst::{IMPL_T, EACH, SIZE_HINT};
+use cmp::{Eq, Ord};
+use inst::{IMPL_T, EACH, SIZE_HINT};
 export extensions;
 
 impl<A> IMPL_T<A>: iter::BaseIter<A> {