/*

 * Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * 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 com.sun.org.apache.xerces.internal.impl;

import com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException;

import com.sun.org.apache.xerces.internal.impl.msg.XMLMessageFormatter;

import com.sun.org.apache.xerces.internal.util.AugmentationsImpl;

import com.sun.org.apache.xerces.internal.util.XMLAttributesIteratorImpl;

import com.sun.org.apache.xerces.internal.util.XMLChar;

import com.sun.org.apache.xerces.internal.util.XMLStringBuffer;

import com.sun.org.apache.xerces.internal.util.XMLSymbols;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager.Limit;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;

import com.sun.org.apache.xerces.internal.xni.Augmentations;

import com.sun.org.apache.xerces.internal.xni.QName;

import com.sun.org.apache.xerces.internal.xni.XMLAttributes;

import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;

import com.sun.org.apache.xerces.internal.xni.XMLString;

import com.sun.org.apache.xerces.internal.xni.XNIException;

import com.sun.org.apache.xerces.internal.xni.parser.XMLComponent;

import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;

import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentScanner;

import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;

import com.sun.xml.internal.stream.XMLBufferListener;

import com.sun.xml.internal.stream.XMLEntityStorage;

import com.sun.xml.internal.stream.dtd.DTDGrammarUtil;

import java.io.CharConversionException;

import java.io.EOFException;

import java.io.IOException;

import javax.xml.XMLConstants;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.events.XMLEvent;

import jdk.xml.internal.JdkConstants;

import jdk.xml.internal.JdkXmlUtils;

import jdk.xml.internal.SecuritySupport;

/**

 *

 * This class is responsible for scanning the structure and content

 * of document fragments.

 *

 * This class has been modified as per the new design which is more suited to

 * efficiently build pull parser. Lot of improvements have been done and

 * the code has been added to support stax functionality/features.

 *

 * @author Neeraj Bajaj SUN Microsystems

 * @author K.Venugopal SUN Microsystems

 * @author Glenn Marcy, IBM

 * @author Andy Clark, IBM

 * @author Arnaud  Le Hors, IBM

 * @author Eric Ye, IBM

 * @author Sunitha Reddy, SUN Microsystems

 *

 * @LastModified: May 2021

 */

