/*

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

 */

/*

 * 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.util.Status;

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

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import javax.xml.stream.events.XMLEvent;

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

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

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.xni.Augmentations;

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

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.xml.internal.stream.Entity;

//import com.sun.xml.stream.XMLEntityManager;

//import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;

/**

 * This class is responsible for holding scanning methods common to

 * scanning the XML document structure and content as well as the DTD

 * structure and content. Both XMLDocumentScanner and XMLDTDScanner inherit

 * from this base class.

 *

 * <p>

 * This component requires the following features and properties from the

 * component manager that uses it:

 * <ul>

 *  <li>http://xml.org/sax/features/validation</li>

 *  <li>http://apache.org/xml/features/scanner/notify-char-refs</li>

 *  <li>http://apache.org/xml/properties/internal/symbol-table</li>

 *  <li>http://apache.org/xml/properties/internal/error-reporter</li>

 *  <li>http://apache.org/xml/properties/internal/entity-manager</li>

 * </ul>

 *

 * @author Andy Clark, IBM

 * @author Arnaud  Le Hors, IBM

 * @author Eric Ye, IBM

 * @author K.Venugopal SUN Microsystems

 * @author Sunitha Reddy, SUN Microsystems

 * @version $Id: XMLScanner.java,v 1.12 2010-11-01 04:39:41 joehw Exp $

 */

