---

yaml
---
r: 57135
b: refs/heads/try
c: 2871f4d
h: refs/heads/master
i:
  57133: cc2e362
  57131: 3987e38
  57127: cb35003
  57119: 3c0b257
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: 391de1c690927ed430708f659a68581368e1e254
+refs/heads/try: 2871f4df6fe7a19d41ddca71d96b9192d86d278b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rustpkg.md

@@ -0,0 +1,108 @@
+% Rustpkg Reference Manual
+
+# Introduction
+
+This document is the reference manual for the Rustpkg packaging and build tool for the Rust programming language.
+
+## Disclaimer
+
+Rustpkg is a work in progress, as is this reference manual.
+If the actual behavior of rustpkg differs from the behavior described in this reference,
+that reflects either an incompleteness or a bug in rustpkg.
+
+# Package searching
+
+rustpkg searches for packages using the `RUST_PATH` environment variable,
+which is a colon-separated list (semicolon-separated on Windows) of directories.
+
+Each directory in this list is a *workspace* for rustpkg.
+
+`RUST_PATH` implicitly contains an entry for `./.rust` (as well as
+`../.rust`, `../../.rust`,
+and so on for every parent of `.` up to the filesystem root).
+That means that if `RUST_PATH` is not set,
+then rustpkg will still search for workspaces in `./.rust` and so on.
+`RUST_PATH` also implicitly contains an entry for the system path:
+`/usr/local` or the equivalent on Windows.
+This entry comes after the implicit entries for `./.rust` and so on.
+Finally, the last implicit entry in `RUST_PATH` is `~/.rust`
+or the equivalent on Windows.
+
+Each workspace may contain one or more packages.
+
+# Package structure
+
+A valid workspace must contain each of the following subdirectories:
+
+* 'src/': contains one subdirectory per package. Each subdirectory contains source files for a given package.
+
+     For example, if `foo` is a workspace containing the package `bar`,
+     then `foo/src/bar/main.rs` could be the `main` entry point for
+     building a `bar` executable.
+* 'lib/': `rustpkg install` installs libraries into a target-specific subdirectory of this directory.
+
+     For example, on a 64-bit machine running Mac OS X,
+     if `foo` is a workspace containing the package `bar`,
+     rustpkg will install libraries for bar to `foo/lib/x86_64-apple-darwin/`.
+     The libraries will have names of the form `foo/lib/x86_64-apple-darwin/libbar-[hash].dylib`,
+     where [hash] is a hash of the package ID.
+* 'bin/': `rustpkg install` installs executable binaries into a target-specific subdirectory of this directory.
+
+     For example, on a 64-bit machine running Mac OS X,
+     if `foo` is a workspace, containing the package `bar`,
+     rustpkg will install executables for `bar` to
+     `foo/bin/x86_64-apple-darwin/`.
+     The executables will have names of the form `foo/bin/x86_64-apple-darwin/bar`.
+* 'build/': `rustpkg build` stores temporary build artifacts in a target-specific subdirectory of this directory.
+
+     For example, on a 64-bit machine running Mac OS X,
+     if `foo` is a workspace containing the package `bar` and `foo/src/bar/main.rs` exists,
+     then `rustpkg build` will create `foo/build/x86_64-apple-darwin/bar/main.o`.
+
+# Package identifiers
+
+A package identifier identifies a package uniquely.
+A package can be stored in a workspace on the local file system,
+or on a remote Web server, in which case the package ID resembles a URL.
+For example, `github.com/mozilla/rust` is a package ID
+that would refer to the git repository browsable at `http://github.com/mozilla/rust`.
+
+## Source files
+
+rustpkg searches for four different fixed filenames in order to determine the crates to build:
+
+* `main.rs`: Assumed to be a main entry point for building an executable.
+* `lib.rs`: Assumed to be a library crate.
+* `test.rs`: Assumed to contain tests declared with the `#[test]` attribute.
+* `bench.rs`: Assumed to contain benchmarks declared with the `#[bench]` attribute.
+
+# Custom build scripts
+
+A file called `pkg.rs` at the root level in a workspace is called a *package script*.
+If a package script exists, rustpkg executes it to build the package
+rather than inferring crates as described previously.
+
+# Command reference
+
+## build
+
+`rustpkg build foo` searches for a package with ID `foo`
+and builds it in any workspace(s) where it finds one.
+Supposing such packages are found in workspaces X, Y, and Z,
+the command leaves behind files in `X`'s, `Y`'s, and `Z`'s `build` directories,
+but not in their `lib` or `bin` directories.
+
+## clean
+
+`rustpkg clean foo` deletes the contents of `foo`'s `build` directory.
+
+## install
+
+`rustpkg install foo` builds the libraries and/or executables that are targets for `foo`,
+and then installs them either into `foo`'s `lib` and `bin` directories,
+or into the `lib` and `bin` subdirectories of the first entry in `RUST_PATH`.
+
+## test
+
+`rustpkg test foo` builds `foo`'s `test.rs` file if necessary,
+then runs the resulting test executable.

