FileDocCategorySizeDatePackage
XIncludeHandler.javaAPI DocJava SE 5 API92726Fri Aug 26 14:55:56 BST 2005com.sun.org.apache.xerces.internal.xinclude

XIncludeHandler

public class XIncludeHandler extends Object implements XMLDTDFilter, XMLDocumentFilter, XMLComponent

This is a pipeline component which performs XInclude handling, according to the W3C specification for XML Inclusions.

This component analyzes each event in the pipeline, looking for <include> elements. An <include> element is one which has a namespace of http://www.w3.org/2001/XInclude and a localname of include. When it finds an <include> element, it attempts to include the file specified in the href attribute of the element. If inclusion succeeds, all children of the <include> element are ignored (with the exception of checking for invalid children as outlined in the specification). If the inclusion fails, the <fallback> child of the <include> element is processed.

See the XInclude specification for more information on how XInclude is to be used.

This component requires the following features and properties from the component manager that uses it:

  • http://xml.org/sax/features/allow-dtd-events-after-endDTD
  • http://apache.org/xml/properties/internal/error-reporter
  • http://apache.org/xml/properties/internal/entity-resolver
Furthermore, the NamespaceContext used in the pipeline is required to be an instance of XIncludeNamespaceSupport.

Currently, this implementation has only partial support for the XInclude specification. Specifically, it is missing support for XPointer document fragments. Thus, only whole documents can be included using this component in the pipeline.

author
Peter McCracken, IBM
version
$Id: XIncludeHandler.java,v 1.26 2004/04/15 04:51:56 mrglavas Exp $
see
XIncludeNamespaceSupport

Fields Summary
public static final String
XPOINTER_DEFAULT_CONFIGURATION
protected static final String
XPOINTER_SCHEMA
protected static final String
XINCLUDE_AWARE
public static final String
XINCLUDE_DEFAULT_CONFIGURATION
public static final String
HTTP_ACCEPT
public static final String
HTTP_ACCEPT_LANGUAGE
public static final String
HTTP_ACCEPT_CHARSET
public static final String
XPOINTER
public static final String
XINCLUDE_NS_URI
public static final String
XINCLUDE_INCLUDE
public static final String
XINCLUDE_FALLBACK
public static final String
XINCLUDE_PARSE_XML
public static final String
XINCLUDE_PARSE_TEXT
public static final String
XINCLUDE_ATTR_HREF
public static final String
XINCLUDE_ATTR_PARSE
public static final String
XINCLUDE_ATTR_ENCODING
public static final String
XINCLUDE_ATTR_ACCEPT
public static final String
XINCLUDE_ATTR_ACCEPT_LANGUAGE
public static final String
XINCLUDE_ATTR_ACCEPT_CHARSET
public static final String
XINCLUDE_INCLUDED
public static final String
CURRENT_BASE_URI
The identifier for the Augmentation that contains the current base URI
public static final String
XINCLUDE_BASE
public static final QName
XML_BASE_QNAME
public static final QName
NEW_NS_ATTR_QNAME
private static final int
STATE_NORMAL_PROCESSING
private static final int
STATE_IGNORE
private static final int
STATE_EXPECT_FALLBACK
protected static final String
ALLOW_UE_AND_NOTATION_EVENTS
Feature identifier: allow notation and unparsed entity events to be sent out of order.
protected static final String
ERROR_REPORTER
Property identifier: error reporter.
protected static final String
ENTITY_RESOLVER
Property identifier: entity resolver.
protected static final String
SECURITY_MANAGER
property identifier: security manager.
private static final String[]
RECOGNIZED_FEATURES
Recognized features.
private static final Boolean[]
FEATURE_DEFAULTS
Feature defaults.
private static final String[]
RECOGNIZED_PROPERTIES
Recognized properties.
private static final Object[]
PROPERTY_DEFAULTS
Property defaults.
protected XMLDocumentHandler
fDocumentHandler
protected XMLDocumentSource
fDocumentSource
protected XPointerFramework
fXPointerFramework
protected XPointerSchema[]
fXPointerSchema
protected XMLDTDHandler
fDTDHandler
protected XMLDTDSource
fDTDSource
protected XIncludeHandler
fParentXIncludeHandler
protected String
fParentRelativeURI
protected XMLParserConfiguration
fChildConfig
protected XMLLocator
fDocLocation
protected XIncludeNamespaceSupport
fNamespaceContext
protected XMLErrorReporter
fErrorReporter
protected XMLEntityResolver
fEntityResolver
protected SecurityManager
fSecurityManager
protected XMLResourceIdentifier
fCurrentBaseURI
protected IntStack
baseURIScope
protected Stack
baseURI
protected Stack
literalSystemID
protected Stack
expandedSystemID
protected ParserConfigurationSettings
fSettings
private int
fDepth
private static final int
INITIAL_SIZE
private boolean[]
fSawInclude
private boolean[]
fSawFallback
private int[]
fState
private Vector
fNotations
private Vector
fUnparsedEntities
private boolean
fSendUEAndNotationEvents
private boolean
fIsXML11
private boolean
fInDTD
Constructors Summary
public XIncludeHandler()

    
    // Constructors
    
      
        fDepth = 0;
        
        fSawFallback[fDepth] = false;
        fSawInclude[fDepth] = false;
        fState[fDepth] = STATE_NORMAL_PROCESSING;
        fNotations = new Vector();
        fUnparsedEntities = new Vector();
        
        baseURIScope = new IntStack();
        baseURI = new Stack();
        literalSystemID = new Stack();
        expandedSystemID = new Stack();
        fCurrentBaseURI = new XMLResourceIdentifierImpl();
    
Methods Summary
protected voidaddNotation(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)
Caches a notation.

param
name the name of the notation
param
identifier the location of the notation
param
augmentations any Augmentations that were on the original notation declaration

        Notation not = new Notation();
        not.name = name;
        not.systemId = identifier.getLiteralSystemId();
        not.publicId = identifier.getPublicId();
        not.baseURI = identifier.getBaseSystemId();
        not.augmentations = augmentations;
        fNotations.add(not);
    
protected voidaddUnparsedEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, java.lang.String notation, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)
Caches an unparsed entity.

param
name the name of the unparsed entity
param
identifier the location of the unparsed entity
param
augmentations any Augmentations that were on the original unparsed entity declaration

        UnparsedEntity ent = new UnparsedEntity();
        ent.name = name;
        ent.systemId = identifier.getLiteralSystemId();
        ent.publicId = identifier.getPublicId();
        ent.baseURI = identifier.getBaseSystemId();
        ent.notation = notation;
        ent.augmentations = augmentations;
        fUnparsedEntities.add(ent);
    
public voidattributeDecl(java.lang.String elementName, java.lang.String attributeName, java.lang.String type, java.lang.String[] enumeration, java.lang.String defaultType, com.sun.org.apache.xerces.internal.xni.XMLString defaultValue, com.sun.org.apache.xerces.internal.xni.XMLString nonNormalizedDefaultValue, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.attributeDecl(
            elementName,
            attributeName,
            type,
            enumeration,
            defaultType,
            defaultValue,
            nonNormalizedDefaultValue,
            augmentations);
        }
    
public voidcharacters(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            // we need to change the depth like this so that modifyAugmentations() works
            fDepth++;
            augs = modifyAugmentations(augs);
            fDocumentHandler.characters(text, augs);
            fDepth--;
        }
    
protected voidcheckAndSendNotation(com.sun.org.apache.xerces.internal.xinclude.XIncludeHandler$Notation not)
The purpose of this method is to check if a Notation conflicts with a previously declared notation in the current pipeline stack. If there is no conflict, the Notation is sent by the root pipeline.

