---

yaml
---
r: 138557
b: refs/heads/try2
c: 3e6b2cf
h: refs/heads/master
i:
  138555: ffd5dbc
v: v3

Author: brson

[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: 99a902c81d7bc57fece1b520591f328afe76154a
+refs/heads/try2: 3e6b2cfab5b838138f2bec5c696089b7f5005361
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -678,7 +678,7 @@ do
         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
         then
-            LLVM_DBG_OPTS=""
+            LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts

branches/try2/doc/rust.md

@@ -1611,6 +1611,7 @@ The following are examples of structure expressions:
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
 # mod game { pub struct User { name: &str, age: uint, score: uint } }
+# use game;
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35u, score: 100_000};

branches/try2/doc/tutorial-tasks.md

@@ -468,6 +468,7 @@ Here is the function that implements the child task:
 
 ~~~~
 # use std::comm::DuplexStream;
+# use comm::{Port, Chan};
 fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
@@ -490,6 +491,7 @@ Here is the code for the parent task:
 
 ~~~~
 # use std::comm::DuplexStream;
+# use comm::{Port, Chan};
 # use task::spawn;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;

branches/try2/doc/tutorial.md

@@ -2270,9 +2270,7 @@ fn chicken_farmer() {
     // The same, but name it `my_chicken`
     use my_chicken = farm::chicken;
     ...
-# my_chicken();
 }
-# chicken();
 # }
 ~~~
 

branches/try2/src/libcore/hash.rs

@@ -186,46 +186,42 @@ fn SipState(key0: u64, key1: u64) -> SipState {
     state
 }
 
