Index: lutinutil/src/java/org/codelutin/util/OptionParserUtil.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.3 lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.4
--- lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.3	Wed Dec  5 03:03:57 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParserUtil.java	Wed Dec 12 22:11:52 2007
@@ -22,7 +22,7 @@
 
 public class OptionParserUtil {
 
-    public static String toString(ApplicationA anno, String head, String headOptions, String headArguments, String prefix) {
+    public static String toString(ApplicationA anno, String head, String headOptions, String prefix) {
         StringBuilder builder = new StringBuilder();
         builder.append(addTitle(head, '=', true)).append("\n\n");
         builder.append(addTitle(headOptions, '-', false)).append("\n");
@@ -30,11 +30,6 @@
             builder.append(prefix).append(OptionParserUtil.toString(definition));
             builder.append("\n    ").append(definition.description()).append("\n\n");
         }
-        builder.append(addTitle(headArguments, '-', false)).append("\n");
-        for (ArgumentA definition : anno.arguments()) {
-            builder.append(prefix).append(OptionParserUtil.toString(definition));
-            builder.append("\n    ").append(definition.description()).append("\n\n");
-        }
         return builder.toString();
     }
 
@@ -351,19 +346,10 @@
         GroupArgumentA[] groupArgumentAs;
         ArgumentA[] argumentAs;
 
-        public ApplicationA run(OptionContext[] options, OptionArgumentContext[] arguments, Class<? extends Option> impl) {
+        public ApplicationA run(OptionContext[] options) {
             optionAs = new OptionA[options.length];
-            ArgumentA[] as = new ArgumentA[arguments.length];
-            if (arguments.length > 0) {
-                for (int i = 0; i < arguments.length; i++) {
-                    OptionArgumentContext argument = arguments[i];
-                    as[i] = OptionParserAnnotationHelper.newArgumentA(
-                            argument.type, argument.valueType, argument.key,
-                            argument.min, argument.max, argument.description);
-                }
-            }
             walk(options);
-            parserA = OptionParserAnnotationHelper.newApplicationA(optionAs, as,impl);
+            parserA = OptionParserAnnotationHelper.newApplicationA(optionAs);
             return parserA;
         }
 
@@ -402,7 +388,7 @@
         protected void exitArgument(OptionArgumentContext argument, int argumentIndex) {
             ArgumentA argumentA = OptionParserAnnotationHelper.newArgumentA(
                     argument.type, argument.valueType, argument.key, argument.min,
-                    argument.max, argument.description);
+                    argument.max);
             argumentAs[argumentIndex] = argumentA;
         }
     }
@@ -424,19 +410,10 @@
         OptionGroupArgumentDefinition[] groupArguments;
         OptionArgumentDefinition[] arguments;
 
