FileDocCategorySizeDatePackage
DTDConfiguration.javaAPI DocApache Xerces 3.0.131627Fri Sep 14 20:33:52 BST 2007org.apache.xerces.parsers

DTDConfiguration

public class DTDConfiguration extends BasicParserConfiguration implements org.apache.xerces.xni.parser.XMLPullParserConfiguration
This is the DTD-only parser configuration. It extends the basic configuration with a standard set of parser components appropriate to DTD-centric validation. Since the Xerces2 reference implementation document and DTD scanner implementations are capable of acting as pull parsers, this configuration implements the XMLPullParserConfiguration interface.

In addition to the features and properties recognized by the base parser configuration, this class recognizes these additional features and properties:

  • Features
    • http://apache.org/xml/features/validation/warn-on-duplicate-attdef
    • http://apache.org/xml/features/validation/warn-on-undeclared-elemdef
    • http://apache.org/xml/features/allow-java-encodings
    • http://apache.org/xml/features/continue-after-fatal-error
    • http://apache.org/xml/features/load-external-dtd
  • Properties
    • http://apache.org/xml/properties/internal/error-reporter
    • http://apache.org/xml/properties/internal/entity-manager
    • http://apache.org/xml/properties/internal/document-scanner
    • http://apache.org/xml/properties/internal/dtd-scanner
    • http://apache.org/xml/properties/internal/grammar-pool
    • http://apache.org/xml/properties/internal/validator/dtd
    • http://apache.org/xml/properties/internal/datatype-validator-factory
author
Arnaud Le Hors, IBM
author
Andy Clark, IBM
author
Neil Graham, IBM
version
$Id: DTDConfiguration.java 548192 2007-06-18 03:34:19Z mrglavas $

Fields Summary
protected static final String
WARN_ON_DUPLICATE_ATTDEF
Feature identifier: warn on duplicate attribute definition.
protected static final String
WARN_ON_DUPLICATE_ENTITYDEF
Feature identifier: warn on duplicate entity definition.
protected static final String
WARN_ON_UNDECLARED_ELEMDEF
Feature identifier: warn on undeclared element definition.
protected static final String
ALLOW_JAVA_ENCODINGS
Feature identifier: allow Java encodings.
protected static final String
CONTINUE_AFTER_FATAL_ERROR
Feature identifier: continue after fatal error.
protected static final String
LOAD_EXTERNAL_DTD
Feature identifier: load external DTD.
protected static final String
NOTIFY_BUILTIN_REFS
Feature identifier: notify built-in refereces.
protected static final String
NOTIFY_CHAR_REFS
Feature identifier: notify character refereces.
protected static final String
ERROR_REPORTER
Property identifier: error reporter.
protected static final String
ENTITY_MANAGER
Property identifier: entity manager.
protected static final String
DOCUMENT_SCANNER
Property identifier document scanner:
protected static final String
DTD_SCANNER
Property identifier: DTD scanner.
protected static final String
XMLGRAMMAR_POOL
Property identifier: grammar pool.
protected static final String
DTD_PROCESSOR
Property identifier: DTD loader.
protected static final String
DTD_VALIDATOR
Property identifier: DTD validator.
protected static final String
NAMESPACE_BINDER
Property identifier: namespace binder.
protected static final String
DATATYPE_VALIDATOR_FACTORY
Property identifier: datatype validator factory.
protected static final String
VALIDATION_MANAGER
protected static final String
JAXP_SCHEMA_LANGUAGE
Property identifier: JAXP schema language / DOM schema-type.
protected static final String
JAXP_SCHEMA_SOURCE
Property identifier: JAXP schema source/ DOM schema-location.
protected static final boolean
PRINT_EXCEPTION_STACK_TRACE
Set to true and recompile to print exception stack trace.
protected org.apache.xerces.xni.grammars.XMLGrammarPool
fGrammarPool
Grammar pool.
protected org.apache.xerces.impl.dv.DTDDVFactory
fDatatypeValidatorFactory
Datatype validator factory.
protected org.apache.xerces.impl.XMLErrorReporter
fErrorReporter
Error reporter.
protected org.apache.xerces.impl.XMLEntityManager
fEntityManager
Entity manager.
protected org.apache.xerces.xni.parser.XMLDocumentScanner
fScanner
Document scanner.
protected org.apache.xerces.xni.parser.XMLInputSource
fInputSource
Input Source
protected org.apache.xerces.xni.parser.XMLDTDScanner
fDTDScanner
DTD scanner.
protected org.apache.xerces.impl.dtd.XMLDTDProcessor
fDTDProcessor
DTD Processor .
protected org.apache.xerces.impl.dtd.XMLDTDValidator
fDTDValidator
DTD Validator.
protected org.apache.xerces.impl.XMLNamespaceBinder
fNamespaceBinder
Namespace binder.
protected org.apache.xerces.impl.validation.ValidationManager
fValidationManager
protected org.apache.xerces.xni.XMLLocator
fLocator
Locator
protected boolean
fParseInProgress
True if a parse is in progress. This state is needed because some features/properties cannot be set while parsing (e.g. validation and namespaces).
Constructors Summary
public DTDConfiguration()
Default constructor.


    //
    // Constructors
    //

       
      
        this(null, null, null);
