---

yaml
---
r: 30797
b: refs/heads/incoming
c: c91821d
h: refs/heads/master
i:
  30795: 6e17fca
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 25715bd59eb339fd37f979a425651802702b4618
+refs/heads/incoming: c91821d356b87dcbede651a1130ea758bf6a5265
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/cleanup.rs

@@ -10,8 +10,6 @@ use repr::BoxRepr;
 use sys::TypeDesc;
 use cast::transmute;
 
-export annihilate;
-
 /**
  * Runtime structures
  *

branches/incoming/src/libcore/cmath.rs

@@ -3,10 +3,6 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-// uncomment once #1433 is fixed
-// FIXME (#1433): export c_float_math_consts;
-// FIXME (#1433): export c_double_math_consts;
-
 use libc::c_int;
 use libc::c_float;
 use libc::c_double;
@@ -193,66 +189,62 @@ pub mod c_double_targ_consts {
 
 FIXME use these once they can be parsed (see Issue #1433)
 
-mod c_float_math_consts {
-    #[legacy_exports];
-    const pi: c_float = 0x1.921fb6p+1_f32;
-    const div_1_pi: c_float = 0x1.45f306p-2_f32;
-    const div_2_pi: c_float = 0x1.45f306p-1_f32;
-    const div_pi_2: c_float = 0x1.921fb6p+0_f32;
-    const div_pi_4: c_float = 0x1.921fb6p-1_f32;
-    const div_2_sqrtpi: c_float = 0x1.20dd76p+0_f32;
-    const e: c_float = 0x1.5bf0a8p+1_f32;
-    const log2_e: c_float = 0x1.715476p+0_f32;
-    const log10_e: c_float = 0x1.bcb7b2p-2_f32;
-    const ln_2: c_float = 0x1.62e43p-1_f32;
-    const ln_10: c_float = 0x1.26bb1cp+1_f32;
-    const sqrt2: c_float = 0x1.6a09e6p+0_f32;
-    const div_1_sqrt2: c_float = 0x1.6a09e6p-1_f32;
+pub mod c_float_math_consts {
+    pub const pi: c_float = 0x1.921fb6p+1_f32;
+    pub const div_1_pi: c_float = 0x1.45f306p-2_f32;
+    pub const div_2_pi: c_float = 0x1.45f306p-1_f32;
+    pub const div_pi_2: c_float = 0x1.921fb6p+0_f32;
+    pub const div_pi_4: c_float = 0x1.921fb6p-1_f32;
+    pub const div_2_sqrtpi: c_float = 0x1.20dd76p+0_f32;
+    pub const e: c_float = 0x1.5bf0a8p+1_f32;
+    pub const log2_e: c_float = 0x1.715476p+0_f32;
+    pub const log10_e: c_float = 0x1.bcb7b2p-2_f32;
+    pub const ln_2: c_float = 0x1.62e43p-1_f32;
+    pub const ln_10: c_float = 0x1.26bb1cp+1_f32;
+    pub const sqrt2: c_float = 0x1.6a09e6p+0_f32;
+    pub const div_1_sqrt2: c_float = 0x1.6a09e6p-1_f32;
 }
 
-mod c_double_math_consts {
-    #[legacy_exports];
-    const pi: c_double = 0x1.921fb54442d18p+1_f64;
-    const div_1_pi: c_double = 0x1.45f306dc9c883p-2_f64;
-    const div_2_pi: c_double = 0x1.45f306dc9c883p-1_f64;
-    const div_pi_2: c_double = 0x1.921fb54442d18p+0_f64;
-    const div_pi_4: c_double = 0x1.921fb54442d18p-1_f64;
-    const div_2_sqrtpi: c_double = 0x1.20dd750429b6dp+0_f64;
-    const e: c_double = 0x1.5bf0a8b145769p+1_f64;
-    const log2_e: c_double = 0x1.71547652b82fep+0_f64;
-    const log10_e: c_double = 0x1.bcb7b1526e50ep-2_f64;
-    const ln_2: c_double = 0x1.62e42fefa39efp-1_f64;
-    const ln_10: c_double = 0x1.26bb1bbb55516p+1_f64;
-    const sqrt2: c_double = 0x1.6a09e667f3bcdp+0_f64;
-    const div_1_sqrt2: c_double = 0x1.6a09e667f3bcdp-1_f64;
+pub mod c_double_math_consts {
+    pub const pi: c_double = 0x1.921fb54442d18p+1_f64;
+    pub const div_1_pi: c_double = 0x1.45f306dc9c883p-2_f64;
+    pub const div_2_pi: c_double = 0x1.45f306dc9c883p-1_f64;
+    pub const div_pi_2: c_double = 0x1.921fb54442d18p+0_f64;
+    pub const div_pi_4: c_double = 0x1.921fb54442d18p-1_f64;
+    pub const div_2_sqrtpi: c_double = 0x1.20dd750429b6dp+0_f64;
+    pub const e: c_double = 0x1.5bf0a8b145769p+1_f64;
+    pub const log2_e: c_double = 0x1.71547652b82fep+0_f64;
+    pub const log10_e: c_double = 0x1.bcb7b1526e50ep-2_f64;
+    pub const ln_2: c_double = 0x1.62e42fefa39efp-1_f64;
+    pub const ln_10: c_double = 0x1.26bb1bbb55516p+1_f64;
+    pub const sqrt2: c_double = 0x1.6a09e667f3bcdp+0_f64;
+    pub const div_1_sqrt2: c_double = 0x1.6a09e667f3bcdp-1_f64;
 }
 
-mod c_float_targ_consts {
-    #[legacy_exports];
-    const radix: uint = 2u;
-    const mantissa_digits: uint = 24u;
-    const digits: uint = 6u;
-    const min_exp: int = -125;
-    const max_exp: int = 128;
-    const min_10_exp: int = -37;
-    const max_10_exp: int = 38;
-    const min_value: c_float = 0x1p-126_f32;
-    const max_value: c_float = 0x1.fffffep+127_f32;
-    const epsilon: c_float = 0x1p-23_f32;
+pub mod c_float_targ_consts {
+    pub const radix: uint = 2u;
+    pub const mantissa_digits: uint = 24u;
+    pub const digits: uint = 6u;
+    pub const min_exp: int = -125;
+    pub const max_exp: int = 128;
+    pub const min_10_exp: int = -37;
+    pub const max_10_exp: int = 38;
+    pub const min_value: c_float = 0x1p-126_f32;
+    pub const max_value: c_float = 0x1.fffffep+127_f32;
+    pub const epsilon: c_float = 0x1p-23_f32;
 }
 
-mod c_double_targ_consts {
-    #[legacy_exports];
-    const radix: uint = 2u;
-    const mantissa_digits: uint = 53u;
-    const digits: uint = 15u;
-    const min_exp: int = -1021;
-    const max_exp: int = 1024;
-    const min_10_exp: int = -307;
-    const max_10_exp: int = 308;
-    const min_value: c_double = 0x1p-1022_f64;
-    const max_value: c_double = 0x1.fffffffffffffp+1023_f64;
-    const epsilon: c_double = 0x1p-52_f64;
+pub mod c_double_targ_consts {
+    pub const radix: uint = 2u;
+    pub const mantissa_digits: uint = 53u;
+    pub const digits: uint = 15u;
+    pub const min_exp: int = -1021;
+    pub const max_exp: int = 1024;
+    pub const min_10_exp: int = -307;
+    pub const max_10_exp: int = 308;
+    pub const min_value: c_double = 0x1p-1022_f64;
+    pub const max_value: c_double = 0x1.fffffffffffffp+1023_f64;
+    pub const epsilon: c_double = 0x1p-52_f64;
 }
 
 */