-        public ApplicationDefinition run(OptionContext[] options, OptionArgumentContext[] arguments, Class<? extends Option> impl) {
+        public ApplicationDefinition run(OptionContext[] options) {
             this.options = new OptionDefinition[options.length + 1];
-            OptionArgumentDefinition[] as = new OptionArgumentDefinition[arguments.length];
-            if (arguments.length > 0) {
-                for (int i = 0; i < arguments.length; i++) {
-                    OptionArgumentContext argument = arguments[i];
-                    as[i] = new OptionArgumentDefinition(
-                            argument.type, argument.valueType, argument.key,
-                            argument.min, argument.max);
-                }
-            }
             walk(options);
-            definition = new ApplicationDefinition(as, this.options,impl);
+            definition = new ApplicationDefinition(this.options);
             return definition;
         }
 

Index: lutinutil/src/java/org/codelutin/util/ApplicationDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/ApplicationDefinition.java:1.1 lutinutil/src/java/org/codelutin/util/ApplicationDefinition.java:1.2
--- lutinutil/src/java/org/codelutin/util/ApplicationDefinition.java:1.1	Wed Dec  5 02:58:03 2007
+++ lutinutil/src/java/org/codelutin/util/ApplicationDefinition.java	Wed Dec 12 22:11:52 2007
@@ -13,12 +13,11 @@
 
 package org.codelutin.util;
 
-import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
 import org.codelutin.util.OptionParserAnnotationHelper.ApplicationA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
 
 /**
- * This class represents a application definition (with his arguments and options)
+ * This class represents a application definition (with his options)
  *
  * @author chemit
  */
@@ -28,45 +27,22 @@
     /** les options de l'application */
     protected OptionDefinition[] options;
 
-    /** les arguments de l'application */
-    protected OptionArgumentDefinition[] arguments;
-
-    /** l'implantation du conteneur des arguments */
-    protected Class<? extends Option> argumentsImpl;
-
-    public ApplicationDefinition(OptionArgumentDefinition[] arguments, OptionDefinition[] options,Class<? extends Option> impl) {
-        this.arguments = arguments;
+    public ApplicationDefinition(OptionDefinition[] options) {
         this.options = options;
-        this.argumentsImpl=impl;
     }
 
     public ApplicationDefinition(ApplicationA anno) {
-        ArgumentA[] argumentAs = anno.arguments();
         OptionA[] optionAs = anno.options();
-        this.argumentsImpl=anno.argumentsImpl();
-        OptionArgumentDefinition[] _arguments = new OptionArgumentDefinition[argumentAs.length];
-        for (int i = 0; i < argumentAs.length; i++) {
-            ArgumentA argumentA = argumentAs[i];
-            _arguments[i] = new OptionArgumentDefinition(argumentA);
-        }
         OptionDefinition[] _options = new OptionDefinition[optionAs.length];
         for (int i = 0; i < optionAs.length; i++) {
             OptionA optionA = optionAs[i];
             _options[i] = new OptionDefinition(optionA);
         }
-        this.arguments = _arguments;
         this.options = _options;
     }
 
-    public OptionArgumentDefinition[] getArguments() {
-        return arguments;
-    }
-
     public OptionDefinition[] getOptions() {
         return options;
     }
 
-    public Class<? extends Option> getArgumentsImpl() {
-        return argumentsImpl;
-    }
 }

Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.7 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.8
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.7	Wed Dec  5 03:03:57 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Wed Dec 12 22:11:52 2007
@@ -25,7 +25,6 @@
 import org.codelutin.log.LutinLog;
 import org.codelutin.log.LutinLogFactory;
 import org.codelutin.util.OptionParserAnnotationHelper.ApplicationA;
-import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA;
 import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
 
 import java.io.IOException;
@@ -98,14 +97,9 @@
     /** la liste des définitions d'options connues */
     protected final Map<String, OptionDefinition> _odefinitions;
 
-    /** la liste des définitions d'arguments connus */
-    protected final Map<String, OptionArgumentDefinition> _adefinitions;
-
     /** le dictionnaire des definitions d'options indexées par leurs alias */
     protected final Map<String, OptionDefinition> _indexAlias;
 
-    protected Class<? extends Option> _argImpl;
-
     /** le dictionnaire d'actions associées aux options */
     protected final Map<String, OptionAction> _actions;
 
@@ -113,9 +107,6 @@
     /** la liste des options trouvées et valides, indexées par leur clef unique. */
     protected final Map<String, List<Option>> _acceptedOptions;
 
-    /** la liste des argum trouvées et valides, indexées par leur clef unique. */
-    protected final Map<String, List<OptionArgument>> _acceptedArguments;
-
     /** list of errors found while parsing */
     protected OptionParserException[] _errors;
 
@@ -133,11 +124,9 @@
         }
         this._anno = anno;
         this._acceptedOptions = new HashMap<String, List<Option>>();
-        this._acceptedArguments = new HashMap<String, List<OptionArgument>>();
         this._actions = new HashMap<String, OptionAction>();
 
         this._odefinitions = new LinkedHashMap<String, OptionDefinition>();
-        this._adefinitions = new LinkedHashMap<String, OptionArgumentDefinition>();
         this._indexAlias = new TreeMap<String, OptionDefinition>();
 
         if (anno.options().length > 0) {
@@ -153,18 +142,6 @@
                 }
             }
         }
