1 files changed, 28 insertions, 38 deletions

diff --git a/src/org/gnunet/util/getopt/Parser.java b/src/org/gnunet/util/getopt/Parser.java
index 9807146..6ecc220 100644
--- a/src/org/gnunet/util/getopt/Parser.java
+++ b/src/org/gnunet/util/getopt/Parser.java
@@ -22,7 +22,6 @@ package org.gnunet.util.getopt;
 
 import org.gnunet.construct.ReflectUtil;
 import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
 import java.util.*;
 
 /**
@@ -45,10 +44,10 @@ public class Parser {
      * An option together with its target field.
      */
     static class OptionField {
-        Option opt;
+        Argument opt;
         Field f;
 
-        public OptionField(Option opt, Field f) {
+        public OptionField(Argument opt, Field f) {
             this.opt = opt;
             this.f = f;
         }
@@ -66,7 +65,7 @@ public class Parser {
     private Map<String, OptionField> longOpt = new HashMap<String, OptionField>();
     private Map<String, OptionField> shortOpt = new HashMap<String, OptionField>();
 
-    private Collection<Option> options = new LinkedList<Option>();
+    private Collection<Argument> arguments = new LinkedList<Argument>();
 
     private Object targetObject;
 
@@ -75,11 +74,7 @@ public class Parser {
         this.targetObject = targetObject;
         // gather option annotations
         for (Field f : getFields(targetObject.getClass())) {
-            if (f.isSynthetic() || Modifier.isStatic(f.getModifiers())) {
-                continue;
-            }
-            // todo: validity checking of annotations
-            Option opt = f.getAnnotation(Option.class);
+            Argument opt = f.getAnnotation(Argument.class);
             if (opt != null) {
                 if (opt.shortname().length() != 1) {
                     throw new AssertionError("short name must be of length 1");
@@ -89,14 +84,14 @@ public class Parser {
 
                 longOpt.put(opt.longname(), new OptionField(opt, f));
                 shortOpt.put(opt.shortname(), new OptionField(opt, f));
-                options.add(opt);
+                arguments.add(opt);
             }
         }
     }
 
     public String getHelp() {
         StringBuilder helpString = new StringBuilder();
-        for (Option opt : options) {
+        for (Argument opt : arguments) {
             StringBuilder line = new StringBuilder();
             line.append("  -");
             line.append(opt.shortname());
@@ -118,10 +113,10 @@ public class Parser {
         return helpString.toString();
     }
 
-    public void doLongOpt(final LinkedList<String> argsList, Field targetField, Option option, String right) {
+    private void doLongOpt(final LinkedList<String> argsList, Field targetField, Argument argument, String right) {
         try {
             Class targetFieldType = targetField.getType();
-            switch (option.action()) {
+            switch (argument.action()) {
                 case SET:
                     if (!targetFieldType.equals(Boolean.TYPE)) {
                         throw new AssertionError("action SET only valid on boolean member");
@@ -141,7 +136,7 @@ public class Parser {
                     if (right == null) {
                         argsList.removeFirst();
                         if (argsList.isEmpty()) {
-                            throw new ArgumentError("missing string argument to option " + option.longname());
+                            throw new ArgumentError("missing string argument to option " + argument.longname());
                         }
                         targetField.set(targetObject, argsList.getFirst());
                     } else {
@@ -154,7 +149,7 @@ public class Parser {
                     if (right == null) {
                         argsList.removeFirst();
                         if (argsList.isEmpty()) {
-                            throw new ArgumentError("missing number argument to option " + option.longname());
+                            throw new ArgumentError("missing number argument to option " + argument.longname());
                         }
                         numString = argsList.getFirst();
                     } else {
@@ -163,11 +158,9 @@ public class Parser {
                     try {
                         nf.set(targetObject, Long.parseLong(numString));
                     } catch (NumberFormatException e) {
-                        throw new ArgumentError("error in number format to option " + option.longname());
+                        throw new ArgumentError("error in number format to option " + argument.longname());
                     }
                     break;
-                case INCREMENT:
-                    throw new UnsupportedOperationException("not yet implemented");
             }
         } catch (IllegalAccessException e) {
             throw new AssertionError(
@@ -175,9 +168,13 @@ public class Parser {
         }
     }
 
-    public boolean doShortOpt(final LinkedList<String> argsList, Field targetField, Option option, String shortName) {
+    /**
+     * returns true if we processed a shortopt with a parameter, and thus have to discard the rest
+     * of the current argument string (that is, stop scanning for more shortopts)
+     */
+    private boolean doShortOpt(final LinkedList<String> argsList, Field targetField, Argument argument, String shortName) {
         try {
-            switch (option.action()) {
+            switch (argument.action()) {
                 case SET:
                     if (!targetField.getType().equals(Boolean.TYPE)) {
                         throw new AssertionError("action SET only valid on boolean member");
@@ -186,16 +183,15 @@ public class Parser {
                     break;
                 case RESET:
                     if (!targetField.getType().equals(Boolean.TYPE)) {
-                        throw new AssertionError("action RESET only valid on boolean member");
+                        throw new AssertionError("action RESET only valid on boolean field");
                     }
                     targetField.set(targetObject, false);
                     break;
                 case STORE_STRING:
                     if (!targetField.getType().equals(String.class)) {
-                        throw new AssertionError("action STORE_STRING only valid on boolean " +
-                                "member");
+                        throw new AssertionError("action STORE_STRING only valid on 'String' field");
                     }
-                    if (argsList.getFirst().length() == 2) { // -X
+                    if (argsList.getFirst().length() == 2) { // -P xxx (with space)
                         argsList.removeFirst();
                         if (argsList.isEmpty()) {
                             throw new ArgumentError(String.format("no argument for short option '%s'",
@@ -205,31 +201,25 @@ public class Parser {
                     } else {
                         targetField.set(targetObject, argsList.getFirst().substring(2)); // -Pxxx...
                     }
-                    // consumed entire shortopt
                     return true;
                 case STORE_NUMBER:
                     ReflectUtil.NumField nf = new ReflectUtil.NumField(targetField);
                     String numString;
-                    boolean consumed;
                     if (argsList.getFirst().length() == 2) { // -X
                         argsList.removeFirst();
                         if (argsList.isEmpty()) {
-                            throw new ArgumentError("missing number argument to option " + option.longname());
+                            throw new ArgumentError("missing number argument to option " + argument.longname());
                         }
                         numString = argsList.getFirst();
-                        consumed = false;
                     } else {
                         numString = argsList.getFirst().substring(2);
-                        consumed = true;
                     }
                     try {
                         nf.set(targetObject, Long.parseLong(numString));
                     } catch (NumberFormatException e) {
-                        throw new ArgumentError("error in number format to option " + option.longname());
+                        throw new ArgumentError("error in number format to option " + argument.longname());
                     }
-                    return consumed;
-                case INCREMENT:
-                    throw new UnsupportedOperationException("not yet implemented");
+                    return true;
             }
         } catch (IllegalAccessException e) {
             throw new ArgumentError(
@@ -238,7 +228,6 @@ public class Parser {
         return false; // did not consume entire shortopt -Xxxxxx
     }
 
-
     /**
      * Parses the given arguments, and sets the target object's fields
      * according to its annotations.
@@ -271,7 +260,8 @@ public class Parser {
                 }
                 String right = (components.length == 2) ? components[1] : null;
                 doLongOpt(argsList, of.f, of.opt, right);
-            } else if (argsList.getFirst().length() > 1 && argsList.getFirst().startsWith("-")) {
+            } else if ((argsList.getFirst().length() > 1) && argsList.getFirst().startsWith("-")) {
+                // handle each flag after the "-"
                 for (int i = 1; i < argsList.getFirst().length(); ++i) {
                     String optShortName = argsList.getFirst().substring(i, i + 1);
                     OptionField of = shortOpt.get(optShortName);
@@ -280,13 +270,13 @@ public class Parser {
                                 String.format("unknown short option: -%s", argsList.getFirst().charAt(i)));
                     }
 
-                    boolean consumed = doShortOpt(argsList, of.f, of.opt, optShortName);
+                    boolean discard = doShortOpt(argsList, of.f, of.opt, optShortName);
 
-                    if (consumed && i != 1) {
+                    if (discard && (i != 1)) {
                         throw new ArgumentError("short options with argument must be seperate");
                     }
 
-                    if (consumed) {
+                    if (discard) {
                         break;
                     }