param
not the Notation to check for conflicts

        if (isRootDocument()) {
            int index = fNotations.indexOf(not);
            if (index == -1) {
                // There is no notation with the same name that we have sent.
                XMLResourceIdentifier id =
                new XMLResourceIdentifierImpl(
                not.publicId,
                not.systemId,
                not.baseURI,
                null);
                this.addNotation(not.name, id, not.augmentations);
                if (fSendUEAndNotationEvents && fDTDHandler != null) {
                    fDTDHandler.notationDecl(not.name, id, not.augmentations);
                }
            }
            else {
                Notation localNotation = (Notation)fNotations.get(index);
                if (!not.isDuplicate(localNotation)) {
                    reportFatalError(
                    "NonDuplicateNotation",
                    new Object[] { not.name });
                }
            }
        }
        else {
            fParentXIncludeHandler.checkAndSendNotation(not);
        }
    
protected voidcheckAndSendUnparsedEntity(com.sun.org.apache.xerces.internal.xinclude.XIncludeHandler$UnparsedEntity ent)
The purpose of this method is to check if an UnparsedEntity conflicts with a previously declared entity in the current pipeline stack. If there is no conflict, the UnparsedEntity is sent by the root pipeline.

param
ent the UnparsedEntity to check for conflicts

        if (isRootDocument()) {
            int index = fUnparsedEntities.indexOf(ent);
            if (index == -1) {
                // There is no unparsed entity with the same name that we have sent.
                // Calling unparsedEntityDecl() will add the entity to our local store,
                // and also send the unparsed entity to the DTDHandler
                XMLResourceIdentifier id =
                new XMLResourceIdentifierImpl(
                ent.publicId,
                ent.systemId,
                ent.baseURI,
                null);
                this.addUnparsedEntity(
                ent.name,
                id,
                ent.notation,
                ent.augmentations);
                if (fSendUEAndNotationEvents && fDTDHandler != null) {
                    fDTDHandler.unparsedEntityDecl(
                    ent.name,
                    id,
                    ent.notation,
                    ent.augmentations);
                }
            }
            else {
                UnparsedEntity localEntity =
                (UnparsedEntity)fUnparsedEntities.get(index);
                if (!ent.isDuplicate(localEntity)) {
                    reportFatalError(
                    "NonDuplicateUnparsedEntity",
                    new Object[] { ent.name });
                }
            }
        }
        else {
            fParentXIncludeHandler.checkAndSendUnparsedEntity(ent);
        }
    
protected voidcheckNotation(java.lang.String notName)
Checks if a Notation with the given name was declared in the DTD of the document for the current pipeline. If so, that Notation is passed to the root pipeline to be checked for conflicts, and sent to the root DTDHandler

param
notName the name of the Notation to check

        Notation not = new Notation();
        not.name = notName;
        int index = fNotations.indexOf(not);
        if (index != -1) {
            not = (Notation)fNotations.get(index);
            checkAndSendNotation(not);
        }
    
protected voidcheckUnparsedEntity(java.lang.String entName)
Checks if an UnparsedEntity with the given name was declared in the DTD of the document for the current pipeline. If so, then the notation for the UnparsedEntity is checked. If that turns out okay, then the UnparsedEntity is passed to the root pipeline to be checked for conflicts, and sent to the root DTDHandler.

param
entName the name of the UnparsedEntity to check

        UnparsedEntity ent = new UnparsedEntity();
        ent.name = entName;
        int index = fUnparsedEntities.indexOf(ent);
        if (index != -1) {
            ent = (UnparsedEntity)fUnparsedEntities.get(index);
            // first check the notation of the unparsed entity
            checkNotation(ent.notation);
            checkAndSendUnparsedEntity(ent);
        }
    
