---

yaml
---
r: 24455
b: refs/heads/master
c: d8287f0
h: refs/heads/master
i:
  24453: 495b8d6
  24451: d9287ef
  24447: 83f7273
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 84bc74e54a2d46f87c4205b99e78c2ce3ef9c881
+refs/heads/master: d8287f0e41be93fa0c902cac71637cbcb1632a50
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/doc/rust.md

@@ -162,7 +162,12 @@ and functions defined in it. If it has a `main` function, it can be
 compiled to an executable. Rust does not allow code that's not a
 declaration to appear at the top level of the file—all statements must
 live inside a function.  Rust programs can also be compiled as
-libraries, and included in other programs.
+libraries, and included in other programs. The `extern mod std`
+directive that appears at the top of many examples imports the
+[standard library][std], described in more detail [later
+on](#modules-and-crates).
+
+[std]: http://doc.rust-lang.org/doc/std
 
 ## Editing Rust code
 
@@ -1279,73 +1284,6 @@ For a more in-depth explanation of borrowed pointers, read the
 
 [borrowtut]: tutorial-borrowed-ptr.html
 
-## Dereferencing pointers
-
-Rust uses the unary star operator (`*`) to access the contents of a
-box or pointer, similarly to C.
-
-~~~
-let managed = @10;
-let owned = ~20;
-let borrowed = &30;
-
-let sum = *managed + *owned + *borrowed;
-~~~
-
-Dereferenced mutable pointers may appear on the left hand side of
-assignments, in which case the value they point to is modified.
-
-~~~
-let managed = @mut 10;
-let owned = ~mut 20;
-
-let mut value = 30;
-let borrowed = &mut value;
-
-*managed = *owned + 10;
-*owned = *borrowed + 100;
-*borrowed = *managed + 1000;
-~~~
-
-Pointers have high operator precedence, but lower precedence than the
-dot operator used for field and method access. This can lead to some
-awkward code filled with parenthesis.
-
-~~~
-# struct Point { x: float, y: float }
-# enum Shape { Rectangle(Point, Point) }
-# impl Shape { fn area() -> int { 0 } }
-let start = @Point { x: 10f, y: 20f };
-let end = ~Point { x: (*start).x + 100f, y: (*start).y + 100f };
-let rect = &Rectangle(*start, *end);
-let area = (*rect).area();
-~~~
-
-To combat this ugliness the dot operator performs _automatic pointer
-dereferencing_ on the receiver (the value on the left hand side of the
-dot), so in most cases dereferencing the receiver is not necessary.
-
-~~~
-# struct Point { x: float, y: float }
-# enum Shape { Rectangle(Point, Point) }
-# impl Shape { fn area() -> int { 0 } }
-let start = @Point { x: 10f, y: 20f };
-let end = ~Point { x: start.x + 100f, y: start.y + 100f };
-let rect = &Rectangle(*start, *end);
-let area = rect.area();
-~~~
-
-Auto-dereferencing is performed through any number of pointers. If you
-felt inclined you could write something silly like
-
-~~~
-# struct Point { x: float, y: float }
-let point = &@~Point { x: 10f, y: 20f };
-io::println(fmt!("%f", point.x));
-~~~
-
-The indexing operator (`[]`) is also auto-dereferencing.
-
 # Vectors and strings
 
 Vectors are a contiguous section of memory containing zero or more
@@ -1443,7 +1381,7 @@ mutable_crayons[0] = Apricot;
 This is a simple example of Rust's _dual-mode data structures_, also
 referred to as _freezing and thawing_.
 
-Strings are implemented with vectors of `u8`, though they have a distinct
+Strings are implemented with vectors of `[u8]`, though they have a distinct
 type. They support most of the same allocation options as
 vectors, though the string literal without a storage sigil, e.g.
 `"foo"` is treated differently than a comparable vector (`[foo]`).
@@ -1553,7 +1491,7 @@ access local variables in the enclosing scope.
 
 ~~~~
 let mut max = 0;
-[1, 2, 3].map(|x| if *x > max { max = *x });
+(~[1, 2, 3]).map(|x| if *x > max { max = *x });
 ~~~~
 
 Stack closures are very efficient because their environment is
@@ -1581,7 +1519,8 @@ This code creates a closure that adds a given string to its argument,
 returns it from a function, and then calls it:
 
 ~~~~
-# extern mod std;
+extern mod std;
+
 fn mk_appender(suffix: ~str) -> fn@(~str) -> ~str {
     return fn@(s: ~str) -> ~str { s + suffix };
 }

trunk/doc/tutorial.md

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE language SYSTEM "language.dtd">
-<language name="Rust" version="0.4.0" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.3.1" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>
@@ -9,39 +9,59 @@
 		<item> type </item>
 	</list>
 	<list name="keywords">
+		<item> alt </item>
+		<item> again </item>
 		<item> as </item>
 		<item> assert </item>
 		<item> break </item>
+		<item> check </item>
+		<item> claim </item>
 		<item> const </item>
 		<item> copy </item>
 		<item> do </item>
 		<item> drop </item>
 		<item> else </item>
-		<item> enum </item>
 		<item> export </item>
 		<item> extern </item>
+		<item> f16 </item>
+		<item> f80 </item>
+		<item> f128 </item>
 		<item> fail </item>
 		<item> for </item>
 		<item> if </item>
 		<item> impl </item>
+		<item> import </item>
+		<item> in </item>
 		<item> let </item>
 		<item> log </item>
 		<item> loop </item>
+		<item> m32 </item>
+		<item> m64 </item>
+		<item> m128 </item>
 		<item> match </item>
 		<item> mod </item>
+		<item> module </item>
 		<item> move </item>
 		<item> mut </item>
+		<item> new </item>
+		<item> of </item>
+		<item> owned </item>
 		<item> priv </item>
 		<item> pub </item>
 		<item> pure </item>
-		<item> ref </item>
+		<item> ret </item>
 		<item> return </item>
-		<item> static </item>
-		<item> struct </item>
-		<item> trait </item>
+		<item> to </item>
+		<item> unchecked </item>
 		<item> unsafe </item>
 		<item> use </item>
 		<item> while </item>
+		<item> with </item>
+		<item> mod </item>
+		<item> trait </item>
+		<item> class </item>
+		<item> struct </item>
+		<item> enum </item>
 	</list>
 	<list name="types">
 		<item> bool </item>
@@ -60,9 +80,8 @@
 		<item> float </item>
 		<item> char </item>
 		<item> str </item>
-		<item> Either </item>
-		<item> Option </item>
-		<item> Result </item>
+		<item> option </item>
+		<item> either </item>
 	</list>
 	<list name="ctypes">
 		<item> c_float </item>
@@ -102,16 +121,16 @@
 	<list name="constants">
 		<item> true </item>
 		<item> false </item>
-		<item> Some </item>
-		<item> None </item>
-		<item> Left </item>
-		<item> Right </item>
-		<item> Ok </item>
-		<item> Err </item>
-		<item> Success </item>
-		<item> Failure </item>
-		<item> Cons </item>
-		<item> Nil </item>
+		<item> some </item>
+		<item> none </item>
+		<item> left </item>
+		<item> right </item>
+		<item> ok </item>
+		<item> err </item>
+		<item> success </item>
+		<item> failure </item>
+		<item> cons </item>
+		<item> nil </item>
 	</list>
 	<list name="cconstants">
 		<item> EXIT_FAILURE </item>

trunk/src/etc/kate/rust.xml

@@ -21,6 +21,10 @@ extern mod rustrt {
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     #[legacy_exports];
+    #[cfg(stage0)]
+    fn move_val_init<T>(&dst: T, -src: T);
+    #[cfg(stage1)]
+    #[cfg(stage2)]
     fn move_val_init<T>(dst: &mut T, -src: T);
 }
 
@@ -177,6 +181,20 @@ pub mod raw {
         }
     }
 