public DTDConfiguration(org.apache.xerces.util.SymbolTable symbolTable)
Constructs a parser configuration using the specified symbol table.

param
symbolTable The symbol table to use.

        this(symbolTable, null, null);
public DTDConfiguration(org.apache.xerces.util.SymbolTable symbolTable, org.apache.xerces.xni.grammars.XMLGrammarPool grammarPool)
Constructs a parser configuration using the specified symbol table and grammar pool.

REVISIT: Grammar pool will be updated when the new validation engine is implemented.

param
symbolTable The symbol table to use.
param
grammarPool The grammar pool to use.

        this(symbolTable, grammarPool, null);
public DTDConfiguration(org.apache.xerces.util.SymbolTable symbolTable, org.apache.xerces.xni.grammars.XMLGrammarPool grammarPool, org.apache.xerces.xni.parser.XMLComponentManager parentSettings)
Constructs a parser configuration using the specified symbol table, grammar pool, and parent settings.

REVISIT: Grammar pool will be updated when the new validation engine is implemented.

param
symbolTable The symbol table to use.
param
grammarPool The grammar pool to use.
param
parentSettings The parent settings.

        super(symbolTable, parentSettings);

        // add default recognized features
        final String[] recognizedFeatures = {
            //WARN_ON_DUPLICATE_ATTDEF,     // from XMLDTDScannerImpl
            //WARN_ON_UNDECLARED_ELEMDEF,   // from XMLDTDScannerImpl
            //ALLOW_JAVA_ENCODINGS,         // from XMLEntityManager
            CONTINUE_AFTER_FATAL_ERROR,
            LOAD_EXTERNAL_DTD,    // from XMLDTDScannerImpl
            //NOTIFY_BUILTIN_REFS,  // from XMLDocumentFragmentScannerImpl
            //NOTIFY_CHAR_REFS,		// from XMLDocumentFragmentScannerImpl
            //WARN_ON_DUPLICATE_ENTITYDEF,  // from XMLEntityManager
        };
        addRecognizedFeatures(recognizedFeatures);

        // set state for default features
        //setFeature(WARN_ON_DUPLICATE_ATTDEF, false);  // from XMLDTDScannerImpl
        //setFeature(WARN_ON_UNDECLARED_ELEMDEF, false);  // from XMLDTDScannerImpl
        //setFeature(ALLOW_JAVA_ENCODINGS, false);      // from XMLEntityManager
        setFeature(CONTINUE_AFTER_FATAL_ERROR, false);
        setFeature(LOAD_EXTERNAL_DTD, true);      // from XMLDTDScannerImpl
        //setFeature(NOTIFY_BUILTIN_REFS, false);   // from XMLDocumentFragmentScannerImpl
        //setFeature(NOTIFY_CHAR_REFS, false);      // from XMLDocumentFragmentScannerImpl
        //setFeature(WARN_ON_DUPLICATE_ENTITYDEF, false);   // from XMLEntityManager

        // add default recognized properties
        final String[] recognizedProperties = {
            ERROR_REPORTER,             
            ENTITY_MANAGER, 
            DOCUMENT_SCANNER,
            DTD_SCANNER,
            DTD_PROCESSOR,
            DTD_VALIDATOR,
            NAMESPACE_BINDER,
            XMLGRAMMAR_POOL,   
            DATATYPE_VALIDATOR_FACTORY,
            VALIDATION_MANAGER,
            JAXP_SCHEMA_SOURCE,
            JAXP_SCHEMA_LANGUAGE
        };
        addRecognizedProperties(recognizedProperties);

        fGrammarPool = grammarPool;
        if(fGrammarPool != null){
            setProperty(XMLGRAMMAR_POOL, fGrammarPool);
        }

        fEntityManager = createEntityManager();
        setProperty(ENTITY_MANAGER, fEntityManager);
        addComponent(fEntityManager);

        fErrorReporter = createErrorReporter();
        fErrorReporter.setDocumentLocator(fEntityManager.getEntityScanner());
        setProperty(ERROR_REPORTER, fErrorReporter);
        addComponent(fErrorReporter);

        fScanner = createDocumentScanner();
        setProperty(DOCUMENT_SCANNER, fScanner);
        if (fScanner instanceof XMLComponent) {
            addComponent((XMLComponent)fScanner);
        }

        fDTDScanner = createDTDScanner();
        if (fDTDScanner != null) {
            setProperty(DTD_SCANNER, fDTDScanner);
            if (fDTDScanner instanceof XMLComponent) {
                addComponent((XMLComponent)fDTDScanner);
            }
        }

        fDTDProcessor = createDTDProcessor();
        if (fDTDProcessor != null) {
            setProperty(DTD_PROCESSOR, fDTDProcessor);
            addComponent(fDTDProcessor);
        }

        fDTDValidator = createDTDValidator();
        if (fDTDValidator != null) {
            setProperty(DTD_VALIDATOR, fDTDValidator);
            addComponent(fDTDValidator);
        }

        fNamespaceBinder = createNamespaceBinder();
        if (fNamespaceBinder != null) {
            setProperty(NAMESPACE_BINDER, fNamespaceBinder);
            addComponent(fNamespaceBinder);
        }
        
        fDatatypeValidatorFactory = createDatatypeValidatorFactory();
        if (fDatatypeValidatorFactory != null) {
            setProperty(DATATYPE_VALIDATOR_FACTORY,
                        fDatatypeValidatorFactory);
        }
        fValidationManager = createValidationManager();

        if (fValidationManager != null) {
            setProperty (VALIDATION_MANAGER, fValidationManager);
        }
        // add message formatters
        if (fErrorReporter.getMessageFormatter(XMLMessageFormatter.XML_DOMAIN) == null) {
            XMLMessageFormatter xmft = new XMLMessageFormatter();
            fErrorReporter.putMessageFormatter(XMLMessageFormatter.XML_DOMAIN, xmft);
            fErrorReporter.putMessageFormatter(XMLMessageFormatter.XMLNS_DOMAIN, xmft);
        }

        // set locale
        try {
            setLocale(Locale.getDefault());
        }
        catch (XNIException e) {
            // do nothing
            // REVISIT: What is the right thing to do? -Ac
        }
