• Home
• com.rackspace.apache
• xerces2-xsd11
• 2.11.2
• source code
• SchemaDOMParser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.apache.xerces.impl.xs.opti.SchemaDOMParser Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.xerces.impl.xs.opti;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.xerces.impl.Constants;
import org.apache.xerces.impl.XMLErrorReporter;
import org.apache.xerces.impl.xs.SchemaSymbols;
import org.apache.xerces.impl.xs.XSMessageFormatter;
import org.apache.xerces.impl.xs.util.XS11TypeHelper;
import org.apache.xerces.util.XMLAttributesImpl;
import org.apache.xerces.util.XMLChar;
import org.apache.xerces.xni.Augmentations;
import org.apache.xerces.xni.NamespaceContext;
import org.apache.xerces.xni.QName;
import org.apache.xerces.xni.XMLAttributes;
import org.apache.xerces.xni.XMLLocator;
import org.apache.xerces.xni.XMLString;
import org.apache.xerces.xni.XNIException;
import org.apache.xerces.xni.parser.XMLEntityResolver;
import org.apache.xerces.xni.parser.XMLInputSource;
import org.apache.xerces.xni.parser.XMLParserConfiguration;
import org.apache.xerces.xs.datatypes.XSDecimal;
import org.w3c.dom.Document;

/**
 * @xerces.internal
 * 
 * @author Rahul Srivastava, Sun Microsystems Inc.
 * @author Sandy Gao, IBM
 *
 * @version $Id$
 */
public class SchemaDOMParser extends DefaultXMLDocumentHandler {
    
    //
    // Data
    //
    
    /** Property identifier: error reporter. */
    public static final String ERROR_REPORTER =
        Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
    
    /** Feature identifier: generate synthetic annotations. */
    public static final String GENERATE_SYNTHETIC_ANNOTATION =
        Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
    
    // the locator containing line/column information
    protected XMLLocator   fLocator;
    
    // namespace context, needed for producing
    // representations of annotations
    protected NamespaceContext fNamespaceContext = null;
    
    SchemaDOM schemaDOM;
    
    XMLParserConfiguration config;
    
    //
    // Constructors
    //
    
    /** Default constructor. */
    public SchemaDOMParser(XMLParserConfiguration config) {
        this.config = config;
        config.setDocumentHandler(this);
        config.setDTDHandler(this);
        config.setDTDContentModelHandler(this);
    }
    
    // Reference to the current annotation element.
    private ElementImpl fCurrentAnnotationElement;
    // where an annotation element itself begins
    // -1 means not in an annotation's scope
    private int fAnnotationDepth = -1;
    // Where xs:appinfo or xs:documentation starts;
    // -1 means not in the scope of either of the two elements.
    private int fInnerAnnotationDepth = -1;
    // The current element depth
    private int fDepth = -1;
    // Use to report the error when characters are not allowed.
    XMLErrorReporter fErrorReporter;
    
    // fields for generate-synthetic annotations feature
    private boolean fGenerateSyntheticAnnotation = false;
    private BooleanStack fHasNonSchemaAttributes = new BooleanStack();
    private BooleanStack fSawAnnotation = new BooleanStack();
    private XMLAttributes fEmptyAttr = new XMLAttributesImpl();

    // fields for conditional inclusion
    private XSDecimal fSupportedVersion;
    private int fIgnoreDepth = -1;
    private boolean fPerformConditionalInclusion = true; //REVISIT: use feature
    
    // instance variable to support XML Schema 1.1 conditional include processing. 
    private SchemaConditionalIncludeHelper schemaCondlInclHelper = new SchemaConditionalIncludeHelper(); 
    
    //
    // XMLDocumentHandler methods
    //
    
    public void startDocument(XMLLocator locator, String encoding, 
            NamespaceContext namespaceContext, Augmentations augs)
    throws XNIException {
        fErrorReporter = (XMLErrorReporter)config.getProperty(ERROR_REPORTER);
        fGenerateSyntheticAnnotation = config.getFeature(GENERATE_SYNTHETIC_ANNOTATION);
        fHasNonSchemaAttributes.clear();
        fSawAnnotation.clear();
        schemaDOM = new SchemaDOM();
        fCurrentAnnotationElement = null;
        fAnnotationDepth = -1;
        fInnerAnnotationDepth = -1;
        fDepth = -1;
        fIgnoreDepth = -1;
        fLocator = locator;
        fNamespaceContext = namespaceContext;
        schemaDOM.setDocumentURI(locator.getExpandedSystemId());
    } // startDocument(XMLLocator,String,NamespaceContext, Augmentations)
    
