---

yaml
---
r: 57715
b: refs/heads/incoming
c: a6dd7dc
h: refs/heads/master
i:
  57713: 48c6be4
  57711: e5317ae
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: bf67eb2362b7d0f37012f2d6dac604c3bbacd2c6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: bf4f088eaccfe24d4c30e7bf52e4c2bd20b9ff47
+refs/heads/incoming: a6dd7dc1f2e1057719179e861a5a5ae55d6a8335
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/rust.md

@@ -1467,10 +1467,10 @@ A complete list of the built-in language items follows:
   : Elements can be subtracted.
 `mul`
   : Elements can be multiplied.
-`div`
-  : Elements can be divided.
-`mod`
-  : Elements have a modulo operation.
+`quot`
+  : Elements have a quotient operation.
+`rem`
+  : Elements have a remainder operation.
 `neg`
   : Elements can be negated arithmetically.
 `not`
@@ -1856,11 +1856,11 @@ The default meaning of the operators on standard types is given here.
   : Multiplication.
     Calls the `mul` method on the `core::ops::Mul` trait.
 `/`
-  : Division.
-    Calls the `div` method on the `core::ops::Div` trait.
+  : Quotient.
+    Calls the `quot` method on the `core::ops::Quot` trait.
 `%`
-  : Modulo (a.k.a. "remainder").
-    Calls the `modulo` method on the `core::ops::Modulo` trait.
+  : Remainder.
+    Calls the `rem` method on the `core::ops::Rem` trait.
 
 #### Bitwise operators
 

branches/incoming/doc/tutorial.md

@@ -362,7 +362,7 @@ The nil type, written `()`, has a single value, also written `()`.
 ## Operators
 
 Rust's set of operators contains very few surprises. Arithmetic is done with
-`*`, `/`, `%`, `+`, and `-` (multiply, divide, take remainder, add, and subtract). `-` is
+`*`, `/`, `%`, `+`, and `-` (multiply, quotient, remainder, add, and subtract). `-` is
 also a unary prefix operator that negates numbers. As in C, the bitwise operators
 `>>`, `<<`, `&`, `|`, and `^` are also supported.
 

branches/incoming/src/etc/kate/rust.xml

@@ -57,8 +57,8 @@
 		<item> Add </item>
 		<item> Sub </item>
 		<item> Mul </item>
-		<item> Div </item>
-		<item> Modulo </item>
+		<item> Quot </item>
+		<item> Rem </item>
 		<item> Neg </item>
 		<item> BitAnd </item>
 		<item> BitOr </item>

branches/incoming/src/etc/vim/syntax/rust.vim

@@ -46,7 +46,7 @@ syn keyword   rustType        off_t dev_t ino_t pid_t mode_t ssize_t
 
 syn keyword   rustTrait       Const Copy Send Owned " inherent traits
 syn keyword   rustTrait       Eq Ord Num Ptr
-syn keyword   rustTrait       Drop Add Sub Mul Div Modulo Neg BitAnd BitOr
+syn keyword   rustTrait       Drop Add Sub Mul Quot Rem Neg BitAnd BitOr
 syn keyword   rustTrait       BitXor Shl Shr Index
 
 syn keyword   rustSelf        self

branches/incoming/src/libcore/at_vec.rs

@@ -41,7 +41,7 @@ pub mod rustrt {
 pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr =
-            ::cast::reinterpret_cast(&addr_of(&v));
+            ::cast::transmute(addr_of(&v));
         (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
@@ -208,7 +208,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
+        let repr: **mut VecRepr = ::cast::transmute(addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -226,7 +226,7 @@ pub mod raw {
 
     #[inline(always)] // really pretty please
     pub unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&v);
+        let repr: **mut VecRepr = ::cast::transmute(v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = addr_of(&((**repr).unboxed.data));
@@ -322,4 +322,4 @@ mod test {
         assert!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]);
         assert!(from_slice([@[42]]) == @[@[42]]);
     }
-}
+}

branches/incoming/src/libcore/cell.rs

