/*

 * Copyright (c) 2003, 2016, 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.ASCIIReader;

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

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

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

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

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

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

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

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

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

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

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

import java.io.EOFException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.util.ArrayList;

import java.util.Locale;

/**

 * Implements the entity scanner methods.

 *

 * @author Neeraj Bajaj, Sun Microsystems

 * @author Andy Clark, IBM

 * @author Arnaud  Le Hors, IBM

 * @author K.Venugopal Sun Microsystems

 *

 */

public class XMLEntityScanner implements XMLLocator  {

    protected Entity.ScannedEntity fCurrentEntity = null;

    protected int fBufferSize = XMLEntityManager.DEFAULT_BUFFER_SIZE;

    protected XMLEntityManager fEntityManager;

    /** Security manager. */

    protected XMLSecurityManager fSecurityManager = null;

    /** Limit analyzer. */

    protected XMLLimitAnalyzer fLimitAnalyzer = null;

    /** Debug switching readers for encodings. */

    private static final boolean DEBUG_ENCODINGS = false;

    /** Listeners which should know when load is being called */

    private ArrayList<XMLBufferListener> listeners = new ArrayList<>();

    private static final boolean [] VALID_NAMES = new boolean[127];

    /**

     * Debug printing of buffer. This debugging flag works best when you

     * resize the DEFAULT_BUFFER_SIZE down to something reasonable like

     * 64 characters.

     */

    private static final boolean DEBUG_BUFFER = false;

    private static final boolean DEBUG_SKIP_STRING = false;

    /**

     * To signal the end of the document entity, this exception will be thrown.

     */

    private static final EOFException END_OF_DOCUMENT_ENTITY = new EOFException() {

        private static final long serialVersionUID = 980337771224675268L;

        public Throwable fillInStackTrace() {

            return this;

        }

    };

    protected SymbolTable fSymbolTable = null;

    protected XMLErrorReporter fErrorReporter = null;

    int [] whiteSpaceLookup = new int[100];

    int whiteSpaceLen = 0;

    boolean whiteSpaceInfoNeeded = true;

    /**

     * Allow Java encoding names. This feature identifier is:

     * http://apache.org/xml/features/allow-java-encodings

     */

    protected boolean fAllowJavaEncodings;

    //Will be used only during internal subsets.

    //for appending data.

    /** 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;

    /** Feature identifier: allow Java encodings. */

    protected static final String ALLOW_JAVA_ENCODINGS =

            Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;

    protected PropertyManager fPropertyManager = null ;

    boolean isExternal = false;

    static {

        for(int i=0x0041;i<=0x005A ; i++){

            VALID_NAMES[i]=true;

        }

        for(int i=0x0061;i<=0x007A; i++){

            VALID_NAMES[i]=true;

        }

        for(int i=0x0030;i<=0x0039; i++){

            VALID_NAMES[i]=true;

        }

        VALID_NAMES[45]=true;

        VALID_NAMES[46]=true;

        VALID_NAMES[58]=true;

        VALID_NAMES[95]=true;

    }

    // Remember, that the XML version has explicitly been set,

    // so that XMLStreamReader.getVersion() can find that out.

    protected boolean xmlVersionSetExplicitly = false;

    //

    // Constructors

    //

    /** Default constructor. */

    public XMLEntityScanner() {

    } // <init>()

    /**  private constructor, this class can only be instantiated within this class. Instance of this class should

     *    be obtained using getEntityScanner() or getEntityScanner(ScannedEntity scannedEntity)

     *    @see getEntityScanner()

     *    @see getEntityScanner(ScannedEntity)

     */

    public XMLEntityScanner(PropertyManager propertyManager, XMLEntityManager entityManager) {

        fEntityManager = entityManager ;

        reset(propertyManager);

    } // <init>()

    // set buffer size:

    public final void setBufferSize(int size) {

        // REVISIT: Buffer size passed to entity scanner

        // was not being kept in synch with the actual size

        // of the buffers in each scanned entity. If any

        // of the buffers were actually resized, it was possible

        // that the parser would throw an ArrayIndexOutOfBoundsException

        // for documents which contained names which are longer than

        // the current buffer size. Conceivably the buffer size passed

        // to entity scanner could be used to determine a minimum size

        // for resizing, if doubling its size is smaller than this

        // minimum. -- mrglavas

        fBufferSize = size;

    }

    /**

     * Resets the components.

     */

    public void reset(PropertyManager propertyManager){

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

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

        resetCommon();

    }

