Convert std::getopts to istrs. Issue #855

3 files changed, 84 insertions, 64 deletions

diff --git a/src/lib/getopts.rs b/src/lib/getopts.rs
index 95747e3c453..c38b93ee8b0 100644
--- a/src/lib/getopts.rs
+++ b/src/lib/getopts.rs
@@ -29,7 +29,7 @@ export opt_strs;
 export opt_maybe_str;
 export opt_default;
 
-tag name { long(str); short(char); }
+tag name { long(istr); short(char); }
 
 tag hasarg { yes; no; maybe; }
 
@@ -37,45 +37,45 @@ tag occur { req; optional; multi; }
 
 type opt = {name: name, hasarg: hasarg, occur: occur};
 
-fn mkname(nm: str) -> name {
-    ret if str::char_len(nm) == 1u {
-            short(str::char_at(nm, 0u))
+fn mkname(nm: &istr) -> name {
+    ret if istr::char_len(nm) == 1u {
+            short(istr::char_at(nm, 0u))
         } else { long(nm) };
 }
 
-fn reqopt(name: str) -> opt {
+fn reqopt(name: &istr) -> opt {
     ret {name: mkname(name), hasarg: yes, occur: req};
 }
 
-fn optopt(name: str) -> opt {
+fn optopt(name: &istr) -> opt {
     ret {name: mkname(name), hasarg: yes, occur: optional};
 }
 
-fn optflag(name: str) -> opt {
+fn optflag(name: &istr) -> opt {
     ret {name: mkname(name), hasarg: no, occur: optional};
 }
 
-fn optflagopt(name: str) -> opt {
+fn optflagopt(name: &istr) -> opt {
     ret {name: mkname(name), hasarg: maybe, occur: optional};
 }
 
-fn optmulti(name: str) -> opt {
+fn optmulti(name: &istr) -> opt {
     ret {name: mkname(name), hasarg: yes, occur: multi};
 }
 
-tag optval { val(str); given; }
+tag optval { val(istr); given; }
 
-type match = {opts: [opt], vals: [mutable [optval]], free: [str]};
+type match = {opts: [opt], vals: [mutable [optval]], free: [istr]};
 
-fn is_arg(arg: str) -> bool {
-    ret str::byte_len(arg) > 1u && arg[0] == '-' as u8;
+fn is_arg(arg: &istr) -> bool {
+    ret istr::byte_len(arg) > 1u && arg[0] == '-' as u8;
 }
 
-fn name_str(nm: name) -> str {
-    ret alt nm { short(ch) { str::from_char(ch) } long(s) { s } };
+fn name_str(nm: &name) -> istr {
+    ret alt nm { short(ch) { istr::from_char(ch) } long(s) { s } };
 }
 
-fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
+fn find_opt(opts: &[opt], nm: &name) -> option::t<uint> {
     let i = 0u;
     let l = vec::len::<opt>(opts);
     while i < l { if opts[i].name == nm { ret some::<uint>(i); } i += 1u; }
@@ -83,65 +83,67 @@ fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
 }
 
 tag fail_ {
-    argument_missing(str);
-    unrecognized_option(str);
-    option_missing(str);
-    option_duplicated(str);
-    unexpected_argument(str);
+    argument_missing(istr);
+    unrecognized_option(istr);
+    option_missing(istr);
+    option_duplicated(istr);
+    unexpected_argument(istr);
 }
 
-fn fail_str(f: fail_) -> str {
+fn fail_str(f: &fail_) -> istr {
     ret alt f {
-          argument_missing(nm) { "Argument to option '" + nm + "' missing." }
-          unrecognized_option(nm) { "Unrecognized option: '" + nm + "'." }
-          option_missing(nm) { "Required option '" + nm + "' missing." }
+          argument_missing(nm) {
+            ~"Argument to option '" + nm + ~"' missing." }
+          unrecognized_option(nm) {
+            ~"Unrecognized option: '" + nm + ~"'." }
+          option_missing(nm) { ~"Required option '" + nm + ~"' missing." }
           option_duplicated(nm) {
-            "Option '" + nm + "' given more than once."
+            ~"Option '" + nm + ~"' given more than once."
           }
           unexpected_argument(nm) {
-            "Option " + nm + " does not take an argument."
+            ~"Option " + nm + ~" does not take an argument."
           }
         };
 }
 
 tag result { success(match); failure(fail_); }
 
-fn getopts(args: &[str], opts: &[opt]) -> result {
+fn getopts(args: &[istr], opts: &[opt]) -> result {
     let n_opts = vec::len::<opt>(opts);
     fn f(_x: uint) -> [optval] { ret []; }
     let vals = vec::init_fn_mut::<[optval]>(f, n_opts);
-    let free: [str] = [];
-    let l = vec::len::<str>(args);
+    let free: [istr] = [];
+    let l = vec::len(args);
     let i = 0u;
     while i < l {
         let cur = args[i];
-        let curlen = str::byte_len(cur);
+        let curlen = istr::byte_len(cur);
         if !is_arg(cur) {
             free += [cur];
-        } else if str::eq(cur, "--") {
+        } else if istr::eq(cur, ~"--") {
             let j = i + 1u;
             while j < l { free += [args[j]]; j += 1u; }
             break;
         } else {
             let names;
-            let i_arg = option::none::<str>;
+            let i_arg = option::none::<istr>;
             if cur[1] == '-' as u8 {
-                let tail = str::slice(cur, 2u, curlen);
-                let eq = str::index(tail, '=' as u8);
+                let tail = istr::slice(cur, 2u, curlen);
+                let eq = istr::index(tail, '=' as u8);
                 if eq == -1 {
                     names = [long(tail)];
                 } else {
-                    names = [long(str::slice(tail, 0u, eq as uint))];
+                    names = [long(istr::slice(tail, 0u, eq as uint))];
                     i_arg =
-                        option::some::<str>(str::slice(tail,
-                                                       (eq as uint) + 1u,
-                                                       curlen - 2u));
+                        option::some::<istr>(istr::slice(tail,
+                                                        (eq as uint) + 1u,
+                                                        curlen - 2u));
                 }
             } else {
                 let j = 1u;
                 names = [];
                 while j < curlen {
-                    let range = str::char_range_at(cur, j);
+                    let range = istr::char_range_at(cur, j);
                     names += [short(range.ch)];
                     j = range.next;
                 }
@@ -156,13 +158,13 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
                 }
                 alt opts[optid].hasarg {
                   no. {
-                    if !option::is_none::<str>(i_arg) {
+                    if !option::is_none::<istr>(i_arg) {
                         ret failure(unexpected_argument(name_str(nm)));
                     }
                     vals[optid] += [given];
                   }
                   maybe. {
-                    if !option::is_none::<str>(i_arg) {
+                    if !option::is_none::<istr>(i_arg) {
                         vals[optid] += [val(option::get(i_arg))];
                     } else if name_pos < vec::len::<name>(names) ||
                                   i + 1u == l || is_arg(args[i + 1u]) {
@@ -170,8 +172,8 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
                     } else { i += 1u; vals[optid] += [val(args[i])]; }
                   }
                   yes. {
-                    if !option::is_none::<str>(i_arg) {
-                        vals[optid] += [val(option::get::<str>(i_arg))];
+                    if !option::is_none::<istr>(i_arg) {
+                        vals[optid] += [val(option::get::<istr>(i_arg))];
                     } else if i + 1u == l {
                         ret failure(argument_missing(name_str(nm)));
                     } else { i += 1u; vals[optid] += [val(args[i])]; }
@@ -200,45 +202,45 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
     ret success({opts: opts, vals: vals, free: free});
 }
 
-fn opt_vals(m: &match, nm: str) -> [optval] {
+fn opt_vals(m: &match, nm: &istr) -> [optval] {
     ret alt find_opt(m.opts, mkname(nm)) {
           some(id) { m.vals[id] }
-          none. { log_err "No option '" + nm + "' defined."; fail }
+          none. { log_err ~"No option '" + nm + ~"' defined."; fail }
         };
 }
 
-fn opt_val(m: &match, nm: str) -> optval { ret opt_vals(m, nm)[0]; }
+fn opt_val(m: &match, nm: &istr) -> optval { ret opt_vals(m, nm)[0]; }
 
-fn opt_present(m: &match, nm: str) -> bool {
+fn opt_present(m: &match, nm: &istr) -> bool {
     ret vec::len::<optval>(opt_vals(m, nm)) > 0u;
 }
 
-fn opt_str(m: &match, nm: str) -> str {
+fn opt_str(m: &match, nm: &istr) -> istr {
     ret alt opt_val(m, nm) { val(s) { s } _ { fail } };
 }
 
-fn opt_strs(m: &match, nm: str) -> [str] {
-    let acc: [str] = [];
+fn opt_strs(m: &match, nm: &istr) -> [istr] {
+    let acc: [istr] = [];
     for v: optval in opt_vals(m, nm) {
         alt v { val(s) { acc += [s]; } _ { } }
     }
     ret acc;
 }
 
-fn opt_maybe_str(m: &match, nm: str) -> option::t<str> {
+fn opt_maybe_str(m: &match, nm: &istr) -> option::t<istr> {
     let vals = opt_vals(m, nm);
-    if vec::len::<optval>(vals) == 0u { ret none::<str>; }
-    ret alt vals[0] { val(s) { some::<str>(s) } _ { none::<str> } };
+    if vec::len::<optval>(vals) == 0u { ret none::<istr>; }
+    ret alt vals[0] { val(s) { some::<istr>(s) } _ { none::<istr> } };
 }
 
 
 /// Returns none if the option was not present, `def` if the option was
 /// present but no argument was provided, and the argument if the option was
 /// present and an argument was provided.
-fn opt_default(m: &match, nm: str, def: str) -> option::t<str> {
+fn opt_default(m: &match, nm: &istr, def: &istr) -> option::t<istr> {
     let vals = opt_vals(m, nm);
-    if vec::len::<optval>(vals) == 0u { ret none::<str>; }
-    ret alt vals[0] { val(s) { some::<str>(s) } _ { some::<str>(def) } }
+    if vec::len::<optval>(vals) == 0u { ret none::<istr>; }
+    ret alt vals[0] { val(s) { some::<istr>(s) } _ { some::<istr>(def) } }
 }
 // Local Variables:
 // mode: rust;
diff --git a/src/lib/istr.rs b/src/lib/istr.rs
index 9e1fa37693d..a15e32e5190 100644
--- a/src/lib/istr.rs
+++ b/src/lib/istr.rs
@@ -3,9 +3,9 @@ index, rindex, find, starts_with, ends_with, substr, slice, split,
 concat, connect, to_upper, replace, char_slice, trim_left, trim_right, trim,
 unshift_char, shift_char, pop_char, push_char, is_utf8, from_chars, to_chars,
 char_len, char_at, bytes, is_ascii, shift_byte, pop_byte, unsafe_from_byte,
-unsafe_from_bytes, from_char;
+unsafe_from_bytes, from_char, char_range_at;
 
-export from_estr, to_estr;
+export from_estr, to_estr, from_estrs, to_estrs;
 
 fn from_estr(s: &str) -> istr {
     let s2 = ~"";
@@ -23,6 +23,22 @@ fn to_estr(s: &istr) -> str {
     ret s2;
 }
 
+fn from_estrs(ss: &[str]) -> [istr] {
+    let ss2 = [];
+    for s in ss {
+        ss2 += [from_estr(s)];
+    }
+    ret ss2;
+}
+
+fn to_estrs(ss: &[istr]) -> [str] {
+    let ss2 = [];
+    for s in ss {
+        ss2 += [to_estr(s)];
+    }
+    ret ss2;
+}
+
 fn eq(a: &istr, b: &istr) -> bool { a == b }
 
 fn lteq(a: &istr, b: &istr) -> bool { a <= b }
diff --git a/src/lib/test.rs b/src/lib/test.rs
index e0d27cd1d52..ef3348dc36b 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -66,20 +66,22 @@ type opt_res = either::t<test_opts, str>;
 // Parses command line arguments into test options
 fn parse_opts(args: &[str]) : vec::is_not_empty(args) -> opt_res {
 
-    let args_ = vec::tail(args);
-    let opts = [getopts::optflag("ignored")];
+    let args_ = istr::from_estrs(vec::tail(args));
+    let opts = [getopts::optflag(~"ignored")];
     let match =
         alt getopts::getopts(args_, opts) {
           getopts::success(m) { m }
-          getopts::failure(f) { ret either::right(getopts::fail_str(f)) }
+          getopts::failure(f) {
+            ret either::right(istr::to_estr(getopts::fail_str(f)))
+          }
         };
 
     let filter =
         if vec::len(match.free) > 0u {
-            option::some(match.free[0])
+            option::some(istr::to_estr(match.free[0]))
         } else { option::none };
 
-    let run_ignored = getopts::opt_present(match, "ignored");
+    let run_ignored = getopts::opt_present(match, ~"ignored");
 
     let test_opts = {filter: filter, run_ignored: run_ignored};