-        if (anno.arguments().length > 0) {
-            // parser have some available options
-            for (ArgumentA argumentA : anno.arguments()) {
-                // build each definition from his associated OptionA
-                OptionArgumentDefinition definition = new OptionArgumentDefinition(argumentA);
-                _adefinitions.put(argumentA.key(), definition);
-                _acceptedArguments.put(argumentA.key(), new ArrayList<OptionArgument>());
-            }
-        }
-        _argImpl = anno.argumentsImpl();
-        // create parser _context from definitions in annotation
-        //this._context = new ParserContext2(anno);
     }
 
     /**
@@ -184,9 +161,6 @@
             return;
         }
 
-        // detect application arguments (before first alias)
-        context.detectApplicationArguments(args.length, args);
-
         // detect options
         context.detectOptions(args);
 
@@ -198,9 +172,6 @@
     }
 
     private void cleanResult() {
-        for (Map.Entry<String, List<OptionArgument>> stringListEntry : _acceptedArguments.entrySet()) {
-            stringListEntry.getValue().clear();
-        }
         for (Map.Entry<String, List<Option>> stringListEntry : _acceptedOptions.entrySet()) {
             stringListEntry.getValue().clear();
         }
@@ -215,14 +186,6 @@
         return result.toArray(new Option[result.size()]);
     }
 
-    public OptionArgument[] getArguments() {
-        List<OptionArgument> result = new ArrayList<OptionArgument>();
-        for (List<OptionArgument> options : _acceptedArguments.values()) {
-            result.addAll(options);
-        }
-        return result.toArray(new OptionArgument[result.size()]);
-    }
-
     public boolean isOptionEnabled(String key) {
         List<Option> list = _acceptedOptions.get(key);
         return list != null && !list.isEmpty();
@@ -324,158 +287,6 @@
             }
         }
 
-        protected void detectApplicationArguments(int length, String... args) {
-
-            String arg;
-            List<String> argsForOption = new ArrayList<String>();
-            // detects application's arguments (before the first option)
-            while (pos < length && !(arg = args[pos]).startsWith("-")) {
-                argsForOption.add(arg);
-                pos++;
-            }
-            if (argsForOption.isEmpty()) {
-                // no application argument found
-                return;
-            }
-            OptionArgumentDefinition[] defs = new ArrayList<OptionArgumentDefinition>(_adefinitions.values()).toArray(new OptionArgumentDefinition[_adefinitions.size()]);
-
-            buildGroupAvailableMap(defs);
-
-            for (String argument : args) {
-                boolean named = argument.indexOf('=') > -1;
-                OptionArgumentDefinition definition;
-                String key;
-                String valueStr;
-                if (named) {
-                    key = argument.substring(0, argument.indexOf('='));
-                    definition = _adefinitions.get(key);
-                    if (definition == null) {
-                        //fatal error : unknown namedAndValued argument
-                        addError(_("could not found a application argument definition with key {0} in {1}", key, _adefinitions.keySet()));
-                        continue;
-                    }
-                    // extract value as String for the argument type
-                    valueStr = definition.type.extractArgumentValue(argument);
-                    log.info(key + " : " + argument);
-                    // check if argument is ok
-                    checkAndAddApplicationArgument(definition, argument, valueStr);
-                }
-                // try a constant
-                //key = argument;
-                definition = _adefinitions.get(argument);
-                if (definition != null) {
-                    // found a constant argument
-                    log.info(argument);
-                    // check if argument is ok
-                    checkAndAddApplicationArgument(definition, argument, argument);
-                    continue;
-                }
-                // try at last a valued argument
-                // try a valued
-                OptionArgumentType type = OptionArgumentType.valued;
-                OptionArgumentValueType valueType = OptionArgumentValueType.findTypeFromArgument(argument);
-                OptionArgumentValueType valueTypeFilter = filterValueType(argument);
-                boolean breakMe = false;
-                if (valueType != null && valueTypeFilter == null) {
-                    // the required type is no more available
-                    switch (valueType) {
-                        case _boolean:
-                        case _class:
-                        case _string:
-                        case _float:
-                        case _integer:
-                            //FATAL!                            
-                            breakMe = true;
-                            break;
-                        case _file:
-                            //FATAL since we found a real file and it is not
-                            // possible to have a newFile, we are done
-                            breakMe = true;
-                            break;
-                        case _newfile:
-                            //FATAL! : can't have a string and newFile in same group
-                            breakMe = true;
-                            break;
-                    }
-                }
-                if (breakMe) {
-                    addError(_("too much of valued argument of this type {0} was found", valueType));
-                    continue;
-                }
-
-                definition = OptionParserUtil.findArgumentByTypeAndValueType(type, valueType, defs);
-
-                if (definition == null && valueType == OptionArgumentValueType._file && availables.contains(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                    
-                    definition = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._newfile, defs);
-                }
-                if (definition == null && valueType == OptionArgumentValueType._newfile && availables.contains(OptionArgumentValueType._string)) {
-                    // we didn't find a _newFile, it could be also a string
-                    definition = OptionParserUtil.findArgumentByTypeAndValueType(type, OptionArgumentValueType._string, defs);
-                }
-                if (definition == null) {
-                    // fatal error could not found anything matching
-                    addError(_("could not found a matching definition for application argument {0}", argument));
-                    continue;
-                }
-                valueStr = definition.type.extractArgumentValue(argument);
-                log.info(argument + " : " + definition);
-                checkAndAddApplicationArgument(definition, argument, valueStr);
-            }
-        }
-
-        private OptionArgumentValueType filterValueType(String argument) {
-            OptionArgumentValueType valueType = OptionArgumentValueType.findTypeFromArgument(argument);
-            return !availables.contains(valueType) ? null : valueType;
-        }
-
-        protected boolean checkMax(OptionArgumentDefinition def) {
-            List<OptionArgument> list = _acceptedArguments.get(def.key);
-            return def.max == -1 || list.size() < def.max;
-        }
-
-        protected void checkAndAddApplicationArgument(OptionArgumentDefinition definition, String argument, String valueStr) {
-            String key = definition.key;
-            OptionArgumentValueType valueType = definition.getValueType();
-
-            // convert to matching type from argument definition value type
-            Object value = null;
-            try {
-                value = ConvertUtils.convert(valueStr, valueType.getClazz());
-            } catch (Exception e) {
-                // ignore
-            }
-            // check value not null
-            if (value == null) {
-                // fatal error
-                addError(_("could not convert argument value {0} to type {1}", valueStr, valueType.getClazz()));
-                return;
-            }
-            List<OptionArgument> list = _acceptedArguments.get(key);
-            if (definition.max != -1 && list.size() == definition.max) {
-                addError(_("too much of this argument {0} was found (maximum {1})", definition, definition.max));
-                return;
-            }
-
-            // the argument is valid, save it
-            OptionArgument<Object> optionArgument = new OptionArgument<Object>(
-                    key,
-                    definition.type,
-                    definition.valueType,
-                    definition.min == 0 ? -1 : 0, // mark the mandatory criteria for this argument (for later checks)
-                    argument,
-                    valueStr
-            );
-            if (definition.type == OptionArgumentType.valued && definition.max > -1) {
-                // valued and not unlimited, so remove one of the valued type
-                removeOneType(definition.valueType);
-            }
-            log.info("success for " + key + " : " + optionArgument);
-            list.add(optionArgument);
-        }
 
         /**
          * Detecte les options et leurs arguments, à partir de la suite des
@@ -574,7 +385,7 @@
                 if (group.pos > -1) {
                     pos = group.pos;
                 }
-                checkAndAddOptionArgument(co, group.pos,  argument, valueStr, result);
+                checkAndAddOptionArgument(co, group.pos, argument, valueStr, result);
             }
 
             return result.toArray(new OptionArgument[result.size()]);
@@ -625,16 +436,16 @@
                     }
                 }
             }
-            int size = map.entrySet().size(); 
+            int size = map.entrySet().size();
             for (Map.Entry<String, Integer> entry : map.entrySet()) {
                 if (entry.getValue() > 0) {
                     size--;
                 }
             }
-            if (size==0) {
+            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;
+                addError(_("a mandatory argument is missing in the group of arguments {0} for option {1})", group, definition));
+                return false;
             }
             // group is ok
             return true;
@@ -700,27 +511,16 @@
     }
 
 
-    public boolean isArgumentEnabled(String key) {
-        List<OptionArgument> list = _acceptedArguments.get(key);
-        return list != null && !list.isEmpty();
-    }
-
     public Option[] getOptions(String key) {
         List<Option> list = _acceptedOptions.get(key);
         return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
     }
 
-    public OptionArgument[] getArguments(String key) {
-        List<OptionArgument> list = _acceptedArguments.get(key);
-        return list == null || list.isEmpty() ? null : list.toArray(new OptionArgument[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 prefixA = _("lutinutil.parserdef.printUsage.arguments.head", name);
         String prefix = "\n";
-        w.append(OptionParserUtil.toString(_anno, head, prefixO, prefixA, prefix));
+        w.append(OptionParserUtil.toString(_anno, head, prefixO, prefix));
     }
 
     /**

Index: lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.4 lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.5
--- lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.4	Wed Dec  5 03:03:57 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java	Wed Dec 12 22:11:52 2007
@@ -53,11 +53,6 @@
         /** @return les options d'application connues du parseur */
         public OptionA[] options() default {};
 