Methods Summary
protected voidcheckFeature(java.lang.String featureId)
Check a feature. If feature is know and supported, this method simply returns. Otherwise, the appropriate exception is thrown.

param
featureId The unique identifier (URI) of the feature.
throws
XMLConfigurationException Thrown for configuration error. In general, components should only throw this exception if it is really a critical error.


        //
        // Xerces Features
        //

        if (featureId.startsWith(Constants.XERCES_FEATURE_PREFIX)) {
            final int suffixLength = featureId.length() - Constants.XERCES_FEATURE_PREFIX.length();
        	
            //
            // http://apache.org/xml/features/validation/dynamic
            //   Allows the parser to validate a document only when it
            //   contains a grammar. Validation is turned on/off based
            //   on each document instance, automatically.
            //
            if (suffixLength == Constants.DYNAMIC_VALIDATION_FEATURE.length() && 
                featureId.endsWith(Constants.DYNAMIC_VALIDATION_FEATURE)) {
                return;
            }

            //
            // http://apache.org/xml/features/validation/default-attribute-values
            //
            if (suffixLength == Constants.DEFAULT_ATTRIBUTE_VALUES_FEATURE.length() &&
                featureId.endsWith(Constants.DEFAULT_ATTRIBUTE_VALUES_FEATURE)) {
                // REVISIT
                short type = XMLConfigurationException.NOT_SUPPORTED;
                throw new XMLConfigurationException(type, featureId);
            }
            //
            // http://apache.org/xml/features/validation/default-attribute-values
            //
            if (suffixLength == Constants.VALIDATE_CONTENT_MODELS_FEATURE.length() && 
                featureId.endsWith(Constants.VALIDATE_CONTENT_MODELS_FEATURE)) {
                // REVISIT
                short type = XMLConfigurationException.NOT_SUPPORTED;
                throw new XMLConfigurationException(type, featureId);
            }
            //
            // http://apache.org/xml/features/validation/nonvalidating/load-dtd-grammar
            //
            if (suffixLength == Constants.LOAD_DTD_GRAMMAR_FEATURE.length() && 
                featureId.endsWith(Constants.LOAD_DTD_GRAMMAR_FEATURE)) {
                return;
            }
            //
            // http://apache.org/xml/features/validation/nonvalidating/load-external-dtd
            //
            if (suffixLength == Constants.LOAD_EXTERNAL_DTD_FEATURE.length() && 
                featureId.endsWith(Constants.LOAD_EXTERNAL_DTD_FEATURE)) {
                return;
            }

            //
            // http://apache.org/xml/features/validation/default-attribute-values
            //
            if (suffixLength == Constants.VALIDATE_DATATYPES_FEATURE.length() && 
                featureId.endsWith(Constants.VALIDATE_DATATYPES_FEATURE)) {
                short type = XMLConfigurationException.NOT_SUPPORTED;
                throw new XMLConfigurationException(type, featureId);
            }
        }

        //
        // Not recognized
        //

        super.checkFeature(featureId);