public class XMLDocumentFragmentScannerImpl

        extends XMLScanner

        implements XMLDocumentScanner, XMLComponent, XMLEntityHandler, XMLBufferListener {

    //

    // Constants

    //

    protected int fElementAttributeLimit, fXMLNameLimit;

    /** External subset resolver. **/

    protected ExternalSubsetResolver fExternalSubsetResolver;

    // scanner states

    //XXX this should be divided into more states.

    /** Scanner state: start of markup. */

    protected static final int SCANNER_STATE_START_OF_MARKUP = 21;

    /** Scanner state: content. */

    protected static final int SCANNER_STATE_CONTENT = 22;

    /** Scanner state: processing instruction. */

    protected static final int SCANNER_STATE_PI = 23;

    /** Scanner state: DOCTYPE. */

    protected static final int SCANNER_STATE_DOCTYPE = 24;

    /** Scanner state: XML Declaration */

    protected static final int SCANNER_STATE_XML_DECL = 25;

    /** Scanner state: root element. */

    protected static final int SCANNER_STATE_ROOT_ELEMENT = 26;

    /** Scanner state: comment. */

    protected static final int SCANNER_STATE_COMMENT = 27;

    /** Scanner state: reference. */

    protected static final int SCANNER_STATE_REFERENCE = 28;

    // <book type="hard"> reading attribute name 'type'

    protected static final int SCANNER_STATE_ATTRIBUTE = 29;

    // <book type="hard"> //reading attribute value.

    protected static final int SCANNER_STATE_ATTRIBUTE_VALUE = 30;

    /** Scanner state: trailing misc. USED BY DOCUMENT_SCANNER_IMPL*/

    //protected static final int SCANNER_STATE_TRAILING_MISC = 32;

    /** Scanner state: end of input. */

    protected static final int SCANNER_STATE_END_OF_INPUT = 33;

    /** Scanner state: terminated. */

    protected static final int SCANNER_STATE_TERMINATED = 34;

    /** Scanner state: CDATA section. */

    protected static final int SCANNER_STATE_CDATA = 35;

    /** Scanner state: Text declaration. */

    protected static final int SCANNER_STATE_TEXT_DECL = 36;

    /** Scanner state: Text declaration. */

    protected static final int SCANNER_STATE_CHARACTER_DATA = 37;

    //<book type="hard">foo</book>

    protected static final int SCANNER_STATE_START_ELEMENT_TAG = 38;

    //<book type="hard">foo</book> reading </book>

    protected static final int SCANNER_STATE_END_ELEMENT_TAG = 39;

    protected static final int SCANNER_STATE_CHAR_REFERENCE = 40;

    protected static final int SCANNER_STATE_BUILT_IN_REFS = 41;

    // feature identifiers

    /** Feature identifier: notify built-in refereces. */

    protected static final String NOTIFY_BUILTIN_REFS =

            Constants.XERCES_FEATURE_PREFIX + Constants.NOTIFY_BUILTIN_REFS_FEATURE;

    /** Property identifier: entity resolver. */

    protected static final String ENTITY_RESOLVER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;

    /** Feature identifier: standard uri conformant */

    protected static final String STANDARD_URI_CONFORMANT =

            Constants.XERCES_FEATURE_PREFIX +Constants.STANDARD_URI_CONFORMANT_FEATURE;

    /** Feature id: create entity ref nodes. */

    protected static final String CREATE_ENTITY_REF_NODES =

            Constants.XERCES_FEATURE_PREFIX + Constants.CREATE_ENTITY_REF_NODES_FEATURE;

    /** Property identifier: Security property manager. */

    private static final String XML_SECURITY_PROPERTY_MANAGER =

            JdkConstants.XML_SECURITY_PROPERTY_MANAGER;

    /** access external dtd: file protocol

     *  For DOM/SAX, the secure feature is set to true by default

     */

    final static String EXTERNAL_ACCESS_DEFAULT = JdkConstants.EXTERNAL_ACCESS_DEFAULT;

    // recognized features and properties

    /** Recognized features. */

    private static final String[] RECOGNIZED_FEATURES = {

                NAMESPACES,

                VALIDATION,

                NOTIFY_BUILTIN_REFS,

                NOTIFY_CHAR_REFS,

                Constants.STAX_REPORT_CDATA_EVENT,

                XMLConstants.USE_CATALOG

    };

    /** Feature defaults. */

    private static final Boolean[] FEATURE_DEFAULTS = {

                Boolean.TRUE,

                null,

                Boolean.FALSE,

                Boolean.FALSE,

                Boolean.TRUE,

                JdkXmlUtils.USE_CATALOG_DEFAULT

    };

    /** Recognized properties. */

    private static final String[] RECOGNIZED_PROPERTIES = {

                SYMBOL_TABLE,

                ERROR_REPORTER,

                ENTITY_MANAGER,

                XML_SECURITY_PROPERTY_MANAGER,

                JdkXmlUtils.CATALOG_DEFER,

                JdkXmlUtils.CATALOG_FILES,

                JdkXmlUtils.CATALOG_PREFER,

                JdkXmlUtils.CATALOG_RESOLVE,

                JdkConstants.CDATA_CHUNK_SIZE

    };

    /** Property defaults. */

    private static final Object[] PROPERTY_DEFAULTS = {

                null,

                null,

                null,

                null,

                null,

                null,

                null,

                null,

                JdkConstants.CDATA_CHUNK_SIZE_DEFAULT

    };

    private static final char [] CDATA = {'[','C','D','A','T','A','['};

    static final char [] XMLDECL = {'<','?','x','m','l'};

    // private static final char [] endTag = {'<','/'};

    // debugging

    /** Debug scanner state. */

    private static final boolean DEBUG_SCANNER_STATE = false;

    /** Debug driver. */

    private static final boolean DEBUG_DISPATCHER = false;

    /** Debug content driver scanning. */

    protected static final boolean DEBUG_START_END_ELEMENT = false;

    /** Debug driver next */

    protected static final boolean DEBUG = false;

    //

    // Data

    //

    // protected data

    /** Document handler. */

    protected XMLDocumentHandler fDocumentHandler;

    protected int fScannerLastState ;

    /** Entity Storage */

    protected XMLEntityStorage fEntityStore;

    /** Entity stack. */

    protected int[] fEntityStack = new int[4];

    /** Markup depth. */

    protected int fMarkupDepth;

    //is the element empty

    protected boolean fEmptyElement ;

    //track if we are reading attributes, this is usefule while

    //there is a callback

    protected boolean fReadingAttributes = false;

    /** Scanner state. */

    protected int fScannerState;

    /** SubScanner state: inside scanContent method. */

    protected boolean fInScanContent = false;

    protected boolean fLastSectionWasCData = false;

    protected boolean fCDataStart = false;

    protected boolean fInCData = false;

    protected boolean fCDataEnd = false;

    protected boolean fLastSectionWasEntityReference = false;

    protected boolean fLastSectionWasCharacterData = false;

    /** has external dtd */

    protected boolean fHasExternalDTD;

    /** Standalone. */

    protected boolean fStandaloneSet;

    protected boolean fStandalone;

    protected String fVersion;

    // element information

    /** Current element. */

    protected QName fCurrentElement;

    /** Element stack. */

    protected ElementStack fElementStack = new ElementStack();

    protected ElementStack2 fElementStack2 = new ElementStack2();

    // other info

    /** Document system identifier.

     * REVISIT:  So what's this used for?  - NG

     * protected String fDocumentSystemId;

     ******/

    protected String fPITarget ;

    //xxx do we need to create an extra XMLString object... look for using fTempString for collecting all the data values

    protected XMLString fPIData  = new XMLString();

    // features

    /** Notify built-in references. */

    protected boolean fNotifyBuiltInRefs = false;

    //STAX related properties

    //defaultValues.

    protected boolean fSupportDTD = true;

    protected boolean fReplaceEntityReferences = true;

    protected boolean fSupportExternalEntities = false;

    protected boolean fReportCdataEvent = false ;

    protected boolean fIsCoalesce = false ;

    protected String fDeclaredEncoding =  null;

    /** Xerces Feature: Disallow doctype declaration. */

    protected boolean fDisallowDoctype = false;

    /** Create entity reference nodes. */

    protected boolean fCreateEntityRefNodes = false;

    /**

     * CDATA chunk size limit

     */

    private int fChunkSize;

    /**

     * comma-delimited list of protocols that are allowed for the purpose

     * of accessing external dtd or entity references

     */

    protected String fAccessExternalDTD = EXTERNAL_ACCESS_DEFAULT;

    /**

     * standard uri conformant (strict uri).

     * http://apache.org/xml/features/standard-uri-conformant

     */

    protected boolean fStrictURI;

    // drivers

    /** Active driver. */

    protected Driver fDriver;

    /** Content driver. */

    protected Driver fContentDriver = createContentDriver();

    // temporary variables

    /** Element QName. */

    protected QName fElementQName = new QName();

    /** Attribute QName. */

    protected QName fAttributeQName = new QName();

    /**

     * CHANGED: Using XMLAttributesIteratorImpl instead of XMLAttributesImpl. This class

     * implements Iterator interface so we can directly give Attributes in the form of

     * iterator.

     */

    protected XMLAttributesIteratorImpl fAttributes = new XMLAttributesIteratorImpl();

    /** String. */

    protected XMLString fTempString = new XMLString();

    /** String. */

    protected XMLString fTempString2 = new XMLString();

    /** Array of 3 strings. */

    private final String[] fStrings = new String[3];

    /** Making the buffer accessible to derived class -- String buffer. */

    protected XMLStringBuffer fStringBuffer = new XMLStringBuffer();

    /** Making the buffer accessible to derived class -- String buffer. */

    protected XMLStringBuffer fStringBuffer2 = new XMLStringBuffer();

    /** stores character data. */

    /** Making the buffer accessible to derived class -- stores PI data */

    protected XMLStringBuffer fContentBuffer = new XMLStringBuffer();

    /** Single character array. */

    private final char[] fSingleChar = new char[1];

    private String fCurrentEntityName = null;

    // New members

    protected boolean fScanToEnd = false;

    protected DTDGrammarUtil dtdGrammarUtil= null;

    protected boolean fAddDefaultAttr = false;

    protected boolean foundBuiltInRefs = false;

    /** Built-in reference character event */

    protected boolean builtInRefCharacterHandled = false;

    //skip element algorithm

    static final short MAX_DEPTH_LIMIT = 5 ;

    static final short ELEMENT_ARRAY_LENGTH = 200 ;

    static final short MAX_POINTER_AT_A_DEPTH = 4 ;

    static final boolean DEBUG_SKIP_ALGORITHM = false;

    //create a elemnet array of length equal to ELEMENT_ARRAY_LENGTH

    String [] fElementArray = new String[ELEMENT_ARRAY_LENGTH] ;

    //pointer location where last element was skipped

    short fLastPointerLocation = 0 ;

    short fElementPointer = 0 ;

    //2D array to store pointer info

    short [] [] fPointerInfo = new short[MAX_DEPTH_LIMIT] [MAX_POINTER_AT_A_DEPTH] ;

    protected String fElementRawname ;

    protected boolean fShouldSkip = false;

    protected boolean fAdd = false ;

    protected boolean fSkip = false;

    /** Reusable Augmentations. */

    private Augmentations fTempAugmentations = null;

    //

    // Constructors

    //

    /** Default constructor. */

    public XMLDocumentFragmentScannerImpl() {

    } // <init>()

    //

    // XMLDocumentScanner methods

    //

    /**

     * Sets the input source.

     *

     * @param inputSource The input source.

     *

     * @throws IOException Thrown on i/o error.

     */

    public void setInputSource(XMLInputSource inputSource) throws IOException {

        fEntityManager.setEntityHandler(this);

        fEntityManager.startEntity(false, "$fragment$", inputSource, false, true);

        // fDocumentSystemId = fEntityManager.expandSystemId(inputSource.getSystemId());

    } // setInputSource(XMLInputSource)

    /**

     * Scans a document.

     *

     * @param complete True if the scanner should scan the document

     *                 completely, pushing all events to the registered

     *                 document handler. A value of false indicates that

     *                 that the scanner should only scan the next portion

     *                 of the document and return. A scanner instance is

     *                 permitted to completely scan a document if it does

     *                 not support this "pull" scanning model.

     *

     * @return True if there is more to scan, false otherwise.

     */

    public boolean scanDocument(boolean complete)

    throws IOException, XNIException {

        // keep dispatching "events"

        fEntityManager.setEntityHandler(this);

        //System.out.println(" get Document Handler in NSDocumentHandler " + fDocumentHandler );

        int event = next();

        do {

            switch (event) {

                case XMLStreamConstants.START_DOCUMENT :

                    //fDocumentHandler.startDocument(fEntityManager.getEntityScanner(),fEntityManager.getEntityScanner().getVersion(),fNamespaceContext,null);// not able to get

                    break;

                case XMLStreamConstants.START_ELEMENT :

                    //System.out.println(" in scann element");

                    //fDocumentHandler.startElement(getElementQName(),fAttributes,null);

                    break;

                case XMLStreamConstants.CHARACTERS :

                    fEntityScanner.checkNodeCount(fEntityScanner.fCurrentEntity);

                    fDocumentHandler.characters(getCharacterData(),null);

                    break;

                case XMLStreamConstants.SPACE:

                    //check if getCharacterData() is the right function to retrieve ignorableWhitespace information.

                    //System.out.println("in the space");

                    //fDocumentHandler.ignorableWhitespace(getCharacterData(), null);

                    break;

                case XMLStreamConstants.ENTITY_REFERENCE :

                    fEntityScanner.checkNodeCount(fEntityScanner.fCurrentEntity);

                    //entity reference callback are given in startEntity

                    break;

                case XMLStreamConstants.PROCESSING_INSTRUCTION :

                    fEntityScanner.checkNodeCount(fEntityScanner.fCurrentEntity);

                    fDocumentHandler.processingInstruction(getPITarget(),getPIData(),null);

                    break;

                case XMLStreamConstants.COMMENT :

                    fEntityScanner.checkNodeCount(fEntityScanner.fCurrentEntity);

                    fDocumentHandler.comment(getCharacterData(),null);

                    break;

                case XMLStreamConstants.DTD :

                    //all DTD related callbacks are handled in DTDScanner.

                    //1. Stax doesn't define DTD states as it does for XML Document.

                    //therefore we don't need to take care of anything here. So Just break;

                    break;

                case XMLStreamConstants.CDATA:

                   fEntityScanner.checkNodeCount(fEntityScanner.fCurrentEntity);

                    if (fCDataStart) {

                        fDocumentHandler.startCDATA(null);

                        fCDataStart = false;

                        fInCData = true;

                    }

                    fDocumentHandler.characters(getCharacterData(),null);

                    if (fCDataEnd) {

                        fDocumentHandler.endCDATA(null);

                        fCDataEnd = false;

                    }

                    break;

                case XMLStreamConstants.NOTATION_DECLARATION :

                    break;

                case XMLStreamConstants.ENTITY_DECLARATION :

                    break;

                case XMLStreamConstants.NAMESPACE :

                    break;

                case XMLStreamConstants.ATTRIBUTE :

                    break;

                case XMLStreamConstants.END_ELEMENT :

                    //do not give callback here.

                    //this callback is given in scanEndElement function.

                    //fDocumentHandler.endElement(getElementQName(),null);

                    break;

                default :

                    // Errors should have already been handled by the Scanner

                    return false;

            }

            //System.out.println("here in before calling next");

            event = next();

            //System.out.println("here in after calling next");

        } while (event!=XMLStreamConstants.END_DOCUMENT && complete);

        if(event == XMLStreamConstants.END_DOCUMENT) {

            fDocumentHandler.endDocument(null);

            return false;

        }

        return true;

    } // scanDocument(boolean):boolean

    public com.sun.org.apache.xerces.internal.xni.QName getElementQName(){

        if(fScannerLastState == XMLEvent.END_ELEMENT){

            fElementQName.setValues(fElementStack.getLastPoppedElement());

        }

        return fElementQName ;

    }

    /** return the next state on the input

     * @return int

     */

    public int next() throws IOException, XNIException {

        return fDriver.next();

    }

    //

    // XMLComponent methods

    //

    /**

     * Resets the component. The component can query the component manager

     * about any features and properties that affect the operation of the

     * component.

     *

     * @param componentManager The component manager.

     *

     * @throws SAXException Thrown by component on initialization error.

     *                      For example, if a feature or property is

     *                      required for the operation of the component, the

     *                      component manager may throw a

     *                      SAXNotRecognizedException or a

     *                      SAXNotSupportedException.

     */

    public void reset(XMLComponentManager componentManager)

    throws XMLConfigurationException {

        super.reset(componentManager);

        // other settings

        // fDocumentSystemId = null;

        // sax features

        //fAttributes.setNamespaces(fNamespaces);

        // xerces features

        fReportCdataEvent = componentManager.getFeature(Constants.STAX_REPORT_CDATA_EVENT, true);

        fSecurityManager = (XMLSecurityManager)componentManager.getProperty(Constants.SECURITY_MANAGER, null);

        fNotifyBuiltInRefs = componentManager.getFeature(NOTIFY_BUILTIN_REFS, false);

        fCreateEntityRefNodes = componentManager.getFeature(CREATE_ENTITY_REF_NODES, fCreateEntityRefNodes);

        Object resolver = componentManager.getProperty(ENTITY_RESOLVER, null);

        fExternalSubsetResolver = (resolver instanceof ExternalSubsetResolver) ?

                (ExternalSubsetResolver) resolver : null;

        //attribute

        fReadingAttributes = false;

        //xxx: external entities are supported in Xerces

        // it would be good to define feature for this case

        fSupportExternalEntities = true;

        fReplaceEntityReferences = true;

        fIsCoalesce = false;

        // setup Driver

        setScannerState(SCANNER_STATE_CONTENT);

        setDriver(fContentDriver);

        // JAXP 1.5 features and properties

        XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager)

                componentManager.getProperty(XML_SECURITY_PROPERTY_MANAGER, null);

        fAccessExternalDTD = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);

        fStrictURI = componentManager.getFeature(STANDARD_URI_CONFORMANT, false);

        fChunkSize = JdkXmlUtils.getValue(componentManager.getProperty(JdkConstants.CDATA_CHUNK_SIZE),

                JdkConstants.CDATA_CHUNK_SIZE_DEFAULT);

        resetCommon();

        //fEntityManager.test();

    } // reset(XMLComponentManager)

    public void reset(PropertyManager propertyManager){

        super.reset(propertyManager);

        // other settings

        // fDocumentSystemId = null;

        fNamespaces = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE));

        fNotifyBuiltInRefs = false ;

        //fElementStack2.clear();

        //fReplaceEntityReferences = true;

        //fSupportExternalEntities = true;

        Boolean bo = (Boolean)propertyManager.getProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES);

        fReplaceEntityReferences = bo;

        bo = (Boolean)propertyManager.getProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES);

        fSupportExternalEntities = bo;

        Boolean cdata = (Boolean)propertyManager.getProperty(

                Constants.ZEPHYR_PROPERTY_PREFIX + Constants.STAX_REPORT_CDATA_EVENT) ;

        if(cdata != null)

            fReportCdataEvent = cdata ;

        Boolean coalesce = (Boolean)propertyManager.getProperty(XMLInputFactory.IS_COALESCING) ;

        if(coalesce != null)

            fIsCoalesce = coalesce;

        fReportCdataEvent = fIsCoalesce ? false : (fReportCdataEvent && true) ;

        //if fIsCoalesce is set to true, set the value of fReplaceEntityReferences to true,

        //if fIsCoalesce is set to false, take the value of fReplaceEntityReferences as set by application

        fReplaceEntityReferences = fIsCoalesce ? true : fReplaceEntityReferences;

        // setup Driver

        //we dont need to do this -- nb.

        //setScannerState(SCANNER_STATE_CONTENT);

        //setDriver(fContentDriver);

        //fEntityManager.test();

         // JAXP 1.5 features and properties

        XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager)

                propertyManager.getProperty(XML_SECURITY_PROPERTY_MANAGER);

        fAccessExternalDTD = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);

        fSecurityManager = (XMLSecurityManager)propertyManager.getProperty(Constants.SECURITY_MANAGER);

        fChunkSize = JdkXmlUtils.getValue(propertyManager.getProperty(JdkConstants.CDATA_CHUNK_SIZE),

                JdkConstants.CDATA_CHUNK_SIZE_DEFAULT);

        resetCommon();

    } // reset(XMLComponentManager)

    void resetCommon() {

        // initialize vars

        fMarkupDepth = 0;

        fCurrentElement = null;

        fElementStack.clear();

        fHasExternalDTD = false;

        fStandaloneSet = false;

        fStandalone = false;

        fInScanContent = false;

        //skipping algorithm

        fShouldSkip = false;

        fAdd = false;

        fSkip = false;

        fEntityStore = fEntityManager.getEntityStore();

        dtdGrammarUtil = null;

        if (fSecurityManager != null) {

            fElementAttributeLimit = fSecurityManager.getLimit(XMLSecurityManager.Limit.ELEMENT_ATTRIBUTE_LIMIT);

            fXMLNameLimit = fSecurityManager.getLimit(XMLSecurityManager.Limit.MAX_NAME_LIMIT);

        } else {

            fElementAttributeLimit = 0;

            fXMLNameLimit = XMLSecurityManager.Limit.MAX_NAME_LIMIT.defaultValue();

        }

        fLimitAnalyzer = fEntityManager.fLimitAnalyzer;

    }

    /**

     * 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.

     */

    public String[] getRecognizedFeatures() {

        return RECOGNIZED_FEATURES.clone();

    } // getRecognizedFeatures():String[]

    /**

     * Sets the state of a feature. This method is called by the component

     * manager any time after reset when a feature changes state.

     * <p>

     * <strong>Note:</strong> 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.

     */

    public void setFeature(String featureId, boolean state)

    throws XMLConfigurationException {

        super.setFeature(featureId, state);

        // Xerces properties

        if (featureId.startsWith(Constants.XERCES_FEATURE_PREFIX)) {

            String feature = featureId.substring(Constants.XERCES_FEATURE_PREFIX.length());

            if (feature.equals(Constants.NOTIFY_BUILTIN_REFS_FEATURE)) {

                fNotifyBuiltInRefs = state;

            }

        }

    } // setFeature(String,boolean)

    /**

     * 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.

     */

    public String[] getRecognizedProperties() {

        return RECOGNIZED_PROPERTIES.clone();

    } // getRecognizedProperties():String[]

    /**

     * Sets the value of a property. This method is called by the component

     * manager any time after reset when a property changes value.

     * <p>

     * <strong>Note:</strong> 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.

     */

    public void setProperty(String propertyId, Object value)

    throws XMLConfigurationException {

        super.setProperty(propertyId, value);

        // Xerces properties

        if (propertyId.startsWith(Constants.XERCES_PROPERTY_PREFIX)) {

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

            if (suffixLength == Constants.ENTITY_MANAGER_PROPERTY.length() &&

                    propertyId.endsWith(Constants.ENTITY_MANAGER_PROPERTY)) {

                fEntityManager = (XMLEntityManager)value;

                return;

            }

            if (suffixLength == Constants.ENTITY_RESOLVER_PROPERTY.length() &&

                    propertyId.endsWith(Constants.ENTITY_RESOLVER_PROPERTY)) {

                fExternalSubsetResolver = (value instanceof ExternalSubsetResolver) ?

                    (ExternalSubsetResolver) value : null;

                return;

            }

        }

                // Xerces properties

        if (propertyId.startsWith(Constants.XERCES_PROPERTY_PREFIX)) {

            String property = propertyId.substring(Constants.XERCES_PROPERTY_PREFIX.length());

            if (property.equals(Constants.ENTITY_MANAGER_PROPERTY)) {

                fEntityManager = (XMLEntityManager)value;

            }

            return;

        }

        //JAXP 1.5 properties

        if (propertyId.equals(XML_SECURITY_PROPERTY_MANAGER))

        {

            XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager)value;

            fAccessExternalDTD = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);

        }

    } // setProperty(String,Object)

    /**

     * 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

     */

    public Boolean getFeatureDefault(String featureId) {

        for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {

            if (RECOGNIZED_FEATURES[i].equals(featureId)) {

                return FEATURE_DEFAULTS[i];

            }

        }

        return null;

    } // getFeatureDefault(String):Boolean

    /**

     * 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

     */

    public Object getPropertyDefault(String propertyId) {

        for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {

            if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {

                return PROPERTY_DEFAULTS[i];

            }

        }

        return null;

    } // getPropertyDefault(String):Object

    //

    // XMLDocumentSource methods

    //

    /**

     * setDocumentHandler

     *

     * @param documentHandler

     */

    public void setDocumentHandler(XMLDocumentHandler documentHandler) {

        fDocumentHandler = documentHandler;

        //System.out.println(" In Set DOCUMENT HANDLER" + fDocumentHandler + " scanner =" + this);

    } // setDocumentHandler(XMLDocumentHandler)

    /** Returns the document handler */

    public XMLDocumentHandler getDocumentHandler(){

        return fDocumentHandler;

    }

    //

    // XMLEntityHandler methods

    //

    /**

     * This method notifies of the start of an entity. The DTD has the

     * pseudo-name of "[dtd]" parameter entity names start with '%'; and

     * general entities are just specified by their name.

     *

     * @param name     The name of the entity.

     * @param identifier The resource identifier.

     * @param encoding The auto-detected IANA encoding name of the entity

     *                 stream. This value will be null in those situations

     *                 where the entity encoding is not auto-detected (e.g.

     *                 internal entities or a document entity that is

     *                 parsed from a java.io.Reader).

     * @param augs     Additional information that may include infoset augmentations

     *

     * @throws XNIException Thrown by handler to signal an error.

     */

    public void startEntity(String name,

            XMLResourceIdentifier identifier,

            String encoding, Augmentations augs) throws XNIException {

        // keep track of this entity before fEntityDepth is increased

        if (fEntityDepth == fEntityStack.length) {

            int[] entityarray = new int[fEntityStack.length * 2];

            System.arraycopy(fEntityStack, 0, entityarray, 0, fEntityStack.length);

            fEntityStack = entityarray;

        }

        fEntityStack[fEntityDepth] = fMarkupDepth;

        super.startEntity(name, identifier, encoding, augs);

        // WFC:  entity declared in external subset in standalone doc

        if(fStandalone && fEntityStore.isEntityDeclInExternalSubset(name)) {

            reportFatalError("MSG_REFERENCE_TO_EXTERNALLY_DECLARED_ENTITY_WHEN_STANDALONE",

                    new Object[]{name});

        }

        /** we are not calling the handlers yet.. */

        // call handler

        if (fDocumentHandler != null && !fScanningAttribute) {

            if (!name.equals("[xml]")) {

                fDocumentHandler.startGeneralEntity(name, identifier, encoding, augs);

            }

        }

    } // startEntity(String,XMLResourceIdentifier,String)

    /**

     * This method notifies the end of an entity. The DTD has the pseudo-name

     * of "[dtd]" parameter entity names start with '%'; and general entities

     * are just specified by their name.

     *

     * @param name The name of the entity.

     * @param augs Additional information that may include infoset augmentations

     *

     * @throws XNIException Thrown by handler to signal an error.

     */

    public void endEntity(String name, Augmentations augs) throws IOException, XNIException {

        /**

         * // flush possible pending output buffer - see scanContent

         * if (fInScanContent && fStringBuffer.length != 0

         * && fDocumentHandler != null) {

         * fDocumentHandler.characters(fStringBuffer, null);

         * fStringBuffer.length = 0; // make sure we know it's been flushed

         * }

         */

        super.endEntity(name, augs);

        // make sure markup is properly balanced

        if (fMarkupDepth != fEntityStack[fEntityDepth]) {

            reportFatalError("MarkupEntityMismatch", null);

        }

        /**/

        // call handler

        if (fDocumentHandler != null && !fScanningAttribute) {

            if (!name.equals("[xml]")) {

                fDocumentHandler.endGeneralEntity(name, augs);

            }

        }

    } // endEntity(String)

    //

    // Protected methods

    //

    // Driver factory methods

    /** Creates a content Driver. */

    protected Driver createContentDriver() {

        return new FragmentContentDriver();

    } // createContentDriver():Driver

    // scanning methods

    /**

     * Scans an XML or text declaration.

     * <p>

     * <pre>

     * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

     * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")

     * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'" )

     * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*

     * [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'")

     *                 | ('"' ('yes' | 'no') '"'))

     *

     * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'

     * </pre>

     *

     * @param scanningTextDecl True if a text declaration is to

     *                         be scanned instead of an XML

     *                         declaration.

     */

    protected void scanXMLDeclOrTextDecl(boolean scanningTextDecl)

    throws IOException, XNIException {

        // scan decl

        super.scanXMLDeclOrTextDecl(scanningTextDecl, fStrings);

        fMarkupDepth--;

        // pseudo-attribute values

        String version = fStrings[0];

        String encoding = fStrings[1];

        String standalone = fStrings[2];

        fDeclaredEncoding = encoding;

        // set standalone

        fStandaloneSet = standalone != null;

        fStandalone = fStandaloneSet && standalone.equals("yes");

        ///xxx see where its used.. this is not used anywhere.

        //it may be useful for entity to store this information

        //but this information is only related with Document Entity.

        fEntityManager.setStandalone(fStandalone);

        // call handler

        if (fDocumentHandler != null) {

            if (scanningTextDecl) {

                fDocumentHandler.textDecl(version, encoding, null);

            } else {

                fDocumentHandler.xmlDecl(version, encoding, standalone, null);

            }

        }

        if(version != null){

            fEntityScanner.setVersion(version);

            fEntityScanner.setXMLVersion(version);

        }

        // set encoding on reader, only if encoding was not specified by the application explicitly

        if (encoding != null && !fEntityScanner.getCurrentEntity().isEncodingExternallySpecified()) {

             fEntityScanner.setEncoding(encoding);

        }

    } // scanXMLDeclOrTextDecl(boolean)

    public String getPITarget(){

        return fPITarget ;

    }

    public XMLStringBuffer getPIData(){

        return fContentBuffer ;

    }

    //XXX: why not this function behave as per the state of the parser?

    public XMLString getCharacterData(){

        if(fUsebuffer){

            return fContentBuffer ;

        }else{

            return fTempString;

        }

    }

    /**

     * Scans a processing data. This is needed to handle the situation

     * where a document starts with a processing instruction whose

     * target name <em>starts with</em> "xml". (e.g. xmlfoo)

     *

     * @param target The PI target

     * @param data The XMLStringBuffer to fill in with the data

     */

    protected void scanPIData(String target, XMLStringBuffer data)

    throws IOException, XNIException {

        super.scanPIData(target, data);

        //set the PI target and values

        fPITarget = target ;

        fMarkupDepth--;

    } // scanPIData(String)

    /**

     * Scans a comment.

     * <p>

     * <pre>

     * [15] Comment ::= '&lt!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

     * </pre>

     * <p>

     * <strong>Note:</strong> Called after scanning past '&lt;!--'

     */

    protected void scanComment() throws IOException, XNIException {

        fContentBuffer.clear();

        scanComment(fContentBuffer);

        //getTextCharacters can also be called for reading comments

        fUsebuffer = true;

        fMarkupDepth--;

    } // scanComment()

    //xxx value returned by this function may not remain valid if another event is scanned.

    public String getComment(){

        return fContentBuffer.toString();

    }

    void addElement(String rawname){

        if(fElementPointer < ELEMENT_ARRAY_LENGTH){

            //storing element raw name in a linear list of array

            fElementArray[fElementPointer] = rawname ;

            //storing elemnetPointer for particular element depth

            if(DEBUG_SKIP_ALGORITHM){

                StringBuffer sb = new StringBuffer() ;

                sb.append(" Storing element information ") ;

                sb.append(" fElementPointer = " + fElementPointer) ;

                sb.append(" fElementRawname = " + fElementQName.rawname) ;

                sb.append(" fElementStack.fDepth = " + fElementStack.fDepth);

                System.out.println(sb.toString()) ;

            }

            //store pointer information only when element depth is less MAX_DEPTH_LIMIT

            if(fElementStack.fDepth < MAX_DEPTH_LIMIT){

                short column = storePointerForADepth(fElementPointer);

                if(column > 0){

                    short pointer = getElementPointer((short)fElementStack.fDepth, (short)(column - 1) );

                    //identity comparison shouldn't take much time and we can rely on this

                    //since its guaranteed to have same object id for same string.

                    if(rawname == fElementArray[pointer]){

                        fShouldSkip = true ;

                        fLastPointerLocation = pointer ;

                        //reset the things and return.

                        resetPointer((short)fElementStack.fDepth , column) ;

                        fElementArray[fElementPointer] = null ;

                        return ;

                    }else{

                        fShouldSkip = false ;

                    }

                }

            }

            fElementPointer++ ;

        }

    }

    void resetPointer(short depth, short column){

        fPointerInfo[depth] [column] = (short)0;

    }

    //returns column information at which pointer was stored.

    short storePointerForADepth(short elementPointer){

        short depth = (short) fElementStack.fDepth ;

        //Stores element pointer locations at particular depth , only 4 pointer locations

        //are stored at particular depth for now.

        for(short i = 0 ; i < MAX_POINTER_AT_A_DEPTH ; i++){

            if(canStore(depth, i)){

                fPointerInfo[depth][i] = elementPointer ;

                if(DEBUG_SKIP_ALGORITHM){

                    StringBuffer sb = new StringBuffer() ;

                    sb.append(" Pointer information ") ;

                    sb.append(" fElementPointer = " + fElementPointer) ;

                    sb.append(" fElementStack.fDepth = " + fElementStack.fDepth);

                    sb.append(" column = " + i ) ;

                    System.out.println(sb.toString()) ;

                }

                return i;

            }

            //else

            //pointer was not stored because we reached the limit

        }

        return -1 ;

    }

    boolean canStore(short depth, short column){

        //colum = 0 , means first element at particular depth

        //column = 1, means second element at particular depth

        //        calle should make sure that it doesn't call for value outside allowed co-ordinates

        return fPointerInfo[depth][column] == 0 ? true : false ;

    }

    short getElementPointer(short depth, short column){

        //colum = 0 , means first element at particular depth

        //column = 1, means second element at particular depth

        //        calle should make sure that it doesn't call for value outside allowed co-ordinates

        return fPointerInfo[depth][column] ;

    }

    //this function assumes that string passed is not null and skips

    //the following string from the buffer this makes sure

    boolean skipFromTheBuffer(String rawname) throws IOException{

        if(fEntityScanner.skipString(rawname)){

            char c = (char)fEntityScanner.peekChar() ;

            //If the start element was completely skipped we should encounter either ' '(space),

            //or '/' (in case of empty element)  or '>'

            if( c == ' ' || c == '/' || c == '>'){

                fElementRawname = rawname ;

                return true ;

            } else{

                return false;

            }

        } else

            return false ;

    }

    boolean skipQElement(String rawname) throws IOException{

        final int c = fEntityScanner.getChar(rawname.length());

        //if this character is still valid element name -- this means string can't match

        if(XMLChar.isName(c)){

            return false;

        }else{

            return fEntityScanner.skipString(rawname);

        }

    }

    protected boolean skipElement() throws IOException {

        if(!fShouldSkip) return false ;

        if(fLastPointerLocation != 0){

            //Look at the next element stored in the array list.. we might just get a match.

            String rawname = fElementArray[fLastPointerLocation + 1] ;

            if(rawname != null && skipFromTheBuffer(rawname)){

                fLastPointerLocation++ ;

                if(DEBUG_SKIP_ALGORITHM){

                    System.out.println("Element " + fElementRawname +

                            " was SKIPPED at pointer location = " + fLastPointerLocation);

                }

                return true ;

            } else{

                //reset it back to zero... we haven't got the correct subset yet.

                fLastPointerLocation = 0 ;

            }

        }

        //xxx: we can put some logic here as from what column it should start looking

        //for now we always start at 0

        //fallback to tolerant algorithm, it would look for differnt element stored at different

        //depth and get us the pointer location.

        return fShouldSkip && skipElement((short)0);

    }

    //start of the column at which it should try searching

    boolean skipElement(short column) throws IOException {

        short depth = (short)fElementStack.fDepth ;

        if(depth > MAX_DEPTH_LIMIT){

            return fShouldSkip = false ;

        }

        for(short i = column ; i < MAX_POINTER_AT_A_DEPTH ; i++){

            short pointer = getElementPointer(depth , i ) ;

            if(pointer == 0){

                return fShouldSkip = false ;

            }

            if(fElementArray[pointer] != null && skipFromTheBuffer(fElementArray[pointer])){

                if(DEBUG_SKIP_ALGORITHM){

                    System.out.println();

                    System.out.println("Element " + fElementRawname + " was SKIPPED at depth = " +

                            fElementStack.fDepth + " column = " + column );

                    System.out.println();

                }

                fLastPointerLocation = pointer ;

                return fShouldSkip = true ;

            }

        }

        return fShouldSkip = false ;

    }

    /**

     * Scans a start element. This method will handle the binding of

     * namespace information and notifying the handler of the start

     * of the element.

     * <p>

     * <pre>

     * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'

     * [40] STag ::= '<' Name (S Attribute)* S? '>'

     * </pre>

     * <p>

     * <strong>Note:</strong> This method assumes that the leading

     * '<' character has been consumed.

     * <p>

     * <strong>Note:</strong> This method uses the fElementQName and

     * fAttributes variables. The contents of these variables will be

     * destroyed. The caller should copy important information out of

     * these variables before calling this method.

     * NB: Content in fAttributes is valid only till the state of the parser is XMLEvent.START_ELEMENT

     *

     * @return True if element is empty. (i.e. It matches

     *          production [44].

     */

    // fElementQName will have the details of element just read..

    // fAttributes will have the details of all the attributes.

    protected boolean scanStartElement()

    throws IOException, XNIException {

        if (DEBUG_START_END_ELEMENT) System.out.println( this.getClass().toString() + ">>> scanStartElement()");

        //when skipping is true and no more elements should be added

        if(fSkip && !fAdd){

            //get the stored element -- if everything goes right this should match the

            //token in the buffer

            QName name = fElementStack.getNext();

            if(DEBUG_SKIP_ALGORITHM){

                System.out.println("Trying to skip String = " + name.rawname);

            }

            //Be conservative -- if skipping fails -- stop.

            fSkip = fEntityScanner.skipString(name.rawname);

            if(fSkip){

                if(DEBUG_SKIP_ALGORITHM){

                    System.out.println("Element SUCESSFULLY skipped = " + name.rawname);

                }

                fElementStack.push();

                fElementQName = name;

            }else{

                //if skipping fails reposition the stack or fallback to normal way of processing

                fElementStack.reposition();

                if(DEBUG_SKIP_ALGORITHM){

                    System.out.println("Element was NOT skipped, REPOSITIONING stack" );

                }

            }

        }

        //we are still at the stage of adding elements

        //the elements were not matched or

        //fSkip is not set to true

        if(!fSkip || fAdd){

            //get the next element from the stack

            fElementQName = fElementStack.nextElement();

            // name

            if (fNamespaces) {

                fEntityScanner.scanQName(fElementQName, NameType.ELEMENTSTART);

            } else {

                String name = fEntityScanner.scanName(NameType.ELEMENTSTART);

                fElementQName.setValues(null, name, name, null);

            }

            if(DEBUG)System.out.println("Element scanned in start element is " + fElementQName.toString());

            if(DEBUG_SKIP_ALGORITHM){

                if(fAdd){

                    System.out.println("Elements are being ADDED -- elemet added is = " +

                            fElementQName.rawname + " at count = " + fElementStack.fCount);

                }

            }

        }

        //when the elements are being added , we need to check if we are set for skipping the elements

        if(fAdd){

            //this sets the value of fAdd variable

            fElementStack.matchElement(fElementQName);

        }

        //xxx: We dont need another pointer, fCurrentElement, we can use fElementQName

        fCurrentElement = fElementQName;

        String rawname = fElementQName.rawname;

        fEmptyElement = false;

        fAttributes.removeAllAttributes();

        checkDepth(rawname);

        if(!seekCloseOfStartTag()){

            fReadingAttributes = true;

            fAttributeCacheUsedCount =0;

            fStringBufferIndex =0;

            fAddDefaultAttr = true;

            do {

                scanAttribute(fAttributes);

                if (fSecurityManager != null && !fSecurityManager.isNoLimit(fElementAttributeLimit) &&

                        fAttributes.getLength() > fElementAttributeLimit){

                    fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,

                                                 "ElementAttributeLimit",

                                                 new Object[]{rawname, fElementAttributeLimit },

                                                 XMLErrorReporter.SEVERITY_FATAL_ERROR );

                }

            } while (!seekCloseOfStartTag());

            fReadingAttributes=false;

        }

        if (fEmptyElement) {

            //decrease the markup depth..