+    // This doesn't bother to make sure we have space.
+    #[cfg(stage0)]
+    #[inline(always)] // really pretty please
+    pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) {
+        let repr: **VecRepr = ::cast::reinterpret_cast(&v);
+        let fill = (**repr).unboxed.fill;
+        (**repr).unboxed.fill += sys::size_of::<T>();
+        let p = addr_of(&((**repr).unboxed.data));
+        let p = ptr::offset(p, fill) as *mut T;
+        rusti::move_val_init(*p, move initval);
+    }
+    // This doesn't bother to make sure we have space.
+    #[cfg(stage1)]
+    #[cfg(stage2)]
     #[inline(always)] // really pretty please
     pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);

trunk/src/libcore/at_vec.rs

@@ -18,6 +18,10 @@ extern mod rustrt {
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
+    #[cfg(stage0)]
+    fn move_val_init<T>(&dst: T, -src: T);
+    #[cfg(stage1)]
+    #[cfg(stage2)]
     fn move_val_init<T>(dst: &mut T, -src: T);
 }
 
@@ -99,6 +103,23 @@ pub pure fn len<T>(v: &[const T]) -> uint {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
  */
+#[cfg(stage0)]
+pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
+    unsafe {
+        let mut v = with_capacity(n_elts);
+        do as_mut_buf(v) |p, _len| {
+            let mut i: uint = 0u;
+            while i < n_elts {
+                rusti::move_val_init(*ptr::mut_offset(p, i), op(i));
+                i += 1u;
+            }
+        }
+        raw::set_len(&mut v, n_elts);
+        return move v;
+    }
+}
+#[cfg(stage1)]
+#[cfg(stage2)]
 pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
     unsafe {
         let mut v = with_capacity(n_elts);
@@ -482,6 +503,19 @@ pub fn push<T>(v: &mut ~[T], initval: T) {
     }
 }
 
+#[cfg(stage0)]
+// This doesn't bother to make sure we have space.
+#[inline(always)] // really pretty please
+unsafe fn push_fast<T>(v: &mut ~[T], initval: T) {
+    let repr: **raw::VecRepr = ::cast::transmute(v);
+    let fill = (**repr).unboxed.fill;
+    (**repr).unboxed.fill += sys::size_of::<T>();
+    let p = addr_of(&((**repr).unboxed.data));
+    let p = ptr::offset(p, fill) as *mut T;
+    rusti::move_val_init(*p, move initval);
+}
+#[cfg(stage1)]
+#[cfg(stage2)]
 // This doesn't bother to make sure we have space.
 #[inline(always)] // really pretty please
 unsafe fn push_fast<T>(v: &mut ~[T], initval: T) {
@@ -1759,6 +1793,18 @@ pub mod raw {
         as_const_buf(v, |p, _len| *ptr::const_offset(p, i))
     }
 
+    #[cfg(stage0)]
+    #[inline(always)]
+    pub unsafe fn init_elem<T>(v: &[mut T], i: uint, val: T) {
+        let mut box = Some(move val);
+        do as_mut_buf(v) |p, _len| {
+            let mut box2 = None;
+            box2 <-> box;
+            rusti::move_val_init(*ptr::mut_offset(p, i),
+                                 option::unwrap(move box2));
+        }
+    }
+    #[cfg(stage1)]
     /**
      * Unchecked vector index assignment.  Does not drop the
      * old value and hence is only suitable when the vector