seq: now passes about half of the Busybox tests

seq/seq.rs

@@ -15,13 +15,14 @@ mod util;
 
 static NAME: &'static str = "seq";
 
-fn print_usage(opts: &[getopts::OptGroup]) {
+#[deriving(Clone)]
-    println!("seq 1.0.0\n");
+struct SeqOptions {
-    println!("Usage:\n  seq [-w] [-s string] [-t string] [first [step]] last\n");
+    separator: String,
-    println!("{:s}", getopts::usage("Print sequences of numbers", opts));
+    terminator: Option<String>,
+    widths: bool
 }
 
-fn parse_float(s: &str) -> Result<f32, String>{
+fn parse_float(s: &str) -> Result<f64, String>{
     match from_str(s) {
         Some(n) => Ok(n),
         None => Err(format!("seq: invalid floating point argument: {:s}", s))
@@ -33,10 +34,95 @@ fn escape_sequences(s: &str) -> String {
         replace("\\t", "\t")
 }
 
-#[allow(dead_code)]
+fn parse_options(args: Vec<String>, options: &mut SeqOptions) -> Result<Vec<String>, int> {
-fn main() { os::set_exit_status(uumain(os::args())); }
+    let mut seq_args = vec!();
+    let program = args.get(0).clone();
+    let mut iter = args.move_iter().skip(1);
+    loop {
+        match iter.next() {
+            Some(arg) => match arg.as_slice() {
+                "--help" | "-h" => {
+                    print_help(&program);
+                    return Err(0);
+                }
+                "--version" | "-V" => {
+                    print_version();
+                    return Err(0);
+                }
+                "-s" | "--separator" => match iter.next() {
+                    Some(sep) => options.separator = sep,
+                    None => {
+                        show_error!("expected a separator after {}", arg);
+                        return Err(1);
+                    }
+                },
+                "-t" | "--terminator" => match iter.next() {
+                    Some(term) => options.terminator = Some(term),
+                    None => {
+                        show_error!("expected a terminator after '{}'", arg);
+                        return Err(1);
+                    }
+                },
+                "-w" | "--widths" => options.widths = true,
+                _ => {
+                    if arg.len() > 1 && arg.as_slice().char_at(0) == '-' {
+                        let argptr: *String = &arg;  // escape from the borrow checker
+                        let mut chiter = unsafe { (*argptr).as_slice() }.chars().skip(1);
+                        let mut ch = ' ';
+                        while match chiter.next() { Some(m) => { ch = m; true } None => false } {
+                            match ch {
+                                'h' => {
+                                    print_help(&program);
+                                    return Err(0);
+                                }
+                                'V' => {
+                                    print_version();
+                                    return Err(0);
+                                }
+                                's' => match iter.next() {
+                                    Some(sep) => {
+                                        options.separator = sep;
+                                        let next = chiter.next();
+                                        if next.is_some() {
+                                            show_error!("unexpected character ('{}')", next.unwrap());
+                                            return Err(1);
+                                        }
+                                    }
+                                    None => {
+                                        show_error!("expected a separator after {}", arg);
+                                        return Err(1);
+                                    }
+                                },
+                                't' => match iter.next() {
+                                    Some(term) => {
+                                        options.terminator = Some(term);
+                                        let next = chiter.next();
+                                        if next.is_some() {
+                                            show_error!("unexpected character ('{}')", next.unwrap());
+                                            return Err(1);
+                                        }
+                                    }
+                                    None => {
+                                        show_error!("expected a terminator after {}", arg);
+                                        return Err(1);
+                                    }
+                                },
+                                'w' => options.widths = true,
+                                _ => { seq_args.push(arg); break }
+                            }
+                        }
+                    } else {
+                        seq_args.push(arg);
+                    }
+                }
+            },
+            None => break
+        }
+    }
+    Ok(seq_args)
+}
 
-pub fn uumain(args: Vec<String>) -> int {
+fn print_help(program: &String) {
     let opts = [
         getopts::optopt("s", "separator", "Separator character (defaults to \\n)", ""),
         getopts::optopt("t", "terminator", "Terminator character (defaults to separator)", ""),
@@ -44,62 +130,73 @@ pub fn uumain(args: Vec<String>) -> int {
         getopts::optflag("h", "help", "print this help text and exit"),
         getopts::optflag("V", "version", "print version and exit"),
     ];
-    let matches = match getopts::getopts(args.tail(), opts) {
+    println!("seq 1.0.0\n");
-        Ok(m) => { m }
+    println!("Usage:\n  {} [-w] [-s string] [-t string] [first [step]] last\n", *program);
-        Err(f) => {
+    println!("{:s}", getopts::usage("Print sequences of numbers", opts));
-            show_error!("{}", f);
+}
-            print_usage(opts);
+
-            return 1;
+fn print_version() {
-        }
+    println!("seq 1.0.0\n");
+}
+
+#[allow(dead_code)]
+fn main() { os::set_exit_status(uumain(os::args())); }
+
+pub fn uumain(args: Vec<String>) -> int {
+    let program = args.get(0).clone();
+    let mut options = SeqOptions {
+        separator: "\n".to_string(),
+        terminator: None,
+        widths: false
     };
-    if matches.opt_present("help") {
+    let free = match parse_options(args, &mut options) {
-        print_usage(opts);
+        Ok(m) => m,
-        return 0;
+        Err(f) => return f
+    };
+    if free.len() < 1 || free.len() > 3 {
+        crash!(1, "too {} operands.\nTry '{} --help' for more information.",
+               if free.len() < 1 { "few" } else { "many" }, program);
     }
-    if matches.opt_present("version") {
+    let first = if free.len() > 1 {
-        println!("seq 1.0.0");
+        match parse_float(free.get(0).as_slice()) {
-        return 0;
-    }
-    if matches.free.len() < 1 || matches.free.len() > 3 {
-        print_usage(opts);
-        return 1;
-    }
-    let first = if matches.free.len() > 1 {
-        match parse_float(matches.free.get(0).as_slice()) {
             Ok(n) => n,
             Err(s) => { show_error!("{:s}", s); return 1; }
         }
     } else {
         1.0
     };
-    let step = if matches.free.len() > 2 {
+    let step = if free.len() > 2 {
-        match parse_float(matches.free.get(1).as_slice()) {
+        match parse_float(free.get(1).as_slice()) {
             Ok(n) => n,
             Err(s) => { show_error!("{:s}", s); return 1; }
         }
     } else {
         1.0
     };
-    let last = match parse_float(matches.free.get(matches.free.len()-1).as_slice()) {
+    let last = match parse_float(free.get(free.len()-1).as_slice()) {
         Ok(n) => n,
         Err(s) => { show_error!("{:s}", s); return 1; }
     };
-    let separator = escape_sequences(matches.opt_str("s").unwrap_or("\n".to_string()).as_slice());
+    let separator = escape_sequences(options.separator.as_slice());
-    let terminator = escape_sequences(matches.opt_str("t").unwrap_or(separator.to_string()).as_slice());
+    let terminator = match options.terminator {
-    print_seq(first, step, last, separator, terminator, matches.opt_present("w"));
+        Some(term) => escape_sequences(term.as_slice()),
+        None => separator.clone()
+    };
+    print_seq(first, step, last, separator, terminator, options.widths);
 
     0
 }
 
-fn done_printing(next: f32, step: f32, last: f32) -> bool {
+#[inline(always)]
-    if step > 0f32 {
+fn done_printing(next: f64, step: f64, last: f64) -> bool {
+    if step > 0f64 {
         next > last
     } else {
         next < last
     }
 }
 
-fn print_seq(first: f32, step: f32, last: f32, separator: String, terminator: String, pad: bool) {
+fn print_seq(first: f64, step: f64, last: f64, separator: String, terminator: String, pad: bool) {
     let mut i = first;
     let maxlen = first.max(last).to_str().len();
     while !done_printing(i, step, last) {
@@ -115,5 +212,7 @@ fn print_seq(first: f32, step: f32, last: f32, separator: String, terminator: St
             print!("{:s}", separator);
         }
     }
-    print!("{:s}", terminator);
+    if i != first {
+        print!("{:s}", terminator);
+    }
 }