-        /** @return les arguments d'application connus du parseur */
-        public ArgumentA[] arguments() default {};
-        
-        /** @return la classe d'implantation du conteneur d'arguments */
-        public Class<? extends Option> argumentsImpl() default Option.class;
     }
 
     /**
@@ -129,9 +124,6 @@
      * <p/>
      * <p/>
      * Par défaut, un argument d'option est obligatoire
-     * TODO Revoir puisque maintenant c'est aussi un argument d'application
-     * TODO dont la cardinalité par défaut est 0,1 !
-     * TODO (voir si cardinalite par défault vraiment utilisé)
      * ({@link #min()} =1)
      * ({@link #max()} =1)
      *
@@ -156,36 +148,23 @@
         /** @return le max */
         public int max() default 1;
 
-        /** @return la description de la définition */
-        public String description() default "";
     }
 
     //------------------------------------------------------------------------
     // Factory methods
     //------------------------------------------------------------------------
 
-    public static ApplicationA newApplicationA(final OptionA[] optionAs,
-                                               final ArgumentA[] argumentsAs,
-                                               final Class<? extends Option> impl) {
-        ApplicationA result;
-        result = new ApplicationA() {
+    public static ApplicationA newApplicationA(final OptionA[] optionAs) {
+        return new ApplicationA() {
+
             public OptionA[] options() {
                 return optionAs;
             }
 
-            public ArgumentA[] arguments() {
-                return argumentsAs;
-            }
-
-            public Class<? extends Option> argumentsImpl() {
-                return impl;
-            }
-
             public Class<? extends Annotation> annotationType() {
                 return ApplicationA.class;
             }
         };
-        return result;
     }
 
     public static OptionA newOptionA(final String key,
@@ -215,10 +194,6 @@
                 return groupAs;
             }
 
-            public ArgumentA[] arguments() {
-                return new ArgumentA[0];
-            }
-
             public String description() {
                 return description;
             }
@@ -264,8 +239,7 @@
                                          final OptionArgumentValueType valueType,
                                          final String key,
                                          final int min,
-                                         final int max,
-                                         final String description) {
+                                         final int max) {
         return new ArgumentA() {
             public String key() {
                 return key;
@@ -287,10 +261,6 @@
                 return max;
             }
 
-            public String description() {
-                return description;
-            }
-
             public Class<? extends Annotation> annotationType() {
                 return ArgumentA.class;
             }

Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.9 lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.10
--- lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.9	Wed Dec 12 21:04:24 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java	Wed Dec 12 22:11:52 2007
@@ -61,15 +61,6 @@
  * <p/>
  * <code>optionName.description= La description de l'option</code>
  * <p/>
- * TODO check option key or argument key are not reserved keyword :
- * <p/>
- * example can't use a class key since we might generate a getter getClass()
- * that will clashes with Generated inherited methods.
- * <p/>
- * To exclude : class.
- * <p/>
- * To make it very safe, all fields of OptionParser are prefixed by a '_' to
- * ensure no collision (since key can not begin with a '_').
  *
  * @author chemit
  */
@@ -132,9 +123,6 @@
         // parse and build application options contexts
         parser.parseOptions(context);
 
-        // parse and build application arguments contexts
-        parser.parseArguments(context);
-
         // transfert errors from parser context
         parser.errors = context.getErrors().toArray(new OptionDefinitionParserException[context.getNbErrors()]);
 
@@ -150,12 +138,6 @@
     /** list of safe options contexts available after parsing */
     protected OptionContext[] options;
 
-    /** list of safe arguments contexts available after parsing */
-    protected OptionArgumentContext[] arguments;
-
-    /** implementation of arguments container : it is an Option */
-    protected Class<? extends Option> argumentImpl = Option.class;
-
     /** list of errors found while parsing */
     protected OptionDefinitionParserException[] errors;
 
@@ -170,7 +152,7 @@
             return null;
         }
         ApplicationDefinition result;
-        result = ToDefinitionWalker.getInstance().run(options, arguments, argumentImpl);
+        result = ToDefinitionWalker.getInstance().run(options);
         return result;
     }
 
@@ -183,7 +165,7 @@
             return null;
         }
         ApplicationA result;