public voidcomment(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (!fInDTD) {
            if (fDocumentHandler != null
            && getState() == STATE_NORMAL_PROCESSING) {
                fDepth++;
                augs = modifyAugmentations(augs);
                fDocumentHandler.comment(text, augs);
                fDepth--;
            }
        }
        else if (fDTDHandler != null) {
            fDTDHandler.comment(text, augs);
        }
    
protected voidcopyFeatures(com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager from, com.sun.org.apache.xerces.internal.util.ParserConfigurationSettings to)

        Enumeration features = Constants.getXercesFeatures();
        copyFeatures1(features, Constants.XERCES_FEATURE_PREFIX, from, to);
        features = Constants.getSAXFeatures();
        copyFeatures1(features, Constants.SAX_FEATURE_PREFIX, from, to);
    
protected voidcopyFeatures(com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager from, com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration to)

        Enumeration features = Constants.getXercesFeatures();
        copyFeatures1(features, Constants.XERCES_FEATURE_PREFIX, from, to);
        features = Constants.getSAXFeatures();
        copyFeatures1(features, Constants.SAX_FEATURE_PREFIX, from, to);
    
private voidcopyFeatures1(java.util.Enumeration features, java.lang.String featurePrefix, com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager from, com.sun.org.apache.xerces.internal.util.ParserConfigurationSettings to)

        while (features.hasMoreElements()) {
            String featureId = featurePrefix + (String)features.nextElement();
            
            to.addRecognizedFeatures(new String[] { featureId });
            
            try {
                to.setFeature(featureId, from.getFeature(featureId));
            }
            catch (XMLConfigurationException e) {
                // componentManager doesn't support this feature,
                // so we won't worry about it
            }
        }
    
private voidcopyFeatures1(java.util.Enumeration features, java.lang.String featurePrefix, com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager from, com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration to)

        while (features.hasMoreElements()) {
            String featureId = featurePrefix + (String)features.nextElement();
            boolean value = from.getFeature(featureId);
            
            try {
                to.setFeature(featureId, value);
            }
            catch (XMLConfigurationException e) {
                // componentManager doesn't support this feature,
                // so we won't worry about it
            }
        }
    
protected com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfigurationcreateXPointerParser()

        XMLParserConfiguration childConfig =
        (XMLParserConfiguration)ObjectFactory.newInstance(
        XPOINTER_DEFAULT_CONFIGURATION,
        ObjectFactory.findClassLoader(),
        true);
        childConfig.setProperty(ERROR_REPORTER, fErrorReporter);
        childConfig.setProperty(
        Constants.XERCES_PROPERTY_PREFIX
        + Constants.NAMESPACE_CONTEXT_PROPERTY,
        fNamespaceContext);
        copyFeatures(fSettings, childConfig);
        return childConfig;
    
public voiddoctypeDecl(java.lang.String rootElement, java.lang.String publicId, java.lang.String systemId, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (isRootDocument() && fDocumentHandler != null) {
            fDocumentHandler.doctypeDecl(rootElement, publicId, systemId, augs);
        }
    
public voidelementDecl(java.lang.String name, java.lang.String contentModel, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.elementDecl(name, contentModel, augmentations);
        }
    
public voidemptyElement(com.sun.org.apache.xerces.internal.xni.QName element, com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        fDepth++;
        setState(getState(fDepth - 1));
        
        // we process the xml:base attributes regardless of what type of element it is
        processXMLBaseAttributes(attributes);
        
        if (isIncludeElement(element)) {
            boolean success = this.handleIncludeElement(attributes);
            if (success) {
                setState(STATE_IGNORE);
            }
            else {
                reportFatalError("NoFallback");
            }
        }
        else if (isFallbackElement(element)) {
            this.handleFallbackElement();
        }
        else if (hasXIncludeNamespace(element)) {
            if (getSawInclude(fDepth - 1)) {
                reportFatalError(
                "IncludeChild",
                new Object[] { element.rawname });
            }
        }
        else if (
        fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            augs = modifyAugmentations(augs);
            attributes = processAttributes(attributes);
            fDocumentHandler.emptyElement(element, attributes, augs);
        }
        // reset the out of scope stack elements
        setSawFallback(fDepth + 1, false);
        setSawInclude(fDepth + 1, false);
        
        // check if an xml:base has gone out of scope
        if (baseURIScope.size() > 0 && fDepth == baseURIScope.peek()) {
            // pop the values from the stack
            restoreBaseURI();
        }
        fDepth--;
    
public voidendAttlist(com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.endAttlist(augmentations);
        }
    
public voidendCDATA(com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.endCDATA(augs);
        }
    
public voidendConditional(com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.endConditional(augmentations);
        }
    
public voidendDTD(com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.endDTD(augmentations);
        }
        fInDTD = false;
    
public voidendDocument(com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (isRootDocument() && fDocumentHandler != null) {
            fDocumentHandler.endDocument(augs);
        }
    
public voidendElement(com.sun.org.apache.xerces.internal.xni.QName element, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        
        if (isIncludeElement(element)) {
            // if we're ending an include element, and we were expecting a fallback
            // we check to see if the children of this include element contained a fallback
            if (getState() == STATE_EXPECT_FALLBACK
            && !getSawFallback(fDepth + 1)) {
                reportFatalError("NoFallback");
            }
        }
        if (isFallbackElement(element)) {
            // the state would have been set to normal processing if we were expecting the fallback element
            // now that we're done processing it, we should ignore all the other children of the include element
            if (getState() == STATE_NORMAL_PROCESSING) {
                setState(STATE_IGNORE);
            }
        }
        else if (
        fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.endElement(element, augs);
        }
        
        // reset the out of scope stack elements
        setSawFallback(fDepth + 1, false);
        setSawInclude(fDepth + 1, false);
        
        // check if an xml:base has gone out of scope
        if (baseURIScope.size() > 0 && fDepth == baseURIScope.peek()) {
            // pop the values from the stack
            restoreBaseURI();
        }
        fDepth--;
    
public voidendExternalSubset(com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.endExternalSubset(augmentations);
        }
    
public voidendGeneralEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.endGeneralEntity(name, augs);
        }
    
public voidendParameterEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.endParameterEntity(name, augmentations);
        }
    
public voidexternalEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.externalEntityDecl(name, identifier, augmentations);
        }
    
public java.lang.StringgetBaseURI(int depth)
Gets the base URI that was in use at that depth

param
depth
return
the base URI

        int scope = scopeOf(depth);
        return (String)expandedSystemID.elementAt(scope);
    
public com.sun.org.apache.xerces.internal.xni.XMLDTDHandlergetDTDHandler()

        return fDTDHandler;
    
public com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSourcegetDTDSource()

        return fDTDSource;
    
public com.sun.org.apache.xerces.internal.xni.XMLDocumentHandlergetDocumentHandler()

        return fDocumentHandler;
    
public com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSourcegetDocumentSource()

        return fDocumentSource;
    
public java.lang.BooleangetFeatureDefault(java.lang.String featureId)
Returns the default state for a feature, or null if this component does not want to report a default value for this feature.

param
featureId The feature identifier.
since
Xerces 2.2.0

        for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {
            if (RECOGNIZED_FEATURES[i].equals(featureId)) {
                return FEATURE_DEFAULTS[i];
            }
        }
        return null;
    
private java.lang.StringgetIncludeParentBaseURI()
Returns the [base URI] of the include parent.

return
the base URI of the include parent.

        int depth = getIncludeParentDepth();
        if (!isRootDocument() && depth == 0) {
            return fParentXIncludeHandler.getIncludeParentBaseURI();
        }
        else {
            return this.getBaseURI(depth);
        }
    
private intgetIncludeParentDepth()
Returns the depth of the include parent. Here, the include parent is calculated as the last non-include or non-fallback element. It is assumed this method is called when the current element is a top level included item. Returning 0 indicates that the top level element in this document was an include element.

return
the depth of the top level include element

        // We don't start at fDepth, since it is either the top level included item,
        // or an include element, when this method is called.
        for (int i = fDepth - 1; i >= 0; i--) {
            // This technically might not always return the first non-include/fallback
            // element that it comes to, since sawFallback() returns true if a fallback
            // was ever encountered at that depth.  However, if a fallback was encountered
            // at that depth, and it wasn't the direct descendant of the current element
            // then we can't be in a situation where we're calling this method (because
            // we'll always be in STATE_IGNORE)
            if (!getSawInclude(i) && !getSawFallback(i)) {
                return i;
            }
        }
        // shouldn't get here, since depth 0 should never have an include element or
        // a fallback element
        return 0;
    
public java.lang.ObjectgetPropertyDefault(java.lang.String propertyId)
Returns the default state for a property, or null if this component does not want to report a default value for this property.

param
propertyId The property identifier.
since
Xerces 2.2.0

        for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {
            if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {
                return PROPERTY_DEFAULTS[i];
            }
        }
        return null;
    
public java.lang.String[]getRecognizedFeatures()
Returns a list of feature identifiers that are recognized by this component. This method may return null if no features are recognized by this component.

        return RECOGNIZED_FEATURES;
    
public java.lang.String[]getRecognizedProperties()
Returns a list of property identifiers that are recognized by this component. This method may return null if no properties are recognized by this component.

        return RECOGNIZED_PROPERTIES;
    
protected java.lang.StringgetRelativeBaseURI()
Returns a URI, relative to the include parent's base URI, of the current [base URI]. For instance, if the current [base URI] was "dir1/dir2/file.xml" and the include parent's [base URI] was "dir/", this would return "dir2/file.xml".

return
the relative URI

        int includeParentDepth = getIncludeParentDepth();
        String relativeURI = this.getRelativeURI(includeParentDepth);
        if (isRootDocument()) {
            return relativeURI;
        }
        else {
            if (relativeURI.equals("")) {
                relativeURI = fCurrentBaseURI.getLiteralSystemId();
            }
            
            if (includeParentDepth == 0) {
                if (fParentRelativeURI == null) {
                    fParentRelativeURI =
                    fParentXIncludeHandler.getRelativeBaseURI();
                }
                if (fParentRelativeURI.equals("")) {
                    return relativeURI;
                }
                URI uri = new URI("file", fParentRelativeURI);
                uri = new URI(uri, relativeURI);
                return uri.getPath();
            }
            else {
                return relativeURI;
            }
        }
    
public java.lang.StringgetRelativeURI(int depth)
Returns a relative URI, which when resolved against the base URI at the specified depth, will create the current base URI. This is accomplished by merged the literal system IDs.

param
depth the depth at which to start creating the relative URI
return
a relative URI to convert the base URI at the given depth to the current base URI

        // The literal system id at the location given by "start" is *in focus* at
        // the given depth. So we need to adjust it to the next scope, so that we
        // only process out of focus literal system ids
        int start = scopeOf(depth) + 1;
        if (start == baseURIScope.size()) {
            // If that is the last system id, then we don't need a relative URI
            return "";
        }
        URI uri = new URI("file", (String)literalSystemID.elementAt(start));
        for (int i = start + 1; i < baseURIScope.size(); i++) {
            uri = new URI(uri, (String)literalSystemID.elementAt(i));
        }
        return uri.getPath();
    
protected booleangetSawFallback(int depth)
Returns whether an <fallback> was encountered at the specified depth, as an ancestor of the current element, or as a sibling of an ancestor of the current element.

param
depth

        if (depth >= fSawFallback.length) {
            return false;
        }
        return fSawFallback[depth];
    
protected booleangetSawInclude(int depth)
Return whether an <include> was encountered at the specified depth, as an ancestor of the current item.

param
depth
return

        if (depth >= fSawInclude.length) {
            return false;
        }
        return fSawInclude[depth];
    
protected intgetState(int depth)

        return fState[depth];
    
protected intgetState()

        return fState[fDepth];
    
protected voidhandleFallbackElement()

        setSawInclude(fDepth, false);
        fNamespaceContext.setContextInvalid();
        if (!getSawInclude(fDepth - 1)) {
            reportFatalError("FallbackParent");
        }
        
        if (getSawFallback(fDepth)) {
            reportFatalError("MultipleFallbacks");
        }
        else {
            setSawFallback(fDepth, true);
        }
        
        // Either the state is STATE_EXPECT_FALLBACK or it's STATE_IGNORE.
        // If we're ignoring, we want to stay ignoring. But if we're expecting this fallback element,
        // we want to signal that we should process the children.
        if (getState() == STATE_EXPECT_FALLBACK) {
            setState(STATE_NORMAL_PROCESSING);
        }
    
protected booleanhandleIncludeElement(com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes)

        setSawInclude(fDepth, true);
        fNamespaceContext.setContextInvalid();
        if (getSawInclude(fDepth - 1)) {
            reportFatalError("IncludeChild", new Object[] { XINCLUDE_INCLUDE });
        }
        if (getState() == STATE_IGNORE)
            return true;
        
        // TODO: does Java use IURIs by default?
        //       [Definition: An internationalized URI reference, or IURI, is a URI reference that directly uses [Unicode] characters.]
        // TODO: figure out what section 4.1.1 of the XInclude spec is talking about
        //       has to do with disallowed ASCII character escaping
        //       this ties in with the above IURI section, but I suspect Java already does it
        
        String href = attributes.getValue(XINCLUDE_ATTR_HREF);
        String parse = attributes.getValue(XINCLUDE_ATTR_PARSE);
        String xpointerPart =  attributes.getValue(XPOINTER);
        String accept = attributes.getValue(XINCLUDE_ATTR_ACCEPT);
        String acceptLanguage = attributes.getValue(XINCLUDE_ATTR_ACCEPT_LANGUAGE);
        
        if (href == null && xpointerPart == null) {
            reportFatalError("XpointerMissing");
        }
        if (parse == null) {
            parse = XINCLUDE_PARSE_XML;
        }
        
        boolean xpointer = false;
        String parserName = null;
        
        //Ignore fragment identifiers, implementation specific as per spec.
        
        if( href.indexOf("#")!=-1 )
            href =  href.substring(0,href.indexOf("#"));
        
        if ( xpointerPart != null && parse.equals(XINCLUDE_PARSE_XML))
            xpointer = true;
        
        // Verify that if an accept and/or an accept-language attribute exist
        // that the value(s) don't contain disallowed characters.
        if (accept != null && !isValidInHTTPHeader(accept)) {
            reportFatalError("AcceptMalformed", null);
        }
        if (acceptLanguage != null && !isValidInHTTPHeader(acceptLanguage)) {
            reportFatalError("AcceptLanguageMalformed", null);
        }
        
        XMLInputSource includedSource = null;
        if (fEntityResolver != null) {
            try {
                XMLResourceIdentifier resourceIdentifier =
                new XMLResourceIdentifierImpl(
                null,
                href,
                fCurrentBaseURI.getExpandedSystemId(),
                XMLEntityManager.expandSystemId(
                href,
                fCurrentBaseURI.getExpandedSystemId(),
                false));
                
                includedSource =
                fEntityResolver.resolveEntity(resourceIdentifier);
            } catch (IOException e) {
                reportResourceError(
                "XMLResourceError",
                new Object[] { href, e.getMessage()});
                return false;
            }
        }
        
        if (includedSource == null) {
            includedSource =
            new XIncludeInputSource(
            null,
            href,
            fCurrentBaseURI.getExpandedSystemId());
        }
        
        if(parse.equals(XINCLUDE_PARSE_XML) && xpointer ){
            if(fXPointerFramework == null){
                fXPointerFramework = new XPointerFramework();
                fXPointerFramework.setXPointerSchema(fXPointerSchema);
            }else{
                fXPointerFramework.reset();
                fXPointerFramework.setXPointerSchema(fXPointerSchema);
            }
            parserName = XPOINTER_DEFAULT_CONFIGURATION;
            fChildConfig = createXPointerParser();
            fXPointerFramework.setSchemaPointer(xpointerPart);
            // we don't want a schema validator on the new pipeline,
            // so we set it to false, regardless of what was copied above
           /* fChildConfig.setFeature(
            Constants.XERCES_FEATURE_PREFIX
            + Constants.SCHEMA_VALIDATION_FEATURE,
            false);*/
           	//-Revisit and clean up this piece of unclean code. 
            XPointerSchema fXPointerSchemaS;
            
            if((fXPointerSchemaS = fXPointerFramework.getNextXPointerSchema()) == null && fXPointerFramework.getSchemaCount() == 0){
                fNamespaceContext.pushScope();
                fXPointerSchemaS = fXPointerFramework.getDefaultSchema();
                fXPointerSchemaS.setXPointerSchemaPointer(xpointerPart);
                processSchema(fXPointerSchemaS,includedSource);
                /*
                 Object sch = null;
                if(!fXPointerFramework.fSchemaNotAvailable.empty())
                    sch = fXPointerFramework.fSchemaNotAvailable.pop();
                reportFatalError("NO_XPointerSchema",  new Object[] {sch});
                 */
            }else {
                try {
                    fNamespaceContext.pushScope();
                    if(fXPointerSchemaS != null && processSchema(fXPointerSchemaS,includedSource)){
                        ;
                    }else{
                        for (int i=fXPointerFramework.getCurrentPointer(); i <=fXPointerFramework.getSchemaCount();i++){
                            fXPointerSchemaS = fXPointerFramework.getNextXPointerSchema();
                            if(fXPointerSchemaS != null && processSchema(fXPointerSchemaS,includedSource)){
                                break;
                            }
                        }
                    }
                }
                catch (XNIException e) {
                    reportFatalError("XMLParseError");
                }
                finally {
                    fNamespaceContext.popScope();
                }
            }
            
        }
        else if (parse.equals(XINCLUDE_PARSE_XML)) {
            // Instead of always creating a new configuration, the first one can be reused
            //if (fChildConfig == null) {
            parserName = XINCLUDE_DEFAULT_CONFIGURATION;
            
            fChildConfig =
            (XMLParserConfiguration)ObjectFactory.newInstance(
            parserName,
            ObjectFactory.findClassLoader(),
            true);
            // use the same error reporter, entity resolver, and security manager.
            if (fErrorReporter != null) fChildConfig.setProperty(ERROR_REPORTER, fErrorReporter);
            if (fEntityResolver != null) fChildConfig.setProperty(ENTITY_RESOLVER, fEntityResolver);
            if (fSecurityManager != null) fChildConfig.setProperty(SECURITY_MANAGER, fSecurityManager);
            
            // use the same namespace context
            fChildConfig.setProperty(
            Constants.XERCES_PROPERTY_PREFIX
            + Constants.NAMESPACE_CONTEXT_PROPERTY,
            fNamespaceContext);
            
            XIncludeHandler newHandler =
            (XIncludeHandler)fChildConfig.getProperty(
            Constants.XERCES_PROPERTY_PREFIX
            + Constants.XINCLUDE_HANDLER_PROPERTY);
            newHandler.setParent(this);
            newHandler.setDocumentHandler(this.getDocumentHandler());
            //}
            
            // set all features on parserConfig to match this parser configuration
            copyFeatures(fSettings, fChildConfig);
            // we don't want a schema validator on the new pipeline,
            // so we set it to false, regardless of what was copied above
            fChildConfig.setFeature(
            Constants.XERCES_FEATURE_PREFIX
            + Constants.SCHEMA_VALIDATION_FEATURE,
            false);
            fChildConfig.setFeature(
            Constants.XERCES_FEATURE_PREFIX
            + Constants.XINCLUDE_AWARE,
            true);
            
            try {
                fNamespaceContext.pushScope();
                includedSource = setHttpProperties(includedSource,attributes);
                fChildConfig.parse(includedSource);
                // necessary to make sure proper location is reported in errors
                if (fErrorReporter != null) {
                    fErrorReporter.setDocumentLocator(fDocLocation);
                }
            }
            catch (XNIException e) {
                // necessary to make sure proper location is reported in errors
                if (fErrorReporter != null) {
                    fErrorReporter.setDocumentLocator(fDocLocation);
                }
                reportFatalError("XMLParseError", new Object[] { href });
            }
            catch (IOException e) {
                // necessary to make sure proper location is reported in errors
                if (fErrorReporter != null) {
                    fErrorReporter.setDocumentLocator(fDocLocation);
                }
                // An IOException indicates that we had trouble reading the file, not
                // that it was an invalid XML file.  So we send a resource error, not a
                // fatal error.
                reportResourceError(
                "XMLResourceError",
                new Object[] { href, e.getMessage()});
                return false;
            }
            finally {
                fNamespaceContext.popScope();
            }
        }
        else if (parse.equals(XINCLUDE_PARSE_TEXT)) {
            // we only care about encoding for parse="text"
            String encoding = attributes.getValue(XINCLUDE_ATTR_ENCODING);
            includedSource.setEncoding(encoding);
            
            XIncludeTextReader reader = null;
            try {
                if (fIsXML11) {
                    reader = new XInclude11TextReader(includedSource, this);
                }
                else {
                    reader = new XIncludeTextReader(includedSource, this);
                }
                if (includedSource.getCharacterStream() == null
                && includedSource.getByteStream() == null) {
                    reader.setHttpProperties(accept, acceptLanguage);
                }
                reader.setErrorReporter(fErrorReporter);
                reader.parse();
            }
            // encoding errors
            catch (MalformedByteSequenceException ex) {
                fErrorReporter.reportError(ex.getDomain(), ex.getKey(),
                ex.getArguments(), XMLErrorReporter.SEVERITY_FATAL_ERROR);
            }
            catch (CharConversionException e) {
                fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
                "CharConversionFailure", null, XMLErrorReporter.SEVERITY_FATAL_ERROR);
            }
            catch (IOException e) {
                reportResourceError(
                "TextResourceError",
                new Object[] { href, e.getMessage()});
                return false;
            }
            finally {
                if (reader != null) {
                    try {
                        reader.close();
                    }
                    catch (IOException e) {
                        reportResourceError(
                        "TextResourceError",
                        new Object[] { href, e.getMessage()});
                        return false;
                    }
                }
            }
        }
        else {
            reportFatalError("InvalidParseValue", new Object[] { parse });
        }
        return true;
    
protected booleanhasXIncludeNamespace(com.sun.org.apache.xerces.internal.xni.QName element)
Returns true if the element has the namespace "http://www.w3.org/2001/XInclude"

param
element the element to check
return
true if the element has the namespace "http://www.w3.org/2001/XInclude"

        // REVISIT: The namespace of this element should be bound
        // already. Why are we looking it up from the namespace
        // context? -- mrglavas
        return element.uri == XINCLUDE_NS_URI
        || fNamespaceContext.getURI(element.prefix) == XINCLUDE_NS_URI;
    
public voidignorableWhitespace(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.ignorableWhitespace(text, augs);
        }
    
public voidignoredCharacters(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.ignoredCharacters(text, augmentations);
        }
    
public voidinternalEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.XMLString nonNormalizedText, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.internalEntityDecl(
            name,
            text,
            nonNormalizedText,
            augmentations);
        }
    