public abstract class XMLScanner

        implements XMLComponent {

    //

    // Constants

    //

    // feature identifiers

    /** Feature identifier: namespaces. */

    protected static final String NAMESPACES =

            Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;

    /** Feature identifier: validation. */

    protected static final String VALIDATION =

            Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;

    /** Feature identifier: notify character references. */

    protected static final String NOTIFY_CHAR_REFS =

            Constants.XERCES_FEATURE_PREFIX + Constants.NOTIFY_CHAR_REFS_FEATURE;

    // property identifiers

    protected static final String PARSER_SETTINGS =

                                Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;

    /** Property identifier: symbol table. */

    protected static final String SYMBOL_TABLE =

            Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;

    /** Property identifier: error reporter. */

    protected static final String ERROR_REPORTER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;

    /** Property identifier: entity manager. */

    protected static final String ENTITY_MANAGER =

            Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;

    // debugging

    /** Debug attribute normalization. */

    protected static final boolean DEBUG_ATTR_NORMALIZATION = false;

    //xxx: setting the default value as false, as we dont need to calculate this value

    //we should have a feature when set to true computes this value

    private boolean fNeedNonNormalizedValue = false;

    protected ArrayList attributeValueCache = new ArrayList();

    protected ArrayList stringBufferCache = new ArrayList();

    protected int fStringBufferIndex = 0;

    protected boolean fAttributeCacheInitDone = false;

    protected int fAttributeCacheUsedCount = 0;

    //

    // Data

    //

    // features

    /**

     * Validation. This feature identifier is:

     * http://xml.org/sax/features/validation

     */

    protected boolean fValidation = false;

    /** Namespaces. */

    protected boolean fNamespaces;

    /** Character references notification. */

    protected boolean fNotifyCharRefs = false;

    /** Internal parser-settings feature */

        protected boolean fParserSettings = true;

    // properties

    protected PropertyManager fPropertyManager = null ;

    /** Symbol table. */

    protected SymbolTable fSymbolTable;

    /** Error reporter. */

    protected XMLErrorReporter fErrorReporter;

    /** Entity manager. */

    //protected XMLEntityManager fEntityManager = PropertyManager.getEntityManager();

    protected XMLEntityManager fEntityManager = null ;

    /** xxx this should be available from EntityManager Entity storage */

    protected XMLEntityStorage fEntityStore = null ;

    // protected data

    /** event type */

    protected XMLEvent fEvent ;

    /** Entity scanner, this alwasy works on last entity that was opened. */

    protected XMLEntityScanner fEntityScanner = null;

    /** Entity depth. */

    protected int fEntityDepth;

    /** Literal value of the last character refence scanned. */

    protected String fCharRefLiteral = null;

    /** Scanning attribute. */

    protected boolean fScanningAttribute;

    /** Report entity boundary. */

    protected boolean fReportEntity;

    // symbols

    /** Symbol: "version". */

    protected final static String fVersionSymbol = "version".intern();

    /** Symbol: "encoding". */

    protected final static String fEncodingSymbol = "encoding".intern();

    /** Symbol: "standalone". */

    protected final static String fStandaloneSymbol = "standalone".intern();

    /** Symbol: "amp". */

    protected final static String fAmpSymbol = "amp".intern();

    /** Symbol: "lt". */

    protected final static String fLtSymbol = "lt".intern();

    /** Symbol: "gt". */

    protected final static String fGtSymbol = "gt".intern();

    /** Symbol: "quot". */

    protected final static String fQuotSymbol = "quot".intern();

    /** Symbol: "apos". */

    protected final static String fAposSymbol = "apos".intern();

    // temporary variables

    // NOTE: These objects are private to help prevent accidental modification

    //       of values by a subclass. If there were protected *and* the sub-

    //       modified the values, it would be difficult to track down the real

    //       cause of the bug. By making these private, we avoid this

    //       possibility.

    /** String. */

    private XMLString fString = new XMLString();

    /** String buffer. */

    private XMLStringBuffer fStringBuffer = new XMLStringBuffer();

    /** String buffer. */

    private XMLStringBuffer fStringBuffer2 = new XMLStringBuffer();

    /** String buffer. */

    private XMLStringBuffer fStringBuffer3 = new XMLStringBuffer();

    // temporary location for Resource identification information.

    protected XMLResourceIdentifierImpl fResourceIdentifier = new XMLResourceIdentifierImpl();

    int initialCacheCount = 6;

    //

    // XMLComponent methods

    //

    /**

     *

     *

     * @param componentManager The component manager.

     *

     * @throws SAXException Throws exception if required features and

     *                      properties cannot be found.

     */

    public void reset(XMLComponentManager componentManager)

    throws XMLConfigurationException {

                fParserSettings = componentManager.getFeature(PARSER_SETTINGS, true);

                if (!fParserSettings) {

                        // parser settings have not been changed

                        init();

                        return;

                }

        // Xerces properties

        fSymbolTable = (SymbolTable)componentManager.getProperty(SYMBOL_TABLE);

        fErrorReporter = (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER);

        fEntityManager = (XMLEntityManager)componentManager.getProperty(ENTITY_MANAGER);

        //this step is extra because we have separated the storage of entity

        fEntityStore = fEntityManager.getEntityStore() ;

        // sax features

        fValidation = componentManager.getFeature(VALIDATION, false);

        fNamespaces = componentManager.getFeature(NAMESPACES, true);

        fNotifyCharRefs = componentManager.getFeature(NOTIFY_CHAR_REFS, false);

        init();

    } // reset(XMLComponentManager)

    protected void setPropertyManager(PropertyManager propertyManager){

        fPropertyManager = propertyManager ;

    }

    /**

     * Sets the value of a property during parsing.

     *

     * @param propertyId

     * @param value

     */

    public void setProperty(String propertyId, Object value)

    throws XMLConfigurationException {

        // Xerces properties

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

            String property =

                    propertyId.substring(Constants.XERCES_PROPERTY_PREFIX.length());

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

                fSymbolTable = (SymbolTable)value;

            } else if (property.equals(Constants.ERROR_REPORTER_PROPERTY)) {

                fErrorReporter = (XMLErrorReporter)value;

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

                fEntityManager = (XMLEntityManager)value;

            }

        }

                /*else if(propertyId.equals(Constants.STAX_PROPERTIES)){

            fStaxProperties = (HashMap)value;

            //TODO::discuss with neeraj what are his thoughts on passing properties.

            //For now use this

        }*/

    } // setProperty(String,Object)

    /*

     * Sets the feature of the scanner.

     */

    public void setFeature(String featureId, boolean value)

    throws XMLConfigurationException {

        if (VALIDATION.equals(featureId)) {

            fValidation = value;

        } else if (NOTIFY_CHAR_REFS.equals(featureId)) {

            fNotifyCharRefs = value;

        }

    }

    /*

     * Gets the state of the feature of the scanner.

     */

    public boolean getFeature(String featureId)

    throws XMLConfigurationException {

        if (VALIDATION.equals(featureId)) {

            return fValidation;

        } else if (NOTIFY_CHAR_REFS.equals(featureId)) {

            return fNotifyCharRefs;

        }

        throw new XMLConfigurationException(Status.NOT_RECOGNIZED, featureId);

    }

    //

    // Protected methods

    //

    // anybody calling this had better have set Symtoltable!

    protected void reset() {

        init();

        // DTD preparsing defaults:

        fValidation = true;

        fNotifyCharRefs = false;

    }

    public void reset(PropertyManager propertyManager) {

        init();

        // Xerces properties

        fSymbolTable = (SymbolTable)propertyManager.getProperty(Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY);

        fErrorReporter = (XMLErrorReporter)propertyManager.getProperty(Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY);

        fEntityManager = (XMLEntityManager)propertyManager.getProperty(ENTITY_MANAGER);

        fEntityStore = fEntityManager.getEntityStore() ;

        fEntityScanner = (XMLEntityScanner)fEntityManager.getEntityScanner() ;

        //fEntityManager.reset();

        // DTD preparsing defaults:

        fValidation = false;

        fNotifyCharRefs = false;

    }

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

     * @param pseudoAttributeValues An array of size 3 to return the version,

     *                         encoding and standalone pseudo attribute values

     *                         (in that order).

     *

     * <strong>Note:</strong> This method uses fString, anything in it

     * at the time of calling is lost.

     */

    protected void scanXMLDeclOrTextDecl(boolean scanningTextDecl,

            String[] pseudoAttributeValues)

            throws IOException, XNIException {

        // pseudo-attribute values

        String version = null;

        String encoding = null;

        String standalone = null;

        // scan pseudo-attributes

        final int STATE_VERSION = 0;

        final int STATE_ENCODING = 1;

        final int STATE_STANDALONE = 2;

        final int STATE_DONE = 3;

        int state = STATE_VERSION;

        boolean dataFoundForTarget = false;

        boolean sawSpace = fEntityScanner.skipSpaces();

        while (fEntityScanner.peekChar() != '?') {

            dataFoundForTarget = true;

            String name = scanPseudoAttribute(scanningTextDecl, fString);

            switch (state) {

                case STATE_VERSION: {

                    if (name.equals(fVersionSymbol)) {

                        if (!sawSpace) {

                            reportFatalError(scanningTextDecl

                                    ? "SpaceRequiredBeforeVersionInTextDecl"

                                    : "SpaceRequiredBeforeVersionInXMLDecl",

                                    null);

                        }

                        version = fString.toString();

                        state = STATE_ENCODING;

                        if (!versionSupported(version)) {

                            reportFatalError("VersionNotSupported",

                                    new Object[]{version});

                        }

                        if (version.equals("1.1")) {

                            Entity.ScannedEntity top = fEntityManager.getTopLevelEntity();

                            if (top != null && (top.version == null || top.version.equals("1.0"))) {

                                reportFatalError("VersionMismatch", null);

                            }

                            fEntityManager.setScannerVersion(Constants.XML_VERSION_1_1);

                        }

                    } else if (name.equals(fEncodingSymbol)) {

                        if (!scanningTextDecl) {

                            reportFatalError("VersionInfoRequired", null);

                        }

                        if (!sawSpace) {

                            reportFatalError(scanningTextDecl

                                    ? "SpaceRequiredBeforeEncodingInTextDecl"

                                    : "SpaceRequiredBeforeEncodingInXMLDecl",

                                    null);

                        }

                        encoding = fString.toString();

                        state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;

                    } else {

                        if (scanningTextDecl) {

                            reportFatalError("EncodingDeclRequired", null);

                        } else {

                            reportFatalError("VersionInfoRequired", null);

                        }

                    }

                    break;

                }

                case STATE_ENCODING: {

                    if (name.equals(fEncodingSymbol)) {

                        if (!sawSpace) {

                            reportFatalError(scanningTextDecl

                                    ? "SpaceRequiredBeforeEncodingInTextDecl"

                                    : "SpaceRequiredBeforeEncodingInXMLDecl",

                                    null);

                        }

                        encoding = fString.toString();

                        state = scanningTextDecl ? STATE_DONE : STATE_STANDALONE;

                        // TODO: check encoding name; set encoding on

                        //       entity scanner

                    } else if (!scanningTextDecl && name.equals(fStandaloneSymbol)) {

                        if (!sawSpace) {

                            reportFatalError("SpaceRequiredBeforeStandalone",

                                    null);

                        }

                        standalone = fString.toString();

                        state = STATE_DONE;

                        if (!standalone.equals("yes") && !standalone.equals("no")) {

                            reportFatalError("SDDeclInvalid", new Object[] {standalone});

                        }

                    } else {

                        reportFatalError("EncodingDeclRequired", null);

                    }

                    break;

                }

                case STATE_STANDALONE: {

                    if (name.equals(fStandaloneSymbol)) {

                        if (!sawSpace) {

                            reportFatalError("SpaceRequiredBeforeStandalone",

                                    null);

                        }

                        standalone = fString.toString();

                        state = STATE_DONE;

                        if (!standalone.equals("yes") && !standalone.equals("no")) {

                            reportFatalError("SDDeclInvalid",  new Object[] {standalone});

                        }

                    } else {

                        reportFatalError("EncodingDeclRequired", null);

                    }

                    break;

                }

                default: {

                    reportFatalError("NoMorePseudoAttributes", null);

                }

            }

            sawSpace = fEntityScanner.skipSpaces();

        }

        // REVISIT: should we remove this error reporting?

        if (scanningTextDecl && state != STATE_DONE) {

            reportFatalError("MorePseudoAttributes", null);

        }

        // If there is no data in the xml or text decl then we fail to report error

        // for version or encoding info above.

        if (scanningTextDecl) {

            if (!dataFoundForTarget && encoding == null) {

                reportFatalError("EncodingDeclRequired", null);

            }

        } else {

            if (!dataFoundForTarget && version == null) {

                reportFatalError("VersionInfoRequired", null);

            }

        }

        // end

        if (!fEntityScanner.skipChar('?')) {

            reportFatalError("XMLDeclUnterminated", null);

        }

        if (!fEntityScanner.skipChar('>')) {

            reportFatalError("XMLDeclUnterminated", null);

        }

        // fill in return array