---

yaml
---
r: 22094
b: refs/heads/snap-stage3
c: a08919a
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e430a699f2c60890d9b86069fd0c68a70ece7120
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: dd80cb22e3591267882136d8d5529dc92f049952
+refs/heads/snap-stage3: a08919a52273e8fdeb044e43be16c72915760035
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/char.rs

@@ -47,9 +47,9 @@ export is_alphabetic,
        to_digit, cmp,
        escape_default, escape_unicode;
 
-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;
+pub use is_alphabetic = unicode::derived_property::Alphabetic;
+pub use is_XID_start = unicode::derived_property::XID_Start;
+pub use is_XID_continue = unicode::derived_property::XID_Continue;
 
 
 /**

branches/snap-stage3/src/libcore/f32.rs

@@ -6,8 +6,8 @@
 
 // PORT
 
-use cmath::c_float::*;
-use cmath::c_float_targ_consts::*;
+pub use cmath::c_float::*;
+pub 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;
@@ -22,58 +22,56 @@ export lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix;
 export modf, pow, round, sin, sinh, sqrt, tan, tanh, tgamma, trunc;
 export signbit;
 
-export num;
-
 // These are not defined inside consts:: for consistency with
 // the integer types
 
-const NaN: f32 = 0.0_f32/0.0_f32;
+pub const NaN: f32 = 0.0_f32/0.0_f32;
 
-const infinity: f32 = 1.0_f32/0.0_f32;
+pub const infinity: f32 = 1.0_f32/0.0_f32;
 
-const neg_infinity: f32 = -1.0_f32/0.0_f32;
+pub const neg_infinity: f32 = -1.0_f32/0.0_f32;
 
-pure fn is_NaN(f: f32) -> bool { f != f }
+pub pure fn is_NaN(f: f32) -> bool { f != f }
 
-pure fn add(x: f32, y: f32) -> f32 { return x + y; }
+pub pure fn add(x: f32, y: f32) -> f32 { return x + y; }
 
-pure fn sub(x: f32, y: f32) -> f32 { return x - y; }
+pub pure fn sub(x: f32, y: f32) -> f32 { return x - y; }
 
-pure fn mul(x: f32, y: f32) -> f32 { return x * y; }
+pub pure fn mul(x: f32, y: f32) -> f32 { return x * y; }
 
-pure fn div(x: f32, y: f32) -> f32 { return x / y; }
+pub pure fn div(x: f32, y: f32) -> f32 { return x / y; }
 
-pure fn rem(x: f32, y: f32) -> f32 { return x % y; }
+pub pure fn rem(x: f32, y: f32) -> f32 { return x % y; }
 
-pure fn lt(x: f32, y: f32) -> bool { return x < y; }
+pub pure fn lt(x: f32, y: f32) -> bool { return x < y; }
 
-pure fn le(x: f32, y: f32) -> bool { return x <= y; }
+pub pure fn le(x: f32, y: f32) -> bool { return x <= y; }
 
-pure fn eq(x: f32, y: f32) -> bool { return x == y; }
+pub pure fn eq(x: f32, y: f32) -> bool { return x == y; }
 
-pure fn ne(x: f32, y: f32) -> bool { return x != y; }
+pub pure fn ne(x: f32, y: f32) -> bool { return x != y; }
 
-pure fn ge(x: f32, y: f32) -> bool { return x >= y; }
+pub pure fn ge(x: f32, y: f32) -> bool { return x >= y; }
 
-pure fn gt(x: f32, y: f32) -> bool { return x > y; }
+pub pure fn gt(x: f32, y: f32) -> bool { return x > y; }
 
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.
 
 /// Returns true if `x` is a positive number, including +0.0f320 and +Infinity
-pure fn is_positive(x: f32) -> bool
+pub pure fn is_positive(x: f32) -> bool
     { return x > 0.0f32 || (1.0f32/x) == infinity; }
 
 /// Returns true if `x` is a negative number, including -0.0f320 and -Infinity
-pure fn is_negative(x: f32) -> bool
+pub pure fn is_negative(x: f32) -> bool
     { return x < 0.0f32 || (1.0f32/x) == neg_infinity; }
 
 /**
  * Returns true if `x` is a negative number, including -0.0f320 and -Infinity
  *
  * This is the same as `f32::is_negative`.
  */