    /**

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

        // xerces features

        fAllowJavaEncodings = componentManager.getFeature(ALLOW_JAVA_ENCODINGS, false);

        //xerces properties

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

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

        resetCommon();

    } // reset(XMLComponentManager)

    public final void reset(SymbolTable symbolTable, XMLEntityManager entityManager,

            XMLErrorReporter reporter) {

        fCurrentEntity = null;

        fSymbolTable = symbolTable;

        fEntityManager = entityManager;

        fErrorReporter = reporter;

        fLimitAnalyzer = fEntityManager.fLimitAnalyzer;

        fSecurityManager = fEntityManager.fSecurityManager;

    }

    private void resetCommon() {

        fCurrentEntity = null;

        whiteSpaceLen = 0;

        whiteSpaceInfoNeeded = true;

        listeners.clear();

        fLimitAnalyzer = fEntityManager.fLimitAnalyzer;

        fSecurityManager = fEntityManager.fSecurityManager;

    }

    /**

     * Returns the XML version of the current entity. This will normally be the

     * value from the XML or text declaration or defaulted by the parser. Note that

     * that this value may be different than the version of the processing rules

     * applied to the current entity. For instance, an XML 1.1 document may refer to

     * XML 1.0 entities. In such a case the rules of XML 1.1 are applied to the entire

     * document. Also note that, for a given entity, this value can only be considered

     * final once the XML or text declaration has been read or once it has been

     * determined that there is no such declaration.

     */

    public final String getXMLVersion() {

        if (fCurrentEntity != null) {

            return fCurrentEntity.xmlVersion;

        }

        return null;

    } // getXMLVersion():String

    /**

     * Sets the XML version. This method is used by the

     * scanners to report the value of the version pseudo-attribute

     * in an XML or text declaration.

     *

     * @param xmlVersion the XML version of the current entity

     */

    public final void setXMLVersion(String xmlVersion) {

        xmlVersionSetExplicitly = true;

        fCurrentEntity.xmlVersion = xmlVersion;

    } // setXMLVersion(String)

    /** set the instance of current scanned entity.

     *   @param ScannedEntity

     */

    public final void setCurrentEntity(Entity.ScannedEntity scannedEntity){

        fCurrentEntity = scannedEntity ;

        if(fCurrentEntity != null){

            isExternal = fCurrentEntity.isExternal();

            if(DEBUG_BUFFER)

                System.out.println("Current Entity is "+scannedEntity.name);

        }

    }

    public  Entity.ScannedEntity getCurrentEntity(){

        return fCurrentEntity ;

    }

    //

    // XMLEntityReader methods

    //

    /**

     * Returns the base system identifier of the currently scanned

     * entity, or null if none is available.

     */

    public final String getBaseSystemId() {

        return (fCurrentEntity != null && fCurrentEntity.entityLocation != null) ? fCurrentEntity.entityLocation.getExpandedSystemId() : null;

    } // getBaseSystemId():String

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier#setBaseSystemId(String)

     */

    public void setBaseSystemId(String systemId) {

        //no-op

    }

    ///////////// Locator methods start.

    public final int getLineNumber(){

        //if the entity is closed, we should return -1

        //xxx at first place why such call should be there...

        return fCurrentEntity != null ? fCurrentEntity.lineNumber : -1 ;

    }

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLLocator#setLineNumber(int)

     */

    public void setLineNumber(int line) {

        //no-op

    }

    public final int getColumnNumber(){

        //if the entity is closed, we should return -1

        //xxx at first place why such call should be there...

        return fCurrentEntity != null ? fCurrentEntity.columnNumber : -1 ;

    }

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLLocator#setColumnNumber(int)

     */

    public void setColumnNumber(int col) {

        // no-op

    }

    public final int getCharacterOffset(){

        return fCurrentEntity != null ? fCurrentEntity.fTotalCountTillLastLoad + fCurrentEntity.position : -1 ;

    }

    /** Returns the expanded system identifier.  */

    public final String getExpandedSystemId() {

        return (fCurrentEntity != null && fCurrentEntity.entityLocation != null) ? fCurrentEntity.entityLocation.getExpandedSystemId() : null;

    }

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier#setExpandedSystemId(String)

     */

    public void setExpandedSystemId(String systemId) {

        //no-op

    }

    /** Returns the literal system identifier.  */

    public final String getLiteralSystemId() {

        return (fCurrentEntity != null && fCurrentEntity.entityLocation != null) ? fCurrentEntity.entityLocation.getLiteralSystemId() : null;

    }

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier#setLiteralSystemId(String)

     */

    public void setLiteralSystemId(String systemId) {

        //no-op

    }

    /** Returns the public identifier.  */

    public final String getPublicId() {

        return (fCurrentEntity != null && fCurrentEntity.entityLocation != null) ? fCurrentEntity.entityLocation.getPublicId() : null;

    }

    /**

     * @see com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier#setPublicId(String)

     */

    public void setPublicId(String publicId) {

        //no-op

    }

    ///////////////// Locator methods finished.

    /** the version of the current entity being scanned */

    public void setVersion(String version){

        fCurrentEntity.version = version;

    }

    public String getVersion(){

        if (fCurrentEntity != null)

            return fCurrentEntity.version ;

        return null;

    }

    /**

     * Returns the encoding of the current entity.

     * Note that, for a given entity, this value can only be

     * considered final once the encoding declaration has been read (or once it

     * has been determined that there is no such declaration) since, no encoding

     * having been specified on the XMLInputSource, the parser

     * will make an initial "guess" which could be in error.

     */

