---

yaml
---
r: 14119
b: refs/heads/try
c: 3a413aa
h: refs/heads/master
i:
  14117: 320f294
  14115: 1b2b059
  14111: 1041880
v: v3

Author: erickt

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 526e73d7f882bf9a88fe957661cc2e09291cef5b
+refs/heads/try: 3a413aabd4ccb0c0f8d6b3e5f380ac47164a1ee3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/str.rs

@@ -95,6 +95,7 @@ export
    char_at,
    substr_all,
    escape_char,
+   as_bytes,
    as_buf,
    //buf,
    sbuf,
@@ -390,10 +391,7 @@ Converts a string to a vector of bytes. The result vector is not
 null-terminated.
 */
 fn bytes(s: str) -> [u8] unsafe {
-    let v = ::unsafe::reinterpret_cast(s);
-    let vcopy = vec::slice(v, 0u, vec::len(v) - 1u);
-    ::unsafe::leak(v);
-    ret vcopy;
+    as_bytes(s) { |v| vec::slice(v, 0u, vec::len(v) - 1u) }
 }
 
 /*
@@ -1026,12 +1024,12 @@ Returns the length in bytes of a string
 FIXME: rename to 'len_bytes'
 */
 pure fn byte_len(s: str) -> uint unsafe {
-    let v: [u8] = ::unsafe::reinterpret_cast(s);
-    let vlen = vec::len(v);
-    ::unsafe::leak(v);
-    // There should always be a null terminator
-    assert (vlen > 0u);
-    ret vlen - 1u;
+    as_bytes(s) { |v|
+        let vlen = vec::len(v);
+        // There should always be a null terminator
+        assert (vlen > 0u);
+        vlen - 1u
+    }
 }
 
 /*
@@ -1299,23 +1297,38 @@ const max_five_b: uint = 67108864u;
 const tag_six_b: uint = 252u;
 
 /*
-Function: as_buf
+Function: as_bytes
 
 Work with the byte buffer of a string. Allows for unsafe manipulation
 of strings, which is useful for native interop.
 
 Example:
 
-> let s = str::as_buf("PATH", { |path_buf| libc::getenv(path_buf) });
+> let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };
 
 */
-fn as_buf<T>(s: str, f: fn(sbuf) -> T) -> T unsafe {
+fn as_bytes<T>(s: str, f: fn([u8]) -> T) -> T unsafe {
     let v: [u8] = ::unsafe::reinterpret_cast(s);
-    let r = vec::as_buf(v, f);
+    let r = f(v);
     ::unsafe::leak(v);
     r
 }
 
+/*
+Function: as_buf
+
+Work with the byte buffer of a string. Allows for unsafe manipulation
+of strings, which is useful for native interop.
+
+Example:
+
+> let s = str::as_buf("PATH", { |path_buf| libc::getenv(path_buf) });
+
+*/
+fn as_buf<T>(s: str, f: fn(sbuf) -> T) -> T unsafe {
+    as_bytes(s) { |v| vec::as_buf(v, f) }
+}
+
 /*
 Type: sbuf
 
@@ -1373,13 +1386,11 @@ mod unsafe {
        assert (begin <= end);
        assert (end <= byte_len(s));
 
-       let v: [u8] = ::unsafe::reinterpret_cast(s);
-       let v2 = vec::slice(v, begin, end);
+       let v = as_bytes(s) { |v| vec::slice(v, begin, end) };
+       v += [0u8];
+       let s: str = ::unsafe::reinterpret_cast(v);
        ::unsafe::leak(v);
-       v2 += [0u8];
-       let s2: str = ::unsafe::reinterpret_cast(v2);
-       ::unsafe::leak(v2);
-       ret s2;
+       ret s;
    }
 
    /*