---

yaml
---
r: 56800
b: refs/heads/try
c: 74807b1
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: 4ad76e66aad1813bc927ae1b5cf8205c8c5a8944
+refs/heads/try: 74807b15944205beb2b86ea5422927c47cac3ecc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/str.rs

@@ -38,7 +38,7 @@ Section: Creating a string
 */
 
 /**
- * Convert a vector of bytes to a new UTF-8 string
+ * Convert a vector of bytes to a UTF-8 string
  *
  * # Failure
  *
@@ -49,26 +49,9 @@ pub fn from_bytes(vv: &const [u8]) -> ~str {
     return unsafe { raw::from_bytes(vv) };
 }
 
-/**
- * Convert a vector of bytes to a UTF-8 string.
- * The vector needs to be one byte longer than the string, and end with a 0 byte.
- *
- * Compared to `from_bytes()`, this fn doesn't need to allocate a new owned str.
- *
- * # Failure
- *
- * Fails if invalid UTF-8
- * Fails if not null terminated
- */
-pub fn from_bytes_with_null<'a>(vv: &'a [u8]) -> &'a str {
-    assert!(vv[vv.len() - 1] == 0);
-    assert!(is_utf8(vv));
-    return unsafe { raw::from_bytes_with_null(vv) };
-}
-
 /// Copy a slice into a new unique str
 pub fn from_slice(s: &str) -> ~str {
-    unsafe { raw::slice_bytes_owned(s, 0, len(s)) }
+    unsafe { raw::slice_bytes_unique(s, 0, len(s)) }
 }
 
 impl ToStr for ~str {
@@ -296,7 +279,7 @@ pub fn pop_char(s: &mut ~str) -> char {
  */
 pub fn shift_char(s: &mut ~str) -> char {
     let CharRange {ch, next} = char_range_at(*s, 0u);
-    *s = unsafe { raw::slice_bytes_owned(*s, next, len(*s)) };
+    *s = unsafe { raw::slice_bytes_unique(*s, next, len(*s)) };
     return ch;
 }
 
@@ -801,9 +784,9 @@ pub fn replace(s: &str, from: &str, to: &str) -> ~str {
         if first {
             first = false;
         } else {
-            push_str(&mut result, to);
+            unsafe { push_str(&mut result, to); }
         }
-        push_str(&mut result, unsafe{raw::slice_bytes(s, start, end)});
+        unsafe { push_str(&mut result, raw::slice_bytes_unique(s, start, end)); }
     }
     result
 }
@@ -2054,37 +2037,6 @@ pub fn as_buf<T>(s: &str, f: &fn(*u8, uint) -> T) -> T {
     }
 }
 
-/**
- * Returns the byte offset of an inner slice relative to an enclosing outer slice
- *
- * # Example
- *
- * ~~~
- * let string = "a\nb\nc";
- * let mut lines = ~[];
- * for each_line(string) |line| { lines.push(line) }
- *
- * assert!(subslice_offset(string, lines[0]) == 0); // &"a"
- * assert!(subslice_offset(string, lines[1]) == 2); // &"b"
- * assert!(subslice_offset(string, lines[2]) == 4); // &"c"
- * ~~~
- */
-#[inline(always)]
-pub fn subslice_offset(outer: &str, inner: &str) -> uint {
-    do as_buf(outer) |a, a_len| {
-        do as_buf(inner) |b, b_len| {
-            let a_start: uint, a_end: uint, b_start: uint, b_end: uint;
-            unsafe {
-                a_start = cast::transmute(a); a_end = a_len + cast::transmute(a);
-                b_start = cast::transmute(b); b_end = b_len + cast::transmute(b);
-            }
-            assert!(a_start <= b_start);
-            assert!(b_end <= a_end);
-            b_start - a_start
-        }
-    }
-}
-
 /**
  * Reserves capacity for exactly `n` bytes in the given string, not including
  * the null terminator.
@@ -2206,20 +2158,13 @@ pub mod raw {
         from_buf_len(::cast::reinterpret_cast(&c_str), len)
     }
 
-    /// Converts a vector of bytes to a new owned string.
+    /// Converts a vector of bytes to a string.
     pub unsafe fn from_bytes(v: &const [u8]) -> ~str {
         do vec::as_const_buf(v) |buf, len| {
             from_buf_len(buf, len)
         }
     }
 
-    /// Converts a vector of bytes to a string.
-    /// The byte slice needs to contain valid utf8 and needs to be one byte longer than
-    /// the string, if possible ending in a 0 byte.
-    pub unsafe fn from_bytes_with_null<'a>(v: &'a [u8]) -> &'a str {
-        cast::transmute(v)
-    }
-
     /// Converts a byte to a string.
     pub unsafe fn from_byte(u: u8) -> ~str { raw::from_bytes([u]) }
 
@@ -2241,7 +2186,7 @@ pub mod raw {
      * If begin is greater than end.
      * If end is greater than the length of the string.
      */
