---

yaml
---
r: 140029
b: refs/heads/try2
c: d834c0d
h: refs/heads/master
i:
  140027: 720a00c
v: v3

Author: catamorphism

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

branches/try2/doc/rustpkg.md

@@ -0,0 +1,103 @@
+% 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
+
+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/try2/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/try2/src/libcore/num/strconv.rs

@@ -655,7 +655,6 @@ 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/try2/src/librustc/back/link.rs

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

branches/try2/src/librustc/driver/driver.rs

@@ -599,7 +599,6 @@ 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.
@@ -638,10 +637,6 @@ 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")
@@ -664,7 +659,6 @@ 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,
@@ -775,9 +769,6 @@ 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/try2/src/librustc/driver/session.rs

@@ -126,7 +126,6 @@ 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
@@ -303,7 +302,6 @@ pub fn basic_options() -> @options {
         addl_lib_search_paths: ~[],
         maybe_sysroot: None,
         target_triple: host_triple(),
-        target_feature: ~"",
         cfg: ~[],
         binary: @~"rustc",
         test: false,

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

@@ -274,6 +274,7 @@ 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/try2/src/librustc/lib/llvm.rs

@@ -1799,10 +1799,9 @@ 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/try2/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);