---

yaml
---
r: 11258
b: refs/heads/master
c: bcbe36b
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 69834646d2efd2170236b1f8db3a71c77e378c5b
+refs/heads/master: bcbe36b33b7d310d64abeb76231cd3bd8b5cd584
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/comp/back/link.rs

@@ -568,11 +568,10 @@ fn link_binary(sess: session,
     // Converts a library file name into a cc -l argument
     fn unlib(config: @session::config, filename: str) -> str unsafe {
         let rmlib = fn@(filename: str) -> str {
-            let found = str::find_bytes(filename, "lib");
             if config.os == session::os_macos ||
                 (config.os == session::os_linux ||
                  config.os == session::os_freebsd) &&
-                option::is_some(found) && option::get(found) == 0u {
+                str::find(filename, "lib") == 0 {
                 ret str::unsafe::slice_bytes(filename, 3u,
                                str::len_bytes(filename));
             } else { ret filename; }

trunk/src/comp/driver/driver.rs

@@ -269,28 +269,28 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
 }
 
 fn get_os(triple: str) -> option<session::os> {
-    ret if str::contains(triple, "win32") ||
-               str::contains(triple, "mingw32") {
+    ret if str::find(triple, "win32") >= 0 ||
+               str::find(triple, "mingw32") >= 0 {
             some(session::os_win32)
-        } else if str::contains(triple, "darwin") {
+        } else if str::find(triple, "darwin") >= 0 {
             some(session::os_macos)
-        } else if str::contains(triple, "linux") {
+        } else if str::find(triple, "linux") >= 0 {
             some(session::os_linux)
-        } else if str::contains(triple, "freebsd") {
+        } else if str::find(triple, "freebsd") >= 0 {
             some(session::os_freebsd)
         } else { none };
 }
 
 fn get_arch(triple: str) -> option<session::arch> {
-    ret if str::contains(triple, "i386") || str::contains(triple, "i486") ||
-               str::contains(triple, "i586") ||
-               str::contains(triple, "i686") ||
-               str::contains(triple, "i786") {
+    ret if str::find(triple, "i386") >= 0 || str::find(triple, "i486") >= 0 ||
+               str::find(triple, "i586") >= 0 ||
+               str::find(triple, "i686") >= 0 ||
+               str::find(triple, "i786") >= 0 {
             some(session::arch_x86)
-        } else if str::contains(triple, "x86_64") {
+        } else if str::find(triple, "x86_64") >= 0 {
             some(session::arch_x86_64)
-        } else if str::contains(triple, "arm") ||
-                      str::contains(triple, "xscale") {
+        } else if str::find(triple, "arm") >= 0 ||
+                      str::find(triple, "xscale") >= 0 {
             some(session::arch_arm)
         } else { none };
 }

trunk/src/comp/middle/shape.rs

@@ -666,7 +666,8 @@ fn static_size_of_enum(cx: @crate_ctxt, t: ty::t)
         let max_size = 0u;
         let variants = ty::enum_variants(cx.tcx, tid);
         for variant: ty::variant_info in *variants {
-            let tup_ty = simplify_type(cx, ty::mk_tup(cx.tcx, variant.args));
+            let tup_ty = simplify_type(cx.tcx,
+                                       ty::mk_tup(cx.tcx, variant.args));
             // Perform any type parameter substitutions.
 
             tup_ty = ty::substitute_type_params(cx.tcx, subtys, tup_ty);
@@ -776,29 +777,26 @@ fn dynamic_metrics(cx: @block_ctxt, t: ty::t) -> metrics {
 // to have (a) the same size as the type that was passed in; (b) to be non-
 // recursive. This is done by replacing all boxes in a type with boxed unit
 // types.
-fn simplify_type(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
-    fn simplifier(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
+// This should reduce all pointers to some simple pointer type, to
+// ensure that we don't recurse endlessly when computing the size of a
+// nominal type that has pointers to itself in it.
+fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
+    fn nilptr(tcx: ty::ctxt) -> ty::t {
+        ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx), mut: ast::imm})
+    }
+    fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
         alt ty::get(typ).struct {
-          ty::ty_box(_) | ty::ty_opaque_box {
-            ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx));
-          }
-          ty::ty_uniq(_) {
-            ret ty::mk_imm_uniq(ccx.tcx, ty::mk_nil(ccx.tcx));
-          }
-          ty::ty_fn(_) {
-            ret ty::mk_tup(ccx.tcx,
-                           [ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)),
-                            ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx))]);
-          }
+          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) | ty::ty_vec(_) |
+          ty::ty_ptr(_) { nilptr(tcx) }
+          ty::ty_fn(_) { ty::mk_tup(tcx, [nilptr(tcx), nilptr(tcx)]) }
           ty::ty_res(_, sub, tps) {
-            let sub1 = ty::substitute_type_params(ccx.tcx, tps, sub);
-            ret ty::mk_tup(ccx.tcx,
-                           [ty::mk_int(ccx.tcx), simplify_type(ccx, sub1)]);
+            let sub1 = ty::substitute_type_params(tcx, tps, sub);
+            ty::mk_tup(tcx, [ty::mk_int(tcx), simplify_type(tcx, sub1)])
           }