protected booleanisFallbackElement(com.sun.org.apache.xerces.internal.xni.QName element)
Checks if the element is an <fallback> element. The element must have the XInclude namespace, and a local name of "fallback".

param
element the element to check
return
true if the element is an <fallback; element
see
#hasXIncludeNamespace(QName)

        return element.localpart.equals(XINCLUDE_FALLBACK) &&
        hasXIncludeNamespace(element);
    
protected booleanisIncludeElement(com.sun.org.apache.xerces.internal.xni.QName element)
Checks if the element is an <include> element. The element must have the XInclude namespace, and a local name of "include".

param
element the element to check
return
true if the element is an <include> element
see
#hasXIncludeNamespace(QName)

        return element.localpart.equals(XINCLUDE_INCLUDE) &&
        hasXIncludeNamespace(element);
    
protected booleanisRootDocument()

        return fParentXIncludeHandler == null;
    
protected booleanisTopLevelIncludedItem()
Returns true if the current element is a top level included item. This means it's either the child of a fallback element, or the top level item in an included document

return
true if the current element is a top level included item

        return isTopLevelIncludedItemViaInclude()
        || isTopLevelIncludedItemViaFallback();
    
protected booleanisTopLevelIncludedItemViaFallback()

        // Technically, this doesn't check if the parent was a fallback, it also
        // would return true if any of the parent's sibling elements were fallbacks.
        // However, this doesn't matter, since we will always be ignoring elements
        // whose parent's siblings were fallbacks.
        return getSawFallback(fDepth - 1);
    