-// sadly, these macro definitions can't appear later,
-// because they're needed in the following defs;
-// this design could be improved.
-
-macro_rules! u8to64_le (
-    ($buf:expr, $i:expr) =>
-    ($buf[0+$i] as u64 |
-     $buf[1+$i] as u64 << 8 |
-     $buf[2+$i] as u64 << 16 |
-     $buf[3+$i] as u64 << 24 |
-     $buf[4+$i] as u64 << 32 |
-     $buf[5+$i] as u64 << 40 |
-     $buf[6+$i] as u64 << 48 |
-     $buf[7+$i] as u64 << 56)
-)
-
-macro_rules! rotl (
-    ($x:expr, $b:expr) =>
-    (($x << $b) | ($x >> (64 - $b)))
-)
-
-macro_rules! compress (
-    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
-    ({
-        $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0;
-        $v0 = rotl!($v0, 32);
-        $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2;
-        $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0;
-        $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2;
-        $v2 = rotl!($v2, 32);
-    })
-)
-
 
 impl io::Writer for SipState {
 
     // Methods for io::writer
     #[inline(always)]
     fn write(&self, msg: &[const u8]) {
 
+        macro_rules! u8to64_le (
+            ($buf:expr, $i:expr) =>
+            ($buf[0+$i] as u64 |
+             $buf[1+$i] as u64 << 8 |
+             $buf[2+$i] as u64 << 16 |
+             $buf[3+$i] as u64 << 24 |
+             $buf[4+$i] as u64 << 32 |
+             $buf[5+$i] as u64 << 40 |
+             $buf[6+$i] as u64 << 48 |
+             $buf[7+$i] as u64 << 56)
+        );
+
+        macro_rules! rotl (
+            ($x:expr, $b:expr) =>
+            (($x << $b) | ($x >> (64 - $b)))
+        );
+
+        macro_rules! compress (
+            ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
+            ({
+                $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0;
+                $v0 = rotl!($v0, 32);
+                $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2;
+                $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0;
+                $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2;
+                $v2 = rotl!($v2, 32);
+            })
+        );
+
         let length = msg.len();
         self.length += length;
 

branches/try2/src/libcore/os.rs

@@ -566,13 +566,17 @@ pub fn path_exists(p: &Path) -> bool {
  *
  * If the given path is relative, return it prepended with the current working
  * directory. If the given path is already an absolute path, return it
- * as is.  This is a shortcut for calling os::getcwd().unsafe_join(p)
+ * as is.
  */
 // NB: this is here rather than in path because it is a form of environment
 // querying; what it does depends on the process working directory, not just
 // the input paths.
 pub fn make_absolute(p: &Path) -> Path {
-    getcwd().unsafe_join(p)
+    if p.is_absolute {
+        copy *p
+    } else {
+        getcwd().push_many(p.components)
+    }
 }
 
 

branches/try2/src/libcore/path.rs

@@ -64,9 +64,6 @@ pub trait GenericPath {
     pure fn push_many((&[~str])) -> Self;
     pure fn pop() -> Self;
 
-    pure fn unsafe_join((&Self)) -> Self;
-    pure fn is_restricted() -> bool;
-
     pure fn normalize() -> Self;
 }
 
@@ -488,19 +485,6 @@ impl GenericPath for PosixPath {
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &PosixPath) -> PosixPath {
-        if other.is_absolute {
-            PosixPath { is_absolute: true,
-                        components: copy other.components }
-        } else {
-            self.push_rel(other)
-        }
-    }
-
-    pure fn is_restricted() -> bool {
-        false
-    }
-
     pure fn push_many(cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
@@ -701,61 +685,6 @@ impl GenericPath for WindowsPath {
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &WindowsPath) -> WindowsPath {
-        /* rhs not absolute is simple push */
-        if !other.is_absolute {
-            return self.push_many(other.components);
-        }
-
-        /* if rhs has a host set, then the whole thing wins */
-        match other.host {
-            Some(copy host) => {
-                return WindowsPath {
-                    host: Some(host),
-                    device: copy other.device,
-                    is_absolute: true,
-                    components: copy other.components
-                };
-            }
-            _ => {}
-        }
-
-        /* if rhs has a device set, then a part wins */
-        match other.device {
-            Some(copy device) => {
-                return WindowsPath {
-                    host: None,
-                    device: Some(device),
-                    is_absolute: true,
-                    components: copy other.components
-                };
-            }
-            _ => {}
-        }
-
-        /* fallback: host and device of lhs win, but the
-           whole path of the right */
-        WindowsPath {
-            host: copy self.host,
-            device: copy self.device,
-            is_absolute: self.is_absolute || other.is_absolute,
-            components: copy other.components
-        }
-    }
-
-    pure fn is_restricted() -> bool {
-        match self.filestem() {
-            Some(stem) => {
-                match stem.to_lower() {
-                    ~"con" | ~"aux" | ~"com1" | ~"com2" | ~"com3" | ~"com4" |
-                    ~"lpt1" | ~"lpt2" | ~"lpt3" | ~"prn" | ~"nul" => true,
-                    _ => false
-                }
-            },
-            None => false
-        }
-    }
-
     pure fn push_many(cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {
@@ -796,10 +725,7 @@ impl GenericPath for WindowsPath {
     pure fn normalize() -> WindowsPath {
         return WindowsPath {
             host: copy self.host,
-            device: match self.device {
-                None => None,
-                Some(ref device) => Some(device.to_upper())
-            },
+            device: copy self.device,
             is_absolute: self.is_absolute,
             components: normalize(self.components)
         }
@@ -838,13 +764,13 @@ pub mod windows {
 
     pub pure fn extract_unc_prefix(s: &str) -> Option<(~str,~str)> {
         if (s.len() > 1 &&
-            (s[0] == '\\' as u8 || s[0] == '/' as u8) &&
-            s[0] == s[1]) {
+            s[0] == '\\' as u8 &&
+            s[1] == '\\' as u8) {
             let mut i = 2;
             while i < s.len() {
-                if is_sep(s[i]) {
+                if s[i] == '\\' as u8 {
                     let pre = s.slice(2, i);
-                    let mut rest = s.slice(i, s.len());
+                    let rest = s.slice(i, s.len());
                     return Some((pre, rest));
                 }
                 i += 1;
@@ -990,21 +916,13 @@ mod tests {
     #[test]
     fn test_extract_unc_prefixes() {
         assert windows::extract_unc_prefix("\\\\").is_none();
-        assert windows::extract_unc_prefix("//").is_none();
         assert windows::extract_unc_prefix("\\\\hi").is_none();
-        assert windows::extract_unc_prefix("//hi").is_none();
         assert windows::extract_unc_prefix("\\\\hi\\") ==
             Some((~"hi", ~"\\"));
-        assert windows::extract_unc_prefix("//hi\\") ==
-            Some((~"hi", ~"\\"));
         assert windows::extract_unc_prefix("\\\\hi\\there") ==
             Some((~"hi", ~"\\there"));
-        assert windows::extract_unc_prefix("//hi/there") ==
-            Some((~"hi", ~"/there"));
         assert windows::extract_unc_prefix("\\\\hi\\there\\friends.txt") ==
             Some((~"hi", ~"\\there\\friends.txt"));
-        assert windows::extract_unc_prefix("//hi\\there\\friends.txt") ==
-            Some((~"hi", ~"\\there\\friends.txt"));
     }
 
     #[test]
@@ -1063,61 +981,5 @@ mod tests {
             .push_many([~"lib", ~"thingy.dll"])
             .with_filename("librustc.dll")),
           "c:\\program files (x86)\\rust\\lib\\librustc.dll");
-
-        t(&(WindowsPath("\\\\computer\\share")
-            .unsafe_join(&WindowsPath("\\a"))),
-          "\\\\computer\\a");
-
-        t(&(WindowsPath("//computer/share")
-            .unsafe_join(&WindowsPath("\\a"))),
-          "\\\\computer\\a");
-
-        t(&(WindowsPath("//computer/share")
-            .unsafe_join(&WindowsPath("\\\\computer\\share"))),
-          "\\\\computer\\share");
-
-        t(&(WindowsPath("C:/whatever")
-            .unsafe_join(&WindowsPath("//computer/share/a/b"))),
-          "\\\\computer\\share\\a\\b");
-
-        t(&(WindowsPath("C:")
-            .unsafe_join(&WindowsPath("D:/foo"))),
-          "D:\\foo");
-
-        t(&(WindowsPath("C:")
-            .unsafe_join(&WindowsPath("B"))),
-          "C:B");
-
-        t(&(WindowsPath("C:")
-            .unsafe_join(&WindowsPath("/foo"))),
-          "C:\\foo");
-
-        t(&(WindowsPath("C:\\")
-            .unsafe_join(&WindowsPath("\\bar"))),
-          "C:\\bar");
-
-        t(&(WindowsPath("")
-            .unsafe_join(&WindowsPath(""))),
-          "");
-
-        t(&(WindowsPath("")
-            .unsafe_join(&WindowsPath("a"))),
-          "a");
-
-        t(&(WindowsPath("")
-            .unsafe_join(&WindowsPath("C:\\a"))),
-          "C:\\a");
-
-        t(&(WindowsPath("c:\\foo")
-            .normalize()),
-          "C:\\foo");
-    }
-
-    #[test]
-    fn test_windows_path_restrictions() {
-        assert WindowsPath("hi").is_restricted() == false;
-        assert WindowsPath("C:\\NUL").is_restricted() == true;
-        assert WindowsPath("C:\\COM1.TXT").is_restricted() == true;
-        assert WindowsPath("c:\\prn.exe").is_restricted() == true;
     }
 }

branches/try2/src/libcore/str.rs

@@ -590,40 +590,6 @@ pub pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
     result
 }
 
-/// Levenshtein Distance between two strings
-pub fn levdistance(s: &str, t: &str) -> uint {
-
-    let slen = str::len(s);
-    let tlen = str::len(t);
-
-    if slen == 0 { return tlen; }
-    if tlen == 0 { return slen; }
-
-    let mut dcol = vec::from_fn(tlen + 1, |x| x);
-
-    for str::each_chari(s) |i, sc| {
-
-        let mut current = i;
-        dcol[0] = current + 1;
-
-        for str::each_chari(t) |j, tc| {
-
-            let mut next = dcol[j + 1];
-
-            if sc == tc {
-                dcol[j + 1] = current;
-            } else {
-                dcol[j + 1] = ::cmp::min(current, next);
-                dcol[j + 1] = ::cmp::min(dcol[j + 1], dcol[j]) + 1;
-            }
-
-            current = next;
-        }
-    }
-
-    return dcol[tlen];
-}
-
 /**
  * Splits a string into a vector of the substrings separated by LF ('\n')
  */