Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.1 lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.1	Mon Nov 19 19:56:04 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java	Mon Nov 19 20:14:13 2007
@@ -24,9 +24,9 @@
 * Created: 22 août 2003
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.1 $
+* @version $Revision: 1.2 $
 *
-* Mise a jour: $Date: 2007-11-19 19:56:04 $
+* Mise a jour: $Date: 2007-11-19 20:14:13 $
 * par : $Author: tchemit $
 */
 
@@ -267,8 +267,8 @@
         tokens = new ArrayList<String>(Arrays.asList(StringUtil.split(openingChars, closingChars, definition, " ")));
 
         // by default, option is mandatory
-        int repetitionMin = 0;
-        int repetitionMax = 1;
+        int min = 0;
+        int max = 1;
         Collection<OptionArgumentDefinition> argumentDefinitions = new ArrayList<OptionArgumentDefinition>();
         boolean safe = true;
         String token;
@@ -289,8 +289,8 @@
 
                 Object[] tmp = parseCardinalite(token, false);
 
-                repetitionMin = (Integer) tmp[1];
-                repetitionMax = (Integer) tmp[2];
+                min = (Integer) tmp[1];
+                max = (Integer) tmp[2];
 
                 tokens.remove(0);
             }
@@ -298,11 +298,9 @@
             if (!tokens.isEmpty()) {
                 // l'option possède des arguments
 
-                //safe = parseOption(tokens.toArray(new String[tokens.size()]), argumentDefinitions);
-
                 // on split tout d'abord les espaces pour obtenir les groupement
                 // d'arguments
-                int mandatoryPosition = 0;
+                int position = 0;
                 // les definitions d"arguments déjàé trouvées dans le groupement
                 Collection<OptionArgumentDefinition> groupArgumentDefinitions;
                 for (String groupArgument : tokens.toArray(new String[tokens.size()])) {
@@ -311,24 +309,27 @@
 
                     if (groupArgument.startsWith("<")) {
                         // il s'agit d'un groupe d'arguments obligatoires
-                        if (!parseOptionGroupArguments(groupArgument, mandatoryPosition, groupArgumentDefinitions)) {
+                        if (!parseOptionGroupArguments(groupArgument,
+                                position, groupArgumentDefinitions)) {
                             safe = false;
                             break;
                         }
                         argumentDefinitions.addAll(groupArgumentDefinitions);
-                        mandatoryPosition++;
+                        position++;
                         continue;
                     }
                     if (groupArgument.startsWith("[")) {
                         // il s'agit d'un groupe d'arguments facultatifs
-                        if (!parseOptionGroupArguments(groupArgument, -1, groupArgumentDefinitions)) {
+                        if (!parseOptionGroupArguments(groupArgument,
+                                -1, groupArgumentDefinitions)) {
                             safe = false;
                             break;
                         }
                         argumentDefinitions.addAll(groupArgumentDefinitions);
                         continue;
                     }
-                    registerError(_("lutinutil.parserdef.error.unvalid.syntax.unknown.group.of.arguments", groupArgument));
+                    addError(_("lutinutil.parserdef.unvalid.syntax.unknown.group.of.arguments",
+                            groupArgument));
                 }
             }
         }
@@ -338,8 +339,8 @@
                 definitionName,
                 description,
                 definition,
-                repetitionMin,
-                repetitionMax,
+                min,
+                max,
                 alias,
                 argumentDefinitions.toArray(new OptionArgumentDefinition[argumentDefinitions.size()])
         ) : new SyntaxUnvalidOptionDefinition(description, definition);
@@ -352,11 +353,13 @@
      * La définition d'un argument d'une option respecte la syntaxe suivante :
      * <lu>
      * <li>
-     * <code><b>&lt;</b>argument_0|argument_1|argument_2|...|argument_n<b>&gt;</b></code>
+     * <code><b>&lt;</b>argument_0|argument_1|argument_2|...|argument_n
+     * <b>&gt;</b></code>
      * pour un argument obligatoire
      * </li>
      * <li>
-     * <code><b>[</b>argument_0|argument_1|argument_2|...|argument_n<b>]</b></code>
+     * <code><b>[</b>argument_0|argument_1|argument_2|...|argument_n<b>]
+     * </b></code>
      * pour un argument facultatif.
      * </li>
      * </ul>
