/*

 */

/*

 * 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.xml.internal.stream.dtd.nonvalidating.DTDGrammar;

import java.io.EOFException;

import java.io.IOException;

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

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

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

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

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

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

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

import com.sun.org.apache.xerces.internal.impl.XMLEntityHandler;

import com.sun.org.apache.xerces.internal.impl.Constants;

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

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

/**

 * This class is responsible for scanning the declarations found

 * in the internal and external subsets of a DTD in an XML document.

 * The scanner acts as the sources for the DTD information which is

 * communicated to the DTD handlers.

 * <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 Arnaud  Le Hors, IBM

 * @author Andy Clark, IBM

 * @author Glenn Marcy, IBM

 * @author Eric Ye, IBM

 *

 */

public class XMLDTDScannerImpl

extends XMLScanner

implements XMLDTDScanner, XMLComponent, XMLEntityHandler {

    //

    // Constants

    //

    // scanner states

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

    protected static final int SCANNER_STATE_END_OF_INPUT = 0;

    /** Scanner state: text declaration. */

    protected static final int SCANNER_STATE_TEXT_DECL = 1;

    /** Scanner state: markup declaration. */

    protected static final int SCANNER_STATE_MARKUP_DECL = 2;

    // recognized features and properties

    /** Recognized features. */

    private static final String[] RECOGNIZED_FEATURES = {

        VALIDATION,

        NOTIFY_CHAR_REFS,

    };

    /** Feature defaults. */

    private static final Boolean[] FEATURE_DEFAULTS = {

        null,

        Boolean.FALSE,

    };

    /** Recognized properties. */

    private static final String[] RECOGNIZED_PROPERTIES = {

        SYMBOL_TABLE,

        ERROR_REPORTER,

        ENTITY_MANAGER,

    };

    /** Property defaults. */

    private static final Object[] PROPERTY_DEFAULTS = {

        null,

        null,

        null,

    };

    // debugging

    /** Debug scanner state. */

    private static final boolean DEBUG_SCANNER_STATE = false;

    //

    // Data

    //

    // handlers

    /** DTD handler. */

    public XMLDTDHandler fDTDHandler = null;

    /** DTD content model handler. */

    protected XMLDTDContentModelHandler fDTDContentModelHandler;

    // state

    /** Scanner state. */

    protected int fScannerState;

    /** Standalone. */

    protected boolean fStandalone;

    /** Seen external DTD. */

    protected boolean fSeenExternalDTD;

    /** Seen external parameter entity. */

    protected boolean fSeenExternalPE;

    // private data

    /** Start DTD called. */

    private boolean fStartDTDCalled;

    /** Default attribute */

    private XMLAttributesImpl fAttributes = new XMLAttributesImpl();

    /**

     * Stack of content operators (either '|' or ',') in children

     * content.

     */

    private int[] fContentStack = new int[5];

    /** Size of content stack. */

    private int fContentDepth;

    /** Parameter entity stack to check well-formedness. */

    private int[] fPEStack = new int[5];

    /** Parameter entity stack to report start/end entity calls. */

    private boolean[] fPEReport = new boolean[5];

    /** Number of opened parameter entities. */

    private int fPEDepth;

    /** Markup depth. */

    private int fMarkUpDepth;

    /** Number of opened external entities. */

    private int fExtEntityDepth;

    /** Number of opened include sections. */

    private int fIncludeSectDepth;

    // temporary variables

    /** Array of 3 strings. */

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

    /** String. */

    private XMLString fString = new XMLString();

    /** String buffer. */

    private XMLStringBuffer fStringBuffer = new XMLStringBuffer();

    /** String buffer. */

    private XMLStringBuffer fStringBuffer2 = new XMLStringBuffer();

    /** Literal text. */

    private XMLString fLiteral = new XMLString();

    /** Literal text. */

    private XMLString fLiteral2 = new XMLString();

    /** Enumeration values. */

    private String[] fEnumeration = new String[5];

    /** Enumeration values count. */

    private int fEnumerationCount;

    /** Ignore conditional section buffer. */

    private XMLStringBuffer fIgnoreConditionalBuffer = new XMLStringBuffer(128);

    /** Object contains grammar information for a non-validaing parser. */

    DTDGrammar nvGrammarInfo = null;

    boolean nonValidatingMode = false;

    //

    // Constructors

    //

    /** Default constructor. */

    public XMLDTDScannerImpl() {

    } // <init>()

    /** Constructor for he use of non-XMLComponentManagers. */

    public XMLDTDScannerImpl(SymbolTable symbolTable,

            XMLErrorReporter errorReporter, XMLEntityManager entityManager) {

        fSymbolTable = symbolTable;

        fErrorReporter = errorReporter;

        fEntityManager = entityManager;

        entityManager.setProperty(SYMBOL_TABLE, fSymbolTable);

    }

    //

    // XMLDTDScanner methods

    //

    /**

     * Sets the input source.

     *

     * @param inputSource The input source or null.

     *

     * @throws IOException Thrown on i/o error.

     */

    public void setInputSource(XMLInputSource inputSource) throws IOException {

        if (inputSource == null) {

            // no system id was available

            if (fDTDHandler != null) {

                fDTDHandler.startDTD(null, null);

                fDTDHandler.endDTD(null);

            }

            if (nonValidatingMode){

                nvGrammarInfo.startDTD(null,null);

                nvGrammarInfo.endDTD(null);

            }

            return;

        }

        fEntityManager.setEntityHandler(this);

        fEntityManager.startDTDEntity(inputSource);

    } // setInputSource(XMLInputSource)

    public void setLimitAnalyzer(XMLLimitAnalyzer limitAnalyzer) {

        fLimitAnalyzer = limitAnalyzer;

    }

    /**

     * Scans the external subset of the 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 scanDTDExternalSubset(boolean complete)

    throws IOException, XNIException {

        fEntityManager.setEntityHandler(this);

        if (fScannerState == SCANNER_STATE_TEXT_DECL) {

            fSeenExternalDTD = true;

            boolean textDecl = scanTextDecl();

            if (fScannerState == SCANNER_STATE_END_OF_INPUT) {

                return false;

            }

            else {

                // next state is markup decls regardless of whether there

                // is a TextDecl or not

                setScannerState(SCANNER_STATE_MARKUP_DECL);

                if (textDecl && !complete) {

                    return true;

                }

            }

        }

        // keep dispatching "events"

        do {

            if (!scanDecls(complete)) {

                return false;

            }

        } while (complete);

        // return that there is more to scan

        return true;

    } // scanDTDExternalSubset(boolean):boolean

    /**

     * Scans the internal subset of the 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.

     * @param standalone True if the document was specified as standalone.

     *                   This value is important for verifying certain

     *                   well-formedness constraints.

     * @param hasExternalDTD True if the document has an external DTD.

     *                       This allows the scanner to properly notify

     *                       the handler of the end of the DTD in the

     *                       absence of an external subset.

     *

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

     */

    public boolean scanDTDInternalSubset(boolean complete, boolean standalone,

    boolean hasExternalSubset)

    throws IOException, XNIException {

        // reset entity scanner

        //xxx:stax getText() is supposed to return only DTD internal subset

        //shouldn't we record position here before we go ahead ??

        fEntityScanner = (XMLEntityScanner)fEntityManager.getEntityScanner();

        fEntityManager.setEntityHandler(this);

        fStandalone = standalone;

        //System.out.println("state"+fScannerState);

        if (fScannerState == SCANNER_STATE_TEXT_DECL) {

            // call handler

            if (fDTDHandler != null) {

                fDTDHandler.startDTD(fEntityScanner, null);

                fStartDTDCalled = true;

            }

            if (nonValidatingMode){

                fStartDTDCalled = true;

                nvGrammarInfo.startDTD(fEntityScanner,null);

            }

            // set starting state for internal subset

            setScannerState(SCANNER_STATE_MARKUP_DECL);

        }

        // keep dispatching "events"

        do {

            if (!scanDecls(complete)) {

                // call handler

                if (fDTDHandler != null && hasExternalSubset == false) {

                    fDTDHandler.endDTD(null);

                }

                if (nonValidatingMode && hasExternalSubset == false ){

                    nvGrammarInfo.endDTD(null);

                }

                // we're done, set starting state for external subset

                setScannerState(SCANNER_STATE_TEXT_DECL);

                // we're done scanning DTD.

                fLimitAnalyzer.reset(XMLSecurityManager.Limit.TOTAL_ENTITY_SIZE_LIMIT);

                return false;

            }

        } while (complete);

        // return that there is more to scan

        return true;

    } // scanDTDInternalSubset(boolean,boolean,boolean):boolean

    /**

     * Skip the DTD if javax.xml.stream.supportDTD is false.

     *

     * @param supportDTD The value of the property javax.xml.stream.supportDTD.

     * @return true if DTD is skipped, false otherwise.

     * @throws java.io.IOException if i/o error occurs

     */

    @Override

    public boolean skipDTD(boolean supportDTD) throws IOException {

        if (!supportDTD) {

            fStringBuffer.clear();

            if (!fEntityScanner.scanData("]", fStringBuffer)) {

                fEntityScanner.fCurrentEntity.position--;

            }

            return true;

        }

        return false;

    }

    //

    // XMLComponent methods

    //

    /**

     * reset

     *

     * @param componentManager

     */

    public void reset(XMLComponentManager componentManager)

    throws XMLConfigurationException {

        super.reset(componentManager);

        init();

    } // reset(XMLComponentManager)

    // this is made for something like XMLDTDLoader--XMLComponentManager-free operation...

    public void reset() {

        super.reset();

        init();

    }

    public void reset(PropertyManager props) {

        setPropertyManager(props);

        super.reset(props);

        init() ;

        nonValidatingMode = true;

        //Revisit : Create new grammar until we implement GrammarPool.

        nvGrammarInfo = new DTDGrammar(fSymbolTable);

    }

    /**

     * 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 (String[])(RECOGNIZED_FEATURES.clone());

    } // getRecognizedFeatures():String[]

    /**

     * 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 (String[])(RECOGNIZED_PROPERTIES.clone());

    } // getRecognizedProperties():String[]

    /**

     * 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

    //

    // XMLDTDSource methods

    //

    /**

     * setDTDHandler

     *

     * @param dtdHandler

     */

    public void setDTDHandler(XMLDTDHandler dtdHandler) {

        fDTDHandler = dtdHandler;

    } // setDTDHandler(XMLDTDHandler)

    /**

     * getDTDHandler

     *

     * @return the XMLDTDHandler

     */

    public XMLDTDHandler getDTDHandler() {

        return fDTDHandler;

    } // getDTDHandler():  XMLDTDHandler

    //

    // XMLDTDContentModelSource methods

    //

    /**

     * setDTDContentModelHandler

     *

     * @param dtdContentModelHandler

     */

    public void setDTDContentModelHandler(XMLDTDContentModelHandler

    dtdContentModelHandler) {

        fDTDContentModelHandler = dtdContentModelHandler;

    } // setDTDContentModelHandler

    /**

     * getDTDContentModelHandler

     *

     * @return XMLDTDContentModelHandler