branches/incoming/src/libcore/future.rs

@@ -19,20 +19,8 @@ use either::Either;
 use pipes::recv;
 use cast::copy_lifetime;
 
-export Future;
-export extensions;
-export from_value;
-export from_port;
-export from_fn;
-export get;
-export with;
-export spawn;
-
-// for task.rs
-export future_pipe;
-
 #[doc = "The future type"]
-struct Future<A> {
+pub struct Future<A> {
     /*priv*/ mut state: FutureState<A>,
 
     // FIXME(#2829) -- futures should not be copyable, because they close
@@ -67,7 +55,7 @@ impl<A> Future<A> {
     }
 }
 
-fn from_value<A>(+val: A) -> Future<A> {
+pub fn from_value<A>(+val: A) -> Future<A> {
     /*!
      * Create a future from a value
      *
@@ -78,7 +66,8 @@ fn from_value<A>(+val: A) -> Future<A> {
     Future {state: Forced(~(move val))}
 }
 
-fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
+pub fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) ->
+        Future<A> {
     /*!
      * Create a future from a port
      *
@@ -97,7 +86,7 @@ fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
     }
 }
 
-fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
+pub fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
     /*!
      * Create a future from a function.
      *
@@ -109,7 +98,7 @@ fn from_fn<A>(+f: ~fn() -> A) -> Future<A> {
     Future {state: Pending(move f)}
 }
 
-fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
+pub fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
     /*!
      * Create a future from a unique closure.
      *
@@ -122,7 +111,7 @@ fn spawn<A:Send>(+blk: fn~() -> A) -> Future<A> {
     }))
 }
 
-fn get_ref<A>(future: &r/Future<A>) -> &r/A {
+pub fn get_ref<A>(future: &r/Future<A>) -> &r/A {
     /*!
      * Executes the future's closure and then returns a borrowed
      * pointer to the result.  The borrowed pointer lasts as long as
@@ -160,13 +149,13 @@ fn get_ref<A>(future: &r/Future<A>) -> &r/A {
     }
 }
 
-fn get<A:Copy>(future: &Future<A>) -> A {
+pub fn get<A:Copy>(future: &Future<A>) -> A {
     //! Get the value of the future
 
     *get_ref(future)
 }
 
-fn with<A,B>(future: &Future<A>, blk: fn((&A)) -> B) -> B {
+pub fn with<A,B>(future: &Future<A>, blk: fn((&A)) -> B) -> B {
     //! Work with the value without copying it
 
     blk(get_ref(future))
@@ -179,74 +168,73 @@ proto! future_pipe (
 )
 
 #[allow(non_implicitly_copyable_typarams)]
-mod test {
-    #[legacy_exports];
+pub mod test {
     #[test]
-    fn test_from_value() {
+    pub fn test_from_value() {
         let f = from_value(~"snail");
         assert get(&f) == ~"snail";
     }
 
     #[test]
-    fn test_from_port() {
+    pub fn test_from_port() {
         let (po, ch) = future_pipe::init();
         future_pipe::server::completed(ch, ~"whale");
         let f = from_port(po);
         assert get(&f) == ~"whale";
     }
 
     #[test]
-    fn test_from_fn() {
+    pub fn test_from_fn() {
         let f = from_fn(|| ~"brail");
         assert get(&f) == ~"brail";
     }
 
     #[test]
-    fn test_interface_get() {
+    pub fn test_interface_get() {
         let f = from_value(~"fail");
         assert f.get() == ~"fail";
     }
 
     #[test]
-    fn test_with() {
+    pub fn test_with() {
         let f = from_value(~"nail");
         assert with(&f, |v| copy *v) == ~"nail";
     }
 
     #[test]
-    fn test_get_ref_method() {
+    pub fn test_get_ref_method() {
         let f = from_value(22);
         assert *f.get_ref() == 22;
     }
 
     #[test]
-    fn test_get_ref_fn() {
+    pub fn test_get_ref_fn() {
         let f = from_value(22);
         assert *get_ref(&f) == 22;
     }
 
     #[test]
-    fn test_interface_with() {
+    pub fn test_interface_with() {
         let f = from_value(~"kale");
         assert f.with(|v| copy *v) == ~"kale";
     }
 
     #[test]
-    fn test_spawn() {
+    pub fn test_spawn() {
         let f = spawn(|| ~"bale");
         assert get(&f) == ~"bale";
     }
 
     #[test]
     #[should_fail]
     #[ignore(cfg(target_os = "win32"))]
-    fn test_futurefail() {
+    pub fn test_futurefail() {
         let f = spawn(|| fail);
         let _x: ~str = get(&f);
     }
 
     #[test]
-    fn test_sendable_future() {
+    pub fn test_sendable_future() {
         let expected = ~"schlorf";
         let f = do spawn |copy expected| { copy expected };
         do task::spawn {

branches/incoming/src/libcore/gc.rs

@@ -34,10 +34,6 @@ use libc::size_t;
 use libc::uintptr_t;
 use send_map::linear::LinearMap;
 
-export Word;
-export gc;
-export cleanup_stack_for_failure;
-
 // Mirrors rust_stack.h stk_seg
 struct StackSegment {
     prev: *StackSegment,
@@ -268,7 +264,7 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
     }
 }
 
-fn gc() {
+pub fn gc() {
     unsafe {
         // Abort when GC is disabled.
         if get_safe_point_count() == 0 {
@@ -301,7 +297,7 @@ fn expect_sentinel() -> bool { false }
 // This should only be called from fail, as it will drop the roots
 // which are *live* on the stack, rather than dropping those that are
 // dead.
-fn cleanup_stack_for_failure() {
+pub fn cleanup_stack_for_failure() {
     unsafe {
         // Abort when GC is disabled.
         if get_safe_point_count() == 0 {