---

yaml
---
r: 139226
b: refs/heads/try2
c: 9aa0ced
h: refs/heads/master
v: v3

Author: thadguidry

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: a56ec8c1342453a88be79e192a11501844375d40
+refs/heads/try2: 9aa0cedc84792e711f49951a2dfdc9f1586d5d38
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -136,9 +136,17 @@ validate_opt () {
                 isArgValid=1
             fi
         done
-        if test $isArgValid -eq 0
+        if [ "$arg" = "--help" ]
         then
-            err "Option '$arg' is not recognized"
+            echo ""
+            echo "No more help available for Configure options,"
+            echo "check the Wiki or join our IRC channel"
+            break
+        else
+            if test $isArgValid -eq 0
+            then
+                err "Option '$arg' is not recognized"
+            fi
         fi
     done
 }
@@ -266,13 +274,42 @@ case $CFG_OSTYPE in
     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;
+# Thad's Cygwin identifers below
+
+#   Vista 32 bit
+    CYGWIN_NT-6.0)
+        CFG_OSTYPE=pc-mingw32
+        CFG_CPUTYPE=i686
+        ;;
+
+#   Vista 64 bit
+    CYGWIN_NT-6.0-WOW64)
+        CFG_OSTYPE=w64-mingw32
+        CFG_CPUTYPE=x86_64
+        ;;
+
+#   Win 7 32 bit
+    CYGWIN_NT-6.1)
+        CFG_OSTYPE=pc-mingw32
+        CFG_CPUTYPE=i686
+        ;;
 
+#   Win 7 64 bit
+    CYGWIN_NT-6.1-WOW64)
+        CFG_OSTYPE=w64-mingw32
+        CFG_CPUTYPE=x86_64
+        ;;
+
+# We do not detect other OS such as XP/2003 using 64 bit using uname.
+# If we want to in the future, we will need to use Cygwin - Chuck's csih helper in /usr/lib/csih/winProductName.exe or alternative.
     *)
         err "unknown OS type: $CFG_OSTYPE"
         ;;
 esac
 
 
+if [ -z "$CFG_CPUTYPE" ]
+then
 case $CFG_CPUTYPE in
 
     i386 | i486 | i686 | i786 | x86)
@@ -290,6 +327,7 @@ case $CFG_CPUTYPE in
     *)
         err "unknown CPU type: $CFG_CPUTYPE"
 esac
+fi
 
 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]

branches/try2/doc/rust.md

@@ -206,7 +206,7 @@ The keywords are the following strings:
 ~~~~~~~~ {.keyword}
 as
 break
-copy
+const copy
 do drop
 else enum extern
 false fn for
@@ -1099,7 +1099,7 @@ const_item : "const" ident ':' type '=' expr ';' ;
 
 A *constant* is a named value stored in read-only memory in a crate.
 The value bound to a constant is evaluated at compile time.
-Constants are declared with the `static` keyword.
+Constants are declared with the `const` keyword.
 A constant item must have an expression giving its definition.
 The definition expression of a constant is limited to expression forms that can be evaluated at compile time.
 
@@ -1108,18 +1108,18 @@ The derived types are borrowed pointers, static arrays, tuples, and structs.
 Borrowed pointers must be have the `'static` lifetime.
 
 ~~~~
-static bit1: uint = 1 << 0;
-static bit2: uint = 1 << 1;
+const bit1: uint = 1 << 0;
+const bit2: uint = 1 << 1;
 
-static bits: [uint, ..2] = [bit1, bit2];
-static string: &'static str = "bitstring";
+const bits: [uint * 2] = [bit1, bit2];
+const string: &'static str = "bitstring";
 
 struct BitsNStrings {
-    mybits: [uint, ..2],
+    mybits: [uint *2],
     mystring: &'self str
 }
 
-static bits_n_strings: BitsNStrings<'static> = BitsNStrings {
+const bits_n_strings: BitsNStrings<'static> = BitsNStrings {
     mybits: bits,
     mystring: string
 };
@@ -1206,10 +1206,10 @@ For example:
 
 ~~~~
 trait Num {
-    fn from_int(n: int) -> Self;
+    static fn from_int(n: int) -> Self;
 }
 impl Num for float {
-    fn from_int(n: int) -> float { n as float }
+    static fn from_int(n: int) -> float { n as float }
 }
 let x: float = Num::from_int(42);
 ~~~~

branches/try2/doc/tutorial-borrowed-ptr.md

