---

yaml
---
r: 55849
b: refs/heads/master
c: 848641f
h: refs/heads/master
i:
  55847: b9b85bd
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 149047e55d8eace3ea9d005905577f17b25c54e2
+refs/heads/master: 848641fcb54c282f6bd616ef1d6ac06087d778f6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a

trunk/src/libcore/os.rs

@@ -639,6 +639,27 @@ pub fn make_dir(p: &Path, mode: c_int) -> bool {
     }
 }
 
+/// Creates a directory with a given mode.
+/// Returns true iff creation
+/// succeeded. Also creates all intermediate subdirectories
+/// if they don't already exist, giving all of them the same mode.
+pub fn mkdir_recursive(p: &Path, mode: c_int) -> bool {
+    if path_is_dir(p) {
+        return true;
+    }
+    let parent = p.dir_path();
+    debug!("mkdir_recursive: parent = %s",
+           parent.to_str());
+    if parent.to_str() == ~"."
+        || parent.to_str() == ~"/" { // !!!
+        // No parent directories to create
+        path_is_dir(&parent) && make_dir(p, mode)
+    }
+    else {
+        mkdir_recursive(&parent, mode) && make_dir(p, mode)
+    }
+}
+
 /// Lists the contents of a directory
 #[allow(non_implicitly_copyable_typarams)]
 pub fn list_dir(p: &Path) -> ~[~str] {
@@ -1467,4 +1488,18 @@ mod tests {
           assert!((remove_file(&out)));
         }
     }
+
+    #[test]
+    fn recursive_mkdir_ok() {
+        use libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+
+        let root = os::tmpdir();
+        let path = "xy/z/zy";
+        let nested = root.push(path);
+        assert!(os::mkdir_recursive(&nested,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
+        assert!(os::path_is_dir(&root.push("xy")));
+        assert!(os::path_is_dir(&root.push("xy/z")));
+        assert!(os::path_is_dir(&nested));
+    }
+
 }

trunk/src/librustpkg/path_util.rs

@@ -14,6 +14,7 @@ use core::path::*;
 use core::{os, str};
 use core::option::*;
 use util::PkgId;
+use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 
 #[deriving(Eq)]
 pub enum OutputType { Main, Lib, Bench, Test }
@@ -25,34 +26,15 @@ pub fn rust_path() -> ~[Path] {
     ~[Path(".")]
 }
 
+static u_rwx: i32 = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
+
 /// Creates a directory that is readable, writeable,
 /// and executable by the user. Returns true iff creation
 /// succeeded.
 pub fn make_dir_rwx(p: &Path) -> bool {
     use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 
-    os::make_dir(p, (S_IRUSR | S_IWUSR | S_IXUSR) as i32)
-}
-
-/// Creates a directory that is readable, writeable,
-/// and executable by the user. Returns true iff creation
-/// succeeded. Also creates all intermediate subdirectories
-/// if they don't already exist.
-pub fn mkdir_recursive(p: &Path) -> bool {
-    if os::path_is_dir(p) {
-        return true;
-    }
-    let parent = p.dir_path();
-    debug!("mkdir_recursive: parent = %s",
-           parent.to_str());
-    if parent.to_str() == ~"."
-        || parent.to_str() == ~"/" { // !!!
-        // No parent directories to create
-        os::path_is_dir(&parent) && make_dir_rwx(p)
-    }
-    else {
-        mkdir_recursive(&parent) && make_dir_rwx(p)
-    }
+    os::make_dir(p, u_rwx)
 }
 
 /// Replace all occurrences of '-' in the stem part of path with '_'
@@ -130,7 +112,7 @@ pub fn build_pkg_id_in_workspace(pkgid: PkgId, workspace: &Path) -> Path {
     // n.b. Should actually use a target-specific
     // subdirectory of build/
     result = result.push(normalize(~pkgid.path).to_str());
-    if os::path_exists(&result) || mkdir_recursive(&result) {
+    if os::path_exists(&result) || os::mkdir_recursive(&result, u_rwx) {
         result
     }
     else {
@@ -148,19 +130,3 @@ pub fn mk_output_path(what: OutputType, short_name: ~str, dir: Path) -> Path {
                            os::EXE_SUFFIX))
     }
 }
-
-#[cfg(test)]
-mod test {
-    use core::os;
-
-    #[test]
-    fn recursive_mkdir_ok() {
-        let root = os::tmpdir();
-        let path = "xy/z/zy";
-        let nested = root.push(path);
-        assert!(super::mkdir_recursive(&nested));
-        assert!(os::path_is_dir(&root.push("xy")));
-        assert!(os::path_is_dir(&root.push("xy/z")));
-        assert!(os::path_is_dir(&nested));
-    }
-}

trunk/src/rt/rust_env.cpp

@@ -97,7 +97,7 @@ get_max_stk_size() {
         return strtol(maxsz, NULL, 0);
     }
     else {
-        return 1024*1024*1024;
+        return 1024*1024*8;
     }
 }
 

trunk/src/rt/rust_task.cpp

@@ -530,11 +530,11 @@ rust_task::new_stack(size_t requested_sz) {
     // arbitrarily selected as 2x the maximum stack size.
     if (!unwinding && used_stack > max_stack) {
         LOG_ERR(this, task, "task %" PRIxPTR " ran out of stack", this);
-        abort();
+        fail();
     } else if (unwinding && used_stack > max_stack * 2) {
         LOG_ERR(this, task,
                 "task %" PRIxPTR " ran out of stack during unwinding", this);
-        abort();
+        fail();
     }
 
     size_t sz = rust_stk_sz + RED_ZONE_SIZE;

trunk/src/test/run-fail/issue-2144.rs

@@ -0,0 +1,19 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:ran out of stack
+
+// Don't leak when the landing pads need to request more stack
+// than is allowed during normal execution
+
+fn useBlock(f: ~fn() -> uint) { useBlock(|| 22u ) }
+fn main() {
+    useBlock(|| 22u );
+}

trunk/src/test/run-fail/out-of-stack-managed-box.rs

@@ -0,0 +1,25 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-test iloops with optimizations on
+
+// NB: Not sure why this works. I expect the box argument to leak when
+// we run out of stack. Maybe the box annihilator works it out?
+
+// error-pattern:ran out of stack
+fn main() {
+    eat(@0);
+}
+
+fn eat(
+    +a: @int
+) {
+    eat(a)
+}

trunk/src/test/run-fail/out-of-stack-owned-box.rs

@@ -0,0 +1,21 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-test
+// error-pattern:ran out of stack
+fn main() {
+    eat(~0);
+}
+
+fn eat(
+    +a: ~int
+) {
+    eat(a)
+}

trunk/src/test/run-fail/too-much-recursion.rs

@@ -0,0 +1,18 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:ran out of stack
+
+// Test that the task fails after hiting the recursion limit
+
+fn main() {
+    debug!(~"don't optimize me out");
+    main();
+}