/**
    * Redistribution and use of this software and associated documentation ("Software"), with or
    * without modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright statements and notices. Redistributions
    * must also contain a copy of this document.
    *
    * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
    * conditions and the following disclaimer in the documentation and/or other materials provided with
   * the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote products derived from this Software
   * without prior written permission of Intalio, Inc. For written permission, please contact
   * info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab" nor may "Exolab" appear in
   * their names without prior written permission of Intalio, Inc. Exolab is a registered trademark of
   * Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR
   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTALIO, INC. OR ITS
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
   * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 1999-2003 (C) Intalio, Inc. All Rights Reserved.
   *
   * This file was originally developed by Keith Visco during the course of employment at Intalio Inc.
   * All portions of this file developed by Keith Visco after Jan 19 2005 are Copyright (C) 2005 Keith
   * Visco. All Rights Reserved.
   *
   * $Id$
   */
  package org.exolab.castor.builder;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.Properties;
  import java.util.Vector;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.castor.core.exceptions.CastorRuntimeException;
  import org.castor.xml.BackwardCompatibilityContext;
  import org.castor.xml.InternalContext;
  import org.exolab.castor.builder.binding.BindingException;
  import org.exolab.castor.builder.binding.BindingLoader;
  import org.exolab.castor.builder.binding.ExtendedBinding;
  import org.exolab.castor.builder.binding.XMLBindingComponent;
  import org.exolab.castor.builder.binding.XPathHelper;
  import org.exolab.castor.builder.binding.xml.PackageType;
  import org.exolab.castor.builder.binding.xml.PackageTypeChoice;
  import org.exolab.castor.builder.binding.xml.types.BindingType;
  import org.exolab.castor.builder.conflict.strategy.ClassNameConflictResolver;
  import org.exolab.castor.builder.conflict.strategy.TypeClassNameConflictResolver;
  import org.exolab.castor.builder.conflict.strategy.XPATHClassNameConflictResolver;
  import org.exolab.castor.builder.conflictresolution.WarningViaDialogClassNameCRStrategy;
  import org.exolab.castor.builder.factory.FieldInfoFactory;
  import org.exolab.castor.builder.factory.SourceFactory;
  import org.exolab.castor.builder.info.ClassInfo;
  import org.exolab.castor.builder.printing.JClassPrinter;
  import org.exolab.castor.builder.printing.JClassPrinterFactory;
  import org.exolab.castor.builder.printing.JClassPrinterFactoryRegistry;
  import org.exolab.castor.mapping.xml.MappingRoot;
  import org.exolab.castor.util.NestedIOException;
  import org.exolab.castor.util.Version;
  import org.exolab.castor.util.dialog.ConsoleDialog;
  import org.exolab.castor.xml.Marshaller;
  import org.exolab.castor.xml.ValidationException;
  import org.exolab.castor.xml.XMLException;
  import org.exolab.castor.xml.schema.AttributeDecl;
  import org.exolab.castor.xml.schema.ComplexType;
  import org.exolab.castor.xml.schema.ContentModelGroup;
  import org.exolab.castor.xml.schema.ContentType;
  import org.exolab.castor.xml.schema.ElementDecl;
  import org.exolab.castor.xml.schema.Facet;
  import org.exolab.castor.xml.schema.Group;
  import org.exolab.castor.xml.schema.ModelGroup;
  import org.exolab.castor.xml.schema.Particle;
  import org.exolab.castor.xml.schema.Schema;
  import org.exolab.castor.xml.schema.SchemaContext;
  import org.exolab.castor.xml.schema.SchemaContextImpl;
  import org.exolab.castor.xml.schema.SimpleContent;
  import org.exolab.castor.xml.schema.SimpleType;
  import org.exolab.castor.xml.schema.Structure;
  import org.exolab.castor.xml.schema.XMLType;
  import org.exolab.castor.xml.schema.reader.Sax2ComponentReader;
  import org.exolab.castor.xml.schema.reader.SchemaUnmarshaller;
 import org.exolab.javasource.JClass;
 import org.xml.sax.InputSource;
 import org.xml.sax.Parser;
 import org.xml.sax.SAXParseException;
 
 /**
  * A Java Source generation tool which uses XML Schema definitions to create an Object model.
  *
  * @author <a href="mailto:kvisco@intalio.com">Keith Visco</a> - Main author.
  * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a> - Contributions.
  * @author <a href="mailto:nsgreen@thazar.com">Nathan Green</a> - Contributions.
  * @version $Revision$ $Date: 2006-03-30 14:58:45 -0700 (Thu, 30 Mar 2006) $
  */
 public class SourceGenerator extends BuilderConfiguration {
 
   /** Jakarta's common-logging logger. */
   private static final Log LOG = LogFactory.getLog(SourceGenerator.class);
 
   // -------------/
   // - Constants -/
   // -------------/
   /** The application name. */
   static final String APP_NAME = "Castor";
   /** The application description. */
   static final String APP_DESC = "XML data binder for Java";
   /** The application version. */
   static final String VERSION = Version.VERSION;
   /** The application URI. */
   static final String APP_URI = "http://www.castor.org";
   /** Warning message to remind users to create source code for imported schema. */
   private static final String IMPORT_WARNING =
       "Note: No code will be generated for the following *imported* schema: ";
 
   // ----------------------/
   // - Instance Variables -/
   // ----------------------/
 
   /** Castor internal context - mother of all. */
   private final InternalContext _internalContext;
   /** The XMLBindingComponent used to create Java classes from an XML Schema. */
   private final XMLBindingComponent _bindingComponent;
   /** Our object used to generate source for a single source file. */
   private final SingleClassGenerator _singleClassGenerator;
   /** The field info factory. */
   private final FieldInfoFactory _infoFactory;
   /** Allows us to ask the user questions. */
   private final ConsoleDialog _dialog;
   /** A vector that keeps track of all the schemas processed. */
   private final Vector<Schema> _schemasProcessed = new Vector<Schema>(7);
 
   /** True if we should suppress non-fatal warnings. */
   private boolean _suppressNonFatalWarnings = false;
   /** Determines whether or not to print extra messages. */
   private boolean _verbose = false;
 
   /**
    * A flag indicating whether or not to create XML-specific class descriptors for the generated
    * classes.
    */
   private boolean _createDescriptors = true;
   /**
    * A flag indicating whether or not to create JDO-specific class descriptors for the generated
    * classes.
    */
   private boolean _createJdoDescriptors = false;
 
   /**
    * A flag indicating whether or not to generate sources for imported XML Schemas.
    */
   private boolean _generateImported = false;
   /** The source factory. */
   private SourceFactory _sourceFactory = null;
   /** A flag to indicate that the mapping file should be generated. */
   private boolean _generateMapping = false;
   /** The name of the mapping file to create used with the gen-mapping flag. */
   private String _mappingFilename = "mapping.xml";
   /**
    * A flag indicating whether or not to generate XML marshalling framework specific methods.
    */
   private boolean _createMarshalMethods = true;
   /**
    * A flag indicating whether or not to implement CastorTestable (used by the Castor Testing
    * Framework).
    */
   private boolean _testable = false;
   /** A flag indicating that SAX1 should be used when generating the source. */
   private boolean _sax1 = false;
   /**
    * A flag indicating that enumerated types should be constructed to perform case insensitive
    * lookups based on the values.
    */
   private boolean _caseInsensitive = false;
   /**
    * A flag indicating, if true, that source generation should fail on the first error.
    */
   private boolean _failOnFirstError = false;
   /** A GroupNaming helper class used to named anonymous groups. */
   private GroupNaming _groupNaming = null;
   /** Strategy for name conflict resolution. */
   private String _nameConflictStrategy = WarningViaDialogClassNameCRStrategy.NAME;
   /** JClass to XPATH registry, used for class name conflict resolution. */
   private JClassRegistry _xmlInfoRegistry;
 
   /**
    * Strategy implementation for resolving class name conflicts.
    */
   private ClassNameConflictResolver _conflictResolver = new XPATHClassNameConflictResolver();
 
   /**
    * The default type of the {@link JClassPrinterFactory} to use for instantiating instances of
    * {@link JClassPrinter} instances.
    */
   private String _jclassPrinterType = "standard";
 
   /**
    * {@link JClassPrinterFactoryRegistry} instance to be used for obtaining instances of
    * {@link JClassPrinterFactory} instances.
    */
   private JClassPrinterFactoryRegistry _jclassPrinterFactoryRegistry;
 
   protected SGStateInfo _sInfo;
 
   /**
    * Creates a SourceGenerator using the default FieldInfo factory.
    */
   public SourceGenerator() {
     this(null);
   } // -- SourceGenerator
 
   /**
    * Creates a SourceGenerator using the specific field info Factory.
    *
    * @param infoFactory the FieldInfoFactory to use.
    */
   public SourceGenerator(final FieldInfoFactory infoFactory) {
     this(infoFactory, null);
   }
 
   /**
    * Creates a SourceGenerator using the specific field info Factory and the given Binding element.
    *
    * @param infoFactory the FieldInfoFactory to use.
    * @param binding the binding element to use.
    */
   public SourceGenerator(final FieldInfoFactory infoFactory, final ExtendedBinding binding) {
     super();
 
     _internalContext = new BackwardCompatibilityContext();
 
     setJavaNaming(_internalContext.getJavaNaming());
     _dialog = new ConsoleDialog();
     if (infoFactory == null) {
       if (useOldFieldNaming()) {
         _infoFactory = new FieldInfoFactory();
       } else {
         _infoFactory = new FieldInfoFactory(false);
       }
     } else {
       _infoFactory = infoFactory;
     }
 
     super.load();
 
     _groupNaming = new GroupNaming(getJavaNaming());
 
     _jclassPrinterFactoryRegistry = new JClassPrinterFactoryRegistry(this);
     _singleClassGenerator =
         new SingleClassGenerator(_dialog, this, _nameConflictStrategy, _jclassPrinterType);
     _bindingComponent = new XMLBindingComponent(this, _groupNaming);
     setBinding(binding);
 
     _conflictResolver.setSourceGenerator(this);
     _xmlInfoRegistry = new JClassRegistry(_conflictResolver, getJavaNaming());
   } // -- SourceGenerator
 
   /**
    * Returns the selected {@link JClassPrinter} type, as defined by the list of
    * {@link JClassPrinterFactory} instances enlisted in the Castor XML code generator property file.
    * 
    * @return the selected {@link JClassPrinter} type.
    */
   private String getJClassPrinterType() {
     return _jclassPrinterType;
   }
 
   /**
    * Sets the filename of the mapping file.
    * 
    * @param filename filename of the mapping file
    */
   public final void setMappingFilename(final String filename) {
     _mappingFilename = filename;
   }
 
   /**
    * Sets the strategy for handling name conflicts.
    *
    * @param nameConflictStrategy the name of the stretegy to use for handling name conflicts.
    */
   public final void setNameConflictStrategy(final String nameConflictStrategy) {
     _nameConflictStrategy = nameConflictStrategy;
     _singleClassGenerator.setNameConflictStrategy(nameConflictStrategy);
   }
 
   /**
    * Returns the version number of this SourceGenerator.
    *
    * @return the version number of this SourceGenerator
    */
   public static String getVersion() {
     return VERSION;
   } // -- getVersion
 
   /**
    * Set to true if SAX1 should be used in the marshal method.
    * 
    * @param sax1 true if SAX1 should be used in the marshal method
    */
   public final void setSAX1(final boolean sax1) {
     _sax1 = sax1;
   }
 
   /**
    * Set to true if enumerated type lookups should be performed in a case insensitive manner.
    *
    * @param caseInsensitive when true, enumerated type lookups will be performed in a case
    *        insensitive manner.
    */
   public final void setCaseInsensitive(final boolean caseInsensitive) {
     _caseInsensitive = caseInsensitive;
   }
 
   /**
    * If true, the source generator will fail on the first error encountered. Otherwise, the source
    * generator will continue on certain errors.
    *
    * @param failOnFirstError if true, the source generator will fail on the first error encountered.
    */
   public final void setFailOnFirstError(final boolean failOnFirstError) {
     _failOnFirstError = failOnFirstError;
   }
 
   /**
    * Sets whether or not to suppress non-fatal warnings encountered during source generation.
    * 
    * @param suppress true if non-fatal warnings should be suppressed.
    */
   public final void setSuppressNonFatalWarnings(final boolean suppress) {
     _singleClassGenerator.setPromptForOverwrite(!suppress);
     _suppressNonFatalWarnings = suppress;
   } // -- setSuppressNonFatalWarnings
 
   /**
    * Sets whether or not the source code generator prints additional messages during generating
    * source code.
    *
    * @param verbose a boolean, when true indicates to print additional messages
    */
   public void setVerbose(final boolean verbose) {
     _verbose = verbose;
   } // -- setVerbose
 
   /**
    * Sets the ClassNameConflictResolver instance to be used for automatic class name conflict
    * resolution.
    *
    * @param resolverName The name of the resolver to be used for automatic class name conflict
    *        resolution
    */
   public void setClassNameConflictResolver(final String resolverName) {
     if (resolverName.equals("type")) {
       _conflictResolver = new TypeClassNameConflictResolver();
       _conflictResolver.setSourceGenerator(this);
     } else if (resolverName.equals("xpath")) {
       // leave default
     } else {
       throw new IllegalArgumentException("Invalid resolver type.");
     }
     _xmlInfoRegistry.setClassNameConflictResolver(_conflictResolver);
   } // -- setClassNameConflictResolver
 
   /**
    * Sets whether or not to create ClassDescriptors for the generated classes. By default,
    * descriptors are generated.
    *
    * @param createDescriptors a boolean, when true indicates to generated ClassDescriptors
    *
    */
   public final void setDescriptorCreation(final boolean createDescriptors) {
     _createDescriptors = createDescriptors;
     _singleClassGenerator.setDescriptorCreation(createDescriptors);
   } // -- setDescriptorCreation
 
   /**
    * Sets whether or not to create JDO-specific class descriptors for the generated classes. By
    * default, JDO-specific class descriptors are NOT generated.
    *
    * @param createJdoDescriptors a boolean, when true indicates to generated JDO-specific class
    *        descriptors
    *
    */
   public final void setJdoDescriptorCreation(final boolean createJdoDescriptors) {
     _createJdoDescriptors = createJdoDescriptors;
     _singleClassGenerator.setJdoDescriptorCreation(createJdoDescriptors);
   } // -- setDescriptorCreation
 
   /**
    * Sets the destination directory.
    *
    * @param destDir the destination directory.
    */
   public final void setDestDir(final String destDir) {
     _singleClassGenerator.setDestDir(destDir);
   }
 
   /**
    * Sets the destination directory for resources, e.g. '.castor.cdr' files.
    *
    * @param destDir the destination directory for resources.
    */
   public final void setResourceDestination(final String destination) {
     _singleClassGenerator.setResourceDestinationDirectory(destination);
   }
 
   /**
    * Sets whether or not to create the XML marshaling framework specific methods (marshal,
    * unmarshal, validate) in the generated classes. By default, these methods are generated.
    *
    * @param createMarshalMethods a boolean, when true indicates to generated the marshaling
    *        framework methods
    */
   public final void setCreateMarshalMethods(final boolean createMarshalMethods) {
     _createMarshalMethods = createMarshalMethods;
   } // -- setCreateMarshalMethods
 
   /**
    * Sets whether or not to generate Java sources for imported XML Schema. By default Java sources
    * for imported XML schemas are not generated.
    *
    * @param generate true to generate the java classes for the imported XML Schema
    */
   public final void setGenerateImportedSchemas(final boolean generate) {
     _generateImported = generate;
   }
 
   /**
    * Sets whether or not a mapping file should be generated, this is false by default. Note that
    * this will only be used when generation of descriptors has been disabled.
    *
    * @param generateMapping a flag that indicates whether or not a mapping file should be generated.
    */
   public final void setGenerateMappingFile(final boolean generateMapping) {
     _generateMapping = generateMapping;
   } // -- setGenerateMappingFile
 
   /**
    * Sets whether or not to implement CastorTestable.
    *
    * @param testable a boolean, when true indicates to implement CastorTestable
    */
   public final void setTestable(final boolean testable) {
     _testable = testable;
   } // -- setTestable
 
   /**
    * Sets the binding to use with this instance of the SourceGenerator.
    *
    * @param binding the binding to use, null indicates that the default binding will be used.
    */
   public final void setBinding(final ExtendedBinding binding) {
     if (binding != null) {
       processNamespaces(binding.getPackage());
     }
     // --initialize the XMLBindingComponent
     _bindingComponent.setBinding(binding);
   } // -- setBinding
 
   /**
    * Sets the binding to use given the path name of a Castor Binding File.
    *
    * @param fileName the file that represents a Binding
    */
   public final void setBinding(final String fileName) {
     try {
       ExtendedBinding binding = BindingLoader.createBinding(fileName);
       setBinding(binding);
     } catch (BindingException e) {
       String err = "Unable to load a binding file due to the following:\n" + e.getMessage()
           + "\nThe Source Generator will continue with no binding file.";
       _dialog.notify(err);
     }
   }
 
   /**
    * Sets the binding to use given an InputSource identifying a Castor Binding File.
    *
    * @param source an InputSource identifying a Castor Binding File.
    */
   public final void setBinding(final InputSource source) {
     try {
       ExtendedBinding binding = BindingLoader.createBinding(source);
       setBinding(binding);
     } catch (BindingException e) {
       String err = "unable to load a binding file due to the following:\n" + e.getMessage()
           + "\nThe Source Generator will continue with no binding file.";
       _dialog.notify(err);
     }
   }
 
   /**
    * Sets the line separator to use when printing the source code.
    * <p>
    * <B>Note:</B>This can be any string, so be careful. I recommend either using the default or
    * using one of the following:
    *
    * <PRE>
    * windows systems use: "\r\n"
    * unix systems use: "\n"
    * mac systems use: "\r"
    * </PRE>
    *
    * @param lineSeparator the line separator to use when printing the source code. This method is
    *        useful if you are generating source on one platform, but will be compiling the source on
    *        a different platform.
    */
   public final void setLineSeparator(final String lineSeparator) {
     _singleClassGenerator.setLineSeparator(lineSeparator);
   } // -- setLineSeparator
 
   /**
    * Tests the org.exolab.castor.builder.javaclassmapping property for the 'element' value.
    *
    * @return True if the Source Generator is mapping schema elements to Java classes.
    */
   public final boolean mappingSchemaElement2Java() {
     if (_bindingComponent != null) {
       ExtendedBinding binding = _bindingComponent.getBinding();
       if (binding != null) {
         BindingType type = binding.getDefaultBindingType();
         if (type != null) {
           return (type == BindingType.ELEMENT);
         }
       }
     }
     return super.mappingSchemaElement2Java();
   } // -- mappingSchemaElement2Java
 
   /**
    * Tests the org.exolab.castor.builder.javaclassmapping property for the 'type' value.
    *
    * @return True if the Source Generator is mapping schema types to Java classes.
    */
   public final boolean mappingSchemaType2Java() {
     if (_bindingComponent != null) {
       ExtendedBinding binding = _bindingComponent.getBinding();
       if (binding != null) {
         BindingType type = binding.getDefaultBindingType();
         if (type != null) {
           return (type == BindingType.TYPE);
         }
       }
     }
     return super.mappingSchemaType2Java();
   } // -- mappingSchemaType2Java
 
   /**
    * Creates Java Source code (Object model) for the given XML Schema. If the file exists, opens a
    * FileReader and passes control to {@link #generateSource(InputSource, String)}.
    *
    * @param filename the full path to the XML Schema definition
    * @param packageName the package for the generated source files
    * @throws IOException if an IOException occurs writing the new source files
    */
   public final void generateSource(final String filename, final String packageName)
       throws IOException {
     final File schemaFile;
     if (filename.startsWith("./")) {
       schemaFile = new File(filename.substring(2));
     } else {
       schemaFile = new File(filename);
     }
 
     FileReader reader = new FileReader(schemaFile);
 
     try {
       InputSource source = new InputSource(reader);
       source.setSystemId(toURIRepresentation(schemaFile.getAbsolutePath()));
       generateSource(source, packageName);
     } finally {
       try {
         reader.close();
       } catch (java.io.IOException iox) {
         // ignore
       }
     }
   } // -- generateSource
 
   /**
    * Creates Java Source code (Object model) for the given XML Schema. This method just passes
    * control to {@link #generateSource(InputSource, String)}.
    *
    * @param reader the Reader with which to read the XML Schema definition. The caller should close
    *        the reader, since thie method will not do so.
    * @param packageName the package for the generated source files
    * @throws IOException if an IOException occurs writing the new source files
    */
   public final void generateSource(final Reader reader, final String packageName)
       throws IOException {
     InputSource source = new InputSource(reader);
     generateSource(source, packageName);
   } // -- generateSource
 
   /**
    * Creates Java Source code (Object model) for the given XML Schema. Parses the schema provided by
    * the InputSource and then calls {@link #generateSource(Schema, String)} to actually generate the
    * source.
    *
    * @param source - the InputSource representing the XML schema.
    * @param packageName the package for the generated source files
    * @throws IOException if an IOException occurs writing the new source files
    */
   public void generateSource(final InputSource source, final String packageName)
       throws IOException {
     // -- get default parser from Configuration
     Parser parser = null;
     try {
       parser = _internalContext.getParser();
     } catch (RuntimeException rte) {
       // ignore
     }
 
     if (parser == null) {
       _dialog.notify("fatal error: unable to create SAX parser.");
       return;
     }
 
     SchemaContext schemaContext = new SchemaContextImpl();
     SchemaUnmarshaller schemaUnmarshaller = null;
     try {
       schemaUnmarshaller = new SchemaUnmarshaller(schemaContext);
     } catch (XMLException e) {
       // --The default constructor cannot throw exception so this should never happen
       // --just log the exception
       e.printStackTrace();
       System.exit(1);
     }
 
     Sax2ComponentReader handler = new Sax2ComponentReader(schemaUnmarshaller);
     parser.setDocumentHandler(handler);
     parser.setErrorHandler(handler);
 
     try {
       parser.parse(source);
     } catch (java.io.IOException ioe) {
       _dialog.notify("error reading XML Schema file");
       if (_failOnFirstError) {
         throw ioe;
       }
       return;
     } catch (org.xml.sax.SAXException sx) {
       Exception except = sx.getException();
       if (except == null) {
         except = sx;
       }
 
       if (except instanceof SAXParseException) {
         SAXParseException spe = (SAXParseException) except;
         _dialog.notify("SAXParseException: " + spe);
         _dialog.notify(" - occured at line ");
         _dialog.notify(Integer.toString(spe.getLineNumber()));
         _dialog.notify(", column ");
         _dialog.notify(Integer.toString(spe.getColumnNumber()));
       } else {
         except.printStackTrace();
       }
       if (_failOnFirstError) {
         String msg = "Source Generator: schema parser threw an Exception";
         throw new CastorRuntimeException(msg, sx);
       }
       return;
     }
 
     Schema schema = schemaUnmarshaller.getSchema();
 
     try {
       schema.validate();
     } catch (ValidationException vx) {
       throw new NestedIOException(vx);
     }
 
     generateSource(schema, packageName);
   } // -- generateSource
 
   /**
    * Creates Java Source code (Object model) for the given XML Schema. Convenience methods exist if
    * you don't have a {@link org.exolab.castor.xml.schema.Schema} already parsed.
    *
    * @param schema the XML schema to generate the Java sources for.
    * @param packageName the package for the generated source files.
    * @throws IOException if this Exception occurs while generating source
    * @see #generateSource(String, String) to provide the schema filename
    * @see #generateSource(Reader, String) to provide a Reader for the schema
    * @see #generateSource(InputSource, String) to provide an InputSource for the schema
    */
   public final void generateSource(final Schema schema, final String packageName)
       throws IOException {
     if (schema == null) {
       throw new IllegalArgumentException("The argument 'schema' must not be null.");
     }
 
     // --make sure the XML Schema is valid
     try {
       schema.validate();
     } catch (ValidationException ve) {
       String err =
           "The schema: " + schema.getSchemaLocation() + " is not valid.\n" + ve.getMessage();
       throw new IllegalArgumentException(err);
     }
 
     // Now that we're ready to generate source and we know our configuration
     // has been fully parsed, create our SourceFactory. (See CASTOR-1346.)
     // We will reuse this SourceFactory if we are invoked multiple times.
     if (_sourceFactory == null) {
       _sourceFactory = new SourceFactory(this, _infoFactory, _groupNaming, this);
       _sourceFactory.setCreateMarshalMethods(_createMarshalMethods);
       _sourceFactory.setTestable(_testable);
       _sourceFactory.setSAX1(_sax1);
       _sourceFactory.setCaseInsensitive(_caseInsensitive);
     }
 
     _sInfo = new SGStateInfo(schema, this);
     _sInfo.setPackageName(packageName);
     _sInfo.setDialog(_dialog);
     _sInfo.setVerbose(_verbose);
     _sInfo.setSuppressNonFatalWarnings(_suppressNonFatalWarnings);
 
     // --map the schemaLocation of the schema with the packageName defined
     if (packageName != null) {
       super.setLocationPackageMapping(schema.getSchemaLocation(), packageName);
     }
 
     // --We start with a blank list of schemas processed
     _schemasProcessed.clear();
 
     generateAllClassFiles(schema, _sInfo);
 
     // -- TODO Cleanup integration (what does this comment mean?)
     if (!_createDescriptors && _generateMapping) {
       generateMappingFile(packageName, _sInfo);
     }
 
     // output statistical information from JClassRegistry in 'automatic'mode only
     if (isAutomaticConflictResolution()) {
       _xmlInfoRegistry.printStatistics(_bindingComponent);
     }
   } // -- generateSource
 
   // -------------------/
   // - Private Methods -/
   // -------------------/
 
   /**
    * Generate all class files for the provided schema. Before processing the current schema, process
    * the schemas imported by this one (unless our configuration says not to).
    *
    * @param schema the schema whose imported schemas to process
    * @param sInfo source generator state information
    * @throws IOException if this Exception occurs while processing an import schema
    */
   private void generateAllClassFiles(final Schema schema, final SGStateInfo sInfo)
       throws IOException {
     // Before processing the current schema, process its imported schemas
     processImportedSchemas(schema, sInfo);
 
     // -- ** Generate code for all TOP-LEVEL structures **
 
     // -- register all global element names for name conflict resolution
     for (ElementDecl element : schema.getElementDecls()) {
       _xmlInfoRegistry.prebindGlobalElement(XPathHelper.getSchemaLocation(element));
     }
     for (ModelGroup modelGroup : schema.getModelGroups()) {
       _xmlInfoRegistry.prebindGlobalElement(XPathHelper.getSchemaLocation(modelGroup));
     }
 
     // -- handle all top-level element declarations
     for (ElementDecl element : schema.getElementDecls()) {
       createClasses(element, sInfo);
     }
 
     // -- handle all top-level complextypes
     for (ComplexType complexType : schema.getComplexTypes()) {
       processComplexType(complexType, sInfo);
     }
 
     // -- handle all top-level simpletypes
     for (SimpleType simpleType : schema.getSimpleTypes()) {
       processSimpleType(simpleType, sInfo);
     }
 
     // -- handle all top-level groups
     for (ModelGroup modelGroup : schema.getModelGroups()) {
       createClasses(modelGroup, sInfo);
     }
 
     // -- clean up any remaining JClasses which need printing
     _singleClassGenerator.processIfNotAlreadyProcessed(sInfo.keys(), sInfo);
 
     // -- handle cdr files
     for (Enumeration<String> cdrFiles = sInfo.getCDRFilenames(); cdrFiles.hasMoreElements();) {
       String filename = cdrFiles.nextElement();
       Properties props = sInfo.getCDRFile(filename);
       final FileOutputStream fileOutputStream = new FileOutputStream(new File(filename));
       props.store(fileOutputStream, null);
       fileOutputStream.close();
     }
   } // -- createClasses
 
   /**
    * Look at each schema imported by the given schema. Either warn that the invoker needs to
    * separately generate source from that schema or process that schema, depending on settings.
    * 
    * @param schema the schema whose imported schemas to process
    * @param sInfo source generator state information
    * @throws IOException if this Exception occurs while processing an import schema
    */
   private void processImportedSchemas(final Schema schema, final SGStateInfo sInfo)
       throws IOException {
     Iterator<Schema> enumeration = schema.getImportedSchema().iterator();
     while (enumeration.hasNext()) {
       Schema importedSchema = enumeration.next();
       if (!_generateImported) {
         LOG.warn("Note: No code will be generated for the following *imported* schema: "
             + importedSchema.getSchemaLocation() + "; if this is on intention, please "
             + "do not forget to generate code for this schema as well. Alternatively,"
             + "consider using the 'generateImportedSchemas' flag.");
         continue;
       }
 
       _schemasProcessed.add(schema);
       if (!_schemasProcessed.contains(importedSchema)) {
         SGStateInfo importedSInfo = new SGStateInfo(importedSchema, this);
         String packageName = sInfo.getPackageName();
         importedSInfo.setPackageName(packageName);
 
         // --map the schemaLocation of the imported schema with the packageName defined
         if (packageName != null) {
           setLocationPackageMapping(importedSchema.getSchemaLocation(), packageName);
         }
 
         generateAllClassFiles(importedSchema, importedSInfo);
 
         // --'store' the imported JClass instances
         sInfo.storeImportedSourcesByName(importedSInfo.getSourcesByName());
         sInfo.storeImportedSourcesByName(importedSInfo.getImportedSourcesByName());
         // --discard the SGStateInfo
         importedSInfo = null;
       }
     }
   }
 
   /**
    * Generates the mapping file.
    * 
    * @param packageName Package name to be generated
    * @param sInfo Source Generator current state
    * @throws IOException if this Exception occurs while generating the mapping file
    */
   private void generateMappingFile(final String packageName, final SGStateInfo sInfo)
       throws IOException {
     String pkg = (packageName != null) ? packageName : "";
     MappingRoot mapping = sInfo.getMapping(pkg);
     if (mapping == null) {
       return;
     }
 
     FileWriter writer = new FileWriter(_mappingFilename);
     try {
       Marshaller marshaller = new Marshaller(writer);
       marshaller.setSuppressNamespaces(true);
       marshaller.marshal(mapping);
     } catch (Exception ex) {
       throw new NestedIOException(ex);
     } finally {
       writer.flush();
       writer.close();
     }
   }
 
   /**
    * Processes the given Element declaration and creates all necessary classes to support it.
    *
    * @param elementDecl the Element declaration to process
    * @param sInfo our state information
    * @throws IOException if this exception occurs while writing source files
    */
   private void createClasses(final ElementDecl elementDecl, final SGStateInfo sInfo)
       throws IOException {
     if (sInfo.getStatusCode() == SGStateInfo.STOP_STATUS || elementDecl == null) {
       return;
     }
 
     // -- when mapping schema types, only interested in producing classes
     // -- for elements with anonymous complex types
     XMLType xmlType = elementDecl.getType();
     if (mappingSchemaType2Java()) {
       if (elementDecl.isReference() || ((xmlType != null) && (xmlType.getName() != null))) {
         return;
       }
     }
 
     // --create component
     _bindingComponent.setView(elementDecl);
 
     // -- already processed --> just return
     ClassInfo cInfo = sInfo.resolve(elementDecl);
     if (cInfo != null && cInfo.getJClass() != null) {
       JClass jClass = cInfo.getJClass();
       if (sInfo.processed(jClass)) {
         return;
       }
       jClass = null;
     }
 
     // -- No type definition
     if (xmlType == null) {
       if (sInfo.verbose()) {
         String msg = "No type found for element: " + elementDecl.getName();
         sInfo.getDialog().notify(msg);
       }
       return;
     } else if (xmlType.isComplexType()) {
       // -- ComplexType
       JClass[] classes = _sourceFactory.createSourceCode(_bindingComponent, sInfo);
       if (!_singleClassGenerator.process(classes, sInfo)) {
         return;
       }
 
       // only create classes for types that are not imported
       if (xmlType.getSchema() == _bindingComponent.getSchema()) {
         processComplexType((ComplexType) xmlType, sInfo);
       }
     } else if (xmlType.isSimpleType()) {
       // -- SimpleType
       processSimpleType((SimpleType) xmlType, sInfo);
     } else {
       // -- AnyType
       // -- no processing needed for 'anyType'
     }
   } // -- createClasses
 
   /**
    * Processes the given Group and creates all necessary classes to support it.
    *
    * @param group the Group to process
    * @param sInfo our state information
    * @throws IOException if this exception occurs while writing source files
    */
   private void createClasses(final Group group, final SGStateInfo sInfo) throws IOException {
     if (group == null) {
       return;
     }
 
     // -- don't generate classes for empty groups
     if (group.getParticleCount() == 0) {
       if (group instanceof ModelGroup) {
         ModelGroup mg = (ModelGroup) group;
         if (mg.isReference()) {
           mg = mg.getReference();
           if (mg.getParticleCount() == 0) {
             return;
           }
         }
       } else {
         return;
       }
     }
 
     _bindingComponent.setView(group);
 
     JClass[] classes = _sourceFactory.createSourceCode(_bindingComponent, sInfo);
     processContentModel(group, sInfo);
     _singleClassGenerator.process(classes, sInfo);
   } // -- createClasses
 
   /**
    * Processes the given ComplexType and creates all necessary classes to support it.
    *
    * @param complexType the ComplexType to process
    * @param sInfo our state information
    * @throws IOException if this exception occurs while writing source files
    */
   private void processComplexType(final ComplexType complexType, final SGStateInfo sInfo)
       throws IOException {
     if (sInfo.getStatusCode() == SGStateInfo.STOP_STATUS || complexType == null) {
       return;
     }
 
     _bindingComponent.setView(complexType);
 
     ClassInfo classInfo = sInfo.resolve(complexType);
     if (classInfo == null) {
       // -- handle top-level complextypes
       if (complexType.isTopLevel()) {
         JClass[] classes = _sourceFactory.createSourceCode(_bindingComponent, sInfo);
         if (!_singleClassGenerator.process(classes, sInfo)) {
           return;
         }
       }
 
       // -- process AttributeDecl
       processAttributes(complexType, sInfo);
 
       // --process content type if necessary
       ContentType temp = complexType.getContentType();
       if (temp.getType() == ContentType.SIMPLE) {
         processSimpleType(((SimpleContent) temp).getSimpleType(), sInfo);
       }
 
       // -- process ContentModel
       processContentModel(complexType, sInfo);
     } else {
       JClass jClass = classInfo.getJClass();
       if (!sInfo.processed(jClass)) {
         // -- process AttributeDecl
         processAttributes(complexType, sInfo);
         // -- process ContentModel
         processContentModel(complexType, sInfo);
         _singleClassGenerator.process(jClass, sInfo);
       }
     }
   } // -- processComplexType
 
   /**
    * Processes the attribute declarations for the given complex type.
    *
    * @param complexType the ComplexType containing the attribute declarations to process.
    * @param sInfo the current source generator state information
    * @throws IOException if this Exception occurs while generating source files
    */
   private void processAttributes(final ComplexType complexType, final SGStateInfo sInfo)
       throws IOException {
     if (sInfo.getStatusCode() == SGStateInfo.STOP_STATUS || complexType == null) {
       return;
     }
 
     Enumeration<AttributeDecl> enumeration = complexType.getAttributeDecls();
     while (enumeration.hasMoreElements()) {
       AttributeDecl attribute = enumeration.nextElement();
       processSimpleType(attribute.getSimpleType(), sInfo);
     }
   } // -- processAttributes
 
   /**
    * Processes the given ContentModelGroup.
    *
    * @param cmGroup the ContentModelGroup to process
    * @param sInfo the current source generator state information
    * @throws IOException if this Exception occurs while generating source files
    */
   private void processContentModel(final ContentModelGroup cmGroup, final SGStateInfo sInfo)
       throws IOException {
     if (sInfo.getStatusCode() == SGStateInfo.STOP_STATUS || cmGroup == null) {
       return;
     }
 
     // Some special code to handle the fact that the enumerate method will simply skip
     // the first group is the number of particle is one
 
     Enumeration<Particle> enumeration = cmGroup.enumerate();
 
     while (enumeration.hasMoreElements()) {
       Structure struct = enumeration.nextElement();
       switch (struct.getStructureType()) {
         case Structure.ELEMENT:
           ElementDecl eDecl = (ElementDecl) struct;
           if (eDecl.isReference()) {
             continue;
           }
           createClasses(eDecl, sInfo);
           break;
         case Structure.GROUP:
           processContentModel((Group) struct, sInfo);
           // handle nested groups
           if (!((cmGroup instanceof ComplexType) || (cmGroup instanceof ModelGroup))) {
             createClasses((Group) struct, sInfo);
           }
           break;
         default:
           break;
       }
     }
   } // -- processContentModel
 
   /**
    * Handle simpleTypes.
    *
    * @param simpleType the SimpleType to be processed
    * @param sInfo the current source generator state information
    * @throws IOException if this Exception occurs while generating source files
    */
   private void processSimpleType(final SimpleType simpleType, final SGStateInfo sInfo)
       throws IOException {
     if (sInfo.getStatusCode() == SGStateInfo.STOP_STATUS || simpleType == null
         || simpleType.getSchema() != sInfo.getSchema()) {
       return;
     }
 
     // -- Right now the only time we actually generate source for a simpletype is
     // -- when it's an enumeration
     if (simpleType.hasFacet(Facet.ENUMERATION)) {
       ClassInfo classInfo = sInfo.resolve(simpleType);
       if (classInfo == null) {
         JClass jClass =
             _sourceFactory.createSourceCode(_bindingComponent.getBinding(), simpleType, sInfo);
         _singleClassGenerator.process(jClass, sInfo);
       } else {
         JClass jClass = classInfo.getJClass();
         _singleClassGenerator.process(jClass, sInfo);
       }
     }
   } // -- processSimpleType
 
   /**
    * Called by setBinding to fill in the mapping between namespaces and Java packages.
    *
    * @param packages the array of package element
    */
   private void processNamespaces(final PackageType[] packages) {
     if (packages.length == 0) {
       return;
     }
 
     for (PackageType temp : packages) {
       PackageTypeChoice choice = temp.getPackageTypeChoice();
       if (choice.getNamespace() != null) {
         super.setNamespacePackageMapping(choice.getNamespace(), temp.getName());
       } else if (choice.getSchemaLocation() != null) {
         // 1--Handle relative locations
         String tempLocation = choice.getSchemaLocation();
         String currentDir = System.getProperty("user.dir");
         currentDir = currentDir.replace('\\', '/');
         if (tempLocation.startsWith("./")) {
           tempLocation = tempLocation.substring(1);
           tempLocation = currentDir + tempLocation;
         } else if (tempLocation.startsWith("../")) {
           tempLocation = tempLocation.substring("../".length());
           int lastDir = currentDir.lastIndexOf('/');
           currentDir = currentDir.substring(0, lastDir + 1);
           tempLocation = currentDir + tempLocation;
         }
         super.setLocationPackageMapping(tempLocation, temp.getName());
         currentDir = null;
         tempLocation = null;
       }
     }
   }
 
   /**
    * Returns a string which is the URI of a file.
    * <ul>
    * <li>file:///DOSpath</li>
    * <li>file://UnixPath</li>
    * </ul>
    * No validation is done to check whether the file exists or not. This method will be no longer
    * used when the JDK URL.toString() is fixed.
    *
    * @param path The absolute path of the file.
    * @return A string representing the URI of the file.
    */
   public static String toURIRepresentation(final String path) {
     String result = path;
     if (!new File(result).isAbsolute()) {
       throw new IllegalArgumentException("The parameter must represent an absolute path.");
     }
 
     if (File.separatorChar != '/') {
       result = result.replace(File.separatorChar, '/');
     }
 
     if (result.startsWith("/")) {
       result = "file://" + result; /* Unix platform */
     } else {
       result = "file:///" + result; /* DOS platform */
     }
 
     return result;
   }
 
   /**
    * For backwards compability, when we are called as the main() routine, delegate the command-line
    * usage to the proper class.
    *
    * @param args our command line arguments.
    * @deprecated Please use {@link SourceGeneratorMain#main(String[])}
    */
   public static void main(final String[] args) {
     LOG.info("org.exolab.castor.builder.SourceGenerator.main() is deprecated. "
         + "Please use org.exolab.castor.builder.SourceGeneratorMain#main() instead.");
 
     SourceGeneratorMain.main(args);
   }
 
   /**
    * Returns the {@link JClassRegistry} instance associated with this source generator.
    * 
    * @return the {@link JClassRegistry} instance currently in use.
    */
   public JClassRegistry getXMLInfoRegistry() {
     return _xmlInfoRegistry;
   }
 
   /**
    * Sets the jclassPrinter type.
    * 
    * @param jClassPrinterType The string identifier of the printer to use.
    */
   public final void setJClassPrinterType(final String jClassPrinterType) {
     LOG.info("Setting JClass printing mode " + jClassPrinterType);
     _jclassPrinterType = jClassPrinterType;
     if (_singleClassGenerator != null) {
       _singleClassGenerator.setJClassPrinterType(jClassPrinterType);
     }
   }
 
   /**
    * Indicates whether classes should be created for imported XML schemas as well.
    * 
    * @return true if classes should be created for imported schemas.
    */
   public boolean getGenerateImportedSchemas() {
     return _generateImported;
   }
 
   /**
    * Returns the registry for {@link JClassPrinterFactory} instances.
    * 
    * @return the registry for {@link JClassPrinterFactory} instances.
    */
   public JClassPrinterFactoryRegistry getJClassPrinterFactoryRegistry() {
     return _jclassPrinterFactoryRegistry;
   }
 
 } // -- SourceGenerator