Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.11 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.12
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.11	Sun Dec 16 01:01:49 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Sun Dec 16 22:30:33 2007
@@ -33,9 +33,11 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.TreeMap;
 
 /**
@@ -76,7 +78,7 @@
 
 public abstract class OptionParser {
 
-    public static final String APPLICATION_ARGUMENTS_FIELD_NAME = "applicationArguments";
+    //public static final String APPLICATION_ARGUMENTS_FIELD_NAME = "applicationArguments";
 
     /** logger non statique pour épouser la catégorie de l'implantation */
     protected final LutinLog log = LutinLogFactory.getLutinLog(getClass());
@@ -90,11 +92,20 @@
     /** le dictionnaire des definitions d'options indexées par leurs alias */
     protected final Map<String, OptionDefinition> indexAlias;
 
+    /** order on options by their names */
+    protected final List<String> definitionsIndex;
+
     /** la liste des options trouvées et valides, indexées par leur clef unique. */
-    protected final Map<String, List<Option>> acceptedOptions;
+    protected Map<String, List<Option>> acceptedOptions;
+
+    /** la liste des arugments non utilisés, indexés par leur position */
+    protected Map<Integer, String> unusedArguments;
 
     /** list of errors found while parsing */
-    protected OptionParserException[] _errors;
+    protected OptionParserException[] errors;
+
+    /** la liste des arguments utilisés dans le dernier parsing */
+    protected String[] arguments;
 
     public OptionParser() throws IllegalArgumentException {
         this(null);
@@ -103,14 +114,15 @@
     protected OptionParser(ApplicationA anno) throws IllegalArgumentException {
         // find ApplicationA annotation associated with parser
         if (anno == null) {
+            // try to find annotation on the implemented class
             anno = getClass().getAnnotation(ApplicationA.class);
             if (anno == null) {
                 throw new IllegalArgumentException(_("lutinutil.parser.unfound.annotation", ApplicationA.class, this));
             }
         }
         this.annotation = anno;
-        this.acceptedOptions = new HashMap<String, List<Option>>();
         this.definitions = new LinkedHashMap<String, OptionDefinition>();
+        this.definitionsIndex = new ArrayList<String>();
         this.indexAlias = new TreeMap<String, OptionDefinition>();
 
         if (anno.options().length > 0) {
@@ -119,7 +131,7 @@
                 // build each definition from his associated OptionA
                 OptionDefinition definition = new OptionDefinition(optionA);
                 definitions.put(optionA.key(), definition);
-                acceptedOptions.put(optionA.key(), new ArrayList<Option>());
+                definitionsIndex.add(optionA.key());
                 // keep all alias of the option
                 for (String alias : optionA.alias()) {
                     indexAlias.put(alias, definition);
@@ -137,35 +149,50 @@
      */
     public void doParse(String... args) throws OptionParserException, IOException {
         cleanResult();
-        ParserContext2 context = new ParserContext2();
-
-
+        arguments = args;
+        unusedArguments = new HashMap<Integer, String>();
+        ParserContext context = new ParserContext();
         if (args.length == 0) {
-            _errors = new OptionParserException[0];
+            errors = new OptionParserException[0];
             return;
         }
-
         // detect options
         context.detectOptions(args);
 
-        // transfert errors from parser context
-        _errors = context.getErrors().toArray(new OptionParserException[context.getNbErrors()]);
+        // instanciate real options from safe contexts
+        acceptedOptions = context.instanciate();
 
-        context.clear();
+        // transfert unused arguments
+        for (Integer unusedArgument : context.unusedArguments) {
+            unusedArguments.put(unusedArgument, args[unusedArgument]);
+        }
 
+        // transfert errors from parser context
+        errors = context.getErrors().toArray(new OptionParserException[context.getNbErrors()]);
+        // clean context
+        context.clear();
     }
 
     private void cleanResult() {
-        for (Map.Entry<String, List<Option>> stringListEntry : acceptedOptions.entrySet()) {
-            stringListEntry.getValue().clear();
+        if (acceptedOptions != null) {
+            acceptedOptions.clear();
+            acceptedOptions = null;
+        }
+
+        if (unusedArguments != null) {
+            unusedArguments.clear();
+            unusedArguments = null;
         }
-        _errors = null;
+        arguments = null;
+        errors = null;
     }
 
     public Option[] getOptions() {
         List<Option> result = new ArrayList<Option>();
-        for (List<Option> options : acceptedOptions.values()) {
-            result.addAll(options);
+        if (acceptedOptions != null) {
+            for (List<Option> options : acceptedOptions.values()) {
+                result.addAll(options);
+            }
         }
         return result.toArray(new Option[result.size()]);
     }
@@ -179,379 +206,557 @@
         return acceptedOptions;
     }
 
-    public void clear() {
-        //TODO clear data
+    public Option[] getOptions(String key) {
+        List<Option> list = acceptedOptions.get(key);
+        return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
+    }
+
+    public void printUsage(Writer w, String name) throws IOException {
+        String head = _("lutinutil.parserdef.printUsage.head", name);
+        String prefixO = _("lutinutil.parserdef.printUsage.options.head", name);
+        String prefix = "\n";
+        w.append(OptionParserUtil.toString(annotation, head, prefixO, prefix));
+    }
+
+    /**
+     * Imprime dans un writer les erreurs rencontrées pendant l'analyse.
+     *
+     * @param w le writer à utiliser
+     * @throws IOException si problèmes d'écriture dans le writer
+     */
+    public void printErrors(Writer w) throws IOException {
+        if (!hasFailed() && (unusedArguments == null || unusedArguments.isEmpty())) {
+            return;
+        }
+        w.append(_("lutinutil.parserdef.printError", Arrays.toString(arguments))).append('\n');
+        if (!unusedArguments.isEmpty()) {
+            Set<Integer> unsedPos = unusedArguments.keySet();
+            w.append(_("lutinutil.parserdef.printError.unused.head", unsedPos.size()));
+            Iterator<Integer> itr = unsedPos.iterator();
+            for (int i = 0, j = unsedPos.size(); i < j; i++) {
+                int pos = itr.next();
+                w.append(_("lutinutil.parserdef.printError.unused", i + 1, j, pos));
+                w.append(unusedArguments.get(i));
+            }
+        }
+        if (hasFailed()) {
+            w.append(_("lutinutil.parserdef.printError.head", errors.length));
+            for (int i = 0, j = errors.length; i < j; i++) {
+                w.append(_("lutinutil.parserdef.printError.error", i + 1, j));
+                w.append(errors[i].toString());
+            }
+        }
+
+    }
+
+    public boolean hasFailed() {
+        return errors != null && errors.length > 0;
     }
 
     @Override
     protected void finalize() throws Throwable {
         super.finalize();
-        clear();
+        cleanResult();
+    }
+
+    public OptionParserException[] getErrors() {
+        return errors;
+    }
+
+    public String[] getUnusedArguments() {
+        return unusedArguments.values().toArray(new String[unusedArguments.size()]);
+    }
+
+    public String[] getArguments() {
+        return arguments;
     }
 
     /**
-     * Cette classe contient les index utilisés pendant le parsing.
+     * Cette classe contient les contextes d'options détectés pendand le parsing.
      * <p/>
      * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
      *
      * @author chemit
      */
-    class ParserContext2 extends OptionParserUtil.OptionParserContext<ParserContext2, ParserContext2> {
+    class ParserContext extends OptionParserUtil.OptionParserContext<ParserContext, OptionContext> {
 
         int pos = 0;
+        /** les occurences des options trouvées (est mis à jour dans la méthode */
+        final int[] optionFounds;
 
-        protected ParserContext2() {
-            super(null, true);
-        }
-
-        protected OptionArgumentDefinition detectArgumentDefinition(String argument, OptionGroupArgumentDefinition currentGroup) {
-            boolean named = argument.indexOf('=') > -1;
-            OptionArgumentDefinition result;
-            OptionArgumentType type;
-            OptionArgumentValueType valueType;
-            OptionArgumentDefinition[] defs = currentGroup.arguments;
-            if (named) {
-                String key = argument.substring(0, argument.indexOf('='));
-                type = OptionArgumentType.namedAndValued;
-                // find a named and valued
-                result = OptionParserUtil.findArgumentByTypeAndKey(type, key, defs);
-                log.info(argument + " : " + result);
-                if (result == null) {
-                    //fatal error : unknown namedAndValued argument
-                    addError(_("could not found a option argument definition with key {0} in {1}", key, Arrays.asList(currentGroup)));
-                    return null;
-                }
-                return result;
-            }
-            // try a constant
-            type = OptionArgumentType.constant;
-            result = OptionParserUtil.findArgumentByTypeAndKey(type, argument, defs);
-            if (result != null) {
-                log.info(argument + " : " + result);
-                return result;
-            }
-
-            // try a valued
-            type = OptionArgumentType.valued;
-            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
-            result = OptionParserUtil.findArgumentByTypeAndValueType(type, valueType, defs);
-
-            if (result == null && valueType == OptionArgumentValueType._file) {
-                // special case : wants a newFile type, but file already
-                // exists (so it was detected as a file argument)
-                // since we arrive here, it means no file argument
-                // try with a _newFile
-                result = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._newfile, defs);
-            }
-            if (result == null && valueType == OptionArgumentValueType._newfile) {
-                // we didn't find a _newFile, it could be also a string
-                result = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._string, defs);
-            }
-            log.info(argument + " : " + result);
-            return result;
-
-        }
-
-        Map<OptionArgumentValueType, Integer> mapAvailable;
-        List<OptionArgumentValueType> availables;
+        /** contient les positions des args non utilisés */
+        final List<Integer> unusedArguments;
 
-        //TODO New rule: for valued can't have twice a type in same group
+        /** la liste des groupes possibles pendant la détection des args */
+        final List<OptionDefinition> availabledOptions;
 
-        protected void buildGroupAvailableMap(OptionArgumentDefinition[] defs) {
-            if (mapAvailable != null) {
-                mapAvailable.clear();
-                availables.clear();
-            }
-            mapAvailable = new HashMap<OptionArgumentValueType, Integer>();
-            for (OptionArgumentValueType type : OptionArgumentValueType.values()) {
-                mapAvailable.put(type, 0);
-            }
-            for (OptionArgumentDefinition def : defs) {
-                mapAvailable.put(def.getValueType(), def.max);
+        protected ParserContext() {
+            super(null, true);
+            optionFounds = new int[definitionsIndex.size()];
+            unusedArguments = new ArrayList<Integer>();
+            availabledOptions = new ArrayList<OptionDefinition>();
+            for (OptionDefinition definition : definitions.values()) {
+                availabledOptions.add(definition);
             }
-            availables = new ArrayList<OptionArgumentValueType>(Arrays.asList(OptionArgumentValueType.values()));
         }
 
-        protected void removeOneType(OptionArgumentValueType type) {
-            if (!availables.contains(type)) {
-                return;
-            }
-            int i = mapAvailable.get(type);
-            if (i == 1) {
-                mapAvailable.remove(type);
-                availables.remove(type);
-            } else {
-                mapAvailable.put(type, i - 1);
-            }
+        @Override
+        void clear() {
+            super.clear();
+            unusedArguments.clear();
+            availabledOptions.clear();
+            pos = 0;
         }
 
-
         /**
          * Detecte les options et leurs arguments, à partir de la suite des
          * arguments donnés et construit la liste des context d'options.
          * <p/>
-         * Prépare avec les contexts d'options.
+         * Détecte les contextes d'options à analyser.
+         * Une fois un contexte d'option détecté (un alias et les arguments
+         * jusqu'au prochain alias), on instancie un {@link OptionContext},
+         * et on lance la méthode
+         * {@link #addSon(OptionParserUtil.ParserContext)}.
+         * <p/>
+         * Cette méthode suit l'algorthime générique, on surcharge
+         * {@link #preAddSonHook(OptionContext)}, pour lancer l'analyse de
+         * l'option, et la méthode {@link #postAddSonHook(OptionContext)}
+         * pour mettre à jour la table d'occurrences des options trouvées si
+         * l'option est valide.
          *
          * @param args la liste des arguments à scanner
          */
         protected void detectOptions(String... args) {
             int length = args.length;
-            // detect application's options
+
+            List<String> argsForOption = new ArrayList<String>();
+            // detect all arguments before first alias
+            fillArgumentsForOption(length, argsForOption, true, args);
+
             while (pos < length) {
                 // detect a new option with his arguments
                 // coming here means pos is exactly an index of an option's alias
                 int start = pos;
-                String alias = args[pos];
-                pos++;
+                String alias = args[pos++];
+                // detect all arguments before next alias
+                argsForOption.clear();
+                fillArgumentsForOption(length, argsForOption, false, args);
 
-                List<String> argsForOption = new ArrayList<String>();
-                // obtains the arguments of the option
-                String arg;
-                while (pos < length && !(arg = args[pos]).startsWith("-")) {
-                    argsForOption.add(arg);
-                    pos++;
-                }
                 // a fully option was detected
-                log.info("pos " + start + " : " + alias + " " + argsForOption);
+                log.info(" (pos " + start + ") " + alias + " " + argsForOption);
                 // find definition from alias
                 OptionDefinition definition = indexAlias.get(alias);
                 if (definition == null) {
-                    //fatal error : unknown.option
+                    //fatal error : unknown option
                     addError(_("lutinutil.parser.unknown.option", alias, start));
                     continue;
                 }
-                // found an option, parse his arguments
-                OptionArgument[] arguments = detectOptionArguments(definition, argsForOption);
+                if (!availabledOptions.contains(definition)) {
+                    // fatal error : the option is not available
+                    addError(_("lutinutil.parser.unavailable.option", alias, start));
+                    continue;
+                }
+                // create a OptionContext
+                OptionContext optionContext = new OptionContext(this, definition, argsForOption.toArray(new String[argsForOption.size()]), pos, alias);
+                // try to add the context
+                addSon(optionContext);
+            }
+            // check if we did not miss a mandatory option
+            for (OptionDefinition definition : availabledOptions) {
+                if (definition.isMandatory()) {
+                    int optionPos = definitionsIndex.indexOf(definition.getKey());
+                    if (optionFounds[optionPos] == 0) {
+                        addError(_("lutinutil.error.parser.unfound.mandatory.option", definition));
+                    }
+                }
+            }
+            // check the min property on each found option
+            for (OptionContext context : contexts) {
+                int optionPos = definitionsIndex.indexOf(context.definition.getKey());
+                int nbOccur = optionFounds[optionPos];
+                int min = context.definition.getMin();
+                if (nbOccur < min) {
+                    addError(_("lutinutil.error.parser.too.less.option.found", context.definition, nbOccur, min));
+                }
+            }
+        }
 
-                // validate the option
-                checkAndAddOption(alias, definition, arguments);
+        protected Map<String, List<Option>> instanciate() {
+            Map<String, List<Option>> acceptedOptions = new LinkedHashMap<String, List<Option>>();
+            for (OptionContext context : contexts) {
+                String key = context.definition.getKey();
+                Option option = context.instanciate();
+                List<Option> options = acceptedOptions.get(key);
+                if (options == null) {
+                    acceptedOptions.put(key, options = new ArrayList<Option>());
+                }
+                options.add(option);
+            }
+            return acceptedOptions;
+        }
+
+        @Override
+        protected void preAddSonHook(OptionContext context) {
+            super.preAddSonHook(context);
+            if (context.valid) {
+                // detect arguments for the option
+                context.detectArguments();
             }
         }
 
-        private OptionArgument[] detectOptionArguments(OptionDefinition optionDefinition, List<String> arguments) {
-            List<OptionArgument> result;
-            result = new ArrayList<OptionArgument>();
-            int lastPosition;
-            int pos = 0;
-            String key = optionDefinition.key;
-            OptionGroupArgumentDefinition[] optionalGroup = getOptionalGroupDefinition(key);
-            OptionGroupArgumentDefinition[] mandatoriesGroup = getMandatoryGroupDefinition(key);
-            OptionGroupArgumentDefinition group = null;
-
-            int max = mandatoriesGroup.length;
-
-            for (String argument : arguments) {
-                // save last position
-                lastPosition = pos;
-
-                // find a matching group
-                OptionArgumentDefinition co = null;
-
-                // try to find a mandatory group to matching from the
-                // current one
-                while (co == null && pos < max) {
-                    // take current group
-                    group = mandatoriesGroup[pos];
-                    // try to find it in the group
-                    co = detectArgumentDefinition(argument, group);
-                    if (co == null) {
-                        // try next group
-                        pos++;
-                    }
-                }
+        @Override
+        protected void postAddSonHook(OptionContext context) {
+            super.postAddSonHook(context);
+            // mark the option added
+            int optionPos = definitionsIndex.indexOf(context.definition.getKey());
+            optionFounds[optionPos] = optionFounds[optionPos] + 1;
+            // remove option from available if required
+            int max = context.definition.getMax();
+            if (max != -1 && optionFounds[optionPos] == max) {
+                // the option is no more available
+                availabledOptions.remove(context.definition);
+            }
+        }
 
-                if (co == null) {
-                    // put back pos
-                    pos = lastPosition;
-                    if (optionalGroup != null && optionalGroup.length > 0) {
-                        int optionIndex = 0;
-                        // try in optional group
-                        while (co == null && optionIndex < optionalGroup.length) {
-                            group = optionalGroup[optionIndex];
-                            co = detectArgumentDefinition(argument, group);
-                            if (co == null) {
-                                optionIndex++;
-                            }
-                        }
-                    }
+        protected void fillArgumentsForOption(int length, List<String> toFill, boolean beforeFirstOption, String... args) {
+            String arg;
+            // obtains the arguments of the option
+            while (pos < length && !(arg = args[pos]).startsWith("-")) {
+                if (beforeFirstOption) {
+                    // transfert it to unused argument
+                    unusedArguments.add(pos);
+                } else {
+                    toFill.add(arg);
                 }
-                if (co == null) {
-                    // could not found a correct argument definition in any group
-                    // option is corrupted
-                    addError(_(""));
+                pos++;
+            }
+        }
+    }
+
+    class OptionContext extends OptionParserUtil.OptionParserContext<ParserContext, ArgumentContext> {
+
+        /** la position de l'alias dans la ligne de commande */
+        final int commandLinePosition;
+        /** la liste des arguments à traiter pour cette option */
+        final String[] argumentsToTreate;
+        /** l'alias utilisé pour cette option dans la ligne de commande */
+        final String alias;
+        /** la définition de l'option */
+        final OptionDefinition definition;
+        /** les occurences des groups trouvés */
+        final int[] groupFounds;
+        /** la liste des groupes possibles pour cette option */
+        final List<OptionGroupDefinition> groups;
+        /** la liste des groupes possibles pendant la détection des arguments */
+        final List<OptionGroupDefinition> availabledGroups;
+        /** le dernier groupe d'argument valide et encore disponible */
+        OptionGroupDefinition lastGroup;
+        /** le dernier argument valide et encore disponible */
+        OptionArgumentDefinition lastArgument;
+
+        protected OptionContext(ParserContext parent, OptionDefinition definition, String[] argumentsToTreate, int commandLinePosition, String alias) {
+            super(parent, true);
+            this.argumentsToTreate = argumentsToTreate;
+            this.commandLinePosition = commandLinePosition;
+            this.alias = alias;
+            this.definition = definition;
+            this.groupFounds = new int[definition.getGroups().length];
+            groups = new ArrayList<OptionGroupDefinition>();
+            availabledGroups = new ArrayList<OptionGroupDefinition>();
+            groups.addAll(Arrays.asList(definition.getGroups()));
+            availabledGroups.addAll(groups);
+        }
+
+        public void detectArguments() {
+            lastArgument = null;
+            lastGroup = null;
+            for (int i = 0; i < argumentsToTreate.length; i++) {
+                String argument = argumentsToTreate[i];
+                ArgumentContext argumentContext = detectArgument(argument, i);
+                if (argumentContext == null) {
+                    // mark the argument as unused
+                    this.parent.unusedArguments.add(commandLinePosition + 1 + i);
                     continue;
                 }
-                // we found a matching group, try to create the argument
-                String valueStr = co.type.extractArgumentValue(argument);
-                log.info(argument + " : " + co);
-                if (group.pos > -1) {
-                    pos = group.pos;
-                    // we found a matching argument
-                    if (co.getMax() == 1) {
-                        // the argument is not repetable, so go to next group
-                        pos++;
-                    } else {
-                        //TODO We should a marker to say we are on a repetable argument
-                        //TODO to guess the next one argument with this definition
+                addSon(argumentContext);
+            }
+            // after parse check
+            for (OptionGroupDefinition groupDefinition : definition.getGroups()) {
+                if (groupDefinition.isMandatory()) {
+                    // check if the group was found
+                    int groupPos = groups.indexOf(groupDefinition);
+                    int nbGroupOccurs = groupFounds[groupPos];
+                    if (nbGroupOccurs == 0) {
+                        // can not accept this option miss a mandatory group
+                        addError(_("lutinutil.error.parser.unfound.mandatory.group", groupDefinition, definition));
                     }
                 }
-                checkAndAddOptionArgument(co, group.pos, argument, valueStr, result);
             }
-
-            return result.toArray(new OptionArgument[result.size()]);
         }
 
-        private void checkAndAddOption(String alias, OptionDefinition definition, OptionArgument[] arguments) {
-
-            List<Option> listFound = acceptedOptions.get(definition.key);
+        @Override
+        protected void preAddSonHook(ArgumentContext context) {
+            super.preAddSonHook(context);
+            Object value = context.value;
+            // check value not null
+            if (value == null) {
+                // fatal error
+                addError(_("lutinutil.error.parser.convertor", context.argument, context.definition.getValueType()));
+            }
+        }
 
-            if (definition.max > -1 && listFound.size() == definition.max) {
-                // too much optioof this option
-                addError(_("too much of this option {0} was found (maximum {1})", definition, definition.max));
+        @Override
+        protected void postAddSonHook(ArgumentContext context) {
+            super.postAddSonHook(context);
+            // mark the group of the argument to be found anoter times
+            OptionGroupDefinition def = context.groupDefinition;
+            int pos = groups.indexOf(def);
+            groupFounds[pos] = groupFounds[pos] + 1;
+            if (!OptionParserUtil.isRepeatable(context.definition)) {
+                lastArgument = null;
+                lastGroup = null;
                 return;
             }
-            // for each mandatory group of option, check if there is required arguments
-            for (OptionGroupArgumentDefinition group : definition.groups) {
-                if (!checkGroup(arguments, group, definition)) {
-                    // this group failed, so do the option
-                    return;
-                }
+            // remove group from available if
+            int max = context.definition.getMax();
+            if (max != -1 && groupFounds[pos] == max) {
+                // the group is no more available
+                availabledGroups.remove(context.groupDefinition);
+                lastArgument = null;
+                lastGroup = null;
+                return;
             }
+            // keep the last argument as still available
+            lastArgument = context.definition;
+            lastGroup = context.groupDefinition;
+        }
+
+        protected Option instanciate() {
             // everything is ok, can instance option
             try {
                 Class<? extends Option> clazz = definition.getImpl();
                 Constructor<? extends Option> cons = clazz.getConstructor(String.class, OptionArgument[].class);
-                Option result = cons.newInstance(alias, arguments);
-                listFound.add(result);
+                Option result;
+                List<OptionArgument> args = new ArrayList<OptionArgument>();
+                for (ArgumentContext argumentContext : contexts) {
+                    args.add(argumentContext.instanciate());
+                }
+                result = cons.newInstance(alias, args.toArray(new OptionArgument[args.size()]));
+                return result;
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
 
-        private boolean checkGroup(OptionArgument[] arguments, OptionGroupArgumentDefinition group, OptionDefinition definition) {
-            if (!group.isMandatory()) {
-                // a optional group is ok,, since we are sure that max is ok
-                return true;
-            }
-            Map<String, Integer> map = new HashMap<String, Integer>();
-            for (OptionArgumentDefinition argument : group.arguments) {
-                map.put(argument.getKey(), argument.min);
-            }
-            int pos = group.getPos();
-            for (OptionArgument option : arguments) {
-                if (option.pos == pos) {
-                    Integer counter = map.get(option.key);
-                    if (counter != null) {
-                        map.put(option.key, --counter);
-                    }
+        /**
+         * Detect the matching argument context for given argument and position.
+         * <p/>
+         * If a {@link #lastArgument} exisits, it means we previously matched
+         * a repeatable argument, so we will try to match it before.
+         * <p/>
+         * If mandatory and not found will add an error to the Option context.
+         *
+         * @param argument the argument from command line
+         * @param pos      the position of argument in option's arguments
+         * @return the context of argument found or null if not found
+         */
+        protected ArgumentContext detectArgument(String argument, int pos) {
+            ArgumentContext result = null;
+            if (lastArgument != null) {
+                // the lastArgument is still available
+                // try to find a match argument with this definition
+                result = detectArgument(lastGroup, lastArgument, argument, pos);
+
+                if (OptionParserUtil.isMandatory(lastArgument) && result == null) {
+                    addError(_("lutinutil.error.parser.unfound.mandatory.argument", lastArgument, lastGroup, argument));
+                    return null;
                 }
+                // the lastGroup is no more available
+                availabledGroups.remove(lastGroup);
             }
-            int size = map.entrySet().size();
-            for (Map.Entry<String, Integer> entry : map.entrySet()) {
-                if (entry.getValue() > 0) {
-                    size--;
+            if (availabledGroups.isEmpty()) {
+                // no more group to match
+                return null;
+            }
+            // always try to match a mandatory
+            OptionGroupDefinition group = OptionParserUtil.getNextMandatoryGroup(availabledGroups);
+            if (group != null) {
+                // must match the argument in this group
+                result = detectArgument(group, argument, pos);
+                if (result == null) {
+                    addError(_("lutinutil.error.parser.unfound.mandatory.group", group, argument));
                 }
+                return result;
             }
-            if (size == 0) {
-                // it miss something, fatal error
-                addError(_("a mandatory argument is missing in the group of arguments {0} for option {1})", group, definition));
-                return false;
+            // try to match in one of the optional groups
+            List<OptionGroupDefinition> optionalGroups = OptionParserUtil.getOptionalGroups(availabledGroups);
+            while (!optionalGroups.isEmpty()) {
+                // try next optional group
+                group = optionalGroups.get(0);
+                result = detectArgument(group, argument, pos);
+                if (result != null) {
+                    break;
+                }
             }
-            // group is ok
-            return true;
+            return result;
         }
 
-        private void checkAndAddOptionArgument(OptionArgumentDefinition definition, int pos, String argument, String valueStr, List<OptionArgument> list) {
-
-            OptionArgumentValueType valueType = definition.getValueType();
-
-            // convert to matching type from argument definition value type
-            Object value = ConvertUtils.convert(valueStr, valueType.getClazz());
-            // check value not null
-            if (value == null) {
-                // fatal error
-                addError(_("could not convert argument value {0} to type {1}", valueStr, valueType.name()));
-                return;
-            }
-            if (definition.max != -1) {
-                //TODO Test the number of time of this argument in list
-                //addError(_("too much of this argument {0} was found (maximum {1})", definition, definition.max));
-                //return;
+        /**
+         * Detect a argument in a group definition.
+         *
+         * @param group    the definition of group to use
+         * @param argument the argument from command line
+         * @param pos      the position of argument inf option's arguments
+         * @return ther matched argument context or null if not found
+         */
+        protected ArgumentContext detectArgument(OptionGroupDefinition group, String argument, int pos) {
+            OptionArgumentDefinition def = detectArgumentDefinition(argument, group);
+            if (def == null) {
+                return null;
             }
-
-            // the argument is valid, save it
-            OptionArgument<Object> optionArgument = new OptionArgument<Object>(
-                    definition.key,
-                    definition.type,
-                    definition.valueType,
-                    pos,
-                    argument,
-                    value
-            );
-            log.info("success for " + definition.key + " : " + optionArgument);
-            list.add(optionArgument);
+            ArgumentContext result;
+            result = detectArgument(group, def, argument, pos);
+            return result;
         }
 
 
-        public OptionDefinition getOptionDefinition(String key) {
-            return definitions.get(key);
-        }
-
-        public OptionGroupArgumentDefinition[] getOptionalGroupDefinition(String key) {
-            OptionDefinition definition = definitions.get(key);
-            List<OptionGroupArgumentDefinition> result = new ArrayList<OptionGroupArgumentDefinition>();
-            for (OptionGroupArgumentDefinition group : definition.groups) {
-                if (!group.isMandatory()) {
-                    result.add(group);
-                }
+        /**
+         * Detect a argument in a argument definition.
+         *
+         * @param group      the definition of group to use
+         * @param definition the definition of argument to use
+         * @param argument   the argument from command line
+         * @param pos        the position of argument inf option's arguments
+         * @return ther matched argument context or null if not found
+         */
+        protected ArgumentContext detectArgument(OptionGroupDefinition group, OptionArgumentDefinition definition, String argument, int pos) {
+            String valueStr = argument;
+            OptionArgumentValueType valueType = definition.getValueType();
+            switch (definition.getType()) {
+                case constant:
+                    if (argument.trim().equalsIgnoreCase(definition.getKey())) {
+                        // we found a matching argument
+                        return new ArgumentContext(this, definition, group, argument, valueStr, commandLinePosition + 1 + pos, pos);
+                    }
+                    break;
+                case namedAndValued:
+                    int index = argument.trim().indexOf('=');
+                    if (index == -1 || !argument.substring(0, index).equals(definition.getKey())) {
+                        break;
+                    }
+                    valueStr = argument.substring(index + 1);
+                case valued:
+                    boolean matchType = valueType.matchType(argument);
+                    if (matchType) {
+                        // convert to matching type from argument definition value type
+                        Object value = ConvertUtils.convert(valueStr, valueType.getClazz());
+                        return new ArgumentContext(this, definition, group, argument, value, commandLinePosition + 1 + pos, pos);
+                    }
+                    break;
             }
-            return result.toArray(new OptionGroupArgumentDefinition[result.size()]);
+            return null;
         }
 
-        public OptionGroupArgumentDefinition[] getMandatoryGroupDefinition(String key) {
-            OptionDefinition definition = definitions.get(key);
-            List<OptionGroupArgumentDefinition> result = new ArrayList<OptionGroupArgumentDefinition>();
-            for (OptionGroupArgumentDefinition group : definition.groups) {
-                if (group.isMandatory()) {
-                    result.add(group);
+        protected OptionArgumentDefinition detectArgumentDefinition(String argument, OptionGroupDefinition currentGroup) {
+            boolean named = argument.indexOf('=') > -1;
+            OptionArgumentDefinition result;
+            OptionArgumentType type;
+            OptionArgumentValueType valueType;
+            OptionArgumentDefinition[] defs = currentGroup.arguments;
+            if (named) {
+                String key = argument.substring(0, argument.indexOf('='));
+                type = OptionArgumentType.namedAndValued;
+                // find a named and valued
+                result = OptionParserUtil.findArgumentByTypeAndKey(type, key, defs);
+                log.info(argument + " : " + result);
+                if (result == null) {
+                    //fatal error : unknown namedAndValued argument
+                    addError(_("lutinutil.error.parser.valued.argument.unfound", key, Arrays.asList(currentGroup)));
+                    return null;
                 }
+                return result;
+            }
+            // try a constant
+            type = OptionArgumentType.constant;
+            result = OptionParserUtil.findArgumentByTypeAndKey(type, argument, defs);
+            if (result != null) {
+                log.info(argument + " : " + result);
+                return result;
             }
-            return result.toArray(new OptionGroupArgumentDefinition[result.size()]);
-        }
-    }
 
+            // try a valued
+            type = OptionArgumentType.valued;
+            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+            result = OptionParserUtil.findArgumentByTypeAndValueType(type, valueType, defs);
 
-    public Option[] getOptions(String key) {
-        List<Option> list = acceptedOptions.get(key);
-        return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
-    }
+            if (result == null && valueType == OptionArgumentValueType._file) {
+                // special case : wants a newFile type, but file already
+                // exists (so it was detected as a file argument)
+                // since we arrive here, it means no file argument
+                // try with a _newFile
+                result = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._newfile, defs);
+            }
+            if (result == null && valueType == OptionArgumentValueType._newfile) {
+                // we didn't find a _newFile, it could be also a string
+                result = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._string, defs);
+            }
+            log.info(argument + " : " + result);
+            return result;
+        }
 
-    public void printUsage(Writer w, String name) throws IOException {
-        String head = _("lutinutil.parserdef.printUsage.head", name);
-        String prefixO = _("lutinutil.parserdef.printUsage.options.head", name);
-        String prefix = "\n";
-        w.append(OptionParserUtil.toString(annotation, head, prefixO, prefix));
+        @Override
+        public String toString() {
+            return super.toString() + " argument:" + Arrays.toString(arguments) + ", definition:" + definition +  ", commandlinepos:" + commandLinePosition;
+        }
     }
 
-    /**
-     * Imprime dans un writer les erreurs rencontrées pendant l'analyse.
-     *
-     * @param w le writer à utiliser
-     * @throws IOException si problèmes d'écriture dans le writer
-     */
-    public void printErrors(Writer w) throws IOException {
-        if (!hasFailed()) {
-            return;
-        }
-        w.append(_("lutinutil.parserdef.printError.head", _errors.length));
-        for (int i = 0, j = _errors.length; i < j; i++) {
-            w.append(_("lutinutil.parserdef.printError.error", i + 1, j));
-            w.append(_errors[i].toString());
+    class ArgumentContext extends OptionParserUtil.OptionParserContext<OptionContext, ArgumentContext> {
+
+        /** la définition de l'argument */
+        final OptionArgumentDefinition definition;
+        /** la définition du group de l'argument */
+        final OptionGroupDefinition groupDefinition;
+        /** la position dans la ligne de commande */
+        final int commandLinePosition;
+        /** la position dans les arguments de l'option */
+        final int pos;
+        /** l'argument correspondant dans la ligne de commande */
+        final String argument;
+        /** la valeur typée de l'argument */
+        final Object value;
+
+        protected ArgumentContext(OptionContext parent,
+                                  OptionArgumentDefinition definition,
+                                  OptionGroupDefinition groupDefinition,
+                                  String argument, Object value,
+                                  int commandLinePosition, int pos) {
+            super(parent, false);
+            this.argument = argument;
+            this.definition = definition;
+            this.commandLinePosition = commandLinePosition;
+            this.value = value;
+            this.pos = pos;
+            this.groupDefinition = groupDefinition;
+            log.info(this);
+        }
+
+        public OptionArgument instanciate() {
+            OptionArgument<Object> optionArgument;
+            optionArgument = new OptionArgument<Object>(
+                    definition.key,
+                    definition.type,
+                    definition.valueType,
+                    pos,
+                    argument,
+                    value
+            );
+            return optionArgument;
         }
-    }
 
-    public boolean hasFailed() {
-        return _errors != null && _errors.length > 0;
+        @Override
+        public String toString() {
+            return super.toString() + " argument:" + argument + ", definition:" + definition + ", pos:" + pos + ", commandlinepos:" + commandLinePosition;
+        }
     }
 }