-        result = ToAnnotationWalker.getInstance().run(options, arguments, argumentImpl);
+        result = ToAnnotationWalker.getInstance().run(options);
         return result;
     }
 
@@ -235,29 +217,6 @@
         return context;
     }
 
-    protected void parseArguments(ParserContext context) {
-        // to realize this operation we create a fake option and group and try
-        // to push arguments inside.
-        // we need also the fakecontext connected to parser context (to use
-        // automatic errors propagation mecanism and data control) 
-        OptionContext fakeOption = new OptionContext(context, "", "", 0, 0, null);
-        // arguments are independant of group mandatory caracter
-        OptionGroupArgumentContext fakeGroup = new OptionGroupArgumentContext(fakeOption, 0);
-        fakeOption.contexts.add(fakeGroup);
-        for (int i = 0, j = context.adefinitions.length; i < j; i++) {
-            //String key = context.akeys[i];
-            String description = context.adescriptions[i];
-            String definition = context.adefinitions[i];
-            OptionArgumentContext r = fakeGroup.parseArgument(definition, description, false);
-            if (r != null) {
-                fakeGroup.addSon(r);
-                context.argumentKeyUsed.add(r.key);
-            }
-        }
-        // keep valid argument's contexts        
-        arguments = fakeGroup.contexts.toArray(new OptionArgumentContext[fakeGroup.contexts.size()]);
-    }
-
     protected void parseOptions(ParserContext context) {
         // parse options
         for (int i = 0, j = context.okeys.length; i < j; i++) {
@@ -285,8 +244,6 @@
         protected final String[] okeys;
         protected final String[] odefinitions;
         protected final String[] odescriptions;
-        protected final String[] adefinitions;
-        protected final String[] adescriptions;
 
         /** la liste des alias d'option déjà rencontrées pendant le parsing */
         protected final List<String> aliaKeyUsed;
@@ -297,18 +254,12 @@
         /** la liste des clefs d'arguments d'options déjà rencontrées pendant le parsing */
         protected final List<String> optionArgumentKeyUsed;
 
-        /** la liste des clefs d'argument déjà rencontrées pendant le parsing */
-        protected final List<String> argumentKeyUsed;
-
-        ParserContext(String[] keys, String[] definitions, String[] descriptions, String[] adefinitions, String[] adescriptions) {
+        ParserContext(String[] keys, String[] definitions, String[] descriptions) {
             super(null, true);
             this.okeys = keys;
             this.odefinitions = definitions;
             this.odescriptions = descriptions;
-            this.adefinitions = adefinitions;
-            this.adescriptions = adescriptions;
             this.optionArgumentKeyUsed = new ArrayList<String>();
-            this.argumentKeyUsed = new ArrayList<String>();
             this.optionKeyUsed = new ArrayList<String>();
             this.aliaKeyUsed = new ArrayList<String>();
         }
@@ -421,7 +372,6 @@
         void clear() {
             super.clear();
             optionKeyUsed.clear();
-            argumentKeyUsed.clear();
             optionArgumentKeyUsed.clear();
             aliaKeyUsed.clear();
         }
@@ -475,7 +425,7 @@
             // on split pour obtenir la définition de chaque argument
             String[] argumentDefinitions = groupDefinition.split("\\|");
             for (String argumentDefinition : argumentDefinitions) {
-                OptionArgumentContext argumentContext = groupContext.parseArgument(argumentDefinition, "", true);
+                OptionArgumentContext argumentContext = groupContext.parseArgument(argumentDefinition);
                 groupContext.addSon(argumentContext);
                 if (!groupContext.valid) {
                     break;
@@ -527,12 +477,9 @@
             parent.parent.optionArgumentKeyUsed.add(context.key);
         }
 
-        OptionArgumentContext parseArgument(String argumentDefinition, String description, boolean fromOption) {
+        OptionArgumentContext parseArgument(String argumentDefinition) {
             log.debug(argumentDefinition);
 
-            if (!fromOption && !checkArgumentSyntax(argumentDefinition, description)) {
-                return null;
-            }
             OptionArgumentContext result = null;
 
             OptionArgumentType type = OptionArgumentType.findType(argumentDefinition);
@@ -543,7 +490,7 @@
             //contient le type (String), min(Integer), max(Integer)
             Object[] typeAndMinAndMax;
 
-            boolean mandatory = fromOption && pos > -1;
+            boolean mandatory = pos > -1;
 
             if (type == OptionArgumentType.constant) {
                 // la clef contient la cardinalite
@@ -564,57 +511,18 @@
             if (checkArgument(argumentDefinition, toString(), type,
                     valueType, keyAndType[0],
                     (Integer) typeAndMinAndMax[1],
-                    (Integer) typeAndMinAndMax[2], mandatory, fromOption)) {
+                    (Integer) typeAndMinAndMax[2], mandatory)) {
                 result = new OptionArgumentContext(this, type, valueType,
                         keyAndType[0], (Integer) typeAndMinAndMax[1],
-                        (Integer) typeAndMinAndMax[2], description);
+                        (Integer) typeAndMinAndMax[2]);
             }
             return result;
         }
 
-        /**
-         * Examine une définition d'argument d'application avant parsing.
-         *
-         * @param definition  la définition de l'argument à parser
-         * @param description la descrption de l'argument
-         * @return <code>valid</code> value after check
-         */
-        boolean checkArgumentSyntax(String definition, String description) {
-            boolean oldValid = valid;
-            // check definition is not empty
-            if (definition == null || definition.isEmpty() || definition.trim().isEmpty()) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.empty.argument.definition", definition, description));
-                return false;
-            }
-            // check description is not empty
-            if (description == null || description.isEmpty() || description.trim().isEmpty()) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.empty.argument.description", definition, description));
-                return false;
-            }
-            if (!definition.matches("^[0-9a-zA-Z_\\=\\:\\-,\\[\\]\\{\\}\\s]+$")) {
-                addError(_("lutinutil.parserdef.unvalid.car.found", definition));
-                return false;
-            }
-            // check same number {[< to >]} in definition
-            if (!StringUtil.checkEnclosure(definition, '{', '}')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.underbrace.option", definition, description));
-                return false;
-            }
-            if (!StringUtil.checkEnclosure(definition, '<', '>')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.lesser.option", definition, description));
-                return false;
-            }
-            if (!StringUtil.checkEnclosure(definition, '[', ']')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.caret.option", definition, description));
-                return false;
-            }
-            return !oldValid || valid;
-        }
-
         boolean checkArgument(String definition, String groupementDefinition,
                               OptionArgumentType type,
                               OptionArgumentValueType valueType,
-                              String key, int min, int max, boolean mandatory, boolean fromOption) {
+                              String key, int min, int max, boolean mandatory) {
             if (type == null) {
                 addError(_("lutinutil.parserdef.unvalid.syntax.unknown.argument.type", definition, groupementDefinition));
                 return false;
@@ -633,16 +541,12 @@
             // check none duplicated option argument key
             // application arguments keys are in a separate namespace
             // and has already be checked in checkArgumentSyntax method
-            if (fromOption && parent.parent.optionArgumentKeyUsed.contains(key)) {
+            if (parent.parent.optionArgumentKeyUsed.contains(key)) {
                 addError(_("lutinutil.parserdef.duplicated.argument.key", key, definition, parent.parent.optionArgumentKeyUsed));
             }
-            // check none duplicated argument key            
-            if (!fromOption && parent.parent.argumentKeyUsed.contains(key)) {
-                addError(_("lutinutil.parserdef.duplicated.argument.name", key, definition));
-            }
             // un argument de type constant ne peut pas avoir de cardinalite autre que {1,1}
             // appliquable uniquement si c'est un argument d'option
-            if (fromOption && type == OptionArgumentType.constant) {
+            if (type == OptionArgumentType.constant) {
                 if (mandatory && !(min == 1 && max == 1)) {
                     addError(_("lutinutil.parserdef.const.argument.mandatory.cardinalite", min, max, definition, groupementDefinition));
                 }
@@ -730,19 +634,16 @@
 
         protected final String key;
 
-        protected final String description;
-
         OptionArgumentContext(OptionGroupArgumentContext parent,
                               OptionArgumentType type,
                               OptionArgumentValueType valueType,
-                              String key, Integer min, Integer max, String description) {
+                              String key, Integer min, Integer max) {
             super(parent, false);
             this.type = type;
             this.valueType = valueType;
             this.key = key;
             this.min = min;
             this.max = max;
-            this.description = description;
         }
     }
 
@@ -761,10 +662,6 @@
         final String ODESCRIPTION_KEY_SUFFIX = ".option.description";
         final int ODEFINITION_KEY_PREFIX_LENGTH = ODEFINITION_KEY_SUFFIX.length();
 
-        final String ADEFINITION_KEY_SUFFIX = ".argument.definition";
-        final String ADESCRIPTION_KEY_SUFFIX = ".argument.description";
-        final int ADEFINITION_KEY_PREFIX_LENGTH = ADEFINITION_KEY_SUFFIX.length();
-
         // load properties file
         Properties properties = new Properties();
         InputStream stream = null;
@@ -775,20 +672,6 @@
             stream.close();
         }
 
-        List<String> adefinitions = new ArrayList<String>();
-        List<String> adescriptions = new ArrayList<String>();
-
-        // récupération des definitions et descriptions d'arguments
-        for (Object o : properties.keySet()) {
-            String key = o.toString();
-            if (!key.endsWith(ADEFINITION_KEY_SUFFIX)) {
-                continue;
-            }
-            String s = key.substring(0, key.length() - ADEFINITION_KEY_PREFIX_LENGTH);
-            adefinitions.add(properties.getProperty(key));
-            adescriptions.add(properties.getProperty(s + ADESCRIPTION_KEY_SUFFIX));
-        }
-
         // récupération des clefs d'options
         List<String> okeys = new ArrayList<String>();
         for (Object o : properties.keySet()) {
@@ -814,19 +697,14 @@
 
         // construction du context de parsing
         int sizeO = okeys.size();
-        int sizeA = adefinitions.size();
         ParserContext context = new ParserContext(
                 okeys.toArray(new String[sizeO]),
                 odefinitions.toArray(new String[sizeO]),
-                odescriptions.toArray(new String[sizeO]),
-                adefinitions.toArray(new String[sizeA]),
-                adescriptions.toArray(new String[sizeA])
+                odescriptions.toArray(new String[sizeO])
         );
         okeys.clear();
         odefinitions.clear();
         odescriptions.clear();
-        adefinitions.clear();
-        adescriptions.clear();
         properties.clear();
         return context;
     }