-          _ { ret typ; }
+          _ { typ }
         }
     }
-    ret ty::fold_ty(ccx.tcx, ty::fm_general(bind simplifier(ccx, _)), typ);
+    ty::fold_ty(tcx, ty::fm_general(bind simplifier(tcx, _)), typ)
 }
 
 // Given a tag type `ty`, returns the offset of the payload.

trunk/src/compiletest/errors.rs

@@ -24,11 +24,9 @@ fn load_errors(testfile: str) -> [expected_error] {
 
 fn parse_expected(line_num: uint, line: str) -> [expected_error] unsafe {
     let error_tag = "//!";
-    let idx;
-    alt str::find_bytes(line, error_tag) {
-         option::none { ret []; }
-         option::some(nn) { idx = (nn as uint) + str::len_bytes(error_tag); }
-    }
+    let idx0 = str::find(line, error_tag);
+    if idx0 < 0 { ret []; }
+    let idx = (idx0 as uint) + str::len_bytes(error_tag);
 
     // "//!^^^ kind msg" denotes a message expected
     // three lines above current line:

trunk/src/compiletest/header.rs

@@ -100,21 +100,18 @@ fn parse_pp_exact(line: str, testfile: str) -> option<str> {
 }
 
 fn parse_name_directive(line: str, directive: str) -> bool {
-    str::contains(line, directive)
+    str::find(line, directive) >= 0
 }
 
 fn parse_name_value_directive(line: str,
                               directive: str) -> option<str> unsafe {
     let keycolon = directive + ":";
-    alt str::find_bytes(line, keycolon) {
-        option::some(colon) {
-            let value =
-                str::unsafe::slice_bytes(line,
-                                         colon + str::len_bytes(keycolon),
-                                         str::len_bytes(line));
-            #debug("%s: %s", directive,  value);
-            option::some(value)
-        }
-        option::none { option::none }
-    }
+    if str::find(line, keycolon) >= 0 {
+        let colon = str::find(line, keycolon) as uint;
+        let value =
+            str::unsafe::slice_bytes(line, colon + str::len_bytes(keycolon),
+                       str::len_bytes(line));
+        #debug("%s: %s", directive,  value);
+        option::some(value)
+    } else { option::none }
 }

trunk/src/compiletest/runtest.rs

@@ -199,7 +199,7 @@ fn check_error_patterns(props: test_props,
     let next_err_idx = 0u;
     let next_err_pat = props.error_patterns[next_err_idx];
     for line: str in str::split_byte(procres.stderr, '\n' as u8) {
-        if str::contains(line, next_err_pat) {
+        if str::find(line, next_err_pat) > 0 {
             #debug("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
             if next_err_idx == vec::len(props.error_patterns) {

trunk/src/fuzzer/fuzzer.rs

@@ -16,7 +16,7 @@ fn write_file(filename: str, content: str) {
 }
 
 fn contains(haystack: str, needle: str) -> bool {
-    str::contains(haystack, needle)
+    str::find(haystack, needle) != -1
 }
 
 fn find_rust_files(&files: [str], path: str) {

trunk/src/libcore/str.rs

@@ -70,7 +70,6 @@ export
    index,
    rindex,
    find,
-   find_bytes,
    contains,
    starts_with,
    ends_with,
@@ -664,10 +663,9 @@ fn replace(s: str, from: str, to: str) : is_not_empty(from) -> str unsafe {
                      unsafe::slice_bytes(s, len_bytes(from), len_bytes(s)),
                                        from, to);
     } else {
-        let idx;
-        alt find_bytes(s, from) {
-            option::some(x) { idx = x; }
-            option::none { ret s; }
+        let idx = find(s, from);
+        if idx == -1 {
+            ret s;
         }
         let before = unsafe::slice_bytes(s, 0u, idx as uint);
         let after  = unsafe::slice_bytes(s, idx as uint + len_bytes(from),
@@ -876,62 +874,38 @@ fn rindex(ss: str, cc: char) -> option<uint> {
     ret option::none;
 }
 
-//Function: find_bytes
-//
-// Find the char position of the first instance of one string
-// within another, or return option::none
-//
-// FIXME: Boyer-Moore should be significantly faster
-fn find_bytes(haystack: str, needle: str) -> option<uint> {
-    let haystack_len = len_bytes(haystack);
-    let needle_len   = len_bytes(needle);
+/*
+Function: find
 
-    if needle_len == 0u { ret option::some(0u); }
-    if needle_len > haystack_len { ret option::none; }
+Finds the index of the first matching substring.
+Returns -1 if `haystack` does not contain `needle`.
 
-    fn match_at(haystack: str, needle: str, ii: uint) -> bool {
-        let jj = ii;
-        for c: u8 in needle { if haystack[jj] != c { ret false; } jj += 1u; }
-        ret true;
-    }
-
-    let ii = 0u;
-    while ii <= haystack_len - needle_len {
-        if match_at(haystack, needle, ii) { ret option::some(ii); }
-        ii += 1u;
-    }
+Parameters:
 
-    ret option::none;
-}
+haystack - The string to look in
+needle - The string to look for
 
-// Function: find
-//
-// Find the char position of the first instance of one string
-// within another, or return option::none
-fn find(haystack: str, needle: str) -> option<uint> {
-   alt find_bytes(haystack, needle) {
-      option::none { ret option::none; }
-      option::some(nn) { ret option::some(b2c_pos(haystack, nn)); }
-   }
-}
+Returns:
 
-// Function: b2c_pos
-//
-// Convert a byte position into a char position
-// within a given string
-fn b2c_pos(ss: str, bpos: uint) -> uint {
-   assert bpos == 0u || bpos < len_bytes(ss);
-
-   let ii = 0u;
-   let cpos = 0u;
-
-   while ii < bpos {
-      let sz = utf8_char_width(ss[ii]);
-      ii += sz;
-      cpos += 1u;
-   }
+The index of the first occurance of `needle`, or -1 if not found.
 
-   ret cpos;
+FIXME: return an option<char position uint> instead
+*/
+fn find(haystack: str, needle: str) -> int {
+    let haystack_len: int = len_bytes(haystack) as int;
+    let needle_len: int = len_bytes(needle) as int;
+    if needle_len == 0 { ret 0; }
+    fn match_at(haystack: str, needle: str, i: int) -> bool {
+        let j: int = i;
+        for c: u8 in needle { if haystack[j] != c { ret false; } j += 1; }
+        ret true;
+    }
+    let i: int = 0;
+    while i <= haystack_len - needle_len {
+        if match_at(haystack, needle, i) { ret i; }
+        i += 1;
+    }
+    ret -1;
 }
 
 /*
@@ -945,7 +919,7 @@ haystack - The string to look in
 needle - The string to look for
 */
 fn contains(haystack: str, needle: str) -> bool {
-    option::is_some(find_bytes(haystack, needle))
+    0 <= find(haystack, needle)
 }
 
 /*
@@ -958,12 +932,12 @@ Parameters:
 haystack - The string to look in
 needle - The string to look for
 */
-fn starts_with(haystack: str, needle: str) -> bool unsafe {
-    let haystack_len: uint = len_bytes(haystack);
-    let needle_len: uint = len_bytes(needle);
+fn starts_with(haystack: str, needle: str) -> bool {
+    let haystack_len: uint = len(haystack);
+    let needle_len: uint = len(needle);
     if needle_len == 0u { ret true; }
     if needle_len > haystack_len { ret false; }
-    ret eq(unsafe::slice_bytes(haystack, 0u, needle_len), needle);
+    ret eq(substr(haystack, 0u, needle_len), needle);
 }
 
 /*
@@ -1722,40 +1696,26 @@ mod tests {
         assert [] == words("");
     }
 
-    #[test]
-    fn test_find_bytes() {
-        // byte positions
-        assert (find_bytes("banana", "apple pie") == option::none);
-        assert (find_bytes("", "") == option::some(0u));
-
-        let data = "ประเทศไทย中华Việt Nam";
-        assert (find_bytes(data, "")     == option::some(0u));
-        assert (find_bytes(data, "ประเ") == option::some( 0u));
-        assert (find_bytes(data, "ะเ")   == option::some( 6u));
-        assert (find_bytes(data, "中华") == option::some(27u));
-        assert (find_bytes(data, "ไท华") == option::none);
-    }
-
     #[test]
     fn test_find() {
-        // char positions
-        assert (find("banana", "apple pie") == option::none);
-        assert (find("", "") == option::some(0u));
-
-        let data = "ประเทศไทย中华Việt Nam";
-        assert (find(data, "")     == option::some(0u));
-        assert (find(data, "ประเ") == option::some(0u));
-        assert (find(data, "ะเ")   == option::some(2u));
-        assert (find(data, "中华") == option::some(9u));
-        assert (find(data, "ไท华") == option::none);
-    }
+        fn t(haystack: str, needle: str, i: int) {
+            let j: int = find(haystack, needle);
+            log(debug, "searched for " + needle);
+            log(debug, j);
+            assert (i == j);
+        }
+        t("this is a simple", "is a", 5);
+        t("this is a simple", "is z", -1);
+        t("this is a simple", "", 0);
+        t("this is a simple", "simple", 10);
+        t("this", "simple", -1);
 
-    #[test]
-    fn test_b2c_pos() {
+        // FIXME: return option<char> position instead
         let data = "ประเทศไทย中华Việt Nam";
-        assert 0u == b2c_pos(data, 0u);
-        assert 2u == b2c_pos(data, 6u);
-        assert 9u == b2c_pos(data, 27u);
+        assert (find(data, "ประเ") ==  0);
+        assert (find(data, "ะเ")   ==  6); // byte position
+        assert (find(data, "中华") ==  27); // byte position
+        assert (find(data, "ไท华") == -1);
     }
 
     #[test]

trunk/src/libstd/test.rs

@@ -258,7 +258,7 @@ fn filter_tests(opts: test_opts,
 
         fn filter_fn(test: test_desc, filter_str: str) ->
             option<test_desc> {
-            if str::contains(test.name, filter_str) {
+            if str::find(test.name, filter_str) >= 0 {
                 ret option::some(test);
             } else { ret option::none; }
         }