protected booleanisTopLevelIncludedItemViaInclude()

        return fDepth == 1 && !isRootDocument();
    
private booleanisValidInHTTPHeader(java.lang.String value)
Returns true if the given string would be valid in an HTTP header.

param
value string to check
return
true if the given string would be valid in an HTTP header

        char ch;
        for (int i = value.length() - 1; i >= 0; --i) {
            ch = value.charAt(i);
            if (ch < 0x20 || ch > 0x7E) {
                return false;
            }
        }
        return true;
    
protected com.sun.org.apache.xerces.internal.xni.AugmentationsmodifyAugmentations(com.sun.org.apache.xerces.internal.xni.Augmentations augs)
Modify the augmentations. Add an [included] infoset item, if the current element is a top level included item.

param
augs the Augmentations to modify.
return
the modified Augmentations

        return modifyAugmentations(augs, false);
    
protected com.sun.org.apache.xerces.internal.xni.AugmentationsmodifyAugmentations(com.sun.org.apache.xerces.internal.xni.Augmentations augs, boolean force)
Modify the augmentations. Add an [included] infoset item, if force is true, or if the current element is a top level included item.

param
augs the Augmentations to modify.
param
force whether to force modification
return
the modified Augmentations

        if (force || isTopLevelIncludedItem()) {
            if (augs == null) {
                augs = new AugmentationsImpl();
            }
            augs.putItem(XINCLUDE_INCLUDED, Boolean.TRUE);
        }
        return augs;
    
public voidnotationDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        this.addNotation(name, identifier, augmentations);
        if (fDTDHandler != null) {
            fDTDHandler.notationDecl(name, identifier, augmentations);
        }
    