protected voidcheckProperty(java.lang.String propertyId)
Check a property. If the property is know and supported, this method simply returns. Otherwise, the appropriate exception is thrown.

param
propertyId The unique identifier (URI) of the property being set.
throws
XMLConfigurationException Thrown for configuration error. In general, components should only throw this exception if it is really a critical error.


        //
        // Xerces Properties
        //

        if (propertyId.startsWith(Constants.XERCES_PROPERTY_PREFIX)) {
            final int suffixLength = propertyId.length() - Constants.XERCES_PROPERTY_PREFIX.length();

            if (suffixLength == Constants.DTD_SCANNER_PROPERTY.length() && 
                propertyId.endsWith(Constants.DTD_SCANNER_PROPERTY)) {
                return;
            }
        }

        //
        // Not recognized
        //

        super.checkProperty(propertyId);
public voidcleanup()
If the application decides to terminate parsing before the xml document is fully parsed, the application should call this method to free any resource allocated during parsing. For example, close all opened streams.

        fEntityManager.closeReaders();
protected voidconfigureDTDPipeline()

        
        // setup dtd pipeline
        if (fDTDScanner != null) {
            fProperties.put(DTD_SCANNER, fDTDScanner);          
            if (fDTDProcessor != null) {
                fProperties.put(DTD_PROCESSOR, fDTDProcessor);
                fDTDScanner.setDTDHandler(fDTDProcessor);
                fDTDProcessor.setDTDSource(fDTDScanner);
                fDTDProcessor.setDTDHandler(fDTDHandler);
                if (fDTDHandler != null) {
                    fDTDHandler.setDTDSource(fDTDProcessor);
                }

                fDTDScanner.setDTDContentModelHandler(fDTDProcessor);
                fDTDProcessor.setDTDContentModelSource(fDTDScanner);
                fDTDProcessor.setDTDContentModelHandler(fDTDContentModelHandler);
                if (fDTDContentModelHandler != null) {
                    fDTDContentModelHandler.setDTDContentModelSource(fDTDProcessor);
                }
            }
            else {
                fDTDScanner.setDTDHandler(fDTDHandler);
                if (fDTDHandler != null) {
                    fDTDHandler.setDTDSource(fDTDScanner);
                }
                fDTDScanner.setDTDContentModelHandler(fDTDContentModelHandler);
                if (fDTDContentModelHandler != null) {
                    fDTDContentModelHandler.setDTDContentModelSource(fDTDScanner);
                }
            }
        }