@@ -20,7 +20,7 @@ Similar to a mutable option type, but friendlier.
 */
 
 pub struct Cell<T> {
-    value: Option<T>
+    priv value: Option<T>
 }
 
 impl<T:cmp::Eq> cmp::Eq for Cell<T> {

branches/incoming/src/libcore/char.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -234,21 +234,6 @@ pub fn escape_default(c: char) -> ~str {
     }
 }
 
-/// Returns the amount of bytes this character would need if encoded in utf8
-pub fn len_utf8_bytes(c: char) -> uint {
-    static max_one_b: uint = 128u;
-    static max_two_b: uint = 2048u;
-    static max_three_b: uint = 65536u;
-    static max_four_b: uint = 2097152u;
-
-    let code = c as uint;
-    if code < max_one_b { 1u }
-    else if code < max_two_b { 2u }
-    else if code < max_three_b { 3u }
-    else if code < max_four_b { 4u }
-    else { fail!(~"invalid character!") }
-}
-
 /**
  * Compare two chars
  *
@@ -349,6 +334,7 @@ fn test_escape_default() {
     assert_eq!(escape_default('\U0001d4b6'), ~"\\U0001d4b6");
 }
 
+
 #[test]
 fn test_escape_unicode() {
     assert_eq!(escape_unicode('\x00'), ~"\\x00");

branches/incoming/src/libcore/core.rc

@@ -75,7 +75,12 @@ they contained the following prologue:
 
 pub use kinds::{Const, Copy, Owned, Durable};
 pub use ops::{Drop};
+#[cfg(stage0)]
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+pub use ops::{Add, Sub, Mul, Quot, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Shl, Shr, Index};
 
@@ -159,9 +164,6 @@ pub mod vec;
 pub mod at_vec;
 pub mod str;
 
-#[path = "str/ascii.rs"]
-pub mod ascii;
-
 pub mod ptr;
 pub mod owned;
 pub mod managed;

branches/incoming/src/libcore/gc.rs

@@ -73,18 +73,19 @@ pub mod rustrt {
         pub unsafe fn rust_gc_metadata() -> *Word;
 
         pub unsafe fn rust_get_stack_segment() -> *StackSegment;
+        pub unsafe fn rust_get_c_stack() -> *StackSegment;
     }
 }
 
 unsafe fn bump<T, U>(ptr: *T, count: uint) -> *U {
-    return cast::reinterpret_cast(&ptr::offset(ptr, count));
+    return cast::transmute(ptr::offset(ptr, count));
 }
 
 unsafe fn align_to_pointer<T>(ptr: *T) -> *T {
     let align = sys::min_align_of::<*T>();
-    let ptr: uint = cast::reinterpret_cast(&ptr);
+    let ptr: uint = cast::transmute(ptr);
     let ptr = (ptr + (align - 1)) & -align;
-    return cast::reinterpret_cast(&ptr);
+    return cast::transmute(ptr);
 }
 
 unsafe fn get_safe_point_count() -> uint {
@@ -129,8 +130,8 @@ type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
 unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
-    let fp_bytes: *u8 = cast::reinterpret_cast(&fp);
-    let sp_meta: *u32 = cast::reinterpret_cast(&sp.sp_meta);
+    let fp_bytes: *u8 = cast::transmute(fp);
+    let sp_meta: *u32 = cast::transmute(sp.sp_meta);
 
     let num_stack_roots = *sp_meta as uint;
     let num_reg_roots = *ptr::offset(sp_meta, 1) as uint;
@@ -171,9 +172,9 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
 
 // Is fp contained in segment?
 unsafe fn is_frame_in_segment(fp: *Word, segment: *StackSegment) -> bool {
-    let begin: Word = cast::reinterpret_cast(&segment);
-    let end: Word = cast::reinterpret_cast(&(*segment).end);
-    let frame: Word = cast::reinterpret_cast(&fp);
+    let begin: Word = cast::transmute(segment);
+    let end: Word = cast::transmute((*segment).end);
+    let frame: Word = cast::transmute(fp);
 
     return begin <= frame && frame <= end;
 }
@@ -339,7 +340,7 @@ pub fn cleanup_stack_for_failure() {
         // own stack roots on the stack anyway.
         let sentinel_box = ~0;
         let sentinel: **Word = if expect_sentinel() {
-            cast::reinterpret_cast(&ptr::addr_of(&sentinel_box))
+            cast::transmute(ptr::addr_of(&sentinel_box))
         } else {
             ptr::null()
         };

branches/incoming/src/libcore/num/f32.rs

@@ -16,8 +16,13 @@ use option::Option;
 use from_str;
 use to_str;
 
-#[cfg(notest)] use cmp;
-#[cfg(notest)] use ops;
+#[cfg(notest)] use cmp::{Eq, Ord};
+#[cfg(stage0,notest)]
+use ops::{Add, Sub, Mul, Div, Modulo, Neg};
+#[cfg(stage1,notest)]
+#[cfg(stage2,notest)]
+#[cfg(stage3,notest)]
+use ops::{Add, Sub, Mul, Quot, Rem, Neg};
 
 pub use cmath::c_float_targ_consts::*;
 
@@ -131,7 +136,7 @@ pub fn sub(x: f32, y: f32) -> f32 { return x - y; }
 pub fn mul(x: f32, y: f32) -> f32 { return x * y; }
 
 #[inline(always)]
-pub fn div(x: f32, y: f32) -> f32 { return x / y; }
+pub fn quot(x: f32, y: f32) -> f32 { return x / y; }
 
 #[inline(always)]
 pub fn rem(x: f32, y: f32) -> f32 { return x % y; }
@@ -265,15 +270,15 @@ pub fn logarithm(n: f32, b: f32) -> f32 {
 }
 
 #[cfg(notest)]
-impl cmp::Eq for f32 {
+impl Eq for f32 {
     #[inline(always)]
     fn eq(&self, other: &f32) -> bool { (*self) == (*other) }
     #[inline(always)]
     fn ne(&self, other: &f32) -> bool { (*self) != (*other) }
 }
 
 #[cfg(notest)]
-impl cmp::Ord for f32 {
+impl Ord for f32 {
     #[inline(always)]
     fn lt(&self, other: &f32) -> bool { (*self) < (*other) }
     #[inline(always)]
@@ -295,33 +300,41 @@ impl num::One for f32 {
 }
 
 #[cfg(notest)]
-impl ops::Add<f32,f32> for f32 {
-    #[inline(always)]
+impl Add<f32,f32> for f32 {
     fn add(&self, other: &f32) -> f32 { *self + *other }
 }
 #[cfg(notest)]
-impl ops::Sub<f32,f32> for f32 {
-    #[inline(always)]
+impl Sub<f32,f32> for f32 {
     fn sub(&self, other: &f32) -> f32 { *self - *other }
 }
 #[cfg(notest)]
-impl ops::Mul<f32,f32> for f32 {
-    #[inline(always)]
+impl Mul<f32,f32> for f32 {
     fn mul(&self, other: &f32) -> f32 { *self * *other }
 }
-#[cfg(notest)]
-impl ops::Div<f32,f32> for f32 {
-    #[inline(always)]
+#[cfg(stage0,notest)]
+impl Div<f32,f32> for f32 {
     fn div(&self, other: &f32) -> f32 { *self / *other }
 }
-#[cfg(notest)]
-impl ops::Modulo<f32,f32> for f32 {
+#[cfg(stage1,notest)]
+#[cfg(stage2,notest)]
+#[cfg(stage3,notest)]
+impl Quot<f32,f32> for f32 {
     #[inline(always)]
+    fn quot(&self, other: &f32) -> f32 { *self / *other }
+}
+#[cfg(stage0,notest)]
+impl Modulo<f32,f32> for f32 {
     fn modulo(&self, other: &f32) -> f32 { *self % *other }
 }
-#[cfg(notest)]
-impl ops::Neg<f32> for f32 {
+#[cfg(stage1,notest)]
+#[cfg(stage2,notest)]
+#[cfg(stage3,notest)]
+impl Rem<f32,f32> for f32 {
     #[inline(always)]
+    fn rem(&self, other: &f32) -> f32 { *self % *other }
+}
+#[cfg(notest)]
+impl Neg<f32> for f32 {
     fn neg(&self) -> f32 { -*self }
 }