    public final String getEncoding() {

        if (fCurrentEntity != null) {

            return fCurrentEntity.encoding;

        }

        return null;

    } // getEncoding():String

    /**

     * Sets the encoding of the scanner. This method is used by the

     * scanners if the XMLDecl or TextDecl line contains an encoding

     * pseudo-attribute.

     * <p>

     * <strong>Note:</strong> The underlying character reader on the

     * current entity will be changed to accomodate the new encoding.

     * However, the new encoding is ignored if the current reader was

     * not constructed from an input stream (e.g. an external entity

     * that is resolved directly to the appropriate java.io.Reader

     * object).

     *

     * @param encoding The IANA encoding name of the new encoding.

     *

     * @throws IOException Thrown if the new encoding is not supported.

     *

     * @see com.sun.org.apache.xerces.internal.util.EncodingMap

     */

    public final void setEncoding(String encoding) throws IOException {

        if (DEBUG_ENCODINGS) {

            System.out.println("$$$ setEncoding: "+encoding);

        }

        if (fCurrentEntity.stream != null) {

            // if the encoding is the same, don't change the reader and

            // re-use the original reader used by the OneCharReader

            // NOTE: Besides saving an object, this overcomes deficiencies

            //       in the UTF-16 reader supplied with the standard Java

            //       distribution (up to and including 1.3). The UTF-16

            //       decoder buffers 8K blocks even when only asked to read

            //       a single char! -Ac

            if (fCurrentEntity.encoding == null ||

                    !fCurrentEntity.encoding.equals(encoding)) {

                // UTF-16 is a bit of a special case.  If the encoding is UTF-16,

                // and we know the endian-ness, we shouldn't change readers.

                // If it's ISO-10646-UCS-(2|4), then we'll have to deduce

                // the endian-ness from the encoding we presently have.

                if(fCurrentEntity.encoding != null && fCurrentEntity.encoding.startsWith("UTF-16")) {

                    String ENCODING = encoding.toUpperCase(Locale.ENGLISH);

                    if(ENCODING.equals("UTF-16")) return;

                    if(ENCODING.equals("ISO-10646-UCS-4")) {

                        if(fCurrentEntity.encoding.equals("UTF-16BE")) {

                            fCurrentEntity.reader = new UCSReader(fCurrentEntity.stream, UCSReader.UCS4BE);

                        } else {

                            fCurrentEntity.reader = new UCSReader(fCurrentEntity.stream, UCSReader.UCS4LE);

                        }

                        return;

                    }

                    if(ENCODING.equals("ISO-10646-UCS-2")) {

                        if(fCurrentEntity.encoding.equals("UTF-16BE")) {

                            fCurrentEntity.reader = new UCSReader(fCurrentEntity.stream, UCSReader.UCS2BE);

                        } else {

                            fCurrentEntity.reader = new UCSReader(fCurrentEntity.stream, UCSReader.UCS2LE);

                        }

                        return;

                    }

                }

                // wrap a new reader around the input stream, changing

                // the encoding

                if (DEBUG_ENCODINGS) {

                    System.out.println("$$$ creating new reader from stream: "+

                            fCurrentEntity.stream);

                }

                //fCurrentEntity.stream.reset();

                fCurrentEntity.reader = createReader(fCurrentEntity.stream, encoding, null);

                fCurrentEntity.encoding = encoding;

            } else {

                if (DEBUG_ENCODINGS)

                    System.out.println("$$$ reusing old reader on stream");

            }

        }

    } // setEncoding(String)

    /** Returns true if the current entity being scanned is external. */

    public final boolean isExternal() {

        return fCurrentEntity.isExternal();

    } // isExternal():boolean

    public int getChar(int relative) throws IOException{

        if(arrangeCapacity(relative + 1, false)){

            return fCurrentEntity.ch[fCurrentEntity.position + relative];

        }else{

            return -1;

        }

    }//getChar()

    /**

     * Returns the next character on the input.

     * <p>

     * <strong>Note:</strong> The character is <em>not</em> consumed.

     *

     * @throws IOException  Thrown if i/o error occurs.

     * @throws EOFException Thrown on end of file.

     */

    public int peekChar() throws IOException {

        if (DEBUG_BUFFER) {

            System.out.print("(peekChar: ");

            print();

            System.out.println();

        }

        // load more characters, if needed

        if (fCurrentEntity.position == fCurrentEntity.count) {

            load(0, true, true);

        }

        // peek at character

        int c = fCurrentEntity.ch[fCurrentEntity.position];

        // return peeked character

        if (DEBUG_BUFFER) {

            System.out.print(")peekChar: ");

            print();

            if (isExternal) {

                System.out.println(" -> '"+(c!='\r'?(char)c:'\n')+"'");

            } else {

                System.out.println(" -> '"+(char)c+"'");

            }

        }

        if (isExternal) {

            return c != '\r' ? c : '\n';

        } else {