/*

 */

/*

 * Copyright 2005 The Apache Software Foundation.

 *

 * Licensed 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.dtd.XMLDTDDescription;

import com.sun.org.apache.xerces.internal.impl.validation.ValidationManager;

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

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

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

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

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

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

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

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

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

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.XMLDTDScanner;

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

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

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

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

import java.io.EOFException;

import java.io.IOException;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.events.XMLEvent;

/**

 * This class is responsible for scanning XML document structure

 * and content.

 *

 * 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

 *

 * Refer to the table in unit-test javax.xml.stream.XMLStreamReaderTest.SupportDTD for changes

 * related to property SupportDTD.

 * @author Joe Wang, Sun Microsystems

 */

public class XMLDocumentScannerImpl

        extends XMLDocumentFragmentScannerImpl{

    //

    // Constants

    //

    // scanner states

    /** Scanner state: XML declaration. */

    protected static final int SCANNER_STATE_XML_DECL = 42;

    /** Scanner state: prolog. */

    protected static final int SCANNER_STATE_PROLOG = 43;

    /** Scanner state: trailing misc. */

    protected static final int SCANNER_STATE_TRAILING_MISC = 44;

    /** Scanner state: DTD internal declarations. */

    protected static final int SCANNER_STATE_DTD_INTERNAL_DECLS = 45;

    /** Scanner state: open DTD external subset. */

    protected static final int SCANNER_STATE_DTD_EXTERNAL = 46;

    /** Scanner state: DTD external declarations. */

    protected static final int SCANNER_STATE_DTD_EXTERNAL_DECLS = 47;

    /** Scanner state: NO MORE ELEMENTS. */

    protected static final int SCANNER_STATE_NO_SUCH_ELEMENT_EXCEPTION = 48;

    // feature identifiers

    /** Property identifier document scanner: */

    protected static final String DOCUMENT_SCANNER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.DOCUMENT_SCANNER_PROPERTY;

    /** Feature identifier: load external DTD. */

    protected static final String LOAD_EXTERNAL_DTD =

            Constants.XERCES_FEATURE_PREFIX + Constants.LOAD_EXTERNAL_DTD_FEATURE;

    /** Feature identifier: load external DTD. */

    protected static final String DISALLOW_DOCTYPE_DECL_FEATURE =

            Constants.XERCES_FEATURE_PREFIX + Constants.DISALLOW_DOCTYPE_DECL_FEATURE;

    // property identifiers

    /** Property identifier: DTD scanner. */

    protected static final String DTD_SCANNER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.DTD_SCANNER_PROPERTY;

    // property identifier:  ValidationManager

    protected static final String VALIDATION_MANAGER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.VALIDATION_MANAGER_PROPERTY;

    /** property identifier:  NamespaceContext */

    protected static final String NAMESPACE_CONTEXT =

        Constants.XERCES_PROPERTY_PREFIX + Constants.NAMESPACE_CONTEXT_PROPERTY;

    // recognized features and properties

    /** Recognized features. */

    private static final String[] RECOGNIZED_FEATURES = {

        LOAD_EXTERNAL_DTD,

                DISALLOW_DOCTYPE_DECL_FEATURE,

    };

    /** Feature defaults. */

    private static final Boolean[] FEATURE_DEFAULTS = {

        Boolean.TRUE,

                Boolean.FALSE,

    };

    /** Recognized properties. */

    private static final String[] RECOGNIZED_PROPERTIES = {

        DTD_SCANNER,

                VALIDATION_MANAGER

    };

    /** Property defaults. */

    private static final Object[] PROPERTY_DEFAULTS = {

            null,

                null

    };

    //

    // Data((Boolean)propertyManager.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE)).booleanValue();

    //

    // properties

    /** DTD scanner. */

    protected XMLDTDScanner fDTDScanner = null;

    /** Validation manager . */

    //xxx: fValidationManager code needs to be added yet!

    protected ValidationManager fValidationManager;

    protected XMLStringBuffer fDTDDecl = null;

    protected boolean fReadingDTD = false;

    protected boolean fAddedListener = false;

    // protected data

    // other info

    /** Doctype name. */

    protected String fDoctypeName;

    /** Doctype declaration public identifier. */

    protected String fDoctypePublicId;

    /** Doctype declaration system identifier. */

    protected String fDoctypeSystemId;

    /** Namespace support. */

    protected NamespaceContext fNamespaceContext = new NamespaceSupport();

    // features

    /** Load external DTD. */

    protected boolean fLoadExternalDTD = true;

    // state

    /** Seen doctype declaration. */

    protected boolean fSeenDoctypeDecl;

    protected boolean fScanEndElement;

    //protected int fScannerLastState ;

    // drivers

    /** XML declaration driver. */

    protected Driver fXMLDeclDriver = new XMLDeclDriver();

    /** Prolog driver. */

    protected Driver fPrologDriver = new PrologDriver();

    /** DTD driver. */

    protected Driver fDTDDriver = null ;

    /** Trailing miscellaneous section driver. */

    protected Driver fTrailingMiscDriver = new TrailingMiscDriver();

    protected int fStartPos = 0;

    protected int fEndPos = 0;

    protected boolean fSeenInternalSubset= false;

    // temporary variables

    /** Array of 3 strings. */

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

    /** External subset source. */

    private XMLInputSource fExternalSubsetSource = null;

    /** A DTD Description. */

    private final XMLDTDDescription fDTDDescription = new XMLDTDDescription(null, null, null, null, null);

    private static final char [] DOCTYPE = {'D','O','C','T','Y','P','E'};

    private static final char [] COMMENTSTRING = {'-','-'};

    //

    // Constructors

    //

    /** Default constructor. */

    public XMLDocumentScannerImpl() {} // <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);

        //this starts a new entity and sets the current entity to the document entity.

        fEntityManager.startDocumentEntity(inputSource);

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

        setScannerState(XMLEvent.START_DOCUMENT);

    } // setInputSource(XMLInputSource)

    /**return the state of the scanner */

    public int getScannetState(){

        return fScannerState ;

    }

    public void reset(PropertyManager propertyManager) {

        super.reset(propertyManager);

        // other settings

        fDoctypeName = null;

        fDoctypePublicId = null;

        fDoctypeSystemId = null;

        fSeenDoctypeDecl = false;

        fNamespaceContext.reset();

        fSupportDTD = ((Boolean)propertyManager.getProperty(XMLInputFactory.SUPPORT_DTD)).booleanValue();

        // xerces features

        fLoadExternalDTD = !((Boolean)propertyManager.getProperty(Constants.ZEPHYR_PROPERTY_PREFIX + Constants.IGNORE_EXTERNAL_DTD)).booleanValue();

        setScannerState(XMLEvent.START_DOCUMENT);

        setDriver(fXMLDeclDriver);

        fSeenInternalSubset = false;

        if(fDTDScanner != null){

            ((XMLDTDScannerImpl)fDTDScanner).reset(propertyManager);

        }

        fEndPos = 0;

        fStartPos = 0;

        if(fDTDDecl != null){

            fDTDDecl.clear();

        }

    }

    /**

     * 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

        fDoctypeName = null;

        fDoctypePublicId = null;

        fDoctypeSystemId = null;

        fSeenDoctypeDecl = false;

        fExternalSubsetSource = null;

        // xerces features

        fLoadExternalDTD = componentManager.getFeature(LOAD_EXTERNAL_DTD, true);

        fDisallowDoctype = componentManager.getFeature(DISALLOW_DOCTYPE_DECL_FEATURE, false);

        fNamespaces = componentManager.getFeature(NAMESPACES, true);

        fSeenInternalSubset = false;

        // xerces properties

        fDTDScanner = (XMLDTDScanner)componentManager.getProperty(DTD_SCANNER);

        fValidationManager = (ValidationManager)componentManager.getProperty(VALIDATION_MANAGER, null);

        try {

            fNamespaceContext = (NamespaceContext)componentManager.getProperty(NAMESPACE_CONTEXT);

        }

        catch (XMLConfigurationException e) { }

        if (fNamespaceContext == null) {

            fNamespaceContext = new NamespaceSupport();

        }

        fNamespaceContext.reset();

        fEndPos = 0;

        fStartPos = 0;

        if(fDTDDecl != null)

            fDTDDecl.clear();

        //fEntityScanner.registerListener((XMLBufferListener)componentManager.getProperty(DOCUMENT_SCANNER));

        // setup driver

        setScannerState(SCANNER_STATE_XML_DECL);

        setDriver(fXMLDeclDriver);

    } // reset(XMLComponentManager)

    /**

     * 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() {

        String[] featureIds = super.getRecognizedFeatures();

        int length = featureIds != null ? featureIds.length : 0;

        String[] combinedFeatureIds = new String[length + RECOGNIZED_FEATURES.length];

        if (featureIds != null) {

            System.arraycopy(featureIds, 0, combinedFeatureIds, 0, featureIds.length);

        }

        System.arraycopy(RECOGNIZED_FEATURES, 0, combinedFeatureIds, length, RECOGNIZED_FEATURES.length);

        return combinedFeatureIds;

    } // 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)) {

            final int suffixLength = featureId.length() - Constants.XERCES_FEATURE_PREFIX.length();

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

                featureId.endsWith(Constants.LOAD_EXTERNAL_DTD_FEATURE)) {

                fLoadExternalDTD = state;

                return;

            }

            else if (suffixLength == Constants.DISALLOW_DOCTYPE_DECL_FEATURE.length() &&

                featureId.endsWith(Constants.DISALLOW_DOCTYPE_DECL_FEATURE)) {

                fDisallowDoctype = state;

                return;

            }

        }

    } // 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() {

        String[] propertyIds = super.getRecognizedProperties();

        int length = propertyIds != null ? propertyIds.length : 0;

        String[] combinedPropertyIds = new String[length + RECOGNIZED_PROPERTIES.length];

        if (propertyIds != null) {

            System.arraycopy(propertyIds, 0, combinedPropertyIds, 0, propertyIds.length);

        }

        System.arraycopy(RECOGNIZED_PROPERTIES, 0, combinedPropertyIds, length, RECOGNIZED_PROPERTIES.length);

        return combinedPropertyIds;

    } // 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.DTD_SCANNER_PROPERTY.length() &&

                propertyId.endsWith(Constants.DTD_SCANNER_PROPERTY)) {

                fDTDScanner = (XMLDTDScanner)value;

            }

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

                propertyId.endsWith(Constants.NAMESPACE_CONTEXT_PROPERTY)) {

                if (value != null) {

                    fNamespaceContext = (NamespaceContext)value;

                }

            }

            return;

        }

    } // 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 super.getFeatureDefault(featureId);

    } // 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 super.getPropertyDefault(propertyId);

    } // getPropertyDefault(String):Object

    //

    // 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).

     *

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

     */

    public void startEntity(String name,

            XMLResourceIdentifier identifier,

            String encoding, Augmentations augs) throws XNIException {

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

        //register current document scanner as a listener for XMLEntityScanner