protected com.sun.org.apache.xerces.internal.xni.XMLAttributesprocessAttributes(com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes)
Processes the XMLAttributes object of startElement() calls. Performs the following tasks:
  • If the element is a top level included item whose [base URI] is different from the [base URI] of the include parent, then an xml:base attribute is added to specify the true [base URI]
  • For all namespace prefixes which are in-scope in an included item, but not in scope in the include parent, a xmlns:prefix attribute is added
  • For all attributes with a type of ENTITY, ENTITIES or NOTATIONS, the notations and unparsed entities are processed as described in the spec, sections 4.5.1 and 4.5.2

param
attributes
return

        if (isTopLevelIncludedItem()) {
            // Modify attributes to fix the base URI (spec 4.5.5).
            // We only do it to top level included elements, which have a different
            // base URI than their include parent.
            if (!sameBaseURIAsIncludeParent()) {
                if (attributes == null) {
                    attributes = new XMLAttributesImpl();
                }
                
                // This causes errors with schema validation, if the schema doesn't
                // specify that these elements can have an xml:base attribute
                // TODO: add a user option to turn this off?
                String uri = null;
                try {
                    uri = this.getRelativeBaseURI();
                }
                catch (MalformedURIException e) {
                    // this shouldn't ever happen, since by definition, we had to traverse
                    // the same URIs to even get to this place
                    uri = fCurrentBaseURI.getExpandedSystemId();
                }
                int index =
                attributes.addAttribute(
                XML_BASE_QNAME,
                XMLSymbols.fCDATASymbol,
                uri);
                attributes.setSpecified(index, true);
            }
            
            // Modify attributes of included items to do namespace-fixup. (spec 4.5.4)
            Enumeration inscopeNS = fNamespaceContext.getAllPrefixes();
            while (inscopeNS.hasMoreElements()) {
                String prefix = (String)inscopeNS.nextElement();
                String parentURI =
                fNamespaceContext.getURIFromIncludeParent(prefix);
                String uri = fNamespaceContext.getURI(prefix);
                if (parentURI != uri && attributes != null) {
                    if (prefix == XMLSymbols.EMPTY_STRING) {
                        if (attributes
                        .getValue(
                        NamespaceContext.XMLNS_URI,
                        XMLSymbols.PREFIX_XMLNS)
                        == null) {
                            if (attributes == null) {
                                attributes = new XMLAttributesImpl();
                            }
                            
                            QName ns = (QName)NEW_NS_ATTR_QNAME.clone();
                            ns.localpart = XMLSymbols.PREFIX_XMLNS;
                            ns.rawname = XMLSymbols.PREFIX_XMLNS;
                            attributes.addAttribute(
                            ns,
                            XMLSymbols.fCDATASymbol,
                            uri);
                        }
                    }
                    else if (
                    attributes.getValue(NamespaceContext.XMLNS_URI, prefix)
                    == null) {
                        if (attributes == null) {
                            attributes = new XMLAttributesImpl();
                        }
                        
                        QName ns = (QName)NEW_NS_ATTR_QNAME.clone();
                        ns.localpart = prefix;
                        ns.rawname += prefix;
                        attributes.addAttribute(
                        ns,
                        XMLSymbols.fCDATASymbol,
                        uri);
                    }
                }
            }
        }
        
        if (attributes != null) {
            int length = attributes.getLength();
            for (int i = 0; i < length; i++) {
                String type = attributes.getType(i);
                String value = attributes.getValue(i);
                if (type == XMLSymbols.fENTITYSymbol) {
                    this.checkUnparsedEntity(value);
                }
                if (type == XMLSymbols.fENTITIESSymbol) {
                    // 4.5.1 - Unparsed Entities
                    StringTokenizer st = new StringTokenizer(value);
                    while (st.hasMoreTokens()) {
                        String entName = st.nextToken();
                        this.checkUnparsedEntity(entName);
                    }
                }
                else if (type == XMLSymbols.fNOTATIONSymbol) {
                    // 4.5.2 - Notations
                    this.checkNotation(value);
                }
                /* We actually don't need to do anything for 4.5.3, because at this stage the
                 * value of the attribute is just a string. It will be taken care of later
                 * in the pipeline, when the IDREFs are actually resolved against IDs.
                 *
                 * if (type == XMLSymbols.fIDREFSymbol || type == XMLSymbols.fIDREFSSymbol) { }
                 */
            }
        }
        
        return attributes;
    
public booleanprocessSchema(com.sun.org.apache.xerces.internal.xinclude.XPointerSchema fXPointerSchemaS, com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource includedSource)

        try{
            fChildConfig = createXPointerParser();//for now -Revisit and change this.
            fChildConfig.setProperty(Constants.XERCES_PROPERTY_PREFIX
            + Constants.XINCLUDE_HANDLER_PROPERTY,
            fXPointerSchemaS);
            fXPointerSchemaS.setParent(this);
            fXPointerSchemaS.setDocumentHandler(this.getDocumentHandler());
            fChildConfig.parse(includedSource);
        }
        catch (Exception e) {
            //Venu For now do this.
            reportResourceError(
            "XMLResourceError",
            new Object[] { null, e.getMessage()});
        }
        return fXPointerSchemaS.isSubResourceIndentified();
    
protected voidprocessXMLBaseAttributes(com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes)
Search for a xml:base attribute, and if one is found, put the new base URI into effect.

        String baseURIValue =
        attributes.getValue(NamespaceContext.XML_URI, "base");
        if (baseURIValue != null) {
            try {
                String expandedValue =
                XMLEntityManager.expandSystemId(
                baseURIValue,
                fCurrentBaseURI.getExpandedSystemId(),
                false);
                fCurrentBaseURI.setLiteralSystemId(baseURIValue);
                fCurrentBaseURI.setBaseSystemId(
                fCurrentBaseURI.getExpandedSystemId());
                fCurrentBaseURI.setExpandedSystemId(expandedValue);
                
                // push the new values on the stack
                saveBaseURI();
            }
            catch (MalformedURIException e) {
                // REVISIT: throw error here
            }
        }
    