@@ -380,89 +383,97 @@
      * </li>
      * </ul>
      * <p/>
-     * On ne traite pas ici du caractère optional ou obligatoire de l'argument de l'option
-     * et on suppose de plus que la définition commence et termine bien par un délimitateur accepté
+     * On ne traite pas ici du caractère optional ou obligatoire de
+     * l'argument de l'option
+     * et on suppose de plus que la définition commence et termine bien
+     * par un délimitateur accepté
      *
-     * @param groupArgumentDefinition  la définition de l'arugment de l'option
-     * @param position                 la position du prochain argument obligatoire
-     * @param argumentDefinitionsFound la liste des arguments detectes dans ce groupe
-     * @return <code>true</code> si le parsing s'est bien déroulé, <code>false</code> autrement.
+     * @param groupDefinition  la définition de l'argument de l'option
+     * @param position         la position du prochain argument
+     *                         obligatoire
+     * @param definitionsFound la liste des arguments detectes dans ce
+     *                         groupe
+     * @return <code>true</code> si le parsing s'est bien déroulé,
+     *         <code>false</code> autrement.
      */
     protected boolean parseOptionGroupArguments(
-            String groupArgumentDefinition, int position,
-            Collection<OptionArgumentDefinition> argumentDefinitionsFound) {
+            String groupDefinition, int position,
+            Collection<OptionArgumentDefinition> definitionsFound) {
 
         boolean result = true;
 
         boolean mandatory = position > -1;
 
         // la liste des type déjà enregistrés
-        Collection<OptionArgumentValueType> argumentValueTypesFound = new ArrayList<OptionArgumentValueType>();
+        Collection<OptionArgumentValueType> valueTypesFound =
+                new ArrayList<OptionArgumentValueType>();
 
         // on supprime tout espace en début ou fin de chaine de définition
-        groupArgumentDefinition = groupArgumentDefinition.trim();
+        groupDefinition = groupDefinition.trim();
 
         // on supprime les délimitateurs de début et fin de chaine de définition
-        groupArgumentDefinition = groupArgumentDefinition.substring(1, groupArgumentDefinition.length() - 1);
+        groupDefinition = groupDefinition.substring(1, groupDefinition.length() - 1);
 
         // on split pour obtenir la définition de chaque argument
-        String[] argumentDefinitions = groupArgumentDefinition.split("\\|");
+        String[] argumentDefinitions = groupDefinition.split("\\|");
 
         for (String argumentDefinition : argumentDefinitions) {
 
-            OptionArgumentType argumentType = OptionArgumentType.findType(argumentDefinition);
+            OptionArgumentType type = OptionArgumentType.findType(argumentDefinition);
 
             //contient la clef et le type
-            String[] keyAndType = argumentType.explodeDefinition(argumentDefinition);
+            String[] keyAndType = type.explodeDefinition(argumentDefinition);
 
             //contient le type (String), min(Integer), repetittionMax(Integer)
-            Object[] typeAndCardMinAndCardMax;
+            Object[] typeAndMinAndMax;
 
-            if (argumentType == OptionArgumentType.constant) {
+            if (type == OptionArgumentType.constant) {
                 // la clef contient la cardinalite
-                typeAndCardMinAndCardMax = parseCardinalite(keyAndType[0], mandatory);
+                typeAndMinAndMax = parseCardinalite(keyAndType[0], mandatory);
                 // on recupère la clef nettoye
-                keyAndType[0] = (String) typeAndCardMinAndCardMax[0];
+                keyAndType[0] = (String) typeAndMinAndMax[0];
                 // on pousse le type connu
-                typeAndCardMinAndCardMax[0] = keyAndType[1];
+                typeAndMinAndMax[0] = keyAndType[1].substring(1);
             } else {
-                typeAndCardMinAndCardMax = parseCardinalite(keyAndType[1], mandatory);
+                typeAndMinAndMax = parseCardinalite(keyAndType[1], mandatory);
             }
 
             // recherche de la classe d'implantation
-            OptionArgumentValueType argumentValueType =
-                    OptionArgumentValueType.findTypeFromDefinition((String) typeAndCardMinAndCardMax[0]);
+            OptionArgumentValueType valueType =
+                    OptionArgumentValueType.findTypeFromDefinition(
+                            (String) typeAndMinAndMax[0]);
+
             // check coherence of the new required argument definition
             if (!checkOptionArgument(
                     argumentDefinition,
-                    groupArgumentDefinition,
-                    argumentType,
-                    argumentValueType,
+                    groupDefinition,
+                    type,
+                    valueType,
                     keyAndType[0],
-                    argumentValueTypesFound,
-                    argumentDefinitionsFound,
-                    (Integer) typeAndCardMinAndCardMax[1],
-                    (Integer) typeAndCardMinAndCardMax[2],
+                    valueTypesFound,
+                    definitionsFound,
+                    (Integer) typeAndMinAndMax[1],
+                    (Integer) typeAndMinAndMax[2],
                     mandatory)) {
                 result = false;
                 continue;
             }
-            if (argumentType == OptionArgumentType.valued) {
+            if (type == OptionArgumentType.valued) {
                 // on sauvegarde le type (pour les conflits possibles)
-                argumentValueTypesFound.add(argumentValueType);
+                valueTypesFound.add(valueType);
             }
 
             // instanciate the new argument definition
             OptionArgumentDefinition definition = new OptionArgumentDefinition(
-                    argumentType,
-                    argumentValueType,
+                    type,
+                    valueType,
                     keyAndType[0],
-                    (Integer) typeAndCardMinAndCardMax[1],
-                    (Integer) typeAndCardMinAndCardMax[2],
+                    (Integer) typeAndMinAndMax[1],
+                    (Integer) typeAndMinAndMax[2],
                     position
             );
             // register le new argument definition
-            argumentDefinitionsFound.add(definition);
+            definitionsFound.add(definition);
         }
         return result;
     }
@@ -470,13 +481,10 @@
     /**
      * @param key       la valeur dont on cherche la cardinalité
      * @param mandatory flag to say if this is a mandatory element or not.
-     * @return un tableau contenant 3 object : le texte donné sans les informations
-     *         de cardinalité, la répétitionMin, la répétitionMax.
-     * @throws OptionDefinitionParserException
-     *          si probleme de parsing ou de syntaxe
+     * @return un tableau contenant 3 object : le texte donné sans les
+     *         informations de cardinalité, la répétitionMin, la répétitionMax.     
      */
-    protected Object[] parseCardinalite(String key, boolean mandatory)
-            throws OptionDefinitionParserException {
+    protected Object[] parseCardinalite(String key, boolean mandatory) {
         Object[] result = new Object[3];
         int repetitionMin;
         int repetitionMax;
@@ -538,40 +546,49 @@
     protected boolean preOptionParsingCheck(String definition, String description) {
         // check definition is not empty
         if (definition == null || definition.isEmpty() || definition.trim().isEmpty()) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.empty.option.definition", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.empty.option.definition",
+                    definition, description));
             return false;
         }
         // check description is not empty
         if (description == null || description.isEmpty() || description.trim().isEmpty()) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.empty.option.description", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.empty.option.description",
+                    definition, description));
             return false;
         }
         // check defintion contains alias ?
         if (definition.trim().indexOf('-') != 0) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.unfound.alias.in.option", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.unfound.alias.in.option",
