---

yaml
---
r: 140754
b: refs/heads/try2
c: be82449
h: refs/heads/master
v: v3

Author: emberian

[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: 1bf2f68bb255cc6833d4253c4f6d071af9e05648
+refs/heads/try2: be82449a9a73efd7831b01a523c5f11cd27baa11
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1425,8 +1425,6 @@ names are effectively reserved. Some significant attributes include:
 * The `test` attribute, for marking functions as unit tests.
 * The `allow`, `warn`, `forbid`, and `deny` attributes, for controlling lint checks. Lint checks supported
 by the compiler can be found via `rustc -W help`.
-* The `deriving` attribute, for automatically generating
-  implementations of certain traits.
 
 Other attributes may be added or removed during development of the language.
 
@@ -1528,47 +1526,6 @@ A complete list of the built-in language items follows:
 > **Note:** This list is likely to become out of date. We should auto-generate it
 > from `librustc/middle/lang_items.rs`.
 
-### Deriving
-
-The `deriving` attribute allows certain traits to be automatically
-implemented for data structures. For example, the following will
-create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type
-parameter `T` will be given the `Eq` or `Clone` constraints for the
-appropriate `impl`:
-
-~~~
-#[deriving(Eq, Clone)]
-struct Foo<T> {
-    a: int,
-    b: T
-}
-~~~
-
-The generated `impl` for `Eq` is equivalent to
-
-~~~
-# struct Foo<T> { a: int, b: T }
-impl<T: Eq> Eq for Foo<T> {
-    fn eq(&self, other: &Foo<T>) -> bool {
-        self.a == other.a && self.b == other.b
-    }
-
-    fn ne(&self, other: &Foo<T>) -> bool {
-        self.a != other.a || self.b != other.b
-    }
-}
-~~~
-
-Supported traits for `deriving` are:
-
-* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
-* Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone`, to perform deep copies.
-* `IterBytes`, to iterate over the bytes in a data type.
-* `Rand`, to create a random instance of a data type.
-* `ToStr`, to convert to a string. For a type with this instance,
-  `obj.to_str()` has the same output as `fmt!("%?", obj)`.
-
 # Statements and expressions
 
 Rust is _primarily_ an expression language. This means that most forms of

branches/try2/doc/tutorial.md

@@ -2290,27 +2290,6 @@ let nonsense = mycircle.radius() * mycircle.area();
 
 > ***Note:*** Trait inheritance does not actually work with objects yet
 
-## Deriving implementations for traits
-
-A small number of traits in `core` and `std` can have implementations
-that can be automatically derived. These instances are specified by
-placing the `deriving` attribute on a data type declaration. For
-example, the following will mean that `Circle` has an implementation
-for `Eq` and can be used with the equality operators, and that a value
-of type `ABC` can be randomly generated and converted to a string:
-
-~~~
-#[deriving(Eq)]
-struct Circle { radius: float }
-
-#[deriving(Rand, ToStr)]
-enum ABC { A, B, C }
-~~~
-
-The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
-`ToStr`.
-
 # Modules and crates
 
 The Rust namespace is arranged in a hierarchy of modules. Each source

branches/try2/src/driver/driver.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[no_core];
+extern mod core(vers = "0.7-pre");
+
 #[cfg(rustpkg)]
 extern mod this(name = "rustpkg", vers = "0.7-pre");
 

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -20,16 +20,6 @@ pub extern "rust-intrinsic" {
     pub fn atomic_cxchg_acq(dst: &mut int, old: int, src: int) -> int;
     pub fn atomic_cxchg_rel(dst: &mut int, old: int, src: int) -> int;
 
-    #[cfg(not(stage0))]
-    pub fn atomic_load(src: &int) -> int;
-    #[cfg(not(stage0))]
-    pub fn atomic_load_acq(src: &int) -> int;
-
-    #[cfg(not(stage0))]
-    pub fn atomic_store(dst: &mut int, val: int);
-    #[cfg(not(stage0))]
-    pub fn atomic_store_rel(dst: &mut int, val: int);
-
     pub fn atomic_xchg(dst: &mut int, src: int) -> int;
     pub fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
     pub fn atomic_xchg_rel(dst: &mut int, src: int) -> int;

branches/try2/src/librust/rust.rc

@@ -20,11 +20,6 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-extern mod rustpkg(vers = "0.7-pre");
-extern mod rustdoc(vers = "0.7-pre");
-extern mod rusti(vers = "0.7-pre");
-extern mod rustc(vers = "0.7-pre");
-
 use core::run;
 
 enum ValidUsage {
@@ -41,13 +36,13 @@ impl ValidUsage {
 }
 
 enum Action<'self> {
-    Call(&'self fn(args: &[~str]) -> ValidUsage),
-    CallMain(&'static str, &'self fn()),
+    Exec(&'self str),
+    Call(&'self fn(args: &[~str]) -> ValidUsage)
 }
 
 enum UsageSource<'self> {
-    UsgStr(&'self str),
-    UsgCall(&'self fn()),
+    UsgExec(&'self str),
+    UsgStr(&'self str)
 }
 
 struct Command<'self> {
@@ -60,9 +55,9 @@ struct Command<'self> {
 static commands: &'static [Command<'static>] = &[
     Command{
         cmd: "build",
-        action: CallMain("rustc", rustc::main),
+        action: Exec("rustc"),
         usage_line: "compile rust source files",
-        usage_full: UsgCall(rustc_help),
+        usage_full: UsgExec("rustc --help")
     },
     Command{
         cmd: "run",
@@ -86,21 +81,21 @@ static commands: &'static [Command<'static>] = &[
     },
     Command{
         cmd: "doc",
-        action: CallMain("rustdoc", rustdoc::main),
+        action: Exec("rustdoc"),
         usage_line: "generate documentation from doc comments",
-        usage_full: UsgCall(rustdoc::config::usage),
+        usage_full: UsgExec("rustdoc --help")
     },
     Command{
         cmd: "pkg",
-        action: CallMain("rustpkg", rustpkg::main),
+        action: Exec("rustpkg"),
         usage_line: "download, build, install rust packages",
-        usage_full: UsgCall(rustpkg::usage::general),
+        usage_full: UsgExec("rustpkg --help")
     },
     Command{
         cmd: "sketch",
-        action: CallMain("rusti", rusti::main),
+        action: Exec("rusti"),
         usage_line: "run a rust interpreter",
-        usage_full: UsgStr("\nUsage:\trusti"),
+        usage_full: UsgStr("\nUsage:\trusti")
     },
     Command{
         cmd: "help",
@@ -114,10 +109,6 @@ static commands: &'static [Command<'static>] = &[
     }
 ];
 
-fn rustc_help() {
-    rustc::usage(copy os::args()[0])
-}
-
 fn find_cmd(command_string: &str) -> Option<Command> {
     do commands.find |command| {
         command.cmd == command_string
@@ -129,14 +120,20 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
         match find_cmd(command_string) {
             Some(command) => {
                 match command.action {
-                    CallMain(prog, _) => io::println(fmt!(
+                    Exec(s) => io::println(fmt!(
                         "The %s command is an alias for the %s program.",
-                        command.cmd, prog)),
+                        command.cmd, s)),
                     _       => ()
                 }
                 match command.usage_full {
-                    UsgStr(msg) => io::println(fmt!("%s\n", msg)),
-                    UsgCall(f)  => f(),
+                    UsgStr(msg)          => io::println(fmt!("%s\n", msg)),
+                    UsgExec(commandline) => {
+                        let mut words = ~[];
+                        for str::each_word(commandline) |word| { words.push(word.to_owned()) }
+                        let words = words;
+                        let (prog, args) = (words.head(), words.tail());
+                        run::run_program(*prog, args);
+                    }
                 }
                 Valid
             },
@@ -154,40 +151,50 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
     match args {
         [filename] => {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
-            invoke("rustc", &[~"--test", filename.to_owned(),
-                              ~"-o", test_exec.to_owned()], rustc::main);
-            run::run_program(~"./" + test_exec, []);
+            if run::run_program("rustc", [
+                ~"--test",
+                filename.to_owned(),
+                ~"-o",
+                test_exec.to_owned()
+            ]) == 0 {
+                run::run_program(~"./" + test_exec, []);
+            }
             Valid
         }
-        _ => Invalid
+        _          => Invalid
     }
 }
 
 fn cmd_run(args: &[~str]) -> ValidUsage {
     match args {
         [filename, ..prog_args] => {
             let exec = Path(filename).filestem().unwrap() + "~";
-            invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
-                   rustc::main);
-            run::run_program(~"./"+exec, prog_args);
+            if run::run_program("rustc", [
+                filename.to_owned(),
+                ~"-o",
+                exec.to_owned()
+            ]) == 0 {
+                run::run_program(~"./"+exec, prog_args);
+            }
             Valid
         }
-        _ => Invalid
+        _          => Invalid
     }
 }
 
-fn invoke(prog: &str, args: &[~str], f: &fn()) {
-    let mut osargs = ~[prog.to_owned()];
-    osargs.push_all_move(args.to_owned());
-    os::set_args(osargs);
-    f();
-}
-
 fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
     match command.action {
         Call(f) => f(args),
-        CallMain(prog, f) => {
-            invoke(prog, args, f);
+        Exec(commandline) => {
+            let mut words = ~[];
+            for str::each_word(commandline) |word| { words.push(word.to_owned()) }
+            let words = words;
+            let (prog, prog_args) = (words.head(), words.tail());
+            let exitstatus = run::run_program(
+                *prog,
+                vec::append(vec::to_owned(prog_args), args)
+            );
+            os::set_exit_status(exitstatus);
             Valid
         }
     }
@@ -225,9 +232,11 @@ pub fn main() {
     let args = os_args.tail();
 
     if !args.is_empty() {
-        for find_cmd(*args.head()).each |command| {
-            let result = do_command(command, args.tail());
-            if result.is_valid() { return; }
+        for commands.each |command| {
+            if command.cmd == *args.head() {
+                let result = do_command(command, args.tail());
+                if result.is_valid() { return; }
+            }
         }
     }
 

branches/try2/src/librustc/lib/llvm.rs

@@ -1339,16 +1339,13 @@ pub mod llvm {
                                     PointerVal: ValueRef) -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildLoad(B: BuilderRef,
-                                    PointerVal: ValueRef,
-                                    Name: *c_char)
-                                 -> ValueRef;
-
+                                PointerVal: ValueRef,
+                                Name: *c_char)
+                             -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildStore(B: BuilderRef,
                                      Val: ValueRef,
-                                     Ptr: ValueRef)
-                                  -> ValueRef;
-
+                                     Ptr: ValueRef) -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildGEP(B: BuilderRef,
                                Pointer: ValueRef,
@@ -1564,17 +1561,6 @@ pub mod llvm {
                                        Name: *c_char) -> ValueRef;
 
         /* Atomic Operations */
-        pub unsafe fn LLVMBuildAtomicLoad(B: BuilderRef,
-                                          PointerVal: ValueRef,
-                                          Order: AtomicOrdering)
-                                       -> ValueRef;
-
-        pub unsafe fn LLVMBuildAtomicStore(B: BuilderRef,
-                                           Val: ValueRef,
-                                           Ptr: ValueRef,
-                                           Order: AtomicOrdering)
-                                        -> ValueRef;
-
         pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef,
                                              LHS: ValueRef,
                                              CMP: ValueRef,