public voidprocessingInstruction(java.lang.String target, com.sun.org.apache.xerces.internal.xni.XMLString data, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (!fInDTD) {
            if (fDocumentHandler != null
            && getState() == STATE_NORMAL_PROCESSING) {
                // we need to change the depth like this so that modifyAugmentations() works
                fDepth++;
                augs = modifyAugmentations(augs);
                fDocumentHandler.processingInstruction(target, data, augs);
                fDepth--;
            }
        }
        else if (fDTDHandler != null) {
            fDTDHandler.processingInstruction(target, data, augs);
        }
    
private voidreportError(java.lang.String key, java.lang.Object[] args, short severity)

        if (fErrorReporter != null) {
            fErrorReporter.reportError(
            XIncludeMessageFormatter.XINCLUDE_DOMAIN,
            key,
            args,
            severity);
        }
        // we won't worry about when error reporter is null, since there should always be
        // at least the default error reporter
    
protected voidreportFatalError(java.lang.String key)

        this.reportFatalError(key, null);
    
protected voidreportFatalError(java.lang.String key, java.lang.Object[] args)

        this.reportError(key, args, XMLErrorReporter.SEVERITY_FATAL_ERROR);
    
protected voidreportResourceError(java.lang.String key)

        this.reportFatalError(key, null);
    
protected voidreportResourceError(java.lang.String key, java.lang.Object[] args)

        this.reportError(key, args, XMLErrorReporter.SEVERITY_WARNING);
    
public voidreset(com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager componentManager)

        fNamespaceContext = null;
        fDepth = 0;
        fNotations = new Vector();
        fUnparsedEntities = new Vector();
        fParentRelativeURI = null;
        fIsXML11 = false;
        fInDTD = false;
        
        baseURIScope.clear();
        baseURI.clear();
        literalSystemID.clear();
        expandedSystemID.clear();
        
        // REVISIT: Find a better method for maintaining
        // the state of the XInclude processor. These arrays
        // can potentially grow quite large. Cleaning them
        // out on reset may be very time consuming. -- mrglavas
        //
        // clear the previous settings from the arrays
        for (int i = 0; i < fState.length; ++i) {
            fState[i] = STATE_NORMAL_PROCESSING;
        }
        for (int i = 0; i < fSawFallback.length; ++i) {
            fSawFallback[i] = false;
        }
        for (int i = 0; i < fSawInclude.length; ++i) {
            fSawInclude[i] = false;
        }
        
        try {
            fSendUEAndNotationEvents =
            componentManager.getFeature(ALLOW_UE_AND_NOTATION_EVENTS);
            if (fChildConfig != null) {
                fChildConfig.setFeature(
                ALLOW_UE_AND_NOTATION_EVENTS,
                fSendUEAndNotationEvents);
            }
        }
        catch (XMLConfigurationException e) {
        }
        
        // Get error reporter.
        try {
            XMLErrorReporter value =
            (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER);
            if (value != null) {
                setErrorReporter(value);
                if (fChildConfig != null) {
                    fChildConfig.setProperty(ERROR_REPORTER, value);
                }
            }
            
        }
        catch (XMLConfigurationException e) {
            fErrorReporter = null;
        }
        
        // Get entity resolver.
        try {
            XMLEntityResolver value =
            (XMLEntityResolver)componentManager.getProperty(
            ENTITY_RESOLVER);
            
            if (value != null) {
                fEntityResolver = value;
                if (fChildConfig != null) {
                    fChildConfig.setProperty(ENTITY_RESOLVER, value);
                }
            }
        }
        catch (XMLConfigurationException e) {
            fEntityResolver = null;
        }
        
        try {
            fXPointerSchema =
            (XPointerSchema [])componentManager.getProperty(
            XPOINTER_SCHEMA);
        }
        catch (XMLConfigurationException e) {
            fXPointerSchema = null;
        }
        
        // Get security manager.
        try {
            SecurityManager value =
            (SecurityManager)componentManager.getProperty(
            SECURITY_MANAGER);
            
            if (value != null) {
                fSecurityManager = value;
                if (fChildConfig != null) {
                    fChildConfig.setProperty(SECURITY_MANAGER, value);
                }
            }
        }
        catch (XMLConfigurationException e) {
            fSecurityManager = null;
        }
        
        fSettings = new ParserConfigurationSettings();
        copyFeatures(componentManager, fSettings);
        // Don't reset fChildConfig -- we don't want it to share the same components.
        // It will be reset when it is actually used to parse something.
    
protected voidrestoreBaseURI()
Discards the URIs at the top of the stack, and restores the ones beneath it.

        baseURI.pop();
        literalSystemID.pop();
        expandedSystemID.pop();
        baseURIScope.pop();
        fCurrentBaseURI.setBaseSystemId((String)baseURI.peek());
        fCurrentBaseURI.setLiteralSystemId((String)literalSystemID.peek());
        fCurrentBaseURI.setExpandedSystemId((String)expandedSystemID.peek());
    
protected booleansameBaseURIAsIncludeParent()
Returns true if the current [base URI] is the same as the [base URI] that was in effect on the include parent. This method should only be called when the current element is a top level included element, i.e. the direct child of a fallback element, or the root elements in an included document. The "include parent" is the element which, in the result infoset, will be the direct parent of the current element.

return
true if the [base URIs] are the same string

        String parentBaseURI = getIncludeParentBaseURI();
        String baseURI = fCurrentBaseURI.getExpandedSystemId();
        // REVISIT: should we use File#sameFile() ?
        //          I think the benefit of using it is that it resolves host names
        //          instead of just doing a string comparison.
        // TODO: [base URI] is still an open issue with the working group.
        //       They're deciding if xml:base should be added if the [base URI] is different in terms
        //       of resolving relative references, or if it should be added if they are different at all.
        //       Revisit this after a final decision has been made.
        //       The decision also affects whether we output the file name of the URI, or just the path.
        return parentBaseURI != null && parentBaseURI.equals(baseURI);
    
protected voidsaveBaseURI()
Saves the current base URI to the top of the stack.

        baseURIScope.push(fDepth);
        baseURI.push(fCurrentBaseURI.getBaseSystemId());
        literalSystemID.push(fCurrentBaseURI.getLiteralSystemId());
        expandedSystemID.push(fCurrentBaseURI.getExpandedSystemId());
    
private intscopeOf(int depth)

        for (int i = baseURIScope.size() - 1; i >= 0; i--) {
            if (baseURIScope.elementAt(i) <= depth)
                return i;
        }
        
        // we should never get here, because 0 was put on the stack in startDocument()
        return -1;
    
protected booleansearchForRecursiveIncludes(com.sun.org.apache.xerces.internal.xni.XMLLocator includedSource)
Checks if the file indicated by the given XMLLocator has already been included in the current stack.

param
includedSource the source to check for inclusion
return
true if the source has already been included

        String includedSystemId = includedSource.getExpandedSystemId();
        
        if (includedSystemId == null) {
            try {
                includedSystemId =
                XMLEntityManager.expandSystemId(
                includedSource.getLiteralSystemId(),
                includedSource.getBaseSystemId(),
                false);
            }
            catch (MalformedURIException e) {
                reportFatalError("ExpandedSystemId");
            }
        }
        
        if (includedSystemId.equals(fCurrentBaseURI.getExpandedSystemId())) {
            return true;
        }
        
        if (fParentXIncludeHandler == null) {
            return false;
        }
        return fParentXIncludeHandler.searchForRecursiveIncludes(
        includedSource);
    
public voidsetDTDHandler(com.sun.org.apache.xerces.internal.xni.XMLDTDHandler handler)

        fDTDHandler = handler;
    
public voidsetDTDSource(com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource source)

        fDTDSource = source;
    
public voidsetDocumentHandler(com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler handler)

        fDocumentHandler = handler;
    
public voidsetDocumentSource(com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource source)

        fDocumentSource = source;
    
private voidsetErrorReporter(com.sun.org.apache.xerces.internal.impl.XMLErrorReporter reporter)

        fErrorReporter = reporter;
        if (fErrorReporter != null) {
            fErrorReporter.putMessageFormatter(
            XIncludeMessageFormatter.XINCLUDE_DOMAIN,
            new XIncludeMessageFormatter());
            // this ensures the proper location is displayed in error messages
            if (fDocLocation != null) {
                fErrorReporter.setDocumentLocator(fDocLocation);
            }
        }
    
public voidsetFeature(java.lang.String featureId, boolean state)
Sets the state of a feature. This method is called by the component manager any time after reset when a feature changes state.

Note: Components should silently ignore features that do not affect the operation of the component.

param
featureId The feature identifier.
param
state The state of the feature.
throws
SAXNotRecognizedException The component should not throw this exception.
throws
SAXNotSupportedException The component should not throw this exception.

        if (featureId.equals(ALLOW_UE_AND_NOTATION_EVENTS)) {
            fSendUEAndNotationEvents = state;
        }
        if (fSettings != null) {
            fSettings.setFeature(featureId, state);
        }
    
protected com.sun.org.apache.xerces.internal.xni.parser.XMLInputSourcesetHttpProperties(com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource source, com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes)
Set the Accept,Accept-Language,Accept-CharSet

        String httpAcceptLang = attributes.getValue(HTTP_ACCEPT_LANGUAGE);
        String httpAccept = attributes.getValue(HTTP_ACCEPT);
        String httpAcceptchar = attributes.getValue(HTTP_ACCEPT_CHARSET);
        if (source.getCharacterStream() == null && source.getByteStream() == null) {
            XIncludeInputSource includeSource = new XIncludeInputSource(source.getPublicId(),source.getSystemId(),source.getBaseSystemId(), source.getByteStream(),source.getEncoding());
            includeSource.setProperty(XINCLUDE_ATTR_ACCEPT,attributes.getValue(XINCLUDE_ATTR_ACCEPT));
            includeSource.setProperty(XINCLUDE_ATTR_ACCEPT_CHARSET,attributes.getValue(XINCLUDE_ATTR_ACCEPT_CHARSET));
            includeSource.setProperty(XINCLUDE_ATTR_ACCEPT_LANGUAGE,attributes.getValue(XINCLUDE_ATTR_ACCEPT_LANGUAGE));
        }
        return source;
    
protected voidsetParent(com.sun.org.apache.xerces.internal.xinclude.XIncludeHandler parent)
Set the parent of this XIncludeHandler in the tree

param
parent

        fParentXIncludeHandler = parent;
    
public voidsetProperty(java.lang.String propertyId, java.lang.Object value)
Sets the value of a property. This method is called by the component manager any time after reset when a property changes value.

Note: Components should silently ignore properties that do not affect the operation of the component.

param
propertyId The property identifier.
param
value The value of the property.
throws
SAXNotRecognizedException The component should not throw this exception.
throws
SAXNotSupportedException The component should not throw this exception.

        if (propertyId.equals(ERROR_REPORTER)) {
            setErrorReporter((XMLErrorReporter)value);
            if (fChildConfig != null) {
                fChildConfig.setProperty(propertyId, value);
            }
        }
        if (propertyId.equals(ENTITY_RESOLVER)) {
            fEntityResolver = (XMLEntityResolver)value;
            if (fChildConfig != null) {
                fChildConfig.setProperty(propertyId, value);
            }
        }
        if (propertyId.equals(SECURITY_MANAGER)) {
            fSecurityManager = (SecurityManager)value;
            if (fChildConfig != null) {
                fChildConfig.setProperty(propertyId, value);
            }
        }
        
    
protected voidsetSawFallback(int depth, boolean val)
Records that an <fallback> was encountered at the specified depth, as an ancestor of the current element, or as a sibling of an ancestor of the current element.

param
depth
param
val

        if (depth >= fSawFallback.length) {
            boolean[] newarray = new boolean[depth * 2];
            System.arraycopy(fSawFallback, 0, newarray, 0, fSawFallback.length);
            fSawFallback = newarray;
        }
        fSawFallback[depth] = val;
    
protected voidsetSawInclude(int depth, boolean val)
Records that an <include> was encountered at the specified depth, as an ancestor of the current item.

param
depth
param
val

        if (depth >= fSawInclude.length) {
            boolean[] newarray = new boolean[depth * 2];
            System.arraycopy(fSawInclude, 0, newarray, 0, fSawInclude.length);
            fSawInclude = newarray;
        }
        fSawInclude[depth] = val;
    
protected voidsetState(int state)

        if (fDepth >= fState.length) {
            int[] newarray = new int[fDepth * 2];
            System.arraycopy(fState, 0, newarray, 0, fState.length);
            fState = newarray;
        }
        fState[fDepth] = state;
    
public voidstartAttlist(java.lang.String elementName, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.startAttlist(elementName, augmentations);
        }
    
public voidstartCDATA(com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.startCDATA(augs);
        }
    
public voidstartConditional(short type, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.startConditional(type, augmentations);
        }
    
public voidstartDTD(com.sun.org.apache.xerces.internal.xni.XMLLocator locator, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        fInDTD = true;
        if (fDTDHandler != null) {
            fDTDHandler.startDTD(locator, augmentations);
        }
    
public voidstartDocument(com.sun.org.apache.xerces.internal.xni.XMLLocator locator, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.NamespaceContext namespaceContext, com.sun.org.apache.xerces.internal.xni.Augmentations augs)
Event sent at the start of the document. A fatal error will occur here, if it is detected that this document has been processed before. This event is only passed on to the document handler if this is the root document.

        
        // we do this to ensure that the proper location is reported in errors
        // otherwise, the locator from the root document would always be used
        if(fErrorReporter != null)
            fErrorReporter.setDocumentLocator(locator);
        if (!isRootDocument()
        && fParentXIncludeHandler.searchForRecursiveIncludes(locator)) {
            reportFatalError(
            "RecursiveInclude",
            new Object[] { locator.getExpandedSystemId()});
        }
        
        if (!(namespaceContext instanceof XIncludeNamespaceSupport)) {
            reportFatalError("IncompatibleNamespaceContext");
        }
        fNamespaceContext = (XIncludeNamespaceSupport)namespaceContext;
        fDocLocation = locator;
        
        // initialize the current base URI
        fCurrentBaseURI.setBaseSystemId(locator.getBaseSystemId());
        fCurrentBaseURI.setExpandedSystemId(locator.getExpandedSystemId());
        fCurrentBaseURI.setLiteralSystemId(locator.getLiteralSystemId());
        saveBaseURI();
        if (augs == null) {
            augs = new AugmentationsImpl();
        }
        augs.putItem(CURRENT_BASE_URI, fCurrentBaseURI);
        
        if (isRootDocument() && fDocumentHandler != null) {
            fDocumentHandler.startDocument(
            locator,
            encoding,
            namespaceContext,
            augs);
        }
    
public voidstartElement(com.sun.org.apache.xerces.internal.xni.QName element, com.sun.org.apache.xerces.internal.xni.XMLAttributes attributes, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        fDepth++;
        setState(getState(fDepth - 1));
        // we process the xml:base attributes regardless of what type of element it is
        processXMLBaseAttributes(attributes);
        
        if (isIncludeElement(element)) {
            boolean success = this.handleIncludeElement(attributes);
            if (success) {
                setState(STATE_IGNORE);
            }
            else {
                setState(STATE_EXPECT_FALLBACK);
            }
        }
        else if (isFallbackElement(element)) {
            this.handleFallbackElement();
        }
        else if (
        fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            augs = modifyAugmentations(augs);
            attributes = processAttributes(attributes);
            fDocumentHandler.startElement(element, attributes, augs);
        }
    
public voidstartExternalSubset(com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.startExternalSubset(identifier, augmentations);
        }
    
public voidstartGeneralEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier resId, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.startGeneralEntity(name, resId, encoding, augs);
        }
    
public voidstartParameterEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        if (fDTDHandler != null) {
            fDTDHandler.startParameterEntity(
            name,
            identifier,
            encoding,
            augmentations);
        }
    
public voidtextDecl(java.lang.String version, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        if (fDocumentHandler != null
        && getState() == STATE_NORMAL_PROCESSING) {
            fDocumentHandler.textDecl(version, encoding, augs);
        }
    
public voidunparsedEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, java.lang.String notation, com.sun.org.apache.xerces.internal.xni.Augmentations augmentations)

        this.addUnparsedEntity(name, identifier, notation, augmentations);
        if (fDTDHandler != null) {
            fDTDHandler.unparsedEntityDecl(
            name,
            identifier,
            notation,
            augmentations);
        }
    
public voidxmlDecl(java.lang.String version, java.lang.String encoding, java.lang.String standalone, com.sun.org.apache.xerces.internal.xni.Augmentations augs)

        fIsXML11 = "1.1".equals(version);
        if (isRootDocument() && fDocumentHandler != null) {
            fDocumentHandler.xmlDecl(version, encoding, standalone, augs);
        }