Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionParserException.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinitionParserException.java:1.1 lutinutil/src/java/org/codelutin/util/OptionDefinitionParserException.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionDefinitionParserException.java:1.1	Sat Nov 17 11:07:20 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionParserException.java	Wed Dec  5 03:03:57 2007
@@ -17,6 +17,9 @@
  *##%**/
 
 package org.codelutin.util;
+import org.codelutin.util.OptionParserUtil.*;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Exception soulevable uniquement par le parser de définition d'option.
@@ -29,15 +32,35 @@
  * @see OptionDefinitionParser
  */
 public class OptionDefinitionParserException extends RuntimeException { // OptionDefinitionParserException
-    private static final long serialVersionUID = -3283937669966903905L;
 
+    final OptionParserUtil.OptionDefinitionParserContext context;
+    private static final long serialVersionUID = 7683172805089232103L;
 
-    public OptionDefinitionParserException(String msg) {
+    public OptionDefinitionParserException(String msg, OptionDefinitionParserContext context) {
         super(msg);
+        this.context = context;
     }
 
-    public OptionDefinitionParserException(String msg, Throwable eee) {
+    public OptionDefinitionParserException(String msg, Throwable eee, OptionDefinitionParserContext context) {
         super(msg, eee);
+        this.context = context;
     }
 
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder().append(super.toString()).append("\nfrom contexts :");
+        OptionDefinitionParserContext cont = context;
+        List<OptionDefinitionParserContext> l = new ArrayList<OptionDefinitionParserContext>();
+        String prefix = "";
+        while (!cont.isRoot()) {
+            l.add(cont);
+            cont = (OptionDefinitionParserContext) cont.parent;
+        }
+        l.add(cont);
+        for (OptionDefinitionParserContext context : l) {
+            builder.append('\n').append(prefix).append(context);
+            prefix += "    ";
+        }
+        return builder.toString();
+    }
 } // OptionDefinitionParserException
\ No newline at end of file

Index: lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.5 lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.6
--- lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.5	Sun Dec  2 05:12:38 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java	Wed Dec  5 03:03:57 2007
@@ -12,8 +12,6 @@
  */
 package org.codelutin.util;
 
-import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
-
 /**
  * Cette classe représente la définition d'un argument d'une option.
  * <p/>
@@ -63,7 +61,7 @@
         this.max = max;
     }
 
-    public OptionArgumentDefinition(OptionArgumentA definition) {
+    public OptionArgumentDefinition(OptionParserAnnotationHelper.ArgumentA definition) {
         this.type = definition.type();
         this.valueType = definition.valueType();
         this.key = definition.key();

Index: lutinutil/src/java/org/codelutin/util/OptionParserUtil.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.2 lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.3
--- lutinutil/src/java/org/codelutin/util/OptionParserUtil.java:1.2	Sun Dec  2 07:13:24 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParserUtil.java	Wed Dec  5 03:03:57 2007
@@ -1,14 +1,15 @@
 package org.codelutin.util;
 
+import static org.codelutin.i18n.I18n._;
 import org.codelutin.log.LutinLog;
 import org.codelutin.log.LutinLogFactory;
 import org.codelutin.util.OptionDefinitionParser.OptionArgumentContext;
 import org.codelutin.util.OptionDefinitionParser.OptionContext;
 import org.codelutin.util.OptionDefinitionParser.OptionGroupArgumentContext;
+import org.codelutin.util.OptionParserAnnotationHelper.ApplicationA;
+import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.GroupArgumentA;
 import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -21,12 +22,19 @@
 
 public class OptionParserUtil {
 
-    public static String toString(OptionParserA anno, String prefix) {
+    public static String toString(ApplicationA anno, String head, String headOptions, String headArguments, String prefix) {
         StringBuilder builder = new StringBuilder();
+        builder.append(addTitle(head, '=', true)).append("\n\n");
+        builder.append(addTitle(headOptions, '-', false)).append("\n");
         for (OptionA definition : anno.options()) {
             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();
     }
 
@@ -43,20 +51,24 @@
         if (min == 0 && max == 1) {
             StringUtil.printCardinalite(builder, s1, min, max, isMandatory, "", "", "", "");
         } else {
-            StringUtil.printCardinalite(builder, s1, min, max, isMandatory, "(", ")", "[", "]");
+            if (min == 1 && max == 1) {
+                builder.append(s1).append(' ').append('{').append(min).append(',').append(max).append("}");
+            } else {
+                StringUtil.printCardinalite(builder, s1, min, max, isMandatory, "", " ", "", " ");
+            }
         }
         if (anno.groups().length > 0) {
-            for (OptionGroupArgumentA group : anno.groups()) {
+            for (GroupArgumentA group : anno.groups()) {
                 builder.append(' ').append(toString(group));
             }
         }
         return builder.toString();
     }
 
-    public static String toString(OptionGroupArgumentA anno) {
+    public static String toString(GroupArgumentA anno) {
         StringBuilder builder = new StringBuilder();
         StringBuffer s = new StringBuffer();
-        for (OptionArgumentA argument : anno.arguments()) {
+        for (ArgumentA argument : anno.arguments()) {
             s.append('|').append(toString(argument));
         }
         String s1 = s.toString();
@@ -64,7 +76,7 @@
         return builder.toString();
     }
 
-    public static String toString(OptionArgumentA anno) {
+    public static String toString(ArgumentA anno) {
         StringBuilder sb = new StringBuilder();
         StringBuffer s = new StringBuffer(anno.key());
         switch (anno.type()) {
@@ -81,6 +93,39 @@
         return sb.toString();
     }
 
+    protected static String addTitle(String txt, char c, boolean headAndTail) {
+        StringBuilder writer = new StringBuilder();
+        if (headAndTail) {
+            for (int i = 0, j = txt.length(); i < j; i++) {
+                writer.append(c);
+            }
+            writer.append('\n');
+        }
+        writer.append(txt).append('\n');
+        for (int i = 0, j = txt.length(); i < j; i++) {
+            writer.append(c);
+        }
+        return writer.toString();
+    }
+
+    public static OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type, String key, OptionArgumentDefinition... defs) {
+        for (OptionArgumentDefinition def : defs) {
+            if (def.getType() == type && def.getKey().equals(key)) {
+                return def;
+            }
+        }
+        return null;
+    }
+
+    public static OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type, OptionArgumentValueType valueType, OptionArgumentDefinition... defs) {
+        for (OptionArgumentDefinition def : defs) {
+            if (def.getType() == type && def.getValueType() == valueType) {
+                return def;
+            }
+        }
+        return null;
+    }
+
     /**
      * Un contexte abstrait pour parseur (qui peut contenir un contexte parent
      * et des contextes enfants).
@@ -88,13 +133,15 @@
      * @author chemit
      */
 
-    public abstract static class ParserContext<P extends ParserContext, S extends ParserContext> {
+    public abstract static class ParserContext<P extends ParserContext<?, ?, E>, S extends ParserContext, E extends Exception> {
+
+        protected abstract E newError(String content, Exception e);
 
         /** logger non statique pour être dans la bonne catégorie */
         protected final LutinLog log = LutinLogFactory.getLutinLog(getClass());
 
         /** le contexte parent (peut être null) */
-        protected final P parent;
+        protected P parent;
 
         /** la liste des contextes enfants (peut être null) */
         protected final List<S> contexts;
@@ -102,22 +149,35 @@
         /** flag pour marquer l'état du context */
         protected boolean valid = true;
 
+        /** list of errors found while parsing */
+        protected List<E> errors;
+
         protected ParserContext(P parent, boolean withSons) {
             this.parent = parent;
             this.contexts = withSons ? new ArrayList<S>() : null;
         }
 
+        boolean isRoot() {
+            return parent == null;
+        }
+
+        boolean hasChilds() {
+            return contexts != null;
+        }
+
         void addSon(S context) {
             preAddSonHook(context);
-            if (valid) {
-                log.info("[" + getClass().getSimpleName() + " : " + context + "]");
+            //TODO See if the test is ok...
+            if (context!=null && context.valid) {
+                log.debug("[" + getClass().getSimpleName() + " : (" + context.valid + ")" + context + "]");
                 contexts.add(context);
                 postAddSonHook(context);
             }
         }
 
         protected void preAddSonHook(S context) {
-            if (contexts == null) {
+            if (!hasChilds()) {
+                //TODO Should throw runtime exception,
                 return;
             }
             if (context == null || !context.valid) {
@@ -129,7 +189,7 @@
         }
 
         void clear() {
-            if (contexts != null) {
+            if (hasChilds()) {
                 for (S context : contexts) {
                     context.clear();
                 }
@@ -137,12 +197,94 @@
             //contexts.clear();
         }
 
+        public List<E> getErrors() {
+            if (errors == null) {
+                errors = new ArrayList<E>();
+            }
+            return errors;
+        }
+
         public void unvalidate() {
             this.valid = false;
-            if (parent != null) {
+            if (!isRoot()) {
                 parent.unvalidate();
             }
         }
+
+        protected int getNbErrors() {
+            return errors == null ? 0 : errors.size();
+        }
+
+        protected E addError(String content) {
+            return addError(content, null);
+        }
+
+        protected E addError(String content, Exception e) {
+            E e1 = newError(content, e);
+            getErrors().add(e1);
+            if (!isRoot()) {
+                parent.addError(content, e1);
+            }
+            unvalidate();
+            return e1;
+        }
+
+        protected boolean checkCardinalite(int min, int max, String definition, String description) {
+            int s = getNbErrors();
+            if (min < 0) {
+                addError(_("lutinutil.parser.min.can.not.be.negative", min, definition, description));
+            }
+            if (max == 0) {
+                addError(_("lutinutil.parser.max.can.not.be.zero", max, definition, description));
+            }
+            if (max < -1) { // on vérifie que la cardinalité max >-2
+                addError(_("lutinutil.parser.max.too.low", max, definition, description));
+            }
+            if (max != -1 && max < min) { // on vérifie que la cardinalité max==-1 || max >= min
+                addError(_("lutinutil.parser.max.lowest.than.min", max, min, definition, description));
+            }
+            return getNbErrors() == s;
+        }
+
+    }
+
+    public abstract static class OptionDefinitionParserContext<P extends OptionDefinitionParserContext<?, ?>, S extends ParserContext> extends ParserContext<P, S, OptionDefinitionParserException> {
+        protected OptionDefinitionParserContext(P parent, boolean withSons) {
+            super(parent, withSons);
+        }
+
+        protected OptionDefinitionParserException newError(String content, Exception e) {
+            OptionDefinitionParserException e1;
+            if (e == null) {
+                e1 = new OptionDefinitionParserException(content, this);
+            } else if (e instanceof OptionDefinitionParserException) {
+                // propage exception
+                e1 = (OptionDefinitionParserException) e;
+
+            } else {
+                e1 = new OptionDefinitionParserException(content, e, this);
+            }
+            return e1;
+        }
+    }
+
+    public abstract static class OptionParserContext<P extends OptionParserContext<?, ?>, S extends ParserContext> extends ParserContext<P, S, OptionParserException> {
+        protected OptionParserContext(P parent, boolean withSons) {
+            super(parent, withSons);
+        }
+
+        protected OptionParserException newError(String content, Exception e) {
+            OptionParserException e1;
+            if (e == null) {
+                e1 = new OptionParserException(content, this);
+            } else if (e instanceof OptionParserException) {
+                // propage exception
+                e1 = (OptionParserException) e;
+            } else {
+                e1 = new OptionParserException(content, e, this);
+            }
+            return e1;
+        }
     }
 
     /**
@@ -204,26 +346,35 @@
             return instance;
         }
 
-        OptionParserA parserA;
+        ApplicationA parserA;
         OptionA[] optionAs;
-        OptionGroupArgumentA[] groupArgumentAs;
-        OptionArgumentA[] argumentAs;
+        GroupArgumentA[] groupArgumentAs;
+        ArgumentA[] argumentAs;
 
-        public OptionParserA run(OptionContext[] options) {
+        public ApplicationA run(OptionContext[] options, OptionArgumentContext[] arguments, Class<? extends Option> impl) {
             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.newOptionParserA(optionAs);
+            parserA = OptionParserAnnotationHelper.newApplicationA(optionAs, as,impl);
             return parserA;
         }
 
         @Override
         protected void enterOption(OptionContext option, int optionIndex) {
-            groupArgumentAs = new OptionGroupArgumentA[option.contexts.size()];
+            groupArgumentAs = new GroupArgumentA[option.contexts.size()];
         }
 
         @Override
         protected void enterGroup(OptionGroupArgumentContext group, int groupIndex) {
-            argumentAs = new OptionArgumentA[group.contexts.size()];
+            argumentAs = new ArgumentA[group.contexts.size()];
         }
 
         @Override
@@ -241,17 +392,17 @@
 
         @Override
         protected void exitGroup(OptionGroupArgumentContext group, int groupIndex) {
-            OptionGroupArgumentA groupArgumentA;
-            groupArgumentA = OptionParserAnnotationHelper.newOptionGroupArgumentA(group.min,
+            GroupArgumentA groupArgumentA;
+            groupArgumentA = OptionParserAnnotationHelper.newGroupArgumentA(group.min,
                     group.max, group.pos, argumentAs);
             groupArgumentAs[groupIndex] = groupArgumentA;
         }
 
         @Override
         protected void exitArgument(OptionArgumentContext argument, int argumentIndex) {
-            OptionArgumentA argumentA = OptionParserAnnotationHelper.newOptionArgumentA(
+            ArgumentA argumentA = OptionParserAnnotationHelper.newArgumentA(
                     argument.type, argument.valueType, argument.key, argument.min,
-                    argument.max);
+                    argument.max, argument.description);
             argumentAs[argumentIndex] = argumentA;
         }
     }
@@ -267,40 +418,52 @@
             return instance;
         }
 
-        OptionDefinition[] optionAs;
-        OptionGroupArgumentDefinition[] groupArgumentAs;
-        OptionArgumentDefinition[] argumentAs;
+        ApplicationDefinition definition;
 
-        public OptionDefinition[] run(OptionContext[] options) {
-            optionAs = new OptionDefinition[options.length];
+        OptionDefinition[] options;
+        OptionGroupArgumentDefinition[] groupArguments;
+        OptionArgumentDefinition[] arguments;
+
+        public ApplicationDefinition run(OptionContext[] options, OptionArgumentContext[] arguments, Class<? extends Option> impl) {
+            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);
-            return optionAs;
+            definition = new ApplicationDefinition(as, this.options,impl);
+            return definition;
         }
 
         @Override
         protected void enterOption(OptionContext option, int optionIndex) {
-            groupArgumentAs = new OptionGroupArgumentDefinition[option.contexts.size()];
+            groupArguments = new OptionGroupArgumentDefinition[option.contexts.size()];
         }
 
         @Override
         protected void enterGroup(OptionGroupArgumentContext group, int groupIndex) {
-            argumentAs = new OptionArgumentDefinition[group.contexts.size()];
+            arguments = new OptionArgumentDefinition[group.contexts.size()];
         }
 
         @Override
         protected void exitOption(OptionContext option, int optionIndex) {
             OptionDefinition optionA = new OptionDefinition(option.key,
                     option.description, option.min, option.max, option.alias,
-                    option.impl, groupArgumentAs);
-            optionAs[optionIndex] = optionA;
+                    option.impl, groupArguments);
+            options[optionIndex] = optionA;
         }
 
         @Override
         protected void exitGroup(OptionGroupArgumentContext group, int groupIndex) {
             OptionGroupArgumentDefinition groupArgumentA;
             groupArgumentA = new OptionGroupArgumentDefinition(group.min,
-                    group.max, group.pos, argumentAs);
-            groupArgumentAs[groupIndex] = groupArgumentA;
+                    group.max, group.pos, arguments);
+            groupArguments[groupIndex] = groupArgumentA;
         }
 
         @Override
@@ -308,7 +471,7 @@
             OptionArgumentDefinition argumentA = new OptionArgumentDefinition(
                     argument.type, argument.valueType, argument.key,
                     argument.min, argument.max);
-            argumentAs[argumentIndex] = argumentA;
+            arguments[argumentIndex] = argumentA;
         }
     }
 }

Index: lutinutil/src/java/org/codelutin/util/OptionParserException.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParserException.java:1.1 lutinutil/src/java/org/codelutin/util/OptionParserException.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionParserException.java:1.1	Sat Nov 17 11:07:20 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParserException.java	Wed Dec  5 03:03:57 2007
@@ -18,6 +18,11 @@
 
 package org.codelutin.util;
 
+import org.codelutin.util.OptionParserUtil.OptionParserContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Exception soulevable uniquement par le parser d'option.
  *
@@ -25,14 +30,35 @@
  * @see OptionParser
  */
 public class OptionParserException extends Exception { // OptionParserException
-    private static final long serialVersionUID = -7847751486506278509L;
 
-    public OptionParserException(String msg) {
+    final OptionParserUtil.OptionParserContext context;
+    private static final long serialVersionUID = -4760568663653584477L;
+
+    public OptionParserException(String msg, OptionParserContext context) {
         super(msg);
+        this.context = context;
     }
 
-    public OptionParserException(String msg, Throwable eee) {
+    public OptionParserException(String msg, Throwable eee, OptionParserContext context) {
         super(msg, eee);
+        this.context = context;
     }
 
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder().append(super.toString()).append("\nfrom contexts :");
+        OptionParserContext cont = context;
+        List<OptionParserContext> l = new ArrayList<OptionParserContext>();
+        String prefix = "";
+        while (!cont.isRoot()) {
+            l.add(cont);
+            cont = (OptionParserContext) cont.parent;
+        }
+        l.add(cont);
+        for (OptionParserContext context : l) {
+            builder.append('\n').append(prefix).append(context);
+            prefix += "    ";
+        }
+        return builder.toString();
+    }
 } // OptionParserException
\ No newline at end of file

Index: lutinutil/src/java/org/codelutin/util/OptionArgument.java
diff -u lutinutil/src/java/org/codelutin/util/OptionArgument.java:1.5 lutinutil/src/java/org/codelutin/util/OptionArgument.java:1.6
--- lutinutil/src/java/org/codelutin/util/OptionArgument.java:1.5	Thu Nov 29 22:23:01 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgument.java	Wed Dec  5 03:03:57 2007
@@ -24,8 +24,7 @@
 public class OptionArgument<T> {
 
     /** la definition de l'argument */
-    protected OptionArgumentDefinition definition;
-
+    //protected OptionArgumentDefinition definition;
     /** l'argument de la ligne de commande qui a été consommé par cet argument */
     protected String arg;
 
@@ -38,11 +37,18 @@
      */
     protected int pos;
 
-    public OptionArgument(OptionArgumentDefinition definition, int pos, String arg, T value) {
+    protected String key;
+    protected OptionArgumentValueType valueType;
+    protected OptionArgumentType type;
+
+    public OptionArgument(String key, OptionArgumentType type, OptionArgumentValueType valueType, int pos, String arg, T value) {
+        this.type = type;
+        this.valueType = valueType;
         this.arg = arg;
         this.value = value;
         this.pos = pos;
-        this.definition = definition;
+        this.key = key;
+        //this.definition = definition;
     }
 
     /** @return l'argument consommé de la ligne de commande */
@@ -66,19 +72,31 @@
         return pos;
     }
 
+    public String getKey() {
+        return key;
+    }
+
     @Override
     public String toString() {
         StringBuilder sb;
         if (pos == -1) {
             sb = new StringBuilder("[");
-            sb.append("key:").append(definition.key).append(", arg:").append(arg).append(", value:").append(value);            
+            sb.append("key:").append(key).append(", arg:").append(arg).append(", value:").append(value);
             sb.append(']');
         } else {
             sb = new StringBuilder("<");
-            sb.append("key:").append(definition.key).append(", arg:").append(arg).append(", value:").append(value);
+            sb.append("key:").append(key).append(", arg:").append(arg).append(", value:").append(value);
             sb.append(", pos:").append(pos);
             sb.append('>');
         }
         return sb.toString();
     }
+
+    public OptionArgumentType getType() {
+        return type;
+    }
+
+    public OptionArgumentValueType getValueType() {
+        return valueType;
+    }
 }

Index: lutinutil/src/java/org/codelutin/util/Option.java
diff -u lutinutil/src/java/org/codelutin/util/Option.java:1.6 lutinutil/src/java/org/codelutin/util/Option.java:1.7
--- lutinutil/src/java/org/codelutin/util/Option.java:1.6	Sun Dec  2 05:14:56 2007
+++ lutinutil/src/java/org/codelutin/util/Option.java	Wed Dec  5 03:03:57 2007
@@ -17,7 +17,7 @@
  *@author Benjamin Poussin <poussin@codelutin.com>
  *
  *      Copyright Code Lutin
- *@version $Revision: 1.6 $ Mise a jour: $Date: 2007-12-02 05:14:56 $ par : $Author: tchemit $
+ *@version $Revision: 1.7 $ Mise a jour: $Date: 2007-12-05 03:03:57 $ par : $Author: tchemit $
  */
 
 package org.codelutin.util;
@@ -142,9 +142,9 @@
     protected <T> T filterValue(int position, OptionArgumentType type, Class<T> clazz, String key) {
         for (OptionArgument argument : arguments) {
             if (argument.getPos() == position
-                    && argument.definition.getType() == type
-                    && argument.definition.getValueType().getClazz() == clazz
-                    && (key == null || argument.definition.getKey().equals(key))) {
+                    && argument.getType() == type
+                    && argument.getValueType().getClazz() == clazz
+                    && (key == null || argument.getKey().equals(key))) {
                 return (T) argument.getValue();
             }
         }
@@ -156,9 +156,9 @@
         List<T> result = new ArrayList<T>();
         for (OptionArgument argument : arguments) {
             if (argument.getPos() == position
-                    && argument.definition.getType() == type
-                    && argument.definition.getValueType().getClazz() == clazz
-                    && (key == null || argument.definition.getKey().equals(key))) {
+                    && argument.getType() == type
+                    && argument.getValueType().getClazz() == clazz
+                    && (key == null || argument.getKey().equals(key))) {
                 result.add((T) argument.getValue());
             }
         }

Index: lutinutil/src/java/org/codelutin/util/OptionGroupArgumentDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/OptionGroupArgumentDefinition.java:1.1 lutinutil/src/java/org/codelutin/util/OptionGroupArgumentDefinition.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionGroupArgumentDefinition.java:1.1	Sun Dec  2 05:11:36 2007
+++ lutinutil/src/java/org/codelutin/util/OptionGroupArgumentDefinition.java	Wed Dec  5 03:03:57 2007
@@ -12,8 +12,7 @@
  */
 package org.codelutin.util;
 
-import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA;
 
 /**
  * Cette classe représente la définition d'un groupe d'arguments d'une option.
@@ -60,11 +59,11 @@
         this.arguments = arguments;
     }
 
-    public OptionGroupArgumentDefinition(OptionGroupArgumentA definition) {
+    public OptionGroupArgumentDefinition(OptionParserAnnotationHelper.GroupArgumentA definition) {
         this.min = definition.min();
         this.max = definition.max();
         this.pos = definition.pos();
-        OptionArgumentA[] argumentDefinitions = definition.arguments();
+        ArgumentA[] argumentDefinitions = definition.arguments();
         this.arguments = new OptionArgumentDefinition[argumentDefinitions.length];
         for (int i = 0; i < argumentDefinitions.length; i++) {
             this.arguments[i] = new OptionArgumentDefinition(argumentDefinitions[i]);

Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.6 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.7
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.6	Thu Nov 29 22:25:29 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Wed Dec  5 03:03:57 2007
@@ -21,20 +21,18 @@
 package org.codelutin.util;
 
 import org.apache.commons.beanutils.ConvertUtils;
-import org.apache.commons.logging.LogFactory;
 import static org.codelutin.i18n.I18n._;
-import static org.codelutin.util.OptionDefinitionParser.LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionDefinitionA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
+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;
 import java.io.Writer;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -45,341 +43,189 @@
  * Parser abstrait d'options de la ligne de commande.
  * <p/>
  * Pour implanter le parseur il suffit de surcharger cette classe et d'y ajouter
- * l'annotation {@link OptionParserAnnotationHelper.OptionParserA} au niveau de la classe, en y
- * indiquant la définition du parser.
+ * l'annotation {@link ApplicationA} au niveau de la classe, en y indiquant
+ * la définition du parser.
  * <p/>
- * Ensuite on utilise la méthode publique statique {@link #newParser(String, ClassLoader)}
- * pour obtenir une nouvelle instance de parser à partir du nom de sa classe et
- * de son classLoader.
+ * A l'instanciation de la classe, l'annotation sera transformée en
+ * {@link OptionDefinition} (et ses sous-classes group, argument).
  * <p/>
- * Enfin sur le parseur retourné, on invoque la méthode {@link #doParse(String[])}
+ * Exemple d'un parseur avec une unique option pour afficher l'aide:
+ * <pre><code>
+ * <code>@ApplicationA</code> ( options =
+ *     <code>@OptionA</code>(
+ *         key="help",
+ *         alias = {"--help", "-h"},
+ *         description = "affiche l'aide"
+ *     )
+ * )
+ * public class MyParser extends OptionParser <code>{...}</code></pre>
+ * <p/>
+ * Voici un exemple plus concret TODO a finir.
+ * <p/>
+ * On peut aussi associer à une définition d'option une implantation d'option
+ * (elle peut être générée automatiquement par le plugin maven-commandline-plugin).
+ * <p/>
+ * Pour utiliser le parseur , on invoque la méthode {@link #doParse(String[])}
  * pour effectuer le parsing des arguments passés.
+ * <p/>
+ * A noter que tous les champs de la classes doivent être préfixés par '_' pour
+ * assurer que des collisions ne peuvent pas arriver avec des propriétés générés
+ * qui elles n'acceptent pas '_' comme premier caractère d'identifiant.
  *
- * @author chemit
- * @see OptionParserAnnotationHelper.OptionParserA
+ * @see ApplicationA
  */
 
 public abstract class OptionParser {
 
-    public static OptionParser newParser(String className, ClassLoader loader) {
-
-        Class parserClass;
-        OptionParser parser;
-        try {
-            // find parser class
-            parserClass = Class.forName(className, true, loader);
-            // instanciate parser, load factory and init ParserContext
-            parser = (OptionParser) parserClass.newInstance();
-            return parser;
-        } catch (ClassNotFoundException e) {
-            throw new IllegalArgumentException(e);
-        } catch (IllegalAccessException e) {
-            throw new IllegalArgumentException(e);
-        } catch (InstantiationException e) {
-            throw new IllegalArgumentException(e);
-        }
-    }
-
-    protected final org.apache.commons.logging.Log log;
+    public static final String APPLICATION_ARGUMENTS_FIELD_NAME = "applicationArguments";
 
-    /** le context du parseur (contenant les données temporaires du parsing). */
-    protected final ParserContext context;
-
-    /** la liste des définitions d'options connues */
-    protected final Map<String, OptionDefinition> definitions;
-
-    /**
-     * la liste des options, la cle est le nom de l'option, et la valeur
-     * est la liste des options qui ont été lues grâce à celle-ci.
-     */
-    protected final Map<String, List<Option>> options;
-
-    /**
-     * La liste des arguments qui ne sont pas des options insérés dans leur
-     * ordre d'apparition dans la ligne de commande
-     */
-    protected final List<String> arguments;
+    Option applicationArguments;
 
-    protected final Map<String, OptionAction> actions;
+    public Option getApplicationArguments() {
+        return applicationArguments;
+    }
 
-    public OptionParser() {
+    public void setApplicationArguments(Option applicationArguments) {
+        this.applicationArguments = applicationArguments;
+    }
 
-        // find the fullyQualifiedFactoryName via OptionParserA annotation
-        OptionParserA def = getClass().getAnnotation(OptionParserA.class);
-        if (def == null) {
-            //TODO  i18n
-            throw new IllegalArgumentException("could not found annotation " +
-                    OptionParserA.class + " in Parser " + this);
-        }
-        this.log = LogFactory.getLog(getClass());
-
-        this.definitions = new LinkedHashMap<String, OptionDefinition>();
-        this.arguments = new ArrayList<String>();
-        this.options = new HashMap<String, List<Option>>();
-        this.actions = new HashMap<String, OptionAction>();
-        try {
-            Map<String, OptionDefinition> map;
-            OptionDefinitionA defA;
-            OptionDefinition definition;
-
-            map = new HashMap<String, OptionDefinition>();
-
-            for (String key : def.keys()) {
-                String fieldName = StringUtil.convertToConstantName(key);
-                Field field = getClass().getField(fieldName);
-                defA = field.getAnnotation(OptionDefinitionA.class);
-                definition = new OptionDefinition(defA);
-                map.put(key, definition);
-            }
-            List<String> keys1 = new ArrayList<String>(map.keySet());
-            Collections.sort(keys1);
-            for (String key : keys1) {
-                this.definitions.put(key, map.get(key));
-            }
-            keys1.clear();
-            map.clear();
-            // create parser context
-            context = new ParserContext(this.definitions);
+    /** logger non statique pour épouser la catégorie de l'implantation */
+    protected final LutinLog log = LutinLogFactory.getLutinLog(getClass());
 
-        } catch (NoSuchFieldException e) {
-            throw new IllegalArgumentException(e);
-        }
-    }
+    /** l'annotation de définition du parseur */
+    protected final ApplicationA _anno;
 
-    /**
-     * Register an action associated to an Option.
-     *
-     * @param optionKey option key
-     * @param action    action to realise for the option
-     */
-    public void registerAction(String optionKey, OptionAction action) {
-        if (!definitions.containsKey(optionKey)) {
-            throw new IllegalArgumentException("could not found this option " + optionKey);
-        }
-        if (actions.containsKey(optionKey)) {
-            throw new IllegalArgumentException("already action registred for this option " + optionKey);
-        }
-        actions.put(optionKey, action);
-    }
+    /** la liste des définitions d'options connues */
+    protected final Map<String, OptionDefinition> _odefinitions;
 
-    /**
-     * Launch parsing of some arguments.
-     *
-     * @param args arguments to parse
-     * @throws OptionParserException if any problem while parsing
-     */
-    public void doParse(String... args) throws OptionParserException {
-        if (args.length > 0) {
-            // detect OptionContexts
-            prepareContexts(args);
-        }
+    /** la liste des définitions d'arguments connus */
+    protected final Map<String, OptionArgumentDefinition> _adefinitions;
 
-        // check coherence on detected OptionContexts TODO Finish me
-        checkPostParsing();
+    /** le dictionnaire des definitions d'options indexées par leurs alias */
+    protected final Map<String, OptionDefinition> _indexAlias;
 
-        if (context.optionContexts != null) {
-            for (OptionContext optionContext : context.optionContexts) {
-                // instanciate option from his context
-                instanciateOption(optionContext);
-            }
-        }
-        //TODO Report errors from context before clear context
+    protected Class<? extends Option> _argImpl;
 
-        context.clear();
-    }
+    /** le dictionnaire d'actions associées aux options */
+    protected final Map<String, OptionAction> _actions;
 
-    public boolean isEnabled(String key) {
-        List<Option> list = options.get(key);
-        return list != null && !list.isEmpty();
-    }
 
-    public Option[] getOptions(String key) {
-        List<Option> list = options.get(key);
-        return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
-    }
+    /** 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;
 
-    public void printUsage(Writer writer, String name) throws IOException {
-        writer.append(_("lutinutil.parserdef.printUsage.factory.head", name));
+    /** list of errors found while parsing */
+    protected OptionParserException[] _errors;
 
-        for (OptionDefinition definition : definitions.values()) {
-            definition.printUsage(writer);
-        }
+    public OptionParser() throws IllegalArgumentException {
+        this(null);
     }
 
-    public void printDetails(Writer writer) throws IOException {
-        int size = definitions.size();
-        writer.append(_("lutinutil.parserdef.printDetail.factory.head",
-                this, size));
-        int i = 0;
-        for (OptionDefinition definition : definitions.values()) {
-            writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD, i + 1, size, definition));
-            definition.printDetail(writer);
-            i++;
+    protected OptionParser(ApplicationA anno) throws IllegalArgumentException {
+        // find ApplicationA annotation associated with parser
+        if (anno == null) {
+            anno = getClass().getAnnotation(ApplicationA.class);
+            if (anno == null) {
+                throw new IllegalArgumentException(_("lutinutil.parser.unfound.annotation", ApplicationA.class, this));
+            }
         }
-    }
+        this._anno = anno;
+        this._acceptedOptions = new HashMap<String, List<Option>>();
+        this._acceptedArguments = new HashMap<String, List<OptionArgument>>();
+        this._actions = new HashMap<String, OptionAction>();
 
-    /**
-     * 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.
-     *
-     * @param args la liste des arguments à scanner
-     */
-    protected void prepareContexts(String... args) {
+        this._odefinitions = new LinkedHashMap<String, OptionDefinition>();
+        this._adefinitions = new LinkedHashMap<String, OptionArgumentDefinition>();
+        this._indexAlias = new TreeMap<String, OptionDefinition>();
 
-        OptionContext optionContext = null;
-
-        for (int i = 0; i < args.length; i++) {
-            String argument = args[i];
-            if (argument.startsWith("-")) {
-                // alias detected
-                OptionDefinition newOption = context.indexAlias.get(argument);
-                if (newOption == null) {
-                    // unknown argument
-                    arguments.add(argument);
-                    continue;
+        if (anno.options().length > 0) {
+            // parser have some available options
+            for (OptionA optionA : anno.options()) {
+                // build each definition from his associated OptionA
+                OptionDefinition definition = new OptionDefinition(optionA);
+                _odefinitions.put(optionA.key(), definition);
+                _acceptedOptions.put(optionA.key(), new ArrayList<Option>());
+                // keep all alias of the option
+                for (String alias : optionA.alias()) {
+                    _indexAlias.put(alias, definition);
                 }
-                // close the current optionContexts and add it to result
-                context.addOptionContext(optionContext);
-
-                optionContext = new OptionContext(newOption,
-                        actions.get(newOption.getName()),argument,i);
-                continue;
             }
-            if (optionContext == null || !optionContext.addArgument(context, argument, i)) {
-                // no option opened or argument not accepted
-                arguments.add(argument);
+        }
+        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>());
             }
         }
-
-        // close the current optionContexts and add it to result
-        context.addOptionContext(optionContext);
-
+        _argImpl = anno.argumentsImpl();
+        // create parser _context from definitions in annotation
+        //this._context = new ParserContext2(anno);
     }
 
     /**
-     * Cette méthode permet d'instancier une option à partir des valeurs
-     * détectées dans le contexte d'option.
-     * <p/>
-     * Le context a été vérifié auparavant et on sait que l'option et ses
-     * arguments sont valides.
-     * <p/>
+     * Launch parsing of some arguments.
      *
-     * @param optionContext le contexte d'une option parsée
+     * @param args arguments to parse
+     * @throws OptionParserException if any problem while parsing
+     * @throws java.io.IOException   if io problems with writers
      */
-    protected void instanciateOption(OptionContext optionContext) {
-
-        int position = 0;
-
-        List<OptionArgument> arguments = new ArrayList<OptionArgument>();
-
-        for (OptionArgumentContext argumentContext : optionContext.argumentsFound) {
-
-            // get argument from command line
-            String argument = argumentContext.getArgument();
+    public void doParse(String... args) throws OptionParserException, IOException {
+        cleanResult();
+        ParserContext2 context = new ParserContext2();
 
-            // get argument definition
-            OptionArgumentDefinition argumentDefinition = argumentContext.getDefinition();
 
-            // extract value as String for the argument type
-            String valueStr = argumentDefinition.getType().extractArgumentValue(argument);
+        if (args.length == 0) {
+            _errors = new OptionParserException[0];
+            return;
+        }
 
-            // convert to matching type from argument definition value type
-            Object value = ConvertUtils.convert(valueStr, argumentDefinition.getValueType().getClazz());
+        // detect application arguments (before first alias)
+        context.detectApplicationArguments(args.length, args);
 
-            // add argument to option
-            OptionArgument optionArgument;
+        // detect options
+        context.detectOptions(args);
 
-            // get real position for this argument (-1 for an optional one)
-            int realPosition = argumentContext.definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
+        // transfert errors from parser context
+        _errors = context.getErrors().toArray(new OptionParserException[context.getNbErrors()]);
 
-            // instanciate concrete argument
-            optionArgument = new OptionArgument<Object>(
-                    argumentContext.definition,
-                    realPosition,
-                    argumentContext.argument,
-                    value
-            );
+        context.clear();
 
-            arguments.add(optionArgument);
+    }
 
-            if (argumentDefinition.isMandatory()) {
-                // increments next mandatory position
-                position++;
-            }
+    private void cleanResult() {
+        for (Map.Entry<String, List<OptionArgument>> stringListEntry : _acceptedArguments.entrySet()) {
+            stringListEntry.getValue().clear();
         }
-
-        // finally instanciate option and store it
-        String key = optionContext.definition.getName();
-        Option option = optionContext.newOption(arguments);
-        List<Option> list = options.get(key);
-        if (list == null) {
-            options.put(key, list = new ArrayList<Option>());
+        for (Map.Entry<String, List<Option>> stringListEntry : _acceptedOptions.entrySet()) {
+            stringListEntry.getValue().clear();
         }
-        list.add(option);
+        _errors = null;
     }
 
-
-    protected void checkPostParsing() throws OptionParserException {
-        // build a map from context
-        Map<OptionDefinition, List<OptionContext>> map;
-        map = new HashMap<OptionDefinition, List<OptionContext>>();
-        for (OptionContext optionContext : context.optionContexts) {
-            OptionDefinition definition = optionContext.definition;
-            List<OptionContext> list = map.get(definition);
-            if (list == null) {
-                map.put(definition, list = new ArrayList<OptionContext>());
-            }
-            list.add(optionContext);
+    public Option[] getOptions() {
+        List<Option> result = new ArrayList<Option>();
+        for (List<Option> options : _acceptedOptions.values()) {
+            result.addAll(options);
         }
-
-        for (OptionDefinition definition : definitions.values()) {
-            List<OptionContext> contextList = map.get(definition);
-            int min = definition.getMin();
-            int max = definition.getMax();
-
-            if ((contextList == null || contextList.isEmpty()) && min > 0) {
-                // fatal error mandatory option
-                throw new OptionParserException("");
-            }
-
-            if (min > 0 && (contextList == null || contextList.size() < min)) {
-                // fatal error required more (min>found)
-                throw new OptionParserException("");
-            }
-
-            if (max > 0 && (contextList != null && contextList.size() > max)) {
-                // fatal error required less (found>max)
-                throw new OptionParserException("");
-            }
-            //TODO check each argument option
-            if (contextList != null) {
-                for (OptionContext optionContext : contextList) {
-                    checkPostParsingOption(optionContext);
-                }
-            }
-        }
-        // clear map
-        map.clear();
+        return result.toArray(new Option[result.size()]);
     }
 
-    protected void checkPostParsingOption(OptionContext optionContext) {
-
-        int max = context.getMaxMandatories(optionContext.definition);
-
-        for (int i = 0; i < max; i++) {
-            // check cardinalite
-
+    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()]);
+    }
 
-        for (OptionArgumentContext argumentContext : optionContext.argumentsFound) {
-            // check there is no mandatory argument missing
-            if (argumentContext == null) {
-                //TODO
-            }
-        }
+    public boolean isOptionEnabled(String key) {
+        List<Option> list = _acceptedOptions.get(key);
+        return list != null && !list.isEmpty();
     }
 
     /**
@@ -389,307 +235,537 @@
      *
      * @author chemit
      */
-    class ParserContext {
+    class ParserContext2 extends OptionParserUtil.OptionParserContext<ParserContext2, ParserContext2> {
 
-        /** liste des définitions arguments obligatoires par position obligatoire */
-        protected final Map<OptionDefinition, OptionArgumentDefinition[][]> mandatories;
+        int pos = 0;
 
-        /** la liste des définitions d'arguments optionnels */
-        protected final Map<OptionDefinition, OptionArgumentDefinition[]> optionals;
-
-        /** la liste des contextes d'options détectés */
-        protected final List<OptionContext> optionContexts;
-
-        /** la liste des définitions connues indexées par chacun de leurs alias */
-        protected final Map<String, OptionDefinition> indexAlias;
+        protected ParserContext2() {
+            super(null, true);
+        }
 
-        ParserContext(Map<String, OptionDefinition> map) {
-            this.mandatories = new HashMap<OptionDefinition, OptionArgumentDefinition[][]>();
-            this.optionals = new HashMap<OptionDefinition, OptionArgumentDefinition[]>();
-            this.optionContexts = new ArrayList<OptionContext>();
-            this.indexAlias = new TreeMap<String, OptionDefinition>();
-            // build indexAlias
-            for (OptionDefinition optionDefinition : map.values()) {
-                for (String alias : optionDefinition.getAlias()) {
-                    indexAlias.put(alias, optionDefinition);
+        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;
             }
-        }
-
-        void addOptionContext(OptionContext context) {
-            if (context != null) {
-                log.info("[" + context.alias + "] : " + context.definition);
-                optionContexts.add(context);
+            // try a constant
+            type = OptionArgumentType.constant;
+            result = OptionParserUtil.findArgumentByTypeAndKey(type, argument, defs);
+            if (result != null) {
+                log.info(argument + " : " + result);
+                return result;
             }
-        }
 
-        OptionArgumentDefinition[] getMandatories(OptionDefinition definition, int mandatoryPosition) {
-            OptionArgumentDefinition[][] result = mandatories.get(definition);
-            if (result == null) {
-                build(definition);
-                result = mandatories.get(definition);
-            }
-            if (mandatoryPosition >= result.length) {
-                return new OptionArgumentDefinition[0];
-            }
-            return result[mandatoryPosition];
-        }
+            // try a valued
+            type = OptionArgumentType.valued;
+            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+            result = OptionParserUtil.findArgumentByTypeAndValueType(type, valueType, defs);
 
-        int getMaxMandatories(OptionDefinition definition) {
-            OptionArgumentDefinition[][] result = mandatories.get(definition);
-            if (result == null) {
-                build(definition);
-                result = mandatories.get(definition);
+            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);
             }
-            return result.length;
-        }
-
-        OptionArgumentDefinition[] getOptionals(OptionDefinition definition) {
-            OptionArgumentDefinition[] result = optionals.get(definition);
-            if (result == null) {
-                build(definition);
-                result = optionals.get(definition);
+            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;
-        }
 
-        private void build(OptionDefinition definition) {
-            // build for this option definition
-            // construit les tables d'arguments optionels et obligatoires
-            List<OptionArgumentDefinition> _optionals = new ArrayList<OptionArgumentDefinition>();
-            List<Collection<OptionArgumentDefinition>> _mandatories = new ArrayList<Collection<OptionArgumentDefinition>>();
-            OptionArgumentDefinition[] argumentDefinitions = definition.getArguments();
-            int size = argumentDefinitions.length;
-            for (int i = 0; i < size; i++) {
-                _mandatories.add(new ArrayList<OptionArgumentDefinition>());
-            }
-            for (OptionArgumentDefinition argument : argumentDefinitions) {
-                if (argument.getPos() == -1) {
-                    _optionals.add(argument);
-                    continue;
-                }
-                int pos = argument.getPos();
-                Collection<OptionArgumentDefinition> list = _mandatories.get(pos);
-                list.add(argument);
-            }
-            this.optionals.put(definition, _optionals.toArray(new OptionArgumentDefinition[_optionals.size()]));
-            _optionals.clear();
-            int mandatoriesLength = _mandatories.size();
-            OptionArgumentDefinition[][] result;
-            result = new OptionArgumentDefinition[mandatoriesLength][];
-            for (int i = 0; i < mandatoriesLength; i++) {
-                Collection<OptionArgumentDefinition> _argumentDefinitions = _mandatories.get(i);
-                result[i] = _argumentDefinitions.toArray(new OptionArgumentDefinition[_argumentDefinitions.size()]);
-            }
-            this.mandatories.put(definition, result);
-            _mandatories.clear();
-        }
-
-        public void clear() {
-            mandatories.clear();
-            optionals.clear();
-            optionContexts.clear();
-            indexAlias.clear();
         }
-    }
 
-    /**
-     * Cette classe contient une option et ses arguments récupérés avant le
-     * parsing de l'option.
-     * <p/>
-     * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
-     *
-     * @author chemit
-     */
-    class OptionContext {
-
-        /** definition of option */
-        protected final OptionDefinition definition;
+        Map<OptionArgumentValueType, Integer> mapAvailable;
+        List<OptionArgumentValueType> availables;
 
-        /** alias used for this option */
-        protected final String alias;
+        //TODO New rule: for valued can't have twice a type in same group
 
-        /** the position of this option in the command line */
-        protected final int commandLinePosition;
-
-        /** la liste des context d'arguments trouvés */
-        protected final List<OptionArgumentContext> argumentsFound;
+        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);
+            }
+            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);
+            }
+        }
+
+        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;
+                }
 
-        protected final OptionAction action;
+                definition = OptionParserUtil.findArgumentByTypeAndValueType(type, valueType, defs);
 
-        /** la position obligatoire courante */
-        protected int mandatoryPosition;
+                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;
+        }
 
-        OptionContext(OptionDefinition definition,OptionAction action,  String alias, int commandLinePosition) {
-            this.definition = definition;
-            this.alias = alias;
-            this.action=action;
-            this.commandLinePosition = commandLinePosition;
-            this.argumentsFound = new ArrayList<OptionArgumentContext>();
-            this.mandatoryPosition = 0;
+        protected boolean checkMax(OptionArgumentDefinition def) {
+            List<OptionArgument> list = _acceptedArguments.get(def.key);
+            return def.max == -1 || list.size() < def.max;
         }
 
-        Option newOption(List<OptionArgument> arguments) {
+        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 {
-                Class<? extends Option> clazz = definition.getImpl();
-                Constructor<? extends Option> cons = clazz.getConstructor(String.class,OptionAction.class, OptionArgument[].class);
-                Option result;
-                result = cons.newInstance(alias, action,arguments.toArray(new OptionArgument[arguments.size()]));
-                return result;
-            } catch (InstantiationException e) {
-                throw new RuntimeException(e);
-            } catch (IllegalAccessException e) {
-                throw new RuntimeException(e);
-            } catch (InvocationTargetException e) {
-                throw new RuntimeException(e);
-            } catch (NoSuchMethodException e) {
-                throw new RuntimeException(e);
+                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);
         }
 
         /**
-         * Tente d'ajouter un argument à l'option du context.
+         * 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.
          *
-         * @param parserContext le context de parser
-         * @param argument      l'argument à ajouter
-         * @param position      la position de l'argument dans la ligne de commande
-         * @return <code>true</code> si l'argument a été ajouté à l'option,<code>false</code> autrement.
+         * @param args la liste des arguments à scanner
          */
-        boolean addArgument(OptionParser.ParserContext parserContext, String argument, int position) {
-
-            OptionArgumentDefinition argumentDefinition = findArgument(parserContext, argument);
+        protected void detectOptions(String... args) {
+            int length = args.length;
+            // detect application's options
+            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++;
+
+                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);
+                // find definition from alias
+                OptionDefinition definition = _indexAlias.get(alias);
+                if (definition == null) {
+                    //fatal error : unknown.option
+                    addError(_("lutinutil.parser.unknown.option", alias, start));
+                    continue;
+                }
+                // found an option, parse his arguments
+                OptionArgument[] arguments = detectOptionArguments(definition, argsForOption);
 
-            // find a matching argument definition
-            if (argumentDefinition != null) {
+                // validate the option
+                checkAndAddOption(alias, definition, arguments);
+            }
+        }
 
-                OptionArgumentContext argumentContext;
-                argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
+        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 (pos < max) {
+                    // take current group
+                    group = mandatoriesGroup[pos];
+                    // try to find it in the group
+                    co = detectArgumentDefinition(argument, group);
+
+                    if (co != null) { // found in this group
+                        break;
+                    } else { // go to next group
+                        pos++;
+                    }
+                }
 
-                argumentsFound.add(argumentContext);
-                //TODO Should test if argument is max* or max+
-                //TODO and change only if argument position is != from current
-                if (argumentDefinition.isMandatory()) {
-                    // was a mandatory argument increments mandatoryPosition
-                    mandatoryPosition++;
+                if (co == null) {
+                    // put back pos
+                    pos = lastPosition;
+                    if (optionalGroup != null) {
+                        group = optionalGroup;
+                        // try in optional group
+                        co = detectArgumentDefinition(argument, group);
+                    }
+                }
+                if (co == null) {
+                    // could not found a correct argument definition in any group
+                    // option is corrupted
+                    addError(_(""));
+                    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;
                 }
+                checkAndAddOptionArgument(co, group.pos,  argument, valueStr, result);
             }
 
-            return argumentDefinition != null;
+            return result.toArray(new OptionArgument[result.size()]);
         }
 
-        OptionArgumentDefinition findArgument(OptionParser.ParserContext parserContext, String argument) {
+        private void checkAndAddOption(String alias, OptionDefinition definition, OptionArgument[] arguments) {
 
-            OptionArgumentDefinition result = null;
+            List<Option> listFound = _acceptedOptions.get(definition.key);
 
-            OptionArgumentDefinition[] defs = parserContext.getMandatories(definition, mandatoryPosition);
-
-            OptionArgumentDefinition[] optionals = parserContext.getOptionals(definition);
-            boolean named = argument.indexOf('=') > -1;
-
-            if (defs.length > 0) {
-                // always try to find a mandatory argument first
-                result = findArgument0(named, argument, defs);
+            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));
+                return;
             }
-
-            if (result == null && optionals.length > 0) {
-                result = findArgument0(named, argument, optionals);
+            // 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;
+                }
+            }
+            // everything is ok, can instance option
+            try {
+                Class<? extends Option> clazz = definition.getImpl();
+                Constructor<? extends Option> cons = clazz.getConstructor(String.class, OptionAction.class, OptionArgument[].class);
+                Option result = cons.newInstance(alias, _actions.get(definition.key), arguments);
+                listFound.add(result);
+            } catch (Exception e) {
+                throw new RuntimeException(e);
             }
-            log.info(result + " : [" + argument + "]");
-            return result;
         }
 
-        private OptionArgumentDefinition findArgument0(boolean named, String argument, OptionArgumentDefinition[] defs) {
-            OptionArgumentType type;
-            OptionArgumentDefinition result;
-            if (named) {
-                String key = argument.substring(0, argument.indexOf('='));
-                type = OptionArgumentType.namedAndValued;
-
-                // find a named and valued
-                result = findArgumentByTypeAndKey(type, key, defs);
-
-                return result;
+        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);
+                    }
+                }
             }
-
-            type = OptionArgumentType.constant;
-            // find in a constant
-            result = findArgumentByTypeAndKey(type, argument, defs);
-            if (result != null) {
-                return result;
+            int size = map.entrySet().size(); 
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() > 0) {
+                    size--;
+                }
+            }
+            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;
             }
+            // group is ok
+            return true;
+        }
 
-            type = OptionArgumentType.valued;
+        private void checkAndAddOptionArgument(OptionArgumentDefinition definition, int pos, String argument, String valueStr, List<OptionArgument> list) {
 
-            OptionArgumentValueType valueType;
+            OptionArgumentValueType valueType = definition.getValueType();
 
-            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+            // 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 && 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>(
+                    definition.key,
+                    definition.type,
+                    definition.valueType,
+                    pos,
+                    argument,
+                    valueStr
+            );
+            log.info("success for " + definition.key + " : " + optionArgument);
+            list.add(optionArgument);
+        }
 
-            // find a valued
-            result = findArgumentByTypeAndValueType(type, valueType, defs);
-            if (result != null) {
-                return result;
-            }
-            if (valueType == OptionArgumentValueType._newfile) {
-                // we didn't find a _newFile, it could be also a string
-                result = findArgumentByTypeAndValueType(type, OptionArgumentValueType._string, defs);
-            }
-            return result;
+
+        public OptionDefinition getOptionDefinition(String key) {
+            return _odefinitions.get(key);
         }
 
-        OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type,
-                                                          String key,
-                                                          OptionArgumentDefinition... defs) {
-            for (OptionArgumentDefinition argumentDefinion : defs) {
-                if (argumentDefinion.getType() == type && argumentDefinion.getKey().equals(key)) {
-                    return argumentDefinion;
+        public OptionGroupArgumentDefinition getOptionalGroupDefinition(String key) {
+            OptionDefinition definition = _odefinitions.get(key);
+            for (OptionGroupArgumentDefinition group : definition.groups) {
+                if (!group.isMandatory()) {
+                    return group;
                 }
             }
             return null;
         }
 
-        OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
-                                                                OptionArgumentValueType valueType,
-                                                                OptionArgumentDefinition... defs) {
-            for (OptionArgumentDefinition argumentDefinion : defs) {
-                if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
-                    return argumentDefinion;
+        public OptionGroupArgumentDefinition[] getMandatoryGroupDefinition(String key) {
+            OptionDefinition definition = _odefinitions.get(key);
+            List<OptionGroupArgumentDefinition> result = new ArrayList<OptionGroupArgumentDefinition>();
+            for (OptionGroupArgumentDefinition group : definition.groups) {
+                if (group.isMandatory()) {
+                    result.add(group);
                 }
             }
-            return null;
+            return result.toArray(new OptionGroupArgumentDefinition[result.size()]);
         }
+
+
     }
-}
 
 
-/**
- * Cette classe contient un argument d'option récupéré pendant le parsing.
- * <p/>
- * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
- *
- * @author chemit
- */
-class OptionArgumentContext {
+    public boolean isArgumentEnabled(String key) {
+        List<OptionArgument> list = _acceptedArguments.get(key);
+        return list != null && !list.isEmpty();
+    }
 
-    protected final OptionArgumentDefinition definition;
+    public Option[] getOptions(String key) {
+        List<Option> list = _acceptedOptions.get(key);
+        return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
+    }
 
-    protected final String argument;
+    public OptionArgument[] getArguments(String key) {
+        List<OptionArgument> list = _acceptedArguments.get(key);
+        return list == null || list.isEmpty() ? null : list.toArray(new OptionArgument[list.size()]);
+    }
 
-    protected final int commandLinePosition;
+    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));
+    }
 
-    public OptionArgumentContext(OptionArgumentDefinition definition,
-                                 String argument, int commandLinePosition) {
-        this.argument = argument;
-        this.commandLinePosition = commandLinePosition;
-        this.definition = definition;
+    /**
+     * 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());
+        }
     }
 
-    public String getArgument() {
-        return argument;
+    public boolean hasFailed() {
+        return _errors != null && _errors.length > 0;
     }
 
-    public OptionArgumentDefinition getDefinition() {
-        return definition;
+
+    /**
+     * Register an action associated to an Option.
+     *
+     * @param optionKey option key
+     * @param action    action to realise for the option
+     * @throws IllegalArgumentException if option key is unknown, or an action
+     *                                  is already registered for the option key
+     *                                  given.
+     */
+    public void registerAction(String optionKey, OptionAction action) throws IllegalArgumentException {
+        if (!_odefinitions.containsKey(optionKey)) {
+            throw new IllegalArgumentException(_("lutinutil.parser.unfound.option", optionKey));
+        }
+        if (_actions.containsKey(optionKey)) {
+            throw new IllegalArgumentException(_("lutinutil.parser.action.already.registred", optionKey));
+        }
+        _actions.put(optionKey, action);
     }
+
 }
 
+
+
+

Index: lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.3 lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.4
--- lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java:1.3	Sun Dec  2 05:13:37 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParserAnnotationHelper.java	Wed Dec  5 03:03:57 2007
@@ -29,7 +29,7 @@
  * option's parser.
  * <p/>
  * We have some factories methods to compute hard annotation (usefull for
- * code generation : we only instanciate the {@link OptionParserA}, then
+ * code generation : we only instanciate the {@link ApplicationA}, then
  * we transform it via javassist to byte-code.
  *
  * @author chemit
@@ -41,16 +41,23 @@
     //------------------------------------------------------------------------
 
     /**
-     * Annotation pour définir le paramétrage d'un parseur d'options.
+     * Annotation pour définir le paramétrage d'une application avec ses
+     * options et arguments.
      *
      * @author chemit
      */
     @Retention(value = RUNTIME)
     @Target(value = {TYPE, LOCAL_VARIABLE, CONSTRUCTOR, METHOD, FIELD})
-    public static @interface OptionParserA {
+    public static @interface ApplicationA {
 
-        /** @return les options connues du parseur */
+        /** @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;
     }
 
     /**
@@ -82,9 +89,9 @@
         public String description();
 
         /** @return les groupes d'arguments connus pour cette option */
-        public OptionGroupArgumentA[] groups() default {};
+        public GroupArgumentA[] groups() default {};
 
-        /** @return la classe d'mplentation de l'option */
+        /** @return la classe d'implantation de l'option */
         public Class<? extends Option> impl() default Option.class;
     }
 
@@ -101,7 +108,7 @@
      */
     @Retention(value = RUNTIME)
     @Target(value = ANNOTATION_TYPE)
-    public static @interface OptionGroupArgumentA {
+    public static @interface GroupArgumentA {
 
         /** @return le min */
         public int min() default 0;
@@ -113,14 +120,18 @@
         public int pos() default -1;
 
         /** @return les arguments connus pour ce groupe */
-        public OptionArgumentA[] arguments();
+        public ArgumentA[] arguments();
     }
 
     /**
      * Annotation pour définir le paramétrage de la définition d'un argument
-     * d'une option (plus précisement d'un groupe d'arguments d'option).
+     * (soit d'option soit d'application)
+     * <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)
      *
@@ -128,7 +139,7 @@
      */
     @Retention(value = RUNTIME)
     @Target(value = ANNOTATION_TYPE)
-    public static @interface OptionArgumentA {
+    public static @interface ArgumentA {
 
         /** @return la clef de l'argument */
         public String key();
@@ -144,21 +155,34 @@
 
         /** @return le max */
         public int max() default 1;
+
+        /** @return la description de la définition */
+        public String description() default "";
     }
 
     //------------------------------------------------------------------------
     // Factory methods
     //------------------------------------------------------------------------
 
-    public static OptionParserA newOptionParserA(final OptionA[] optionAs) {
-        OptionParserA result;
-        result = new OptionParserA() {
+    public static ApplicationA newApplicationA(final OptionA[] optionAs,
+                                               final ArgumentA[] argumentsAs,
+                                               final Class<? extends Option> impl) {
+        ApplicationA result;
+        result = 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 OptionParserA.class;
+                return ApplicationA.class;
             }
         };
         return result;
@@ -169,7 +193,7 @@
                                      final int min, final int max,
                                      final String[] alias,
                                      final Class<? extends Option> impl,
-                                     final OptionGroupArgumentA[] groupAs) {
+                                     final GroupArgumentA[] groupAs) {
         return new OptionA() {
             public String key() {
                 return key;
@@ -187,12 +211,12 @@
                 return max;
             }
 
-            public OptionGroupArgumentA[] groups() {
+            public GroupArgumentA[] groups() {
                 return groupAs;
             }
 
-            public OptionArgumentA[] arguments() {
-                return new OptionArgumentA[0];
+            public ArgumentA[] arguments() {
+                return new ArgumentA[0];
             }
 
             public String description() {
@@ -209,11 +233,11 @@
         };
     }
 
-    public static OptionGroupArgumentA newOptionGroupArgumentA(final int min,
-                                                               final int max,
-                                                               final int pos,
-                                                               final OptionArgumentA[] argumentAs) {
-        return new OptionGroupArgumentA() {
+    public static GroupArgumentA newGroupArgumentA(final int min,
+                                                   final int max,
+                                                   final int pos,
+                                                   final ArgumentA[] argumentAs) {
+        return new GroupArgumentA() {
             public int min() {
                 return min;
             }
@@ -226,23 +250,23 @@
                 return pos;
             }
 
-            public OptionArgumentA[] arguments() {
+            public ArgumentA[] arguments() {
                 return argumentAs;
             }
 
             public Class<? extends Annotation> annotationType() {
-                return OptionGroupArgumentA.class;
+                return GroupArgumentA.class;
             }
         };
     }
 
-    public static OptionArgumentA newOptionArgumentA(final OptionArgumentType type,
-                                                     final OptionArgumentValueType valueType,
-                                                     final String key,
-                                                     final int min,
-                                                     final int max
-    ) {
-        return new OptionArgumentA() {
+    public static ArgumentA newArgumentA(final OptionArgumentType type,
+                                         final OptionArgumentValueType valueType,
+                                         final String key,
+                                         final int min,
+                                         final int max,
+                                         final String description) {
+        return new ArgumentA() {
             public String key() {
                 return key;
             }
@@ -263,8 +287,12 @@
                 return max;
             }
 
+            public String description() {
+                return description;
+            }
+
             public Class<? extends Annotation> annotationType() {
-                return OptionArgumentA.class;
+                return ArgumentA.class;
             }
         };
     }

Index: lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java
diff -u lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java:1.1 lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java:1.1	Mon Nov 19 19:05:58 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java	Wed Dec  5 03:03:57 2007
@@ -145,6 +145,7 @@
         }
         return null;
     }
+    
 
     /** @return la class d'implantation du type */
     public Class getClazz() {

Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.7 lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.8
--- lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.7	Sun Dec  2 07:16:39 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java	Wed Dec  5 03:03:57 2007
@@ -24,9 +24,9 @@
 * Created: 22 août 2003
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.7 $
+* @version $Revision: 1.8 $
 *
-* Mise a jour: $Date: 2007-12-02 07:16:39 $
+* Mise a jour: $Date: 2007-12-05 03:03:57 $
 * par : $Author: tchemit $
 */
 
@@ -35,9 +35,10 @@
 import static org.codelutin.i18n.I18n._;
 import org.codelutin.log.LutinLog;
 import org.codelutin.log.LutinLogFactory;
-import static org.codelutin.util.OptionArgumentValueType._newfile;
-import static org.codelutin.util.OptionArgumentValueType._string;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
+import org.codelutin.util.OptionParserAnnotationHelper.ApplicationA;
+import org.codelutin.util.OptionParserUtil.OptionDefinitionParserContext;
+import org.codelutin.util.OptionParserUtil.ToAnnotationWalker;
+import org.codelutin.util.OptionParserUtil.ToDefinitionWalker;
 
 import java.io.BufferedInputStream;
 import java.io.File;
@@ -59,10 +60,10 @@
  * <p/>
  * à partir de définition d'options données via un fichier de propriétés.
  * <p/>
- * La classe contient une méthode statique publique :
+ * La classe contient une méthode statique publique : TODO Revoir (changements)
  * <p/>
- * {@link #doParse(org.codelutin.util.OptionDefinitionParser.TypeSource,Object)} pour lancer un parsing sur le fichier de définitions
- * donné.
+ * {@link #doParse(org.codelutin.util.OptionDefinitionParser.TypeSource,Object)}
+ * pour lancer un parsing sur le fichier de définitions donné.
  * <p/>
  * <p/>
  * <p/>
@@ -72,12 +73,23 @@
  * <groupArgument2> [groupArgumentFacultatif]</code>
  * <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
  */
 
 public class OptionDefinitionParser {
 
+
     /**
      * permet de définir le type de source pour lire les définitions à analyser.
      * <p/>
@@ -108,65 +120,57 @@
      * A ce stade, aunce definition ou annotation n'as été crée, on connait
      * uniquement les contexts d'options valides.
      * <p/>
-     * Pour obtenir la liste des définitions valides : {@link #toDefinitions()}
+     * Pour obtenir la liste des définitions valides : {@link #toDefinition()}
      * <p/>
-     * Pour obtenir l'annotation OptionParserA de définition du parseur :
+     * Pour obtenir l'annotation ApplicationA de définition du parseur :
      * {@link #toAnnotation()}
      *
-     * @param type   le type de source à traiter.
-     * @param source la source contenant les définitions des options
+     * @param type le type de source à traiter.
+     * @param src  la source contenant les définitions des options
      * @return le parseur après parsing du fichier
+     * @throws java.io.IOException if any problem when reading source
      */
-    public static OptionDefinitionParser doParse(TypeSource type, Object source) {
-        // instanciate parser
-        OptionDefinitionParser parser = new OptionDefinitionParser();
-        // init parser context reading from source
-        ParserContext context;
-        switch (type) {
-            case properties:
-                context = parser.initProperties((File) source);
-                break;
-            case console:
-            case xml:
-                throw new IllegalArgumentException(_("lutinutil.parserdef.notimplemented.sourceType", type, parser));
-            default:
-                throw new IllegalArgumentException(_("lutinutil.parserdef.unknown.sourceType", type, parser, Arrays.toString(TypeSource.values())));
+    public static OptionDefinitionParser doParse(TypeSource type, Object src) throws IOException {
+        if (type == null) {
+            throw new IllegalArgumentException(_("lutinutil.parserdef.null.sourceType", type, Arrays.toString(TypeSource.values())));
         }
-        // parse and build option contexts
-        for (int i = 0, j = context.keys.length; i < j; i++) {
-            String key = context.keys[i];
-            String definition = context.definitions[i];
-            String description = context.descriptions[i];
-            int nbErrors = parser.errors.size();
-            if (!context.preOptionCheck(key, definition, description) && nbErrors < parser.errors.size()) {
-                // we don't treate this option, keep a fake option definition
-                // for error reporting
-                parser.unvalidDefinitions.add(new SyntaxUnvalidOptionDefinition(key, description, definition));
-                continue;
-            }
-            OptionContext optionContext = context.parseOption(key, definition, description);
-            context.addSon(optionContext);
+        if (src == null) {
+            throw new IllegalArgumentException(_("lutinutil.parserdef.null.source"));
         }
-        // keep valid option's contexts
-        parser.safeContexts = context.contexts.toArray(new OptionContext[context.contexts.size()]);
+        OptionDefinitionParser parser = new OptionDefinitionParser();
+
+        // init parser context : reading from source
+        ParserContext context = parser.init(type, src);
+
+        // 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()]);
+
         // clean context
         context.clear();
+
         return parser;
     }
 
-    /** list of safe contexts available after parsing */
-    protected OptionContext[] safeContexts;
+    /** type of source to use to obtain definitions */
+    protected TypeSource type;
 
-    /** lists of unvalid definitions found while parsing */
-    protected List<OptionDefinition> unvalidDefinitions;
+    /** list of safe options contexts available after parsing */
+    protected OptionContext[] options;
 
-    /** list of errors found while parsing */
-    protected List<OptionDefinitionParserException> errors;
+    /** list of safe arguments contexts available after parsing */
+    protected OptionArgumentContext[] arguments;
 
-    /** @return la liste des définitions marqués comme invalides. */
-    public OptionDefinition[] getUnvalidDefinitions() {
-        return unvalidDefinitions.toArray(new OptionDefinition[unvalidDefinitions.size()]);
-    }
+    /** implementation of arguments container : it is an Option */
+    protected Class<? extends Option> argumentImpl = Option.class;
+
+    /** list of errors found while parsing */
+    protected OptionDefinitionParserException[] errors;
 
     /**
      * @return la liste des définitions valides.
@@ -174,12 +178,12 @@
      *             raison d'attaquer les définitions à partir d'ici : c'est la
      *             responsabilité du parseur d'options...
      */
-    public OptionDefinition[] toDefinitions() {
+    public ApplicationDefinition toDefinition() {
         if (hasFailed()) {
-            return new OptionDefinition[0];
+            return null;
         }
-        OptionDefinition[] result;
-        result = OptionParserUtil.ToDefinitionWalker.getInstance().run(safeContexts);
+        ApplicationDefinition result;
+        result = ToDefinitionWalker.getInstance().run(options, arguments, argumentImpl);
         return result;
     }
 
@@ -187,28 +191,28 @@
      * @return l'annotation de définition du parseur d'options à partir des
      *         options reconnues comme valides.
      */
-    public OptionParserA toAnnotation() {
+    public ApplicationA toAnnotation() {
         if (hasFailed()) {
             return null;
         }
-        OptionParserA result;
-        result = OptionParserUtil.ToAnnotationWalker.getInstance().run(safeContexts);
+        ApplicationA result;
+        result = ToAnnotationWalker.getInstance().run(options, arguments, argumentImpl);
         return result;
     }
 
     /**
-     * @return <code>true</code> si des erreurs ont été détectés pendant l'analyse
-     *         des définitions d'options.
+     * @return <code>true</code> si des erreurs ont été détectées pendant
+     *         l'analyse des définitions.
      */
     public boolean hasFailed() {
-        return errors != null && !errors.isEmpty();
+        return errors != null && errors.length > 0;
     }
 
     /**
      * @return la liste des erreurs rencontrées pendant l'analyse des définitions
      *         d'options.
      */
-    public List<OptionDefinitionParserException> getErrors() {
+    public OptionDefinitionParserException[] getErrors() {
         return errors;
     }
 
@@ -222,109 +226,64 @@
         if (!hasFailed()) {
             return;
         }
-        w.append(_("lutinutil.parserdef.printError.head", errors.size()));
-        for (int i = 0, j = errors.size(); i < j; i++) {
-            w.append(_("lutinutil.parserdef.printError.error", i + 1, j, errors.get(i)));
+        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());
         }
     }
 
-    protected OptionDefinitionParser() {
-        this.errors = new ArrayList<OptionDefinitionParserException>();
-        this.unvalidDefinitions = new ArrayList<OptionDefinition>();
-    }
-
-    protected boolean checkCardinalite(int min, int max, String definition, String description) {
-        if (min < 0) {
-            addError(_("lutinutil.parser.min.can.not.be.negative", min, definition, description), null);
-            return false;
-        }
-        if (max == 0) {
-            addError(_("lutinutil.parser.max.can.not.be.zero", max, definition, description), null);
-            return false;
-        }
-        if (max < -1) { // on vérifie que la cardinalité max >-2
-            addError(_("lutinutil.parser.max.too.low", max, definition, description), null);
-            return false;
-        }
-        if (max > -1 && max < min) { // on vérifie que la cardinalité max==-1 || max >= min
-            addError(_("lutinutil.parser.max.lowest.than.min", max, min, definition, description), null);
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * Initialise un contexte de parseur à partir d'un fichier de propriétés.
-     *
-     * @param source la source où lire les définitions (un fichier de propriétés)
-     * @return un contexte de parseur avec les définitions lues
-     */
-    protected ParserContext initProperties(File source) {
-
-        final String DEFINITION_KEY_SUFFIX = ".definition";
-        final String DESCRIPTION_KEY_SUFFIX = ".description";
-        final int DEFINITION_KEY_PREFIX_LENGTH = DEFINITION_KEY_SUFFIX.length();
-
-        // load properties file
-        Properties properties = new Properties();
-        InputStream stream = null;
-        try {
-            try {
-                stream = new BufferedInputStream(new FileInputStream(source));
-                properties.load(stream);
-            } finally {
-                stream.close();
-            }
-
-        } catch (IOException e) {
-            throw new RuntimeException(
-                    _("lutinutil.error.could.not.load.properties.file", source, e.getMessage()), e);
-        }
-
-        // récupération des clefs d'options
-        List<String> keys = new ArrayList<String>();
-        for (Object o : properties.keySet()) {
-            String key = o.toString();
-            if (!key.endsWith(DEFINITION_KEY_SUFFIX)) {
-                continue;
-            }
-            String s = key.substring(0, key.length() - DEFINITION_KEY_PREFIX_LENGTH);
-            keys.add(s);
-        }
-        // on trie les clefs d'options une seule fois
-        // ensuite on travaille sur cet ordre établi.
-        Collections.sort(keys);
-
-        List<String> definitions = new ArrayList<String>();
-        List<String> descriptions = new ArrayList<String>();
-
-        // récupérations des définitions et descriptions des options
-        for (String optionKey : keys) {
-            definitions.add(properties.getProperty(optionKey + DEFINITION_KEY_SUFFIX));
-            descriptions.add(properties.getProperty(optionKey + DESCRIPTION_KEY_SUFFIX));
+    protected ParserContext init(TypeSource type, Object source) throws IOException {
+        ParserContext context;
+        switch (type) {
+            case properties:
+                context = initProperties((File) source);
+                break;
+            case console:
+            case xml:
+                throw new IllegalArgumentException(_("lutinutil.parserdef.notimplemented.sourceType", type, this));
+            default:
+                throw new IllegalArgumentException(_("lutinutil.parserdef.unknown.sourceType", type, this, Arrays.toString(TypeSource.values())));
         }
-
-        // construction du context de parsing
-        ParserContext context = new ParserContext(
-                keys.toArray(new String[keys.size()]),
-                definitions.toArray(new String[keys.size()]),
-                descriptions.toArray(new String[keys.size()])
-        );
-        keys.clear();
-        definitions.clear();
-        descriptions.clear();
-        properties.clear();
         return context;
     }
 
-    protected void addError(String content, Exception e) {
-        OptionDefinitionParserException e1;
-        if (e == null) {
-            e1 = new OptionDefinitionParserException(content);
-        } else {
-            e1 = new OptionDefinitionParserException(content, e);
+    protected void parseArguments(ParserContext context) {
+        // to realise 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++) {
+            String key = context.okeys[i];
+            String definition = context.odefinitions[i];
+            String description = context.odescriptions[i];
+            if (context.checkOptionSyntax(key, definition, description)) {
+                OptionContext optionContext = context.parseOption(key, definition, description);
+                context.addSon(optionContext);
+            }
         }
-        errors.add(e1);
+        // keep valid option's contexts
+        options = context.contexts.toArray(new OptionContext[context.contexts.size()]);
     }
 
     /**
@@ -334,32 +293,41 @@
      *
      * @author chemit
      */
-    class ParserContext extends OptionParserUtil.ParserContext<ParserContext, OptionContext> {
+    class ParserContext extends OptionDefinitionParserContext<ParserContext, OptionContext> {
 
-        protected final String[] keys;
+        protected final String[] okeys;
+        protected final String[] odefinitions;
+        protected final String[] odescriptions;
+        protected final String[] adefinitions;
+        protected final String[] adescriptions;
 
-        protected final String[] definitions;
-        protected final String[] descriptions;
+        /** la liste des alias d'option déjà rencontrées pendant le parsing */
+        protected final List<String> aliaKeyUsed;
 
-        /** la liste des clefs d'arguments déjà rencontrées pendant le parsing */
-        protected final List<String> argumentKeyUsed;
         /** la liste des clefs d'option déjà rencontrées pendant le parsing */
         protected final List<String> optionKeyUsed;
-        /** la liste des alias d'option déjà rencontrées pendant le parsing */
-        protected final List<String> aliaKeyUsed;
 
-        ParserContext(String[] keys, String[] definitions, String[] descriptions) {
+        /** 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) {
             super(null, true);
-            this.keys = keys;
-            this.definitions = definitions;
-            this.descriptions = descriptions;
+            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>();
         }
 
         OptionContext parseOption(String key, String definition, String description) {
-            log.info('[' + key + "][" + definition + ']');
+            log.info('[' + key + "] '" + definition + "'");
 
             String[] strings = StringUtil.split(openingChars, closingChars, definition, " ");
             List<String> tokens = new ArrayList<String>(Arrays.asList(strings));
@@ -381,12 +349,12 @@
                 }
             }
 
-            if (!preOptionCheck2(alias, definition, description, min, max)) {
-                return null;
-            }
-            OptionContext context;
-            context = new OptionContext(this, key, description, min, max, alias);
+            OptionContext context = new OptionContext(this, key, description, min, max, alias);
 
+            if (!checkOption(alias, definition, description, min, max)) {
+                context.unvalidate();
+                return context;
+            }
             if (!tokens.isEmpty()) {
                 // l'option possede des arguments
                 for (String groupArgument : tokens) {
@@ -400,7 +368,7 @@
         protected void postAddSonHook(OptionContext context) {
             aliaKeyUsed.addAll(Arrays.asList(context.alias));
             optionKeyUsed.add(context.key);
-            argumentKeyUsed.clear();
+            optionArgumentKeyUsed.clear();
         }
 
         /**
@@ -411,73 +379,63 @@
          * @param description la descrption de l'option
          * @return <code>valid</code> value after check
          */
-        boolean preOptionCheck(String key, String definition, String description) {
+        boolean checkOptionSyntax(String key, 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.option.definition", definition, description), null);
-                unvalidate();
+                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()) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.empty.option.description", definition, description), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.empty.option.description", definition, description));
+                return false;
             }
             // check definition contains alias ?
             if (definition.trim().indexOf('-') != 0) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.unfound.alias.in.option", definition, description), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.unfound.alias.in.option", definition, description));
             }
             // on vérifier que le nom n'est pas dupliqué
             if (optionKeyUsed.contains(key)) {
-                addError(_("lutinutil.parserdef.duplicated.option.name", key, definition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.duplicated.option.name", key, definition));
             }
             // check same number {[< to >]} in definition
             if (!StringUtil.checkEnclosure(definition, '{', '}')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.underbrace.option", definition, description), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.underbrace.option", definition, description));
             }
             if (!StringUtil.checkEnclosure(definition, '<', '>')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.lesser.option", definition, description), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.lesser.option", definition, description));
             }
             if (!StringUtil.checkEnclosure(definition, '[', ']')) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.caret.option", definition, description), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.caret.option", definition, description));
             }
-            return valid;
+            return !oldValid || valid;
         }
 
-        boolean preOptionCheck2(String[] alias, String definition, String description, int min, int max) {
-
+        boolean checkOption(String[] alias, String definition, String description, int min, int max) {
             if (alias.length > 4) {
-                addError(_("lutinutil.parserdef.too.much.alias.option", Arrays.toString(alias), definition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.too.much.alias.option", Arrays.toString(alias), definition));
             }
-
             // on vérifier que les alias commencent tous par '-' et ne sont
             // pas déjà utilisés
             for (String alia : alias) {
                 if (!alia.startsWith("-")) {
-                    addError(_("lutinutil.parserdef.unvalid.syntax.alias.option", alia, definition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.unvalid.syntax.alias.option", alia, definition));
                 }
                 if (aliaKeyUsed.contains(alia)) {
-                    addError(_("lutinutil.parserdef.duplicated.option.alias", alia, definition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.duplicated.option.alias", alia, definition));
                 }
             }
-            if (!checkCardinalite(min, max, definition, description)) {
-                unvalidate();
-            }
+            checkCardinalite(min, max, definition, description);
             return valid;
         }
 
+        @Override
         void clear() {
             super.clear();
             optionKeyUsed.clear();
             argumentKeyUsed.clear();
+            optionArgumentKeyUsed.clear();
             aliaKeyUsed.clear();
         }
     }
@@ -489,7 +447,8 @@
      *
      * @author chemit
      */
-    class OptionContext extends OptionParserUtil.ParserContext<ParserContext, OptionGroupArgumentContext> {
+    class OptionContext extends OptionDefinitionParserContext<ParserContext, OptionGroupArgumentContext> {
+
         protected final String description;
         protected final String key;
         protected final int min;
@@ -510,33 +469,27 @@
         }
 
         OptionGroupArgumentContext parseGroup(String groupDefinition) {
-            log.info('[' + groupDefinition + ']');
+            log.debug(groupDefinition);
 
             // on supprime tout espace en début ou fin de chaine de définition
             groupDefinition = groupDefinition.trim();
-
-            if (!preGroupCheck(groupDefinition)) {
+            if (!checkGroup(groupDefinition)) {
                 // check failed
                 return null;
             }
-
-            OptionGroupArgumentContext groupContext;
             boolean mandatory = groupDefinition.startsWith("<");
 
             // on supprime les délimitateurs de début et fin de chaine de définition
             groupDefinition = groupDefinition.substring(1, groupDefinition.length() - 1);
 
+            OptionGroupArgumentContext groupContext;
             groupContext = new OptionGroupArgumentContext(this, mandatory ? currentPos : -1);
 
             // on split pour obtenir la définition de chaque argument
             String[] argumentDefinitions = groupDefinition.split("\\|");
-
             for (String argumentDefinition : argumentDefinitions) {
-
-                OptionArgumentContext argumentContext = groupContext.parseArgument(argumentDefinition);
-
+                OptionArgumentContext argumentContext = groupContext.parseArgument(argumentDefinition, "", true);
                 groupContext.addSon(argumentContext);
-
                 if (!groupContext.valid) {
                     break;
                 }
@@ -544,12 +497,11 @@
             return groupContext;
         }
 
-        boolean preGroupCheck(String definition) {
+        boolean checkGroup(String definition) {
             definition = definition.trim();
             if (!(definition.startsWith("<") || definition.startsWith("[")) ||
                     !(definition.endsWith(">") || definition.endsWith("]"))) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.group.of.arguments", definition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.group.of.arguments", definition));
             }
             return valid;
         }
@@ -562,7 +514,7 @@
      *
      * @author chemit
      */
-    class OptionGroupArgumentContext extends OptionParserUtil.ParserContext<OptionContext, OptionArgumentContext> {
+    class OptionGroupArgumentContext extends OptionDefinitionParserContext<OptionContext, OptionArgumentContext> {
 
         protected final int min;
         protected final int max;
@@ -585,12 +537,16 @@
                 valueTypesFound.add(context.valueType);
             }
             // keep the key used
-            parent.parent.argumentKeyUsed.add(context.key);
+            parent.parent.optionArgumentKeyUsed.add(context.key);
         }
 
-        OptionArgumentContext parseArgument(String argumentDefinition) {
-            log.info('[' + argumentDefinition + ']');
-            OptionArgumentContext result;
+        OptionArgumentContext parseArgument(String argumentDefinition, String description, boolean fromOption) {
+            log.debug(argumentDefinition);
+
+            if (!fromOption && !checkArgumentSyntax(argumentDefinition, description)) {
+                return null;
+            }
+            OptionArgumentContext result = null;
 
             OptionArgumentType type = OptionArgumentType.findType(argumentDefinition);
 
@@ -600,7 +556,7 @@
             //contient le type (String), min(Integer), max(Integer)
             Object[] typeAndMinAndMax;
 
-            boolean mandatory = pos > -1;
+            boolean mandatory = fromOption && pos > -1;
 
             if (type == OptionArgumentType.constant) {
                 // la clef contient la cardinalite
@@ -618,89 +574,143 @@
             valueType = OptionArgumentValueType.findTypeFromDefinition((String) typeAndMinAndMax[0]);
 
             // check coherence of the new required argument definition
-            if (!preArgumentCheck(
-                    argumentDefinition,
-                    toString(),
-                    type,
-                    valueType,
-                    keyAndType[0],
+            if (checkArgument(argumentDefinition, toString(), type,
+                    valueType, keyAndType[0],
                     (Integer) typeAndMinAndMax[1],
-                    (Integer) typeAndMinAndMax[2],
-                    mandatory)) {
-                return null;
+                    (Integer) typeAndMinAndMax[2], mandatory, fromOption)) {
+                result = new OptionArgumentContext(this, type, valueType,
+                        keyAndType[0], (Integer) typeAndMinAndMax[1],
+                        (Integer) typeAndMinAndMax[2], description);
             }
-
-            result = new OptionArgumentContext(this,
-                    type,
-                    valueType,
-                    keyAndType[0],
-                    (Integer) typeAndMinAndMax[1],
-                    (Integer) typeAndMinAndMax[2]
-            );
             return result;
         }
 
-        boolean preArgumentCheck(String definition,
-                                 String groupementDefinition,
-                                 OptionArgumentType type,
-                                 OptionArgumentValueType valueType,
-                                 String key,
-                                 int min,
-                                 int max,
-                                 boolean mandatory) {
+        /**
+         * 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) {
             if (type == null) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.argument.type", definition, groupementDefinition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.argument.type", definition, groupementDefinition));
             }
             if (valueType == null) {
-                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.value.type", definition, groupementDefinition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unvalid.syntax.unknown.value.type", definition, groupementDefinition));
             }
             if (key == null) {
-                addError(_("lutinutil.parserdef.unfound.key", definition, groupementDefinition), null);
-                unvalidate();
+                addError(_("lutinutil.parserdef.unfound.key", definition, groupementDefinition));
             }
             if (!checkCardinalite(min, max, definition, groupementDefinition)) {
-                unvalidate();
+                return false;
             }
-            if (parent.parent.argumentKeyUsed.contains(key)) {
-                addError(_("lutinutil.parserdef.duplicated.argument.key", key, definition, groupementDefinition), null);
-                unvalidate();
+            // 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)) {
+                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}
-            if (type == OptionArgumentType.constant) {
+            // appliquable uniquement si c'est un argument d'option
+            if (fromOption && type == OptionArgumentType.constant) {
                 if (mandatory && !(min == 1 && max == 1)) {
-                    addError(_("lutinutil.parserdef.const.argument.mandatory.cardinalite", min, max, definition, groupementDefinition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.const.argument.mandatory.cardinalite", min, max, definition, groupementDefinition));
                 }
                 if (!mandatory && !(min == 0 && max == 1)) {
-                    addError(_("lutinutil.parserdef.const.argument.optional.cardinalite", min, max, definition, groupementDefinition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.const.argument.optional.cardinalite", min, max, definition, groupementDefinition));
                 }
             } else {
                 if (mandatory && min < 1) {
-                    addError(_("lutinutil.parserdef.argument.mandatory.cardinalite", min, max, definition, groupementDefinition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.argument.mandatory.cardinalite", min, max, definition, groupementDefinition));
                 }
                 if (!mandatory && min > 0) {
-                    addError(_("lutinutil.parserdef.argument.optional.cardinalite", min, max, definition, groupementDefinition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.argument.optional.cardinalite", min, max, definition, groupementDefinition));
                 }
             }
-
             if (type == OptionArgumentType.valued) {
-                if (((valueType == _newfile) && valueTypesFound.contains(_string)) ||
-                        ((valueType == _string) && valueTypesFound.contains(_newfile))) {
-                    addError(_("lutinutil.parserdef.string.and.newfile.in.same.group", definition, groupementDefinition), null);
-                    unvalidate();
-                }
                 // on vérifier qu'un type n'est pas dupliqué
                 if (valueTypesFound.contains(valueType)) {
-                    addError(_("lutinutil.parserdef.duplicated.argument.valued.type", valueType, definition, groupementDefinition), null);
-                    unvalidate();
+                    addError(_("lutinutil.parserdef.duplicated.argument.valued.type", valueType, definition, groupementDefinition));
+                }
+                switch (valueType) {
+                    case _boolean:
+                        break;
+                    case _class:
+                        break;
+                    case _file:
+                        // don't accept with _newfile
+                        if (valueTypesFound.contains(OptionArgumentValueType._newfile)) {
+                            // never!
+                            addError(_("lutinutil.parserdef.file.and.newfile.in.same.group", definition, groupementDefinition));
+                        }
+                        break;
+                    case _float:
+                        if (valueTypesFound.contains(OptionArgumentValueType._integer)) {
+                            // not for the moment
+                            addError(_("lutinutil.parserdef.float.and.integer.in.same.group", definition, groupementDefinition));
+                        }
+                        break;
+                    case _integer:
+                        if (valueTypesFound.contains(OptionArgumentValueType._float)) {
+                            // not for the moment
+                            addError(_("lutinutil.parserdef.float.and.integer.in.same.group", definition, groupementDefinition));
+                        }
+                        break;
+                    case _newfile:
+                        if (valueTypesFound.contains(OptionArgumentValueType._string)) {
+                            // never!
+                            addError(_("lutinutil.parserdef.string.and.newfile.in.same.group", definition, groupementDefinition));
+                        }
+                        break;
+                    case _string:
+                        if (valueTypesFound.contains(OptionArgumentValueType._newfile)) {
+                            // never!
+                            addError(_("lutinutil.parserdef.string.and.newfile.in.same.group", definition, groupementDefinition));
+                        }
+                        break;
                 }
             }
+            //TODO better to count errors
             return valid;
         }
 
@@ -718,37 +728,117 @@
      *
      * @author chemit
      */
-    class OptionArgumentContext extends OptionParserUtil.ParserContext<OptionGroupArgumentContext, OptionArgumentContext> {
+    class OptionArgumentContext extends OptionDefinitionParserContext<OptionGroupArgumentContext, OptionArgumentContext> {
 
         protected final OptionArgumentType type;
+
         protected final OptionArgumentValueType valueType;
+
         protected final int min;
+
         protected final int max;
+
         protected final String key;
 
+        protected final String description;
+
         OptionArgumentContext(OptionGroupArgumentContext parent,
                               OptionArgumentType type,
                               OptionArgumentValueType valueType,
-                              String key, Integer min, Integer max) {
+                              String key, Integer min, Integer max, String description) {
             super(parent, false);
             this.type = type;
             this.valueType = valueType;
             this.key = key;
             this.min = min;
             this.max = max;
+            this.description = description;
         }
     }
 
     /**
-     * To contain a syntax unvalid OptionDefinition.
+     * Initialise un contexte de parseur à partir d'un fichier de propriétés.
      *
-     * @author chemit
+     * @param source la source où lire les définitions (un fichier de propriétés)
+     * @return un contexte de parseur avec les définitions lues
+     * @throws java.io.IOException if any problem while reading source
      */
+    protected ParserContext initProperties(File source) throws IOException {
+        if (!source.exists()) {
+            throw new IllegalArgumentException(_("lutinutil.parserdef.unfound.source", source));
+        }
+        final String ODEFINITION_KEY_SUFFIX = ".option.definition";
+        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();
 
-    protected static class SyntaxUnvalidOptionDefinition extends OptionDefinition {
-        private SyntaxUnvalidOptionDefinition(String key, String description, String definition) {
-            super(key + " : " + definition, description, 0, 0, null, null, null);
+        // load properties file
+        Properties properties = new Properties();
+        InputStream stream = null;
+        try {
+            stream = new BufferedInputStream(new FileInputStream(source));
+            properties.load(stream);
+        } finally {
+            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()) {
+            String key = o.toString();
+            if (!key.endsWith(ODEFINITION_KEY_SUFFIX)) {
+                continue;
+            }
+            String s = key.substring(0, key.length() - ODEFINITION_KEY_PREFIX_LENGTH);
+            okeys.add(s);
+        }
+        // on trie les clefs d'options une seule fois
+        // ensuite on travaille sur cet ordre établi.
+        Collections.sort(okeys);
+
+        List<String> odefinitions = new ArrayList<String>();
+        List<String> odescriptions = new ArrayList<String>();
+
+        // récupérations des définitions et descriptions des options
+        for (String optionKey : okeys) {
+            odefinitions.add(properties.getProperty(optionKey + ODEFINITION_KEY_SUFFIX));
+            odescriptions.add(properties.getProperty(optionKey + ODESCRIPTION_KEY_SUFFIX));
+        }
+
+        // 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])
+        );
+        okeys.clear();
+        odefinitions.clear();
+        odescriptions.clear();
+        adefinitions.clear();
+        adescriptions.clear();
+        properties.clear();
+        return context;
     }
+
 }

Index: lutinutil/src/java/org/codelutin/util/OptionDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.7 lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.8
--- lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.7	Sun Dec  2 07:06:20 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinition.java	Wed Dec  5 03:03:57 2007
@@ -14,7 +14,6 @@
 package org.codelutin.util;
 
 import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
 
 /**
  * Classe qui représente la définition d'une option.
@@ -64,7 +63,7 @@
         this.max = anno.max();
         this.alias = anno.alias();
         this.impl = anno.impl();
-        OptionGroupArgumentA[] groups = anno.groups();
+        OptionParserAnnotationHelper.GroupArgumentA[] groups = anno.groups();
         this.groups = new OptionGroupArgumentDefinition[groups.length];
         for (int i = 0; i < groups.length; i++) {
             this.groups[i] = new OptionGroupArgumentDefinition(groups[i]);
@@ -138,7 +137,8 @@
         if (min == 0 && max == 1) {
             StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "", "", "", "");
         } else {
-            StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "(", ")", "[", "]");
+            StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "", " ", "[", "]");
+            //StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "(", ")", "[", "]");
         }
         if (groups.length > 0) {
             for (OptionGroupArgumentDefinition group : groups) {