+                    definition, description));
             return false;
         }
         // check same number {[< to >]} in definition
         if (!StringUtil.checkEnclosure(definition, '{', '}')) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.underbrace.option", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.underbrace.option",
+                    definition, description));
             return false;
         }
         if (!StringUtil.checkEnclosure(definition, '<', '>')) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.lesser.option", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.lesser.option",
+                    definition, description));
             return false;
         }
         if (!StringUtil.checkEnclosure(definition, '[', ']')) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.caret.option", definition, description));
+            addError(_("lutinutil.parserdef.unvalid.syntax.caret.option",
+                    definition, description));
             return false;
         }
         // what else ?
         return true;
     }
 
-    protected boolean postOptionParsingCheck(OptionDefinition definition, List<OptionDefinition> definitions) {
+    protected boolean postOptionParsingCheck(OptionDefinition definition,
+                                             List<OptionDefinition> definitions) {
 
         if (definition.getAlias().length > 4) {
-            registerError(_("lutinutil.parserdef.error.too.much.alias.option", Arrays.toString(definition.getAlias()), definition.getDefinition()));
+            addError(_("lutinutil.parserdef.too.much.alias.option",
+                    Arrays.toString(definition.getAlias()),
+                    definition.getDefinition()));
             return false;
         }
 
@@ -580,7 +597,8 @@
         for (String alia : definition.getAlias()) {
 
             if (!alia.startsWith("-")) {
-                registerError(_("lutinutil.parserdef.error.unvalid.syntax.alias.option", alia, definition.getDefinition()));
+                addError(_("lutinutil.parserdef.unvalid.syntax.alias.option",
+                        alia, definition.getDefinition()));
                 return false;
             }
         }
@@ -588,20 +606,25 @@
         for (OptionDefinition optionDefinition : definitions) {
             // on vérifier que le nom n'est pas dupliqué
             if (optionDefinition.getName().equals(definition.getName())) {
-                registerError(_("lutinutil.parserdef.error.duplicated.option.name", definition.getName(), definition.getDefinition(), optionDefinition.getDefinition()));
+                addError(_("lutinutil.parserdef.duplicated.option.name",
+                        definition.getName(), definition.getDefinition(),
+                        optionDefinition.getDefinition()));
                 return false;
             }
             // on vérifie les conflits sur les alias
             alias.addAll(Arrays.asList(optionDefinition.getAlias()));
             for (String alia : definition.getAlias()) {
                 if (alias.contains(alia)) {
-                    registerError(_("lutinutil.parserdef.error.duplicated.option.alias", alia, definition.getDefinition(), optionDefinition.getDefinition()));
+                    addError(_("lutinutil.parserdef.duplicated.option.alias",
+                            alia, definition.getDefinition(),
+                            optionDefinition.getDefinition()));
                     return false;
                 }
             }
         }
 
-        if (!checkCardinalite(definition.getMin(), definition.getMax(), definition.getDefinition(), definition.getDescription())) {
+        if (!checkCardinalite(definition.getMin(), definition.getMax(),
+                definition.getDefinition(), definition.getDescription())) {
             return false;
         }
 
@@ -609,100 +632,115 @@
         return true;
     }
 
-    protected boolean checkCardinalite(int min, int max, String definition, String description) {
+    protected boolean checkCardinalite(int min, int max, String definition,
+                                       String description) {
         if (min < 0) {
-            registerError(_("lutinutil.parserdef.error.min.can.not.be.negative", min, definition, description));
+            addError(_("lutinutil.parserdef.min.can.not.be.negative", min,
+                    definition, description));
             return false;
         }
         if (max == 0) {
-            registerError(_("lutinutil.parserdef.error.max.can.not.be.zero", max, definition, description));
+            addError(_("lutinutil.parserdef.max.can.not.be.zero", max,
+                    definition, description));
             return false;
         }
         // on vérifie que la cardinalité max >-2
         if (max < -1) {
-            registerError(_("lutinutil.parserdef.error.max.too.low", max, definition, description));
+            addError(_("lutinutil.parserdef.max.too.low", max,
+                    definition, description));
             return false;
         }
         // on vérifie que la cardinalité max==-1 || max >= min
         if (max > -1 && max < min) {
-            registerError(_("lutinutil.parserdef.error.max.lowest.than.min", max, min, definition, description));
+            addError(_("lutinutil.parserdef.max.lowest.than.min",
+                    max, min, definition, description));
             return false;
         }
         return true;
     }
 
-    protected boolean checkOptionArgument(String argumentDefinition,
+    protected boolean checkOptionArgument(String definition,
                                           String groupementDefinition,
                                           OptionArgumentType type,
-                                          OptionArgumentValueType argumentValueType,
+                                          OptionArgumentValueType valueType,
                                           String key,
-                                          Collection<OptionArgumentValueType> argumentValueTypesUsed,
+                                          Collection<OptionArgumentValueType> valueTypesUsed,
                                           Collection<OptionArgumentDefinition> argumentsFound,
-                                          int repetitionMin,
-                                          int repetitionMax,
+                                          int min,
+                                          int max,
                                           boolean mandatory) {
 
         if (type == null) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.unknown.argument.type", argumentDefinition, groupementDefinition));
+            addError(_("lutinutil.parserdef.unvalid.syntax.unknown.argument.type",
+                    definition, groupementDefinition));
             return false;
         }
-        if (argumentValueType == null) {
-            registerError(_("lutinutil.parserdef.error.unvalid.syntax.unknown.value.type", argumentDefinition, groupementDefinition));
+        if (valueType == null) {
+            addError(_("lutinutil.parserdef.unvalid.syntax.unknown.value.type",
+                    definition, groupementDefinition));
             return false;
         }
         if (key == null) {
-            registerError(_("lutinutil.parserdef.error.unfound.key", argumentDefinition, groupementDefinition));
+            addError(_("lutinutil.parserdef.unfound.key",
+                    definition, groupementDefinition));
             return false;
         }
-        if (!checkCardinalite(repetitionMin, repetitionMax, argumentDefinition, groupementDefinition)) {
+        if (!checkCardinalite(min, max, definition, groupementDefinition)) {
             return false;
         }
 
         // un argument de type constant ne peut pas avoir de cardinalite autre que {1,1}
         if (type == OptionArgumentType.constant) {
-            if (mandatory && !(repetitionMin == 1 && repetitionMax == 1)) {
-                registerError(_("lutinutil.parserdef.error.const.argument.mandatory.cardinalite", repetitionMin, repetitionMax, argumentDefinition, groupementDefinition));
+            if (mandatory && !(min == 1 && max == 1)) {
+                addError(_("lutinutil.parserdef.const.argument.mandatory.cardinalite",
+                        min, max, definition, groupementDefinition));
                 return false;
             }
-            if (!mandatory && !(repetitionMin == 0 && repetitionMax == 1)) {
-                registerError(_("lutinutil.parserdef.error.const.argument.optional.cardinalite", repetitionMin, repetitionMax, argumentDefinition, groupementDefinition));
+            if (!mandatory && !(min == 0 && max == 1)) {
+                addError(_("lutinutil.parserdef.const.argument.optional.cardinalite",
+                        min, max, definition, groupementDefinition));
                 return false;
             }
         } else {
-            if (mandatory && repetitionMin < 1) {
-                registerError(_("lutinutil.parserdef.error.argument.mandatory.cardinalite", repetitionMin, repetitionMax, argumentDefinition, groupementDefinition));
+            if (mandatory && min < 1) {
+                addError(_("lutinutil.parserdef.argument.mandatory.cardinalite",
+                        min, max, definition, groupementDefinition));
                 return false;
             }
-            if (!mandatory && repetitionMin > 0) {
-                registerError(_("lutinutil.parserdef.error.argument.optional.cardinalite", repetitionMin, repetitionMax, argumentDefinition, groupementDefinition));
+            if (!mandatory && min > 0) {
+                addError(_("lutinutil.parserdef.argument.optional.cardinalite",
+                        min, max, definition, groupementDefinition));
                 return false;
             }
         }
         // on verifie que la clef n'est pas déjà enregistrée
         for (OptionArgumentDefinition optionArgumentDefinition : argumentsFound) {
             if (optionArgumentDefinition.getKey().equals(key)) {
-                registerError(_("lutinutil.parserdef.error.duplicated.argument.key", key, argumentDefinition, groupementDefinition));
+                addError(_("lutinutil.parserdef.duplicated.argument.key",
+                        key, definition, groupementDefinition));
                 return false;
             }
         }
 
         if (type == OptionArgumentType.valued) {
-            if (((argumentValueType == _newfile) && argumentValueTypesUsed.contains(_string)) ||
-                    ((argumentValueType == _string) && argumentValueTypesUsed.contains(_newfile))) {
-                registerError(_("lutinutil.parserdef.error.string.and.newfile.in.same.group", argumentDefinition, groupementDefinition));
+            if (((valueType == _newfile) && valueTypesUsed.contains(_string)) ||
+                    ((valueType == _string) && valueTypesUsed.contains(_newfile))) {
+                addError(_("lutinutil.parserdef.string.and.newfile.in.same.group",
+                        definition, groupementDefinition));
                 return false;
 
             }
             // on vérifier qu'un type n'est pas dupliqué
-            if (argumentValueTypesUsed.contains(argumentValueType)) {
-                registerError(_("lutinutil.parserdef.error.duplicated.argument.valued.type", argumentValueType, argumentDefinition, groupementDefinition));
+            if (valueTypesUsed.contains(valueType)) {
+                addError(_("lutinutil.parserdef.duplicated.argument.valued.type",
+                        valueType, definition, groupementDefinition));
                 return false;
             }
         }
         return true;
     }
 
-    protected void registerError(String content) {
+    protected void addError(String content) {
         registerError(content, null);
     }