Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ActionJavaGenerator.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ActionJavaGenerator.java:1.2 maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ActionJavaGenerator.java:1.3
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ActionJavaGenerator.java:1.2	Thu Jan  3 05:49:04 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ActionJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -29,7 +29,6 @@
 import java.io.File;
 import java.io.IOException;
 import static java.lang.reflect.Modifier.ABSTRACT;
-import static java.lang.reflect.Modifier.PROTECTED;
 import static java.lang.reflect.Modifier.PUBLIC;
 import java.text.FieldPosition;
 import java.text.MessageFormat;
@@ -38,7 +37,7 @@
  * Le générateur d'action.
  * <p/>
  * Utiliser la méthode
- * {@link #doGenerate(File,long,String, OptionContext , String, String, String, String, String, String, String,boolean)}
+ * {@link #doGenerate(File,long,String, OptionContext , String, String, String, String, String, String, String)}
  * <p/>
  * pour générer une nouvelle action.
  *
@@ -56,12 +55,11 @@
                                   String optionPack,
                                   String optionClass,
                                   String parserPack,
-                                  String parserClass,
-                                  boolean neddConstructor) throws IOException {
+                                  String parserClass) throws IOException {
         ActionJavaGenerator gen = new ActionJavaGenerator(out, timestamp, i18nPrefix, context,
                 pack, simpleName, superClass,
                 optionPack, optionClass,
-                parserPack, parserClass,neddConstructor
+                parserPack, parserClass
         );
         gen.generate();
     }
@@ -72,7 +70,6 @@
     protected String optionPack, parserPack;
 
     protected String optionClass, parserClass;
-     protected boolean neddConstructor;
 
     protected ActionJavaGenerator(File out,
                                   long timestamp,
@@ -84,15 +81,13 @@
                                   String optionPack,
                                   String optionClass,
                                   String parserPack,
-                                  String parserClass,
-                                  boolean neddConstructor) {
+                                  String parserClass) {
         super(out, timestamp, i18nPrefix, PUBLIC | ABSTRACT, pack, simpleName, superClass);
         this.optionClass = optionClass;
         this.parserClass = parserClass;
         this.optionPack = optionPack;
         this.parserPack = parserPack;
         this.context = context;
-        this.neddConstructor=neddConstructor;
     }
 
     protected void addContent() {
@@ -100,9 +95,8 @@
         builder.append('\n');
         registerImport(normalImports, optionPack, optionClass);
         registerImport(normalImports, parserPack, parserClass);
-        if (neddConstructor) {
-            addConstructor(null, PROTECTED, "super(parser);", null, parserClass + " parser");
-        }
+        registerImport(normalImports, parserPack, superClass);
+
         // add delegated accessor to option argumentents
         if (context.getGroups() != null) {
             for (GroupContext groupContext : context.getGroups()) {

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractJavaGenerator.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractJavaGenerator.java:1.5 maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractJavaGenerator.java:1.6
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractJavaGenerator.java:1.5	Fri Mar 14 23:41:48 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -341,7 +341,7 @@
             for (String exception : exceptions) {
                 sb.append(", ").append(exception);
             }
-            builder.append(" throws").append(sb.toString().substring(2));
+            builder.append(" throws ").append(sb.toString().substring(2));
         }
         builder.append(" {\n");
         for (String s : body.split("\n")) {

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ConfigJavaGenerator.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ConfigJavaGenerator.java:1.9 maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ConfigJavaGenerator.java:1.10
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ConfigJavaGenerator.java:1.9	Mon Feb 25 10:42:09 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/ConfigJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -38,23 +38,24 @@
 /**
  * Generateur d'implantation de Config.
  * <p/>
- * Utiliser la méthode {@link #doGenerate(File, long, String, ConfigContext, String, String, String,boolean)}
+ * Utiliser la méthode {@link #doGenerate(File, long, String, ConfigContext, String,String, String, String,String,boolean)}
  * pour générer la nouvelle config.
  *
  * @author tony
  */
 public class ConfigJavaGenerator extends AbstractJavaGenerator {
-
     public static void doGenerate(File out,
                                   long timestamp,
                                   String i18nPrefix,
                                   ConfigContext context,
+                                  String parserPack,
                                   String pack,
                                   String simpleName,
+                                  String parserSimpleName,
                                   String superClass,
                                   boolean concreteClass) throws IOException {
         ConfigJavaGenerator gen;
-        gen = new ConfigJavaGenerator(out, timestamp, i18nPrefix, context, pack, simpleName, superClass,concreteClass);
+        gen = new ConfigJavaGenerator(out, timestamp, i18nPrefix, context,parserPack, pack, simpleName, parserSimpleName, superClass,concreteClass);
         gen.generate();
     }
 
@@ -66,22 +67,32 @@
 
     protected ConfigContext context;
 
+    protected String parserPack;
+    protected String parserSimpleName;
+
     protected ConfigJavaGenerator(File out,
                                   long timestamp,
                                   String i18nPrefix,
                                   ConfigContext context,
+                                  String parserPack,
                                   String pack,
                                   String simpleName,
+                                  String parserSimpleName,
                                   String superClass,
                                   boolean concreteClass) {
         super(out, timestamp, i18nPrefix, concreteClass ? PUBLIC : ABSTRACT | PUBLIC, pack, simpleName, superClass);
         this.concreteClass=concreteClass;
         this.context = context;
+        this.parserPack=parserPack;
+        this.parserSimpleName=parserSimpleName;
     }
 
     protected void addContent() {
         registerStaticImport(staticImports, ConfigPropertyKey.class, "newConfigPropertyKey");
         registerImport(normalImports, ConfigPropertyKey.class);
+        registerImport(normalImports,parserPack, parserSimpleName);
+        registerImport(normalImports,parserPack, superClass);
+
         registerStaticImport(staticImports, I18n.class, "n_");
 
         StringBuilder staticBloc = new StringBuilder();
@@ -111,7 +122,7 @@
         // add propertec constructor (this is an abstract class)
         builder.append('\n');
         description = invokeI18N("description");
-        addConstructor(null, concreteClass ? PUBLIC : PROTECTED, "super(\"" + context.getCategory() + "\", " + description + ");", null);
+        addConstructor(null, concreteClass ? PUBLIC : PROTECTED, "super(parser ,\"" + context.getCategory() + "\", " + description + ");", null,parserSimpleName+" parser");
         // add properties typed accessors
         for (ConfigPropertyContext propertyContext : context.getContexts()) {
             generatePropertyAccessor(propertyContext);

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractActionJavaGenerator.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractActionJavaGenerator.java:1.2 maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractActionJavaGenerator.java:1.3
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractActionJavaGenerator.java:1.2	Thu Jan  3 05:49:48 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractActionJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -24,7 +24,6 @@
 import java.io.File;
 import java.io.IOException;
 import static java.lang.reflect.Modifier.ABSTRACT;
-import static java.lang.reflect.Modifier.PROTECTED;
 import static java.lang.reflect.Modifier.PUBLIC;
 import java.text.FieldPosition;
 import java.text.MessageFormat;
@@ -32,7 +31,7 @@
 /**
  * Generateur d'implantation de clef d'Option.
  * <p/>
- * Utiliser la méthode {@link #doGenerate(java.io.File,long, String, String, String, String,String)}
+ * Utiliser la méthode {@link #doGenerate(java.io.File,long, String, String, String, String, String, String, String)}
  * pour générer une nouvelle action.
  *
  * @author tony
@@ -42,13 +41,15 @@
                                   long timestamp,
                                   String i18nPrefix,
                                   String parserPack,
+                                  String contextPack,
                                   String parserSimpleName,
+                                  String contextSimpleName,
                                   String simpleName,
                                   String superClass) throws IOException {
-        String superClassWithType = superClass + "<O, " + parserSimpleName + '>';
+        String superClassWithType = superClass + "<O, " + parserSimpleName + ',' + contextSimpleName + '>';
         String simpleNameWithType = simpleName + getClassType();
         AbstractActionJavaGenerator gen;
-        gen = new AbstractActionJavaGenerator(out, timestamp, i18nPrefix, parserPack, simpleNameWithType, superClassWithType, parserSimpleName);
+        gen = new AbstractActionJavaGenerator(out, timestamp, i18nPrefix, parserPack,contextPack, simpleNameWithType, superClassWithType, parserSimpleName, contextSimpleName);
         gen.generate();
     }
 
@@ -56,34 +57,43 @@
         return "<O extends Option>";
     }
 
-    private static final MessageFormat CLASS_JAVADOC_MESSAGE = new MessageFormat("Implantation de base des actions sp\u00E9cifiques au parseur <b><code>{0}</code></b>.\n\n@author {1}\n@see {2}\n@see {3}");
+    private static final MessageFormat CLASS_JAVADOC_MESSAGE = new MessageFormat("Implantation de base des actions sp\u00E9cifiques au parseur <b><code>{0}</code></b>.\n\n@author {1}\n@see {2}\n@see {3}\n@see {4}");
 
     protected String parserSimpleName;
+    protected String contextSimpleName;
+    protected String contextPack;
 
     protected AbstractActionJavaGenerator(File out,
                                           long timestamp,
                                           String i18nPrefix,
                                           String pack,
+                                          String contextPack,
                                           String simpleName,
                                           String superClass,
-                                          String parserSimpleName) {
+                                          String parserSimpleName,
+                                          String contextSimpleName) {
         super(out, timestamp, i18nPrefix, ABSTRACT | PUBLIC, pack, simpleName, superClass);
         this.parserSimpleName = parserSimpleName;
+        this.contextSimpleName = contextSimpleName;
+        this.contextPack=contextPack;
 
     }
 
     protected void addContent() {
         // add a proptected constructor (this is an abstract class)
         registerImport(normalImports, Option.class);
-        //registerImport(normalImports, superClassWithNoType);
+        registerImport(normalImports,pack,parserSimpleName);
+        registerImport(normalImports, contextPack, contextSimpleName);
+
         builder.append('\n');
-        addConstructor(null, PROTECTED, "super(parser);", null, parserSimpleName + " parser");
+        // optionAction is now with default constructor
+        //addConstructor(null, PROTECTED, "super(parser);", null, parserSimpleName + " parser");
     }
 
     @Override
     protected String generateClassJavadoc() {
         StringBuffer sb = new StringBuffer();
-        CLASS_JAVADOC_MESSAGE.format(new Object[]{parserSimpleName, userName, superClassWithNoType, parserSimpleName}, sb, new FieldPosition(0));
+        CLASS_JAVADOC_MESSAGE.format(new Object[]{parserSimpleName, userName, superClassWithNoType, parserSimpleName, contextSimpleName}, sb, new FieldPosition(0));
         return sb.toString();
     }
 

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/OptionKeyJavaGenerator.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/java/OptionKeyJavaGenerator.java:1.2 maven-commandline-plugin/src/java/org/codelutin/option/generate/java/OptionKeyJavaGenerator.java:1.3
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/java/OptionKeyJavaGenerator.java:1.2	Thu Jan  3 05:49:48 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/OptionKeyJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -33,7 +33,7 @@
 /**
  * Generateur d'implantation de clef d'Option.
  * <p/>
- * Utiliser la méthode {@link #doGenerate(java.io.File,long, String, String, String, String, String)}
+ * Utiliser la méthode {@link #doGenerate(java.io.File,long, String, String,String,  String, String, String, String, String)}
  * pour générer une nouvelle action.
  *
  * @author tony
@@ -43,14 +43,17 @@
                                   long timestamp,
                                   String i18nPrefix,
                                   String parserPack,
+                                  String contextPack,
+                                  String optionPack,
                                   String parserSimpleName,
+                                  String contextSimpleName,
                                   String simpleName,
                                   String abstractActionSimpleName
     ) throws IOException {
-        String superClassWithType = OptionKey.class.getSimpleName() + "<O, " + parserSimpleName + ", A>";
+        String superClassWithType = OptionKey.class.getSimpleName() + "<O, " + parserSimpleName + "," + contextSimpleName + ", A>";
         String simpleNameWithType = simpleName + getClassType(abstractActionSimpleName);
         OptionKeyJavaGenerator gen;
-        gen = new OptionKeyJavaGenerator(out, timestamp, i18nPrefix, parserPack, simpleNameWithType, superClassWithType, parserSimpleName, abstractActionSimpleName);
+        gen = new OptionKeyJavaGenerator(out, timestamp, i18nPrefix, parserPack, contextPack, optionPack,simpleNameWithType, superClassWithType, parserSimpleName, contextSimpleName, abstractActionSimpleName);
         gen.generate();
     }
 
@@ -61,25 +64,42 @@
     private static final MessageFormat CLASS_JAVADOC_MESSAGE = new MessageFormat("Implantation de clef d''option sp\u00E9cifique pour le parseur <b><code>{0}</code></b>.\n\n@author {1}\n@see {2}\n@see {3}");
 
     protected String parserSimpleName;
+
+    protected String contextSimpleName;
+
     protected String abstractActionSimpleName;
+    protected String contextPack;
+    protected String actionPack;
+    protected String optionPack;
 
     protected OptionKeyJavaGenerator(File out,
                                      long timestamp,
                                      String i18nPrefix,
-                                     String pack,
+                                     String parserPack,
+                                     String contextPack,
+                                     String optionPack,
                                      String simpleName,
                                      String superClass,
                                      String parserSimpleName,
-                                     String abstractActionSimpleName) {
-        super(out, timestamp, i18nPrefix, PUBLIC, pack, simpleName, superClass);
+                                     String contextSimpleName,
+                                     String abstractActionSimpleName
+    ) {
+        super(out, timestamp, i18nPrefix, PUBLIC, parserPack, simpleName, superClass);
         this.parserSimpleName = parserSimpleName;
         this.abstractActionSimpleName = abstractActionSimpleName;
+        this.contextSimpleName = contextSimpleName;
+        this.optionPack= optionPack;
+        this.contextPack = contextPack;
+
     }
 
     protected void addContent() {
         registerImport(normalImports, Option.class);
         registerImport(normalImports, OptionKey.class);
         registerImport(normalImports, OptionDefinition.class);
+        //registerImport(normalImports, parserPack,parserSimpleName);
+        registerImport(normalImports, contextPack,contextSimpleName);
+
         // add factory static method newXXX
         String methodName = "new" + simpleNameWithNoType;
         String returnType = getClassType(abstractActionSimpleName) + " " + simpleNameWithNoType + "<O, A>";

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractContextJavaGenerator.java
diff -u /dev/null maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractContextJavaGenerator.java:1.1
--- /dev/null	Sat Mar 15 01:22:27 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractContextJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -0,0 +1,233 @@
+/*
+* ##% Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Code Lutin,
+* Tony Chemit
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+* ##% */
+package org.codelutin.option.generate.java;
+
+import org.apache.commons.lang.StringUtils;
+import org.codelutin.option.ParserException;
+import org.codelutin.option.def.ArgumentType;
+import org.codelutin.option.def.ArgumentValueType;
+import org.codelutin.option.def.DefinitionParserContexts.ArgumentContext;
+import org.codelutin.option.def.DefinitionParserContexts.ConfigContext;
+import org.codelutin.option.def.DefinitionParserContexts.GroupContext;
+import org.codelutin.option.def.DefinitionParserContexts.OptionContext;
+import org.codelutin.option.def.DefinitionParserUtil;
+
+import java.io.File;
+import java.io.IOException;
+import static java.lang.reflect.Modifier.*;
+import java.text.FieldPosition;
+import java.text.MessageFormat;
+
+/**
+ * Permet de générer un {@link org.codelutin.option.AbstractContext}  encapsulant le parser et les configurations
+ * <p/>
+ * Utiliser la méthode {@link #doGenerate(java.io.File,long, String,ConfigContext[], String, String, String,  String,String, String)}
+ * pour générer un nouveeau parseur.
+ *
+ * @author chemit
+ */
+public class AbstractContextJavaGenerator extends AbstractJavaGenerator {
+    public static void doGenerate(File out,
+                                  long timestamp,
+                                  String i18nPrefix,
+                                  ConfigContext[] ccontexts,
+                                  String pack,
+                                  String configPack,
+                                  String parserSimpleName,
+                                  String configSimpleName,
+                                  String simpleName,
+                                  String superClass) throws IOException {
+        AbstractContextJavaGenerator gen;
+        String superClassWithType = superClass + "<" + parserSimpleName + ">";
+        gen = new AbstractContextJavaGenerator(out, timestamp, i18nPrefix, ccontexts, pack, configPack, parserSimpleName, configSimpleName, simpleName, superClassWithType);
+        gen.generate();
+    }
+
+    private static final MessageFormat CLASS_JAVADOC_MESSAGE = new MessageFormat("Implantation du context d''aplication encapsulant le parseur et les configurations.\n\n@author {0}\n@see {1}");
+
+    protected String configPack;
+    protected String configSimpleName;
+    protected String parserSimpleName;
+
+    protected ConfigContext[] ccontexts;
+
+    protected AbstractContextJavaGenerator(File out,
+                                           long timestamp,
+                                           String i18nPrefix,
+                                           ConfigContext[] ccontexts,
+                                           String pack,
+                                           String configPack,
+                                           String parserSimpleName,
+                                           String configSimpleName,
+                                           String simpleName,
+                                           String superClass) {
+        super(out, timestamp, i18nPrefix, PUBLIC | ABSTRACT, pack, simpleName, superClass);
+        this.configPack = configPack;
+        this.parserSimpleName = parserSimpleName;
+        this.configSimpleName = configSimpleName;
+        this.ccontexts = ccontexts;
+
+    }
+
+    protected void addContent() {
+        registerImport(normalImports, IOException.class);
+        registerImport(normalImports, ParserException.class);
+
+        builder.append('\n');
+        addConstructor(null, PROTECTED, "super(args);", new String[]{IOException.class.getSimpleName(), ParserException.class.getSimpleName()}, "String[] args");
+
+        // add parser accessor
+        generateParserAccessor();
+
+        // add configs shared instances accessors
+        for (ConfigContext context : ccontexts) {
+            generateConfigAccessor(context);
+            String key = context.getCategory();
+            if (key.equals("main")) {
+                // register as main config
+                String mainConfig = configSimpleName + "Main";
+                String javadoc = generateMainConfigAccessorJavadoc(mainConfig);
+                addMethod(mainConfig, "getConfig", javadoc, PUBLIC, "return getMainConfig();", null);
+            }
+        }
+    }
+
+    protected void generateParserAccessor() {
+
+        String javadoc = generateParserAccessorJavadoc(parserSimpleName);
+
+        addMethod(parserSimpleName, "getParser", javadoc, PUBLIC, "return parser==null?parser=new " + parserSimpleName + "():parser;", null);
+    }
+
+    protected void generateMainConfigAccessor() {
+
+        String javadoc = generateParserAccessorJavadoc(parserSimpleName);
+        String methodName = "getConfig";
+
+        addMethod(parserSimpleName, methodName, javadoc, PUBLIC, "return parser==null?parser=new " + parserSimpleName + "():parser;", null);
+    }
+
+    protected void generateConfigAccessor(ConfigContext context) {
+        String key = context.getCategory();
+
+        String suffix = StringUtils.capitalize(key);
+        String methodName = "get" + suffix + "Config";
+        String abstractClass = configSimpleName + suffix;
+        registerImport(normalImports, configPack, abstractClass);
+
+        String javadoc = generateConfigAccessorJavadoc(parserSimpleName + "#" + methodName + "()", key);
+
+        addMethod(abstractClass, methodName, javadoc, PUBLIC, "return getParser()." + methodName + "();", null);
+
+    }
+
+    @Override
+    protected String generateClassJavadoc() {
+        StringBuffer sb = new StringBuffer();
+        CLASS_JAVADOC_MESSAGE.format(new Object[]{userName, superClass}, sb, new FieldPosition(0));
+        return sb.toString();
+    }
+
+    protected String generateConfigAccessorJavadoc(String abstractClass, String key) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Accesseur typ\u00E9 de l'instance partag\u00E9e de la configuration de cat\u00E9gorie <b><code>").append(key).append("</code></b>\n(implantantion abstraite dans la classe <b><code>");
+        sb.append(abstractClass).append("</code></b>)\n.");
+        sb.append("\n\n@return l'unique instance parta\u00E9e de la configuration de cat\u00E9gorie <b><code>").append(key).append("</code></b>");
+        sb.append("\n@see ").append(abstractClass).append('\n');
+        return sb.toString();
+    }
+
+    protected String generateMainConfigAccessorJavadoc(String abstractClass) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Accesseur typ\u00E9 de l'instance partag\u00E9e de la configuration principale.");
+            sb.append("\n\n@return la configuration principale");
+            sb.append("\n@see ").append(abstractClass).append('\n');
+            return sb.toString();
+        }
+
+    protected String generateParserAccessorJavadoc(String abstractClass) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Accesseur typ\u00E9 de l'instance partag\u00E9e du parseur <b><code>").append(abstractClass).append("</code></b>.");
+        sb.append("\n\n@return l'unique instance parta\u00E9e du parseur.");
+        sb.append("\n@see ").append(abstractClass).append('\n');
+        return sb.toString();
+    }
+
+    private final static MessageFormat OPTION_BEGIN = new MessageFormat("// option {0}/{1} : {2}\n");
+
+    /**
+     * A walker to generate the content of <code>buildDefinition(OptionDefinitionBuilder)</code>
+     * method.
+     *
+     * @author chemit
+     */
+    class ToInitMethodSourceWalker extends DefinitionParserUtil.DefinitionParserWalker {
+
+        protected StringBuilder builder;
+
+        public String doWalk(OptionContext[] ocontexts) {
+            this.builder = new StringBuilder();
+            invokeBuilderMethod("beginBuilder", ocontexts.length);
+            walk(ocontexts);
+            invokeBuilderMethod("endBuilder");
+            return builder.toString();
+        }
+
+        @Override
+        protected void enterOption(OptionContext option, int optionIndex) {
+            StringBuffer sb = new StringBuffer();
+            OPTION_BEGIN.format(new Object[]{optionIndex + 1, option.getParent().getContexts().size(), option.getKey()}, sb, new FieldPosition(0));
+            builder.append(sb.toString());
+            invokeBuilderMethod("beginOption", option.getContexts().size());
+        }
+
+        @Override
+        protected void exitOption(OptionContext option, int optionIndex) {
+            invokeBuilderMethod("endOption", option.getKey(), option.getMin(), option.getMax(), option.getAlias());
+        }
+
+
+        @Override
+        protected void enterGroup(GroupContext group, int groupIndex) {
+            invokeBuilderMethod("beginGroup", group.getContexts().size());
+        }
+
+        @Override
+        protected void exitGroup(GroupContext group, int groupIndex) {
+            invokeBuilderMethod("endGroup", group.getPos());
+        }
+
+        @Override
+        protected void enterArgument(ArgumentContext argument, int argumentIndex) {
+            ArgumentType type = argument.getType();
+            if (type == ArgumentType.constant) {
+                invokeBuilderMethod("addConstantArgument", argument.getKey(), argument.getMin());
+            } else {
+                ArgumentValueType valueType = argument.getValueType();
+                registerStaticImport(staticImports, ArgumentType.class, type + "");
+                registerStaticImport(staticImports, ArgumentValueType.class, valueType + "");
+                invokeBuilderMethod("addArgument", type, valueType, argument.getKey(), argument.getMin(), argument.getMax());
+            }
+        }
+
+        private void invokeBuilderMethod(String methodName, Object... params) {
+            invokeMethod(builder, "builder", methodName, params);
+        }
+    }
+}
\ No newline at end of file

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractConfigJavaGenerator.java
diff -u /dev/null maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractConfigJavaGenerator.java:1.1
--- /dev/null	Sat Mar 15 01:22:27 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/java/AbstractConfigJavaGenerator.java	Sat Mar 15 01:22:22 2008
@@ -0,0 +1,132 @@
+/* 
+* ##% Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Code Lutin,
+* Tony Chemit
+*
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+* ##% */
+package org.codelutin.option.generate.java;
+
+import org.codelutin.option.ConfigPropertyKey;
+import org.codelutin.option.def.DefinitionParserContexts;
+
+import java.io.File;
+import java.io.IOException;
+import static java.lang.reflect.Modifier.*;
+import java.text.FieldPosition;
+import java.text.MessageFormat;
+
+/**
+ * Generateur d'implantation de classe de base de config.
+ * <p/>
+ * Utiliser la méthode
+ * {@link #doGenerate(java.io.File,long, String, DefinitionParserContexts.ConfigContext[], String, String,String, String, String,String, String,String,  String,String,String)}
+ * pour générer une nouvelle action.
+ *
+ * @author tony
+ */
+public class AbstractConfigJavaGenerator extends AbstractJavaGenerator {
+    public static void doGenerate(File out,
+                                  long timestamp,
+                                  String i18nPrefix,
+                                  DefinitionParserContexts.ConfigContext[] ccontexts,
+                                  String parserPack,
+                                  String contextPack,
+                                  String optionPack,
+                                  String parserSimpleName,
+                                  String contextSimpleName,
+                                  String optionKeySimpleName,
+                                  String simpleName,
+                                  String superClass,
+                                  String configOptionKey,
+                                  String configFileOptionKey,
+                                  String filenameOptionKey) throws IOException {
+        String superClassWithType = superClass + '<' + parserSimpleName + ", " + contextSimpleName + ", " + optionKeySimpleName + '>';
+        AbstractConfigJavaGenerator gen;
+        gen = new AbstractConfigJavaGenerator(out, timestamp, i18nPrefix, ccontexts, parserPack,contextPack,optionPack,  simpleName, superClassWithType, parserSimpleName, contextSimpleName, optionKeySimpleName, configOptionKey, configFileOptionKey, filenameOptionKey);
+        gen.generate();
+    }
+
+    private static final MessageFormat CLASS_JAVADOC_MESSAGE = new MessageFormat("Implantation de base des configurations sp\u00E9cifiques a l''application au parseur <b><code>{0}</code></b>.\n\n@author {1}\n@see {2}\n@see {3}\n@see {4}");
+
+
+    protected String parserSimpleName;
+
+    protected String contextSimpleName;
+
+    protected String optionKeySimpleName;
+    protected DefinitionParserContexts.ConfigContext[] ccontexts;
+    protected String filenameOptionKey;
+    protected String configOptionKey;
+    protected String configFileOptionKey;
+    protected String contextPack;
+
+    protected String optionPack;
+
+
+    protected AbstractConfigJavaGenerator(File out,
+                                          long timestamp,
+                                          String i18nPrefix,
+                                          DefinitionParserContexts.ConfigContext[] ccontexts,
+                                          String pack,
+                                          String contextPack,
+                                          String optionPack,
+                                          String simpleName,
+                                          String superClass,
+                                          String parserSimpleName,
+                                          String contextSimpleName,
+                                          String optionKeySimpleName,
+                                          String configOptionKey,
+                                          String configFileOptionKey,
+                                          String filenameOptionKey) {
+        super(out, timestamp, i18nPrefix, ABSTRACT | PUBLIC, pack, simpleName, superClass);
+        this.parserSimpleName = parserSimpleName;
+        this.contextSimpleName = contextSimpleName;
+        this.optionKeySimpleName = optionKeySimpleName;
+        this.ccontexts = ccontexts;
+        this.configOptionKey = configOptionKey;
+        this.configFileOptionKey = configFileOptionKey;
+        this.filenameOptionKey = filenameOptionKey;
+
+        this.contextPack=contextPack;
+        this.optionPack=optionPack;
+
+    }
+
+    protected void addContent() {
+        // add a proptected constructor (this is an abstract class)
+        registerImport(normalImports, ConfigPropertyKey.class);
+        registerImport(normalImports, File.class);
+        //registerImport(normalImports, superClassWithNoType);
+        registerImport(normalImports, pack,parserSimpleName);
+        registerImport(normalImports, pack,optionKeySimpleName);
+        registerImport(normalImports, contextPack,contextSimpleName);
+        registerImport(normalImports, pack, optionKeySimpleName);
+        builder.append('\n');
+        addConstructor(null, PUBLIC, "super(parser, category, description);", null, parserSimpleName + " parser", "String category", "String description");
+
+        addMethod(optionKeySimpleName, "getConfigOptionKey", null, PROTECTED, "return " + parserSimpleName + "." + configOptionKey + ";", null);
+        addMethod(optionKeySimpleName, "getConfigFileOptionKey", null, PROTECTED, "return " + parserSimpleName + "." + configFileOptionKey + ";", null);
+        addMethod("ConfigPropertyKey<File>", "getFileNameConfigKey", null, PROTECTED, "return " + filenameOptionKey + ";", null);
+    }
+
+    @Override
+    protected String generateClassJavadoc() {
+        StringBuffer sb = new StringBuffer();
+        CLASS_JAVADOC_MESSAGE.format(new Object[]{parserSimpleName, userName, superClassWithNoType, parserSimpleName, contextSimpleName}, sb, new FieldPosition(0));
+        return sb.toString();
+    }
+
+}
\ No newline at end of file