protected voidconfigurePipeline()
Configures the pipeline.


		// REVISIT: This should be better designed. In other words, we
		//          need to figure out what is the best way for people to
		//          re-use *most* of the standard configuration but do 
		//          things common things such as remove a component (e.g.
		//          the validator), insert a new component (e.g. XInclude), 
		//          etc... -Ac

		// setup document pipeline
		if (fDTDValidator != null) {
			fScanner.setDocumentHandler(fDTDValidator);
			if (fFeatures.get(NAMESPACES) == Boolean.TRUE) {

				// filters
				fDTDValidator.setDocumentHandler(fNamespaceBinder);
				fDTDValidator.setDocumentSource(fScanner);
				fNamespaceBinder.setDocumentHandler(fDocumentHandler);
				fNamespaceBinder.setDocumentSource(fDTDValidator);
				fLastComponent = fNamespaceBinder;
			}
			else {
				fDTDValidator.setDocumentHandler(fDocumentHandler);
				fDTDValidator.setDocumentSource(fScanner);
				fLastComponent = fDTDValidator;
			}
		}
		else {
			if (fFeatures.get(NAMESPACES) == Boolean.TRUE) {
				fScanner.setDocumentHandler(fNamespaceBinder);
				fNamespaceBinder.setDocumentHandler(fDocumentHandler);
				fNamespaceBinder.setDocumentSource(fScanner);
				fLastComponent = fNamespaceBinder;
			}
			else {
				fScanner.setDocumentHandler(fDocumentHandler);
				fLastComponent = fScanner;
			}
		}
        
        configureDTDPipeline();
protected org.apache.xerces.impl.dtd.XMLDTDProcessorcreateDTDProcessor()
Create a DTD loader .

        return new XMLDTDProcessor();
protected org.apache.xerces.xni.parser.XMLDTDScannercreateDTDScanner()
Create a DTD scanner.

        return new XMLDTDScannerImpl();
protected org.apache.xerces.impl.dtd.XMLDTDValidatorcreateDTDValidator()
Create a DTD validator.

        return new XMLDTDValidator();
protected org.apache.xerces.impl.dv.DTDDVFactorycreateDatatypeValidatorFactory()
Create a datatype validator factory.

        return DTDDVFactory.getInstance();
protected org.apache.xerces.xni.parser.XMLDocumentScannercreateDocumentScanner()
Create a document scanner.

        return new XMLDocumentScannerImpl();