@@ -394,7 +394,7 @@ copying.
 #     Circle(Point, float),   // origin, radius
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
-# static tau: float = 6.28f;
+# const tau: float = 6.28f;
 fn compute_area(shape: &Shape) -> float {
     match *shape {
         Circle(_, radius) => 0.5 * tau * radius * radius,

branches/try2/doc/tutorial.md

@@ -237,7 +237,7 @@ can specify a variable's type by following it with a colon, then the type
 name. Constants, on the other hand, always require a type annotation.
 
 ~~~~
-static monster_factor: float = 57.8;
+const monster_factor: float = 57.8;
 let monster_size = monster_factor * 10.0;
 let monster_size: int = 50;
 ~~~~
@@ -916,7 +916,7 @@ use core::libc::types::os::arch::c95::size_t;
 struct Blob { priv ptr: *c_void }
 
 impl Blob {
-    fn new() -> Blob {
+    static fn new() -> Blob {
         unsafe { Blob{ptr: calloc(1, int::bytes as size_t)} }
     }
 }
@@ -1222,7 +1222,7 @@ pointers to vectors are also called 'slices'.
 #     Black, BlizzardBlue, Blue
 # }
 // A fixed-size stack vector
-let stack_crayons: [Crayon, ..3] = [Almond, AntiqueBrass, Apricot];
+let stack_crayons: [Crayon * 3] = [Almond, AntiqueBrass, Apricot];
 
 // A borrowed pointer to stack-allocated vector
 let stack_crayons: &[Crayon] = &[Aquamarine, Asparagus, AtomicTangerine];
@@ -1264,7 +1264,7 @@ Square brackets denote indexing into a vector:
 #               Aquamarine, Asparagus, AtomicTangerine,
 #               BananaMania, Beaver, Bittersweet };
 # fn draw_scene(c: Crayon) { }
-let crayons: [Crayon, ..3] = [BananaMania, Beaver, Bittersweet];
+let crayons: [Crayon * 3] = [BananaMania, Beaver, Bittersweet];
 match crayons[0] {
     Bittersweet => draw_scene(crayons[0]),
     _ => ()
@@ -1274,7 +1274,7 @@ match crayons[0] {
 A vector can be destructured using pattern matching:
 
 ~~~~
-let numbers: [int, ..3] = [1, 2, 3];
+let numbers: [int * 3] = [1, 2, 3];
 let score = match numbers {
     [] => 0,
     [a] => a * 10,
@@ -1768,25 +1768,32 @@ s.draw_borrowed();
 (&@~s).draw_borrowed();
 ~~~
 
-Implementations may also define standalone (sometimes called "static")
-methods. The absence of a `self` paramater distinguishes such methods.
-These methods are the preferred way to define constructor functions.
+Implementations may also define _static_ methods,
+which don't have an explicit `self` argument.
+The `static` keyword distinguishes static methods from methods that have a `self`:
 
 ~~~~ {.xfail-test}
 impl Circle {
     fn area(&self) -> float { ... }
-    fn new(area: float) -> Circle { ... }
+    static fn new(area: float) -> Circle { ... }
 }
 ~~~~
 
-To call such a method, just prefix it with the type name and a double colon:
+> ***Note***: In the future the `static` keyword will be removed and static methods
+> will be distinguished solely by the presence or absence of the `self` argument.
+> In the current langugage instance methods may also be declared without an explicit
+> `self` argument, in which case `self` is an implicit reference.
+> That form of method is deprecated.
+
+Constructors are one common application for static methods, as in `new` above.
+To call a static method, you have to prefix it with the type name and a double colon:
 
 ~~~~
 # use core::float::consts::pi;
 # use core::float::sqrt;
 struct Circle { radius: float }
 impl Circle {
-    fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
+    static fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
 }
 let c = Circle::new(42.5);
 ~~~~
@@ -2048,23 +2055,22 @@ second parameter of type `self`.
 In contrast, in the `impl`, `equals` takes a second parameter of
 type `int`, only using `self` as the name of the receiver.
 
-Just as in type implementations, traits can define standalone (static)
-methods.  These methods are called by prefixing the method name with the trait
-name and a double colon.  The compiler uses type inference to decide which
-implementation to use.
+Traits can also define static methods which are called by prefixing
+the method name with the trait name.
+The compiler will use type inference to decide which implementation to call.
 
 ~~~~
-trait Shape { fn new(area: float) -> Self; }
+trait Shape { static fn new(area: float) -> Self; }
 # use core::float::consts::pi;
 # use core::float::sqrt;
 struct Circle { radius: float }
 struct Square { length: float }
 
 impl Shape for Circle {
-    fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
+    static fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
 }
 impl Shape for Square {
-    fn new(area: float) -> Square { Square { length: sqrt(area) } }
+    static fn new(area: float) -> Square { Square { length: sqrt(area) } }
 }
 
 let area = 42.5;
@@ -2306,7 +2312,7 @@ them. The `pub` keyword modifies an item's visibility, making it
 visible outside its containing module. An expression with `::`, like
 `farm::chicken`, can name an item outside of its containing
 module. Items, such as those declared with `fn`, `struct`, `enum`,
-`type`, or `static`, are module-private by default.
+`type`, or `const`, are module-private by default.
 
 Visibility restrictions in Rust exist only at module boundaries. This
 is quite different from most object-oriented languages that also

branches/try2/src/compiletest/runtest.rs

@@ -81,7 +81,7 @@ fn run_rfail_test(config: config, props: TestProps, testfile: &Path) {
     };
 
     // The value our Makefile configures valgrind to return on failure
-    static valgrind_err: int = 100;
+    const valgrind_err: int = 100;
     if ProcRes.status == valgrind_err {
         fatal_ProcRes(~"run-fail test isn't valgrind-clean!", ProcRes);
     }
@@ -92,7 +92,7 @@ fn run_rfail_test(config: config, props: TestProps, testfile: &Path) {
 
 fn check_correct_failure_status(ProcRes: ProcRes) {
     // The value the rust runtime returns on failure
-    static rust_err: int = 101;
+    const rust_err: int = 101;
     if ProcRes.status != rust_err {
         fatal_ProcRes(
             fmt!("failure produced the wrong error code: %d",

branches/try2/src/libcore/at_vec.rs

@@ -291,7 +291,7 @@ pub fn test() {
         }
     }
 
-    assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]);
+    fail_unless!(seq_range(10, 15) == @[10, 11, 12, 13, 14]);
     fail_unless!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]);
     fail_unless!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]);
 }

branches/try2/src/libcore/condition.rs

@@ -22,11 +22,11 @@ pub struct Handler<T, U> {
 
 pub struct Condition<T, U> {
     name: &'static str,
-    key: task::local_data::LocalDataKey<'self, Handler<T, U>>
+    key: task::local_data::LocalDataKey/&self<Handler<T, U>>
 }
 
-pub impl<T, U> Condition<'self, T, U> {
-    fn trap(&self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
+pub impl<T, U> Condition/&self<T, U> {
+    fn trap(&self, h: &'self fn(T) -> U) -> Trap/&self<T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
             let prev = task::local_data::local_data_get(self.key);
@@ -65,11 +65,11 @@ pub impl<T, U> Condition<'self, T, U> {
 }
 
 struct Trap<T, U> {
-    cond: &'self Condition<'self, T, U>,
+    cond: &'self Condition/&self<T, U>,
     handler: @Handler<T, U>
 }
 
-pub impl<T, U> Trap<'self, T, U> {
+pub impl<T, U> Trap/&self<T, U> {
     fn in<V>(&self, inner: &'self fn() -> V) -> V {
         unsafe {
             let _g = Guard { cond: self.cond };
@@ -81,11 +81,11 @@ pub impl<T, U> Trap<'self, T, U> {
 }
 
 struct Guard<T, U> {
-    cond: &'self Condition<'self, T, U>
+    cond: &'self Condition/&self<T, U>
 }
 
 #[unsafe_destructor]
-impl<T, U> Drop for Guard<'self, T, U> {
+impl<T, U> Drop for Guard/&self<T, U> {
     fn finalize(&self) {
         unsafe {
             debug!("Guard: popping handler from TLS");

branches/try2/src/libcore/flate.rs

@@ -41,10 +41,10 @@ pub mod rustrt {
     }
 }
 
-static lz_none : c_int = 0x0;   // Huffman-coding only.
-static lz_fast : c_int = 0x1;   // LZ with only one probe
-static lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
-static lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
+const lz_none : c_int = 0x0;   // Huffman-coding only.
+const lz_fast : c_int = 0x1;   // LZ with only one probe
+const lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
+const lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
 
 pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {

branches/try2/src/libcore/gc.rs

@@ -211,11 +211,11 @@ unsafe fn find_segment_for_frame(fp: *Word, segment: *StackSegment)
 
 type Memory = uint;
 
-static task_local_heap: Memory = 1;
-static exchange_heap:   Memory = 2;
-static stack:           Memory = 4;
+const task_local_heap: Memory = 1;
+const exchange_heap:   Memory = 2;
+const stack:           Memory = 4;
 
-static need_cleanup:    Memory = exchange_heap | stack;
+const need_cleanup:    Memory = exchange_heap | stack;
 
 // Walks stack, searching for roots of the requested type, and passes
 // each root to the visitor.

branches/try2/src/libcore/hashmap.rs

@@ -25,7 +25,7 @@ pub mod linear {
     use uint;
     use vec;
 
-    static INITIAL_CAPACITY: uint = 32u; // 2^5
+    const INITIAL_CAPACITY: uint = 32u; // 2^5
 
     struct Bucket<K,V> {
         hash: uint,