    /**
     * The end of the document.
     * @param augs     Additional information that may include infoset augmentations
     *
     * @throws XNIException Thrown by handler to signal an error.
     */
    public void endDocument(Augmentations augs) throws XNIException {
        // To debug the DOM created uncomment the line below
        // schemaDOM.printDOM();
    } // endDocument()
    
    
    /**
     * A comment.
     * 
     * @param text   The text in the comment.
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by application to signal an error.
     */
    public void comment(XMLString text, Augmentations augs) throws XNIException {
        if(fAnnotationDepth > -1 && fIgnoreDepth == -1) {
            schemaDOM.comment(text);
        }
    }
    
    /**
     * A processing instruction. Processing instructions consist of a
     * target name and, optionally, text data. The data is only meaningful
     * to the application.
     * 

     * Typically, a processing instruction's data will contain a series
     * of pseudo-attributes. These pseudo-attributes follow the form of
     * element attributes but are not parsed or presented
     * to the application as anything other than text. The application is
     * responsible for parsing the data.
     * 
     * @param target The target.
     * @param data   The data or null if none specified.
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void processingInstruction(String target, XMLString data, Augmentations augs)
    throws XNIException {
        if (fAnnotationDepth > -1 && fIgnoreDepth == -1) {
            schemaDOM.processingInstruction(target, data);
        }
    }
    
    /**
     * Character content.
     * 
     * @param text   The content.
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void characters(XMLString text, Augmentations augs) throws XNIException {
        if (fIgnoreDepth > -1) {
            return;
        }
        // when it's not within xs:appinfo or xs:documentation
        if (fInnerAnnotationDepth == -1 ) {
            for (int i=text.offset; i -1) {
                fIgnoreDepth++;
                return;
            }

            // perform conditional exclusion checks for schema versioning namespace 
            // (does not apply to  element).
            if (fDepth > -1) {
                checkVersionControlAttributes(element, attributes);
                if (fIgnoreDepth > -1) {
                    return;
                }
            }
        }

        // while it is true that non-whitespace character data
        // may only occur in appInfo or documentation
        // elements, it's certainly legal for comments and PI's to
        // occur as children of annotation; we need
        // to account for these here.
        if (fAnnotationDepth == -1) {
            if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
                    element.localpart == SchemaSymbols.ELT_ANNOTATION) {
                if (fGenerateSyntheticAnnotation) {
                    if (fSawAnnotation.size() > 0) {
                        fSawAnnotation.pop();
                    }
                    fSawAnnotation.push(true);
                }
                fAnnotationDepth = fDepth;
                schemaDOM.startAnnotation(element, attributes, fNamespaceContext);
                fCurrentAnnotationElement = schemaDOM.startElement(element, attributes, 
                        fLocator.getLineNumber(),
                        fLocator.getColumnNumber(),
                        fLocator.getCharacterOffset());
                return;
            } 
            else if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && fGenerateSyntheticAnnotation) {
                fSawAnnotation.push(false);
                fHasNonSchemaAttributes.push(hasNonSchemaAttributes(element, attributes));
            }
        } 
        else if (fDepth == fAnnotationDepth + 1) {
            fInnerAnnotationDepth = fDepth;
            schemaDOM.startAnnotationElement(element, attributes);
        } 
        else {
            schemaDOM.startAnnotationElement(element, attributes);
            // avoid falling through; don't call startElement in this case
            return;
        }
        schemaDOM.startElement(element, attributes, 
                fLocator.getLineNumber(),
                fLocator.getColumnNumber(),
                fLocator.getCharacterOffset());
        
    }
    
    
    /**
     * An empty element.
     * 
     * @param element    The name of the element.
     * @param attributes The element attributes.
     * @param augs       Additional information that may include infoset augmentations
     *                   
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void emptyElement(QName element, XMLAttributes attributes, Augmentations augs)
    throws XNIException {
        
        if (fPerformConditionalInclusion) {
            if (fIgnoreDepth > -1) {
                return;
            }

            if (fDepth > -1) {
                // perform conditional exclusion checks for schema versioning
                // namespace.
                boolean vcExclude = checkVersionControlAttributes(element, attributes);
                if (fIgnoreDepth > -1) {
                    if (vcExclude) {
                       fIgnoreDepth--;   
                    }
                    return;
                }
            }
        }

        if (fGenerateSyntheticAnnotation && fAnnotationDepth == -1 && 
                element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && element.localpart != SchemaSymbols.ELT_ANNOTATION && hasNonSchemaAttributes(element, attributes)) { 
            
            schemaDOM.startElement(element, attributes,
                    fLocator.getLineNumber(),
                    fLocator.getColumnNumber(),
                    fLocator.getCharacterOffset());
            
            attributes.removeAllAttributes();
            String schemaPrefix = fNamespaceContext.getPrefix(SchemaSymbols.URI_SCHEMAFORSCHEMA);
            final String annRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_ANNOTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_ANNOTATION);
            schemaDOM.startAnnotation(annRawName, attributes, fNamespaceContext);
            final String elemRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_DOCUMENTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_DOCUMENTATION);
            schemaDOM.startAnnotationElement(elemRawName, attributes);
            schemaDOM.charactersRaw("SYNTHETIC_ANNOTATION");     
            schemaDOM.endSyntheticAnnotationElement(elemRawName, false);
            schemaDOM.endSyntheticAnnotationElement(annRawName, true);
            
            schemaDOM.endElement();
            
            return;
        }
        // the order of events that occurs here is:
        //   schemaDOM.startAnnotation/startAnnotationElement (if applicable)
        //   schemaDOM.emptyElement  (basically the same as startElement then endElement)
        //   schemaDOM.endAnnotationElement (if applicable)
        // the order of events that would occur if this was :
        //   schemaDOM.startAnnotation/startAnnotationElement (if applicable)
        //   schemaDOM.startElement
        //   schemaDOM.endAnnotationElement (if applicable)
        //   schemaDOM.endElementElement
        // Thus, we can see that the order of events isn't the same.  However, it doesn't
        // seem to matter.  -- PJM
        if (fAnnotationDepth == -1) {
            // this is messed up, but a case to consider:
            if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
                    element.localpart == SchemaSymbols.ELT_ANNOTATION) {
                schemaDOM.startAnnotation(element, attributes, fNamespaceContext);
            }
        } 
        else {
            schemaDOM.startAnnotationElement(element, attributes);
        }
        
        ElementImpl newElem = schemaDOM.emptyElement(element, attributes, 
                fLocator.getLineNumber(),
                fLocator.getColumnNumber(),
                fLocator.getCharacterOffset());
        
        if (fAnnotationDepth == -1) {
            // this is messed up, but a case to consider:
            if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
                    element.localpart == SchemaSymbols.ELT_ANNOTATION) {
                schemaDOM.endAnnotation(element, newElem);
            }
        } 
        else {
            schemaDOM.endAnnotationElement(element);
        }

    }
    
    
    /**
     * The end of an element.
     * 
     * @param element The name of the element.
     * @param augs    Additional information that may include infoset augmentations
     *                
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void endElement(QName element, Augmentations augs) throws XNIException {
        
        // when we reach the endElement of xs:appinfo or xs:documentation,
        // change fInnerAnnotationDepth to -1
        if (fIgnoreDepth == -1) {
            if(fAnnotationDepth > -1) {
                if (fInnerAnnotationDepth == fDepth) {
                    fInnerAnnotationDepth = -1;
                    schemaDOM.endAnnotationElement(element);
                    schemaDOM.endElement();
                } else if (fAnnotationDepth == fDepth) {
                    fAnnotationDepth = -1;
                    schemaDOM.endAnnotation(element, fCurrentAnnotationElement);
                    schemaDOM.endElement();
                } else { // inside a child of annotation
                    schemaDOM.endAnnotationElement(element);
                }
            } else { // not in an annotation at all
                if(element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && fGenerateSyntheticAnnotation) {
                    boolean value = fHasNonSchemaAttributes.pop();
                    boolean sawann = fSawAnnotation.pop();
                    if (value && !sawann) {
                        String schemaPrefix = fNamespaceContext.getPrefix(SchemaSymbols.URI_SCHEMAFORSCHEMA);
                        final String annRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_ANNOTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_ANNOTATION);
                        schemaDOM.startAnnotation(annRawName, fEmptyAttr, fNamespaceContext);
                        final String elemRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_DOCUMENTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_DOCUMENTATION);
                        schemaDOM.startAnnotationElement(elemRawName, fEmptyAttr);
                        schemaDOM.charactersRaw("SYNTHETIC_ANNOTATION");     
                        schemaDOM.endSyntheticAnnotationElement(elemRawName, false);
                        schemaDOM.endSyntheticAnnotationElement(annRawName, true);
                    }
                }
                schemaDOM.endElement();
            }
        }
        else {
            fIgnoreDepth--;
        }
        fDepth--;
    }
    
    /**
     * @param attributes
     * @return
     */
    private boolean hasNonSchemaAttributes(QName element, XMLAttributes attributes) {
        final int length = attributes.getLength();
        for (int i = 0; i < length; ++i) {
            String uri = attributes.getURI(i);
            if (uri != null && uri != SchemaSymbols.URI_SCHEMAFORSCHEMA && 
                    uri != NamespaceContext.XMLNS_URI &&
                    !(uri == NamespaceContext.XML_URI && 
                            attributes.getQName(i) == SchemaSymbols.ATT_XML_LANG && element.localpart == SchemaSymbols.ELT_SCHEMA)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * Ignorable whitespace. For this method to be called, the document
     * source must have some way of determining that the text containing
     * only whitespace characters should be considered ignorable. For
     * example, the validator can determine if a length of whitespace
     * characters in the document are ignorable based on the element
     * content model.
     * 
     * @param text   The ignorable whitespace.
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException {
        // unlikely to be called, but you never know...
        if (fAnnotationDepth != -1 && fIgnoreDepth == -1) {
            schemaDOM.characters(text);
        }
    }
    
    /**
     * The start of a CDATA section.
     * 
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void startCDATA(Augmentations augs) throws XNIException {
        // only deal with CDATA boundaries within an annotation.
        if (fAnnotationDepth != -1 && fIgnoreDepth == -1) {
            schemaDOM.startAnnotationCDATA();
        }
    }
    
    /**
     * The end of a CDATA section.
     * 
     * @param augs   Additional information that may include infoset augmentations
     *               
     * @exception XNIException
     *                   Thrown by handler to signal an error.
     */
    public void endCDATA(Augmentations augs) throws XNIException {
        // only deal with CDATA boundaries within an annotation.
        if (fAnnotationDepth != -1 && fIgnoreDepth == -1) {
            schemaDOM.endAnnotationCDATA();
        }
    }
    
    
    //
    // other methods
    //
    
    /**
     * Returns the DOM document object.
     */
    public Document getDocument() {
        return schemaDOM;
    }
    
    /**
     * Delegates to SchemaParsingConfig.setFeature
     * @param featureId
     * @param state
     */
    public void setFeature(String featureId, boolean state){
        config.setFeature(featureId, state);
    }
    
    /**
     * Delegates to SchemaParsingConfig.getFeature
     * @param featureId
     * @return boolean
     */
    public boolean getFeature(String featureId){
        return config.getFeature(featureId);
    }
    
    /**
     * Delegates to SchemaParsingConfig.setProperty.
     * @param propertyId
     * @param value
     */
    public void setProperty(String propertyId, Object value){
        config.setProperty(propertyId, value);
    }
    
    /**
     * Delegates to SchemaParsingConfig.getProperty.
     * @param propertyId
     * @return Object
     */
    public Object getProperty(String propertyId){
        return config.getProperty(propertyId);
    }
    
    /**
     * Delegates to SchemaParsingConfig.setEntityResolver.
     * @param er XMLEntityResolver
     */
    public void setEntityResolver(XMLEntityResolver er) {
        config.setEntityResolver(er);
    }
    
    /**
     * Delegates parsing to SchemaParsingConfig
     * 
     * @param inputSource
     * @throws IOException
     */
    public void parse(XMLInputSource inputSource) throws IOException {
        config.parse(inputSource);
    }
    
    /**
     * Reset SchemaParsingConfig
     */
    public void reset() {
        ((SchemaParsingConfig)config).reset();
    }
    
    /**
     * ResetNodePool on SchemaParsingConfig
     */
    public void resetNodePool() {
        ((SchemaParsingConfig)config).resetNodePool();
    }

    public void setSupportedVersion(XSDecimal version) {
        fSupportedVersion = version;
    }
    
    
    /*
     *  Method to check if any of attributes of schema versioning namespace should cause exclusion of a schema component along 
     *  with it's descendant instructions.
     */
    private boolean checkVersionControlAttributes(QName element, XMLAttributes attributes) {             
        
        boolean isIgnoreSchemaComponent = false;

        // variables holding schema versioning attribute values
        BigDecimal minVer = null;
        BigDecimal maxVer = null;
        List typeAvailableList = null;
        List typeUnavailableList = null;
        List facetAvailableList = null;
        List facetUnavailableList = null;

        // iterate all attributes of an element, and get values of schema versioning attributes.
        for (int attrIdx = 0; attrIdx < attributes.getLength(); ++attrIdx) {
            if (SchemaSymbols.URI_SCHEMAVERSION.equals(attributes.getURI(attrIdx))) {
                String attrLocalName = attributes.getLocalName(attrIdx);
                String attrValue = attributes.getValue(attrIdx);
                if (SchemaSymbols.ATT_MINVERSION.equals(attrLocalName)) {
                    try {
                        minVer = new BigDecimal(attrValue);                    
                    }
                    catch (NumberFormatException nfe) {
                        fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN, "s4s-att-invalid-value",
                                                   new Object[] {element.localpart, attrLocalName, nfe.getMessage()}, XMLErrorReporter.SEVERITY_ERROR);
                    }
                }
                else if (SchemaSymbols.ATT_MAXVERSION.equals(attrLocalName)) {
                    try {
                        maxVer = new BigDecimal(attrValue);                        
                    }
                    catch (NumberFormatException nfe) {
                        fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN, "s4s-att-invalid-value",
                                                   new Object[] {element.localpart, attrLocalName, nfe.getMessage()}, XMLErrorReporter.SEVERITY_ERROR);
                    }
                }
                else if (SchemaSymbols.ATT_TYPEAVAILABLE.equals(attrLocalName)) {
                    typeAvailableList = tokenizeQNameListString(attrValue);
                }
                else if (SchemaSymbols.ATT_TYPEUNAVAILABLE.equals(attrLocalName)) {
                    typeUnavailableList = tokenizeQNameListString(attrValue);
                }
                else if (SchemaSymbols.ATT_FACETAVAILABLE.equals(attrLocalName)) {
                    facetAvailableList = tokenizeQNameListString(attrValue);
                }
                else if (SchemaSymbols.ATT_FACETUNAVAILABLE.equals(attrLocalName)) {
                    facetUnavailableList = tokenizeQNameListString(attrValue);
                }
                else {
                    // report a warning
                    fErrorReporter.reportError(fLocator, XSMessageFormatter.SCHEMA_DOMAIN, "src-cip.1", new Object[]{attrLocalName}, XMLErrorReporter.SEVERITY_WARNING);
                }
            }
        }

        // perform checks for attributes vc:minVersion, vc:maxVersion, vc:typeAvailable, vc:typeUnavailable, vc:facetAvailable & vc:facetUnavailable
        boolean minMaxSchemaVerAllowsIgnore = (minVer == null && maxVer == null) ? false : isSchemaLangVersionAllowsExclude(minVer, maxVer);
        boolean typeAvlAllowsIgnore = (typeAvailableList == null) ? false : isTypeAndFacetAvailableAllowsExclude(
                                                                                 typeAvailableList, Constants.IS_TYPE,
                                                                                 Constants.TYPE_AND_FACET_AVAILABILITY);
        boolean typeUnavlAllowsIgnore = (typeUnavailableList == null) ? false : isTypeAndFacetAvailableAllowsExclude(
                                                                                 typeUnavailableList, Constants.IS_TYPE,
                                                                                 Constants.TYPE_AND_FACET_UNAVAILABILITY);
        boolean facetAvlAllowsIgnore = (facetAvailableList == null) ? false : isTypeAndFacetAvailableAllowsExclude(
                                                                                 facetAvailableList,Constants.IS_FACET,
                                                                                 Constants.TYPE_AND_FACET_AVAILABILITY);
        boolean facetUnavlAllowsIgnore = (facetUnavailableList == null) ? false : isTypeAndFacetAvailableAllowsExclude(
                                                                                 facetUnavailableList, Constants.IS_FACET,
                                                                                 Constants.TYPE_AND_FACET_UNAVAILABILITY);

        if (minMaxSchemaVerAllowsIgnore || typeAvlAllowsIgnore || typeUnavlAllowsIgnore || facetAvlAllowsIgnore || facetUnavlAllowsIgnore) {
            isIgnoreSchemaComponent =  true;  
        }
        else {
            isIgnoreSchemaComponent = false; 
        }

        return isIgnoreSchemaComponent;
        
    } // checkVersionControlAttributes
    
    
    /* 
     * Method to determine whether a schema component and it's descendant instructions should be excluded
     * from schema processing, depending on the values of vc:minVersion & vc:maxVersion attributes from
     * schema versioning namespace.
    */
    private boolean isSchemaLangVersionAllowsExclude(BigDecimal minVer, BigDecimal maxVer) {
        
        boolean minMaxSchemaVerAllowsIgnore = false;
        
        // The condition "vc:minVersion <= V < vc:maxVersion" needs to be true for a schema component to be
        // included in a validation episode. Here value of "V" is an instance variable fSupportedVersion.
        
        if (minVer != null && maxVer != null) {
           // if both vc:minVersion & vc:maxVersion attributes are present on a schema component.
           if (!(minVer.compareTo(fSupportedVersion.getBigDecimal()) <= 0 &&
                 maxVer.compareTo(fSupportedVersion.getBigDecimal()) == 1)) {
               fIgnoreDepth++;
               minMaxSchemaVerAllowsIgnore = true;   
           }
        }
        else if (minVer != null && maxVer == null) {
          // only vc:minVersion attribute is present
          if (!(minVer.compareTo(fSupportedVersion.getBigDecimal()) <= 0)) {
              fIgnoreDepth++;
              minMaxSchemaVerAllowsIgnore = true; 
          }
        }
        else if (minVer == null && maxVer != null) {
          // only vc:maxVersion attribute is present
          if (!(maxVer.compareTo(fSupportedVersion.getBigDecimal()) == 1)) {
              fIgnoreDepth++;
              minMaxSchemaVerAllowsIgnore = true;  
          }
        }
        
        return minMaxSchemaVerAllowsIgnore;
        
    } // isSchemaLangVersionAllowsExclude
    

    /* 
     * Method to determine whether a schema component and it's descendant instructions should be excluded from schema processing, 
     * depending on values of vc:typeAvailable, vc:typeUnavailable, vc:facetAvailable and vc:facetUnavailable attributes from 
     * schema versioning namespace. 
    */
    private boolean isTypeAndFacetAvailableAllowsExclude(List typeOrFacetList, short typeOrFacet, short availaibilityUnavlCheck) {
        
        // either of the following boolean values would be returned from this method, depending on whether availability or 
        // unavailability check is asked for.
        boolean typeOrFacetAvlAllowsIgnore = false;        
        boolean typeOrFacetUnavlAllowsIgnore = true;

        // iterate all the items of type/facet list
        for (Iterator iter = typeOrFacetList.iterator(); iter.hasNext(); ) {           
            String typeOrFacetRawValue = (String) iter.next();
            String typeOrFacetLocalName = null;
            String typeOrFacetUri = null;
            if (typeOrFacetRawValue.indexOf(':') != -1) {              
                typeOrFacetLocalName = typeOrFacetRawValue.substring(typeOrFacetRawValue.indexOf(':') + 1);
                String typeOrFacetPrefix = typeOrFacetRawValue.substring(0, typeOrFacetRawValue.indexOf(':'));
                typeOrFacetUri = fNamespaceContext.getURI(typeOrFacetPrefix.intern());
            }
            else {
                typeOrFacetLocalName = typeOrFacetRawValue;    
            }

            if (typeOrFacet == Constants.IS_TYPE) {
                // check for availability of schema types
                if (availaibilityUnavlCheck == Constants.TYPE_AND_FACET_AVAILABILITY && !schemaCondlInclHelper.isTypeSupported(typeOrFacetLocalName, typeOrFacetUri)) {
                    typeOrFacetAvlAllowsIgnore = true;
                    break;             
                }
                else if (availaibilityUnavlCheck == Constants.TYPE_AND_FACET_UNAVAILABILITY && !schemaCondlInclHelper.isTypeSupported(typeOrFacetLocalName, typeOrFacetUri)) {
                    typeOrFacetUnavlAllowsIgnore = false;
                    break;
                }
            } 
            else if (typeOrFacet == Constants.IS_FACET) {
                // check for availability of schema facets
                if (availaibilityUnavlCheck == Constants.TYPE_AND_FACET_AVAILABILITY && !schemaCondlInclHelper.isFacetSupported(typeOrFacetLocalName, typeOrFacetUri)) {
                    typeOrFacetAvlAllowsIgnore = true;
                    break;             
                }
                else if (availaibilityUnavlCheck == Constants.TYPE_AND_FACET_UNAVAILABILITY && !schemaCondlInclHelper.isFacetSupported(typeOrFacetLocalName, typeOrFacetUri)) {
                    typeOrFacetUnavlAllowsIgnore = false;
                    break;
                }
            }

        }

        if (availaibilityUnavlCheck == Constants.TYPE_AND_FACET_AVAILABILITY) {
            if (typeOrFacetAvlAllowsIgnore) {
                fIgnoreDepth++;   
            }           
            return typeOrFacetAvlAllowsIgnore;
        }
        else {
            if (typeOrFacetUnavlAllowsIgnore) {
                fIgnoreDepth++;   
            }
            return typeOrFacetUnavlAllowsIgnore;    
        }
        
    } // isTypeAndFacetAvailableAllowsExclude

    
    /*
     * Method to tokenize a QName list specified as a string value (with XML white spaces as the delimiter) and return a List
     * containing the string tokens. 
     */
    private List tokenizeQNameListString(String strValue) {
        
        StringTokenizer st = new StringTokenizer(strValue, " \n\t\r");
        List stringTokens = new ArrayList(st.countTokens());

        while (st.hasMoreTokens()) {
            String QNameStr = st.nextToken();
            XS11TypeHelper.validateQNameValue(QNameStr, fNamespaceContext, fErrorReporter);          
            stringTokens.add(QNameStr);
        }

        return stringTokens;
        
    } // tokenizeQNameListString


    /**
     * A simple boolean based stack.
     * 
     * @xerces.internal
     */
    private static final class BooleanStack {

        //
        // Data
        //

        /** Stack depth. */
        private int fDepth;

        /** Stack data. */
        private boolean[] fData;
        
        //
        // Constructor
        //
        
        public BooleanStack () {}

        //
        // Public methods
        //

        /** Returns the size of the stack. */
        public int size() {
            return fDepth;
        }

        /** Pushes a value onto the stack. */
        public void push(boolean value) {
            ensureCapacity(fDepth + 1);
            fData[fDepth++] = value;
        }

        /** Pops a value off of the stack. */
        public boolean pop() {
            return fData[--fDepth];
        }

        /** Clears the stack. */
        public void clear() {
            fDepth = 0;
        }

        //
        // Private methods
        //

        /** Ensures capacity. */
        private void ensureCapacity(int size) {
            if (fData == null) {
                fData = new boolean[32];
            }
            else if (fData.length <= size) {
                boolean[] newdata = new boolean[fData.length * 2];
                System.arraycopy(fData, 0, newdata, 0, fData.length);
                fData = newdata;
            }
        }
    }
}