about summary refs log tree commit diff
path: root/src/libstd/getopts.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/getopts.rs')
-rw-r--r--src/libstd/getopts.rs71
1 files changed, 38 insertions, 33 deletions
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index c03042fe9c2..3ddc80dfb92 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -229,13 +229,13 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
     let l = args.len();
     let mut i = 0;
     while i < l {
-        let cur = args[i];
+        let cur = copy args[i];
         let curlen = cur.len();
         if !is_arg(cur) {
             free.push(cur);
         } else if cur == ~"--" {
             let mut j = i + 1;
-            while j < l { free.push(args[j]); j += 1; }
+            while j < l { free.push(copy args[j]); j += 1; }
             break;
         } else {
             let mut names;
@@ -248,8 +248,8 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                     names = ~[Long(tail)];
                 } else {
                     names =
-                        ~[Long(tail_eq[0])];
-                    i_arg = Some(tail_eq[1]);
+                        ~[Long(copy tail_eq[0])];
+                    i_arg = Some(copy tail_eq[1]);
                 }
             } else {
                 let mut j = 1;
@@ -266,7 +266,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                        interpreted correctly
                     */
 
-                    match find_opt(opts, opt) {
+                    match find_opt(opts, copy opt) {
                       Some(id) => last_valid_opt_id = Some(id),
                       None => {
                         let arg_follows =
@@ -292,7 +292,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
             let mut name_pos = 0;
             for names.each() |nm| {
                 name_pos += 1;
-                let optid = match find_opt(opts, *nm) {
+                let optid = match find_opt(opts, copy *nm) {
                   Some(id) => id,
                   None => return Err(UnrecognizedOption(name_str(nm)))
                 };
@@ -305,18 +305,18 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                   }
                   Maybe => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val(i_arg.get()));
+                        vals[optid].push(Val((copy i_arg).get()));
                     } else if name_pos < names.len() ||
                                   i + 1 == l || is_arg(args[i + 1]) {
                         vals[optid].push(Given);
-                    } else { i += 1; vals[optid].push(Val(args[i])); }
+                    } else { i += 1; vals[optid].push(Val(copy args[i])); }
                   }
                   Yes => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val(i_arg.get()));
+                        vals[optid].push(Val((copy i_arg).get()));
                     } else if i + 1 == l {
                         return Err(ArgumentMissing(name_str(nm)));
-                    } else { i += 1; vals[optid].push(Val(args[i])); }
+                    } else { i += 1; vals[optid].push(Val(copy args[i])); }
                   }
                 }
             }
@@ -346,7 +346,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
 
 fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
     return match find_opt(mm.opts, mkname(nm)) {
-      Some(id) => mm.vals[id],
+      Some(id) => copy mm.vals[id],
       None => {
         error!("No option '%s' defined", nm);
         fail!()
@@ -354,7 +354,7 @@ fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
     };
 }
 
-fn opt_val(mm: &Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; }
+fn opt_val(mm: &Matches, nm: &str) -> Optval { copy opt_vals(mm, nm)[0] }
 
 /// Returns true if an option was matched
 pub fn opt_present(mm: &Matches, nm: &str) -> bool {
@@ -547,25 +547,29 @@ pub mod groups {
     // translate OptGroup into Opt
     // (both short and long names correspond to different Opts)
     pub fn long_to_short(lopt: &OptGroup) -> ~[Opt] {
-        match ((*lopt).short_name.len(),
-               (*lopt).long_name.len()) {
+        let OptGroup{short_name: short_name,
+                     long_name: long_name,
+                     hasarg: hasarg,
+                     occur: occur,
+                     _} = copy *lopt;
 
+        match (short_name.len(), long_name.len()) {
            (0,0) => fail!(~"this long-format option was given no name"),
 
-           (0,_) => ~[Opt {name:   Long(((*lopt).long_name)),
-                           hasarg: (*lopt).hasarg,
-                           occur:  (*lopt).occur}],
+           (0,_) => ~[Opt {name: Long((long_name)),
+                           hasarg: hasarg,
+                           occur: occur}],
 
-           (1,0) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
-                           hasarg: (*lopt).hasarg,
-                           occur:  (*lopt).occur}],
+           (1,0) => ~[Opt {name: Short(str::char_at(short_name, 0)),
+                           hasarg: hasarg,
+                           occur: occur}],
 
-           (1,_) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
-                           hasarg: (*lopt).hasarg,
-                           occur:  (*lopt).occur},
-                      Opt {name:   Long(((*lopt).long_name)),
-                           hasarg: (*lopt).hasarg,
-                           occur:  (*lopt).occur}],
+           (1,_) => ~[Opt {name: Short(str::char_at(short_name, 0)),
+                           hasarg: hasarg,
+                           occur:  occur},
+                      Opt {name:   Long((long_name)),
+                           hasarg: hasarg,
+                           occur:  occur}],
 
            (_,_) => fail!(~"something is wrong with the long-form opt")
         }
@@ -586,11 +590,12 @@ pub mod groups {
         let desc_sep = ~"\n" + str::repeat(~" ", 24);
 
         let rows = vec::map(opts, |optref| {
-            let short_name = (*optref).short_name;
-            let long_name = (*optref).long_name;
-            let hint = (*optref).hint;
-            let desc = (*optref).desc;
-            let hasarg = (*optref).hasarg;
+            let OptGroup{short_name: short_name,
+                         long_name: long_name,
+                         hint: hint,
+                         desc: desc,
+                         hasarg: hasarg,
+                         _} = copy *optref;
 
             let mut row = str::repeat(~" ", 4);
 
@@ -620,7 +625,7 @@ pub mod groups {
             row += if rowlen < 24 {
                 str::repeat(~" ", 24 - rowlen)
             } else {
-                desc_sep
+                copy desc_sep
             };
 
             // Normalize desc to contain words seperated by one space character
@@ -892,7 +897,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Err(copy f) => {
-            error!(fail_str(f));
+            error!(fail_str(copy f));
             check_fail_type(f, UnexpectedArgument_);
           }
           _ => fail!()