-    pub unsafe fn slice_bytes_owned(s: &str, begin: uint, end: uint) -> ~str {
+    pub unsafe fn slice_bytes_unique(s: &str, begin: uint, end: uint) -> ~str {
         do as_buf(s) |sbuf, n| {
             assert!((begin <= end));
             assert!((end <= n));
@@ -2313,7 +2258,7 @@ pub mod raw {
         let len = len(*s);
         assert!((len > 0u));
         let b = s[0];
-        *s = unsafe { raw::slice_bytes_owned(*s, 1u, len) };
+        *s = unsafe { raw::slice_bytes_unique(*s, 1u, len) };
         return b;
     }
 
@@ -3344,66 +3289,6 @@ mod tests {
          let _x = from_bytes(bb);
     }
 
-    #[test]
-    fn test_unsafe_from_bytes_with_null() {
-        let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
-        let b = unsafe { raw::from_bytes_with_null(a) };
-        assert_eq!(b, "AAAAAAA");
-    }
-
-    #[test]
-    fn test_from_bytes_with_null() {
-        let ss = "ศไทย中华Việt Nam";
-        let bb = [0xe0_u8, 0xb8_u8, 0xa8_u8,
-                  0xe0_u8, 0xb9_u8, 0x84_u8,
-                  0xe0_u8, 0xb8_u8, 0x97_u8,
-                  0xe0_u8, 0xb8_u8, 0xa2_u8,
-                  0xe4_u8, 0xb8_u8, 0xad_u8,
-                  0xe5_u8, 0x8d_u8, 0x8e_u8,
-                  0x56_u8, 0x69_u8, 0xe1_u8,
-                  0xbb_u8, 0x87_u8, 0x74_u8,
-                  0x20_u8, 0x4e_u8, 0x61_u8,
-                  0x6d_u8, 0x0_u8];
-
-        assert_eq!(ss, from_bytes_with_null(bb));
-    }
-
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(windows))]
-    fn test_from_bytes_with_null_fail() {
-        let bb = [0xff_u8, 0xb8_u8, 0xa8_u8,
-                  0xe0_u8, 0xb9_u8, 0x84_u8,
-                  0xe0_u8, 0xb8_u8, 0x97_u8,
-                  0xe0_u8, 0xb8_u8, 0xa2_u8,
-                  0xe4_u8, 0xb8_u8, 0xad_u8,
-                  0xe5_u8, 0x8d_u8, 0x8e_u8,
-                  0x56_u8, 0x69_u8, 0xe1_u8,
-                  0xbb_u8, 0x87_u8, 0x74_u8,
-                  0x20_u8, 0x4e_u8, 0x61_u8,
-                  0x6d_u8, 0x0_u8];
-
-         let _x = from_bytes_with_null(bb);
-    }
-
-    #[test]
-    #[should_fail]
-    #[ignore(cfg(windows))]
-    fn test_from_bytes_with_null_fail_2() {
-        let bb = [0xff_u8, 0xb8_u8, 0xa8_u8,
-                  0xe0_u8, 0xb9_u8, 0x84_u8,
-                  0xe0_u8, 0xb8_u8, 0x97_u8,
-                  0xe0_u8, 0xb8_u8, 0xa2_u8,
-                  0xe4_u8, 0xb8_u8, 0xad_u8,
-                  0xe5_u8, 0x8d_u8, 0x8e_u8,
-                  0x56_u8, 0x69_u8, 0xe1_u8,
-                  0xbb_u8, 0x87_u8, 0x74_u8,
-                  0x20_u8, 0x4e_u8, 0x61_u8,
-                  0x6d_u8, 0x60_u8];
-
-         let _x = from_bytes_with_null(bb);
-    }
-
     #[test]
     fn test_from_buf() {
         unsafe {
@@ -3466,30 +3351,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_subslice_offset() {
-        let a = "kernelsprite";
-        let b = slice(a, 7, len(a));
-        let c = slice(a, 0, len(a) - 6);
-        assert!(subslice_offset(a, b) == 7);
-        assert!(subslice_offset(a, c) == 0);
-
-        let string = "a\nb\nc";
-        let mut lines = ~[];
-        for each_line(string) |line| { lines.push(line) }
-        assert!(subslice_offset(string, lines[0]) == 0);
-        assert!(subslice_offset(string, lines[1]) == 2);
-        assert!(subslice_offset(string, lines[2]) == 4);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_subslice_offset_2() {
-        let a = "alchemiter";
-        let b = "cruxtruder";
-        subslice_offset(a, b);
-    }
-
     #[test]
     fn vec_str_conversions() {
         let s1: ~str = ~"All mimsy were the borogoves";

branches/try/src/libsyntax/print/pprust.rs

@@ -95,7 +95,6 @@ pub fn rust_printer(writer: @io::Writer, intr: @ident_interner) -> @ps {
 }
 
 pub static indent_unit: uint = 4u;
-pub static match_indent_unit: uint = 2u;
 
 pub static default_columns: uint = 78u;
 
@@ -1227,16 +1226,16 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
         print_block(s, blk);
       }
       ast::expr_match(expr, ref arms) => {
-        cbox(s, match_indent_unit);
+        cbox(s, indent_unit);
         ibox(s, 4);
         word_nbsp(s, ~"match");
         print_expr(s, expr);
         space(s.s);
         bopen(s);
-        let len = (*arms).len();
-        for (*arms).eachi |i, arm| {
+        let len = arms.len();
+        for arms.eachi |i, arm| {
             space(s.s);
-            cbox(s, match_indent_unit);
+            cbox(s, indent_unit);
             ibox(s, 0u);
             let mut first = true;
             for arm.pats.each |p| {
@@ -1269,7 +1268,7 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
                             ast::expr_block(ref blk) => {
                                 // the block will close the pattern's ibox
                                 print_block_unclosed_indent(
-                                    s, blk, match_indent_unit);
+                                    s, blk, indent_unit);
                             }
                             _ => {
                                 end(s); // close the ibox for the pattern
@@ -1286,10 +1285,10 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
                 }
             } else {
                 // the block will close the pattern's ibox
-                print_block_unclosed_indent(s, &arm.body, match_indent_unit);
+                print_block_unclosed_indent(s, &arm.body, indent_unit);
             }
         }
-        bclose_(s, expr.span, match_indent_unit);
+        bclose_(s, expr.span, indent_unit);
       }
       ast::expr_fn_block(ref decl, ref body) => {
         // in do/for blocks we don't want to show an empty

branches/try/src/test/pretty/alt-naked-expr-long.rs

@@ -17,9 +17,9 @@ fn main() {
     let x = Some(3);
     let y =
         match x {
-          Some(_) =>
-          ~"some" + ~"very" + ~"very" + ~"very" + ~"very" + ~"very" + ~"very"
-              + ~"very" + ~"very" + ~"long" + ~"string",
-          None => ~"none"
+            Some(_) =>
+            ~"some" + ~"very" + ~"very" + ~"very" + ~"very" + ~"very" +
+                ~"very" + ~"very" + ~"very" + ~"long" + ~"string",
+            None => ~"none"
         };
 }

branches/try/src/test/pretty/alt-naked-expr-medium.rs

@@ -14,7 +14,7 @@ fn main() {
     let x = Some(3);
     let _y =
         match x {
-          Some(_) => ~[~"some(_)", ~"not", ~"SO", ~"long", ~"string"],
-          None => ~[~"none"]
+            Some(_) => ~[~"some(_)", ~"not", ~"SO", ~"long", ~"string"],
+            None => ~[~"none"]
         };
 }