branches/try/mk/docs.mk

@@ -81,6 +81,20 @@ doc/rust.pdf: doc/rust.tex
     endif
   endif
 
+DOCS += doc/rustpkg.html
+doc/rustpkg.html: rustpkg.md doc/version_info.html doc/rust.css doc/manual.css
+	@$(call E, pandoc: $@)
+	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
+	"$(CFG_PANDOC)" \
+         --standalone --toc \
+         --section-divs \
+         --number-sections \
+         --from=markdown --to=html \
+         --css=rust.css \
+         --css=manual.css \
+	     --include-before-body=doc/version_info.html \
+         --output=$@
+
 ######################################################################
 # Node (tutorial related)
 ######################################################################

branches/try/src/libcore/num/strconv.rs

@@ -655,6 +655,7 @@ mod test {
     use option::*;
 
     #[test]
+    #[ignore(reason = "fails in x86")]
     fn from_str_ignore_underscores() {
         let s : Option<u8> = from_str_common("__1__", 2, false, false, false,
                                              ExpNone, false, true);

branches/try/src/librustc/back/link.rs

@@ -61,23 +61,32 @@ pub fn llvm_err(sess: Session, msg: ~str) -> ! {
 
 pub fn WriteOutputFile(sess: Session,
         PM: lib::llvm::PassManagerRef, M: ModuleRef,
-        Triple: *c_char,
+        Triple: &str,
+        Feature: &str,
+        Output: &str,
         // FIXME: When #2334 is fixed, change
         // c_uint to FileType
-        Output: *c_char, FileType: c_uint,
+        FileType: c_uint,
         OptLevel: c_int,
         EnableSegmentedStacks: bool) {
     unsafe {
-        let result = llvm::LLVMRustWriteOutputFile(
-                PM,
-                M,
-                Triple,
-                Output,
-                FileType,
-                OptLevel,
-                EnableSegmentedStacks);
-        if (!result) {
-            llvm_err(sess, ~"Could not write output");
+        do str::as_c_str(Triple) |Triple| {
+            do str::as_c_str(Feature) |Feature| {
+                do str::as_c_str(Output) |Output| {
+                    let result = llvm::LLVMRustWriteOutputFile(
+                            PM,
+                            M,
+                            Triple,
+                            Feature,
+                            Output,
+                            FileType,
+                            OptLevel,
+                            EnableSegmentedStacks);
+                    if (!result) {
+                        llvm_err(sess, ~"Could not write output");
+                    }
+                }
+            }
         }
     }
 }
@@ -310,66 +319,49 @@ pub mod write {
                         llvm::LLVMWriteBitcodeToFile(llmod, buf)
                     });
                     pm = mk_pass_manager();
-                    // Save the assembly file if -S is used
 
+                    // Save the assembly file if -S is used
                     if output_type == output_type_assembly {
-                        let _: () = str::as_c_str(
+                        WriteOutputFile(
+                            sess,
+                            pm.llpm,
+                            llmod,
                             sess.targ_cfg.target_strs.target_triple,
-                            |buf_t| {
-                                str::as_c_str(output.to_str(), |buf_o| {
-                                    WriteOutputFile(
-                                        sess,
-                                        pm.llpm,
-                                        llmod,
-                                        buf_t,
-                                        buf_o,
-                                        lib::llvm::AssemblyFile as c_uint,
-                                        CodeGenOptLevel,
-                                        true)
-                                })
-                            });
+                            opts.target_feature,
+                            output.to_str(),
+                            lib::llvm::AssemblyFile as c_uint,
+                            CodeGenOptLevel,
+                            true);
                     }
 
-
                     // Save the object file for -c or --save-temps alone
                     // This .o is needed when an exe is built
                     if output_type == output_type_object ||
                            output_type == output_type_exe {
-                        let _: () = str::as_c_str(
+                        WriteOutputFile(
+                            sess,
+                            pm.llpm,
+                            llmod,
                             sess.targ_cfg.target_strs.target_triple,
-                            |buf_t| {
-                                str::as_c_str(output.to_str(), |buf_o| {
-                                    WriteOutputFile(
-                                        sess,
-                                        pm.llpm,
-                                        llmod,
-                                        buf_t,
-                                        buf_o,
-                                        lib::llvm::ObjectFile as c_uint,
-                                        CodeGenOptLevel,
-                                        true)
-                                })
-                            });
+                            opts.target_feature,
+                            output.to_str(),
+                            lib::llvm::ObjectFile as c_uint,
+                            CodeGenOptLevel,
+                            true);
                     }
                 } else {
                     // If we aren't saving temps then just output the file
                     // type corresponding to the '-c' or '-S' flag used
-
-                    let _: () = str::as_c_str(
+                    WriteOutputFile(
+                        sess,
+                        pm.llpm,
+                        llmod,
                         sess.targ_cfg.target_strs.target_triple,
-                        |buf_t| {
-                            str::as_c_str(output.to_str(), |buf_o| {
-                                WriteOutputFile(
-                                    sess,
-                                    pm.llpm,
-                                    llmod,
-                                    buf_t,
-                                    buf_o,
-                                    FileType as c_uint,
-                                    CodeGenOptLevel,
-                                    true)
-                            })
-                        });
+                        opts.target_feature,
+                        output.to_str(),
+                        FileType as c_uint,
+                        CodeGenOptLevel,
+                        true);
                 }
                 // Clean up and return
 

branches/try/src/librustc/driver/driver.rs

@@ -599,6 +599,7 @@ pub fn build_session_options(binary: @~str,
     let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
     let sysroot_opt = sysroot_opt.map(|m| Path(*m));
     let target_opt = getopts::opt_maybe_str(matches, ~"target");
+    let target_feature_opt = getopts::opt_maybe_str(matches, ~"target-feature");
     let save_temps = getopts::opt_present(matches, ~"save-temps");
     match output_type {
       // unless we're emitting huamn-readable assembly, omit comments.
@@ -637,6 +638,10 @@ pub fn build_session_options(binary: @~str,
             None => host_triple(),
             Some(s) => s
         };
+    let target_feature = match target_feature_opt {
+        None => ~"",
+        Some(s) => s
+    };
 
     let addl_lib_search_paths =
         getopts::opt_strs(matches, ~"L")
@@ -659,6 +664,7 @@ pub fn build_session_options(binary: @~str,
         addl_lib_search_paths: addl_lib_search_paths,
         maybe_sysroot: sysroot_opt,
         target_triple: target,
+        target_feature: target_feature,
         cfg: cfg,
         binary: binary,
         test: test,
@@ -769,6 +775,9 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                         ~"Target triple cpu-manufacturer-kernel[-os]
                           to compile for (see chapter 3.4 of http://www.sourceware.org/autobook/
                           for detail)", ~"TRIPLE"),
+  optopt(~"", ~"target-feature",
+                        ~"Target specific attributes (llc -mattr=help
+                          for detail)", ~"FEATURE"),
   optopt(~"", ~"android-cross-path",
          ~"The path to the Android NDK", "PATH"),
   optmulti(~"W", ~"warn",

branches/try/src/librustc/driver/session.rs

@@ -126,6 +126,7 @@ pub struct options {
     addl_lib_search_paths: ~[Path],
     maybe_sysroot: Option<Path>,
     target_triple: ~str,
+    target_feature: ~str,
     // User-specified cfg meta items. The compiler itself will add additional
     // items to the crate config, and during parsing the entire crate config
     // will be added to the crate AST node.  This should not be used for
@@ -302,6 +303,7 @@ pub fn basic_options() -> @options {
         addl_lib_search_paths: ~[],
         maybe_sysroot: None,
         target_triple: host_triple(),
+        target_feature: ~"",
         cfg: ~[],
         binary: @~"rustc",
         test: false,

branches/try/src/librustc/front/test.rs

@@ -274,7 +274,6 @@ fn mk_std(cx: &TestCtxt) -> @ast::view_item {
         ast::view_item_use(
             ~[@nospan(ast::view_path_simple(id_std,
                                             path_node(~[id_std]),
-                                            ast::type_value_ns,
                                             cx.sess.next_node_id()))])
     } else {
         ast::view_item_extern_mod(id_std, ~[@mi],

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

@@ -1799,9 +1799,10 @@ pub mod llvm {
         pub unsafe fn LLVMRustWriteOutputFile(PM: PassManagerRef,
                                               M: ModuleRef,
                                               Triple: *c_char,
+                                              Feature: *c_char,
+                                              Output: *c_char,
                                               // FIXME: When #2334 is fixed,
                                               // change c_uint to FileType
-                                              Output: *c_char,
                                               FileType: c_uint,
                                               OptLevel: c_int,
                                               EnableSegmentedStacks: bool)

branches/try/src/librustc/middle/resolve.rs

@@ -1413,7 +1413,7 @@ pub impl Resolver {
 
                     let mut module_path = ~[];
                     match view_path.node {
-                        view_path_simple(_, full_path, _, _) => {
+                        view_path_simple(_, full_path, _) => {
                             let path_len = full_path.idents.len();
                             assert!(path_len != 0);
 
@@ -1435,7 +1435,7 @@ pub impl Resolver {
                     // Build up the import directives.
                     let module_ = self.get_module_from_parent(parent);
                     match view_path.node {
-                        view_path_simple(binding, full_path, _, _) => {
+                        view_path_simple(binding, full_path, _) => {
                             let source_ident = *full_path.idents.last();
                             let subclass = @SingleImport(binding,
                                                          source_ident);