protected org.apache.xerces.impl.XMLEntityManagercreateEntityManager()
Creates an entity manager.

        return new XMLEntityManager();
protected org.apache.xerces.impl.XMLErrorReportercreateErrorReporter()
Creates an error reporter.

        return new XMLErrorReporter();
protected org.apache.xerces.impl.XMLNamespaceBindercreateNamespaceBinder()
Create a namespace binder.

        return new XMLNamespaceBinder();
protected org.apache.xerces.impl.validation.ValidationManagercreateValidationManager()

        return new ValidationManager();
public booleanparse(boolean complete)
Parses the document in a pull parsing fashion.

param
complete True if the pull parser should parse the remaining document completely.
return
True if there is more document to parse.
exception
XNIException Any XNI exception, possibly wrapping another exception.
exception
IOException An IO exception from the parser, possibly from a byte stream or character stream supplied by the parser.
see
#setInputSource

        //
        // reset and configure pipeline and set InputSource.
        if (fInputSource !=null) {
            try {
                // resets and sets the pipeline.
                reset();
                fScanner.setInputSource(fInputSource);
                fInputSource = null;
            } 
            catch (XNIException ex) {
                if (PRINT_EXCEPTION_STACK_TRACE)
                    ex.printStackTrace();
                throw ex;
            } 
            catch (IOException ex) {
                if (PRINT_EXCEPTION_STACK_TRACE)
                    ex.printStackTrace();
                throw ex;
            } 
            catch (RuntimeException ex) {
                if (PRINT_EXCEPTION_STACK_TRACE)
                    ex.printStackTrace();
                throw ex;
            }
            catch (Exception ex) {
                if (PRINT_EXCEPTION_STACK_TRACE)
                    ex.printStackTrace();
                throw new XNIException(ex);
            }
        }

        try {
            return fScanner.scanDocument(complete);
        } 
        catch (XNIException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        } 
        catch (IOException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        } 
        catch (RuntimeException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        }
        catch (Exception ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw new XNIException(ex);
        }
public voidparse(org.apache.xerces.xni.parser.XMLInputSource source)
Parses the specified input source.

param
source The input source.
exception
XNIException Throws exception on XNI error.
exception
java.io.IOException Throws exception on i/o error.


        if (fParseInProgress) {
            // REVISIT - need to add new error message
            throw new XNIException("FWK005 parse may not be called while parsing.");
        }
        fParseInProgress = true;

        try {
            setInputSource(source);
            parse(true);
        } 
        catch (XNIException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        } 
        catch (IOException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        }
        catch (RuntimeException ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw ex;
        }              
        catch (Exception ex) {
            if (PRINT_EXCEPTION_STACK_TRACE)
                ex.printStackTrace();
            throw new XNIException(ex);
        }
        finally {
            fParseInProgress = false;
            // close all streams opened by xerces
            this.cleanup();
        }
protected voidreset()
Reset all components before parsing.

throws
XNIException Thrown if an error occurs during initialization.


        if (fValidationManager != null)
            fValidationManager.reset();
        // configure the pipeline and initialize the components
        configurePipeline();
        super.reset();
public voidsetInputSource(org.apache.xerces.xni.parser.XMLInputSource inputSource)
Sets the input source for the document to parse.

param
inputSource The document's input source.
exception
XMLConfigurationException Thrown if there is a configuration error when initializing the parser.
exception
IOException Thrown on I/O error.
see
#parse(boolean)

        
        // REVISIT: this method used to reset all the components and
        //          construct the pipeline. Now reset() is called
        //          in parse (boolean) just before we parse the document
        //          Should this method still throw exceptions..?

        fInputSource = inputSource;
public voidsetLocale(java.util.Locale locale)
Set the locale to use for messages.

param
locale The locale object to use for localization of messages.
exception
XNIException Thrown if the parser does not support the specified locale.

        super.setLocale(locale);
        fErrorReporter.setLocale(locale);