-pure fn is_nonpositive(x: f32) -> bool {
+pub pure fn is_nonpositive(x: f32) -> bool {
   return x < 0.0f32 || (1.0f32/x) == neg_infinity;
 }
 
@@ -82,78 +80,76 @@ pure fn is_nonpositive(x: f32) -> bool {
  *
  * This is the same as `f32::is_positive`.)
  */
-pure fn is_nonnegative(x: f32) -> bool {
+pub pure fn is_nonnegative(x: f32) -> bool {
   return x > 0.0f32 || (1.0f32/x) == infinity;
 }
 
 /// Returns true if `x` is a zero number (positive or negative zero)
-pure fn is_zero(x: f32) -> bool {
+pub pure fn is_zero(x: f32) -> bool {
     return x == 0.0f32 || x == -0.0f32;
 }
 
 /// Returns true if `x`is an infinite number
-pure fn is_infinite(x: f32) -> bool {
+pub pure fn is_infinite(x: f32) -> bool {
     return x == infinity || x == neg_infinity;
 }
 
 /// Returns true if `x`is a finite number
-pure fn is_finite(x: f32) -> bool {
+pub pure fn is_finite(x: f32) -> bool {
     return !(is_NaN(x) || is_infinite(x));
 }
 
 // FIXME (#1999): add is_normal, is_subnormal, and fpclassify.
 
 /* Module: consts */
-mod consts {
-    #[legacy_exports];
-
+pub mod consts {
     // FIXME (requires Issue #1433 to fix): replace with mathematical
     // constants from cmath.
     /// Archimedes' constant
-    const pi: f32 = 3.14159265358979323846264338327950288_f32;
+    pub const pi: f32 = 3.14159265358979323846264338327950288_f32;
 
     /// pi/2.0
-    const frac_pi_2: f32 = 1.57079632679489661923132169163975144_f32;
+    pub const frac_pi_2: f32 = 1.57079632679489661923132169163975144_f32;
 
     /// pi/4.0
-    const frac_pi_4: f32 = 0.785398163397448309615660845819875721_f32;
+    pub const frac_pi_4: f32 = 0.785398163397448309615660845819875721_f32;
 
     /// 1.0/pi
-    const frac_1_pi: f32 = 0.318309886183790671537767526745028724_f32;
+    pub const frac_1_pi: f32 = 0.318309886183790671537767526745028724_f32;
 
     /// 2.0/pi
-    const frac_2_pi: f32 = 0.636619772367581343075535053490057448_f32;
+    pub const frac_2_pi: f32 = 0.636619772367581343075535053490057448_f32;
 
     /// 2.0/sqrt(pi)
-    const frac_2_sqrtpi: f32 = 1.12837916709551257389615890312154517_f32;
+    pub const frac_2_sqrtpi: f32 = 1.12837916709551257389615890312154517_f32;
 
     /// sqrt(2.0)
-    const sqrt2: f32 = 1.41421356237309504880168872420969808_f32;
+    pub const sqrt2: f32 = 1.41421356237309504880168872420969808_f32;
 
     /// 1.0/sqrt(2.0)
-    const frac_1_sqrt2: f32 = 0.707106781186547524400844362104849039_f32;
+    pub const frac_1_sqrt2: f32 = 0.707106781186547524400844362104849039_f32;
 
     /// Euler's number
-    const e: f32 = 2.71828182845904523536028747135266250_f32;
+    pub const e: f32 = 2.71828182845904523536028747135266250_f32;
 
     /// log2(e)
-    const log2_e: f32 = 1.44269504088896340735992468100189214_f32;
+    pub const log2_e: f32 = 1.44269504088896340735992468100189214_f32;
 
     /// log10(e)
-    const log10_e: f32 = 0.434294481903251827651128918916605082_f32;
+    pub const log10_e: f32 = 0.434294481903251827651128918916605082_f32;
 
     /// ln(2.0)
-    const ln_2: f32 = 0.693147180559945309417232121458176568_f32;
+    pub const ln_2: f32 = 0.693147180559945309417232121458176568_f32;
 
     /// ln(10.0)
-    const ln_10: f32 = 2.30258509299404568401799145468436421_f32;
+    pub const ln_10: f32 = 2.30258509299404568401799145468436421_f32;
 }
 
-pure fn signbit(x: f32) -> int {
+pub pure fn signbit(x: f32) -> int {
     if is_negative(x) { return 1; } else { return 0; }
 }
 
-pure fn logarithm(n: f32, b: f32) -> f32 {
+pub pure fn logarithm(n: f32, b: f32) -> f32 {
     return log2(n) / log2(b);
 }