/*
 * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.org.apache.xerces.internal.impl;

import com.sun.org.apache.xerces.internal.util.NamespaceContextWrapper;
import com.sun.org.apache.xerces.internal.util.NamespaceSupport;
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.XNIException;
import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
import com.sun.xml.internal.stream.Entity;
import com.sun.xml.internal.stream.StaxErrorReporter;
import com.sun.xml.internal.stream.XMLEntityStorage;
import com.sun.xml.internal.stream.dtd.nonvalidating.DTDGrammar;
import com.sun.xml.internal.stream.dtd.nonvalidating.XMLNotationDecl;
import com.sun.xml.internal.stream.events.EntityDeclarationImpl;
import com.sun.xml.internal.stream.events.NotationDeclarationImpl;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.stream.Location;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.EntityDeclaration;
import javax.xml.stream.events.NotationDeclaration;
import javax.xml.stream.events.XMLEvent;

/**
 * This class implements javax.xml.stream.XMLStreamReader. It makes use of
 * XML*Scanner classes to derive most of its functionality. If desired,
 * Application can reuse this instance by calling reset() and setInputSource().
 *
 * @author Neeraj Bajaj Sun Microsystems,Inc.
 * @author K.Venugopal Sun Microsystems,Inc.
 * @author Sunitha Reddy Sun Microsystems,Inc.
 */
public class XMLStreamReaderImpl implements javax.xml.stream.XMLStreamReader {

    /**
     * Property identifier: entity manager.
     */
    protected static final String ENTITY_MANAGER
            = Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;

    /**
     * Property identifier: Error Reporter.
     */
    protected static final String ERROR_REPORTER
            = Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;

    /**
     * Property identifier: Symbol table.
     */
    protected static final String SYMBOL_TABLE
            = Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;

    protected static final String READER_IN_DEFINED_STATE
            = Constants.READER_IN_DEFINED_STATE;

    private SymbolTable fSymbolTable = new SymbolTable();

    /**
     * Document scanner.
     */
    protected XMLDocumentScannerImpl fScanner = new XMLNSDocumentScannerImpl();

    //make Global NamespaceContextWrapper object,  fScanner.getNamespaceContext()
    //is dynamic object and ita value changes as per the state of the parser.
    protected NamespaceContextWrapper fNamespaceContextWrapper =
            new NamespaceContextWrapper((NamespaceSupport) fScanner.getNamespaceContext());
    protected XMLEntityManager fEntityManager = new XMLEntityManager();
    protected StaxErrorReporter fErrorReporter = new StaxErrorReporter();

    /**
     * Entity scanner, this alwasy works on last entity that was opened.
     */
    protected XMLEntityScanner fEntityScanner = null;

    /**
     * Input Source
     */
    protected XMLInputSource fInputSource = null;
    /**
     * Store properties
     */
    protected PropertyManager fPropertyManager = null;

    /**
     * current event type
     */
    private int fEventType;
    /**
     * debug flag
     */
    static final boolean DEBUG = false;
    /**
     * more to scan
     */
    private boolean fReuse = true;
    private boolean fReaderInDefinedState = true;
    private String fDTDDecl = null;
    private String versionStr = null;

    /**
     * @param inputStream
     * @param props
     * @throws XMLStreamException
     */
    public XMLStreamReaderImpl(InputStream inputStream, PropertyManager props) throws XMLStreamException {
        init(props);
        //publicId, systemid, baseSystemId, inputStream, enocding
        XMLInputSource inputSource = new XMLInputSource(null, null, null, inputStream, null);
        //pass the input source to document scanner impl.
        setInputSource(inputSource);
    }

    public XMLDocumentScannerImpl getScanner() {
        System.out.println("returning scanner");
        return fScanner;
    }

    /**
     * @param systemid
     * @param props
     * @throws XMLStreamException
     */
    public XMLStreamReaderImpl(String systemid, PropertyManager props) throws XMLStreamException {
        init(props);
        //publicId, systemid, baseSystemId, inputStream, enocding
        XMLInputSource inputSource = new XMLInputSource(null, systemid, null, false);
        //pass the input source to document scanner impl.
        setInputSource(inputSource);
    }

    /**
     * @param inputStream
     * @param encoding
     * @param props
     * @throws XMLStreamException
     */
    public XMLStreamReaderImpl(InputStream inputStream, String encoding, PropertyManager props)
            throws XMLStreamException {
        init(props);
        //publicId, systemid, baseSystemId, inputStream, enocding
        XMLInputSource inputSource = new XMLInputSource(null, null, null,
                new BufferedInputStream(inputStream), encoding);
        //pass the input source to document scanner impl.
        setInputSource(inputSource);
    }

    /**
     * @param reader
     * @param props
     * @throws XMLStreamException
     */
    public XMLStreamReaderImpl(Reader reader, PropertyManager props)
            throws XMLStreamException {
        init(props);
        //publicId, systemid, baseSystemId, inputStream, enocding
        //xxx: Using buffered reader
        XMLInputSource inputSource = new XMLInputSource(null, null, null,
                new BufferedReader(reader), null);
        //pass the input source to document scanner impl.
        setInputSource(inputSource);
    }

    /**
     * @param inputSource
     * @param props
     * @throws XMLStreamException
     */
    public XMLStreamReaderImpl(XMLInputSource inputSource, PropertyManager props)
            throws XMLStreamException {
        init(props);
        //pass the input source to document scanner impl.
        setInputSource(inputSource);
    }

    /**
     * @param inputSource
     * @throws XMLStreamException
     */
    public final void setInputSource(XMLInputSource inputSource) throws XMLStreamException {
        //once setInputSource() is called this instance is busy parsing the inputsource supplied
        //this instances is free for reuse if parser has reached END_DOCUMENT state or application has
        //called close()
        fReuse = false;

        try {

            fScanner.setInputSource(inputSource);
            //XMLStreamReader should be in defined state
            if (fReaderInDefinedState) {
                fEventType = fScanner.next();
                if (versionStr == null) {
                    versionStr = getVersion();
                }

                if (fEventType == XMLStreamConstants.START_DOCUMENT && versionStr != null
                        && versionStr.equals("1.1")) {
                    switchToXML11Scanner();
                }

            }
        } catch (java.io.IOException ex) {
            throw new XMLStreamException(ex);
        } catch (XNIException ex) { //Issue 56 XNIException not caught
            throw new XMLStreamException(ex.getMessage(), getLocation(), ex.getException());
        }
    }//setInputSource

    final void init(PropertyManager propertyManager) throws XMLStreamException {
        fPropertyManager = propertyManager;
        //set Stax internal properties -- Note that these instances are being created in XMLReaderImpl.
        //1.SymbolTable
        //2.XMLMessageFormatter
        //3.XMLEntityManager
        //4. call reset()
        //1.
        propertyManager.setProperty(SYMBOL_TABLE, fSymbolTable);
        //2.
        propertyManager.setProperty(ERROR_REPORTER, fErrorReporter);
        //3.
        propertyManager.setProperty(ENTITY_MANAGER, fEntityManager);
        //4.
        reset();
    }

    /**
     * This function tells if this instances is available for reuse. One must
     * call reset() and setInputSource() to be able to reuse this instance.
     */
    public boolean canReuse() {
        if (DEBUG) {
            System.out.println("fReuse = " + fReuse);
            System.out.println("fEventType = " + getEventTypeString(fEventType));
        }
        //when parsing begins, fReuse is set to false
        //fReuse is set to 'true' when application calls close()
        return fReuse;
    }

    /**
     * Resets this instance so that this instance is ready for reuse.
     */
    public void reset() {
        fReuse = true;
        fEventType = 0;
        //reset entity manager
        fEntityManager.reset(fPropertyManager);
        //reset the scanner
        fScanner.reset(fPropertyManager);
        //REVISIT:this is too ugly -- we are getting XMLEntityManager and XMLEntityReader from
        //property manager, it should be only XMLEntityManager
        fDTDDecl = null;
        fEntityScanner = fEntityManager.getEntityScanner();
        //default value for this property is true. However, this should be false
        //when using XMLEventReader, because XMLEventReader should not have defined state.
        fReaderInDefinedState = ((Boolean) fPropertyManager.getProperty(READER_IN_DEFINED_STATE));
        versionStr = null;
    }

    /**
     * Frees any resources associated with this Reader. This method does not
     * close the underlying input source.
     *
     * @throws XMLStreamException if there are errors freeing associated
     * resources
     */
    public void close() throws XMLStreamException {
        //xxx: Check what this function is intended to do.
        //reset();
        fReuse = true;
    }

    /**
     * Returns the character encoding declared on the xml declaration Returns
     * null if none was declared
     *
     * @return the encoding declared in the document or null
     */
    public String getCharacterEncodingScheme() {
        return fScanner.getCharacterEncodingScheme();

    }

    /**
     * @return
     */
    public int getColumnNumber() {
        return fEntityScanner.getColumnNumber();
    }//getColumnNumber

    /**
     * Return input encoding if known or null if unknown.
     *
     * @return the encoding of this instance or null
     */
    public String getEncoding() {
        return fEntityScanner.getEncoding();
    }//getEncoding

    /**
     * Returns the current value of the parse event as a string, this returns
     * the string value of a CHARACTERS event, returns the value of a COMMENT,
     * the replacement value for an ENTITY_REFERENCE, the string value of a
     * CDATA section, the string value for a SPACE event, or the String value of
     * the internal subset of the DTD. If an ENTITY_REFERENCE has been resolved,
     * any character data will be reported as CHARACTERS events.
     *
     * @return the current text or null
     */
    public int getEventType() {
        return fEventType;
    }//getEventType

    /**
     * @return
     */
    public int getLineNumber() {
        return fEntityScanner.getLineNumber();
    }//getLineNumber

    public String getLocalName() {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            //xxx check whats the value of fCurrentElement
            return fScanner.getElementQName().localpart;
        } else if (fEventType == XMLEvent.ENTITY_REFERENCE) {
            return fScanner.getEntityName();
        }
        throw new IllegalStateException("Method getLocalName() cannot be called for "
                + getEventTypeString(fEventType) + " event.");
    }//getLocalName()

    /**
     * @return
     */
    public String getNamespaceURI() {
        //doesn't take care of Attribute as separte event
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            return fScanner.getElementQName().uri;
        }
        return null;
    }//getNamespaceURI

    /**
     * Get the data section of a processing instruction
     *
     * @return the data or null
     */
    public String getPIData() {
        if (fEventType == XMLEvent.PROCESSING_INSTRUCTION) {
            return fScanner.getPIData().toString();
        } else {
            throw new java.lang.IllegalStateException("Current state of the parser is " + getEventTypeString(fEventType)
                    + " But Expected state is " + XMLEvent.PROCESSING_INSTRUCTION);
        }
    }//getPIData

    /**
     * Get the target of a processing instruction
     *
     * @return the target or null
     */
    public String getPITarget() {
        if (fEventType == XMLEvent.PROCESSING_INSTRUCTION) {
            return fScanner.getPITarget();
        } else {
            throw new java.lang.IllegalStateException("Current state of the parser is " + getEventTypeString(fEventType)
                    + " But Expected state is " + XMLEvent.PROCESSING_INSTRUCTION);
        }

    }//getPITarget

    /**
     * @return the prefix of the current event, or null if the event does not
     * have a prefix. For START_ELEMENT and END_ELEMENT, return
     * XMLConstants.DEFAULT_NS_PREFIX when no prefix is available.
     */
    public String getPrefix() {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            String prefix = fScanner.getElementQName().prefix;
            return prefix == null ? XMLConstants.DEFAULT_NS_PREFIX : prefix;
        }
        return null;
    }//getPrefix()

    /**
     * @return
     */
    public char[] getTextCharacters() {
        if (fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE) {
            return fScanner.getCharacterData().ch;
        } else {
            throw new IllegalStateException("Current state = " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , "
                    + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA)
                    + " , " + getEventTypeString(XMLEvent.SPACE) + " valid for getTextCharacters() ");
        }
    }

    /**
     * @return
     */
    public int getTextLength() {
        if (fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE) {
            return fScanner.getCharacterData().length;
        } else {
            throw new IllegalStateException("Current state = " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , "
                    + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA)
                    + " , " + getEventTypeString(XMLEvent.SPACE) + " valid for getTextLength() ");
        }

    }

    /**
     * @return
     */
    public int getTextStart() {
        if (fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE) {
            return fScanner.getCharacterData().offset;
        } else {
            throw new IllegalStateException("Current state = " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , "
                    + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA)
                    + " , " + getEventTypeString(XMLEvent.SPACE) + " valid for getTextStart() ");
        }
    }

    /**
     * @return
     */
    public String getValue() {
        if (fEventType == XMLEvent.PROCESSING_INSTRUCTION) {
            return fScanner.getPIData().toString();
        } else if (fEventType == XMLEvent.COMMENT) {
            return fScanner.getComment();
        } else if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            return fScanner.getElementQName().localpart;
        } else if (fEventType == XMLEvent.CHARACTERS) {
            return fScanner.getCharacterData().toString();
        }
        return null;
    }//getValue()

    /**
     * Get the XML language version of the current document being parsed
     */
    public String getVersion() {
        //apply SAP's patch: the default version in the scanner was set to 1.0 because of DOM and SAX
        //so this patch is a workaround of the difference between StAX and DOM
        // SAPJVM: Return null if the XML version has not been declared (as specified in the JavaDoc).

        String version = fEntityScanner.getXMLVersion();

        return "1.0".equals(version) && !fEntityScanner.xmlVersionSetExplicitly ? null : version;
    }

    /**
     * @return
     */
    public boolean hasAttributes() {
        return fScanner.getAttributeIterator().getLength() > 0 ? true : false;
    }

    /**
     * this Funtion returns true if the current event has name
     */
    public boolean hasName() {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            return true;
        } else {
            return false;
        }
    }//hasName()

    /**
     * @throws XMLStreamException
     * @return
     */
    public boolean hasNext() throws XMLStreamException {
        //the scanner returns -1 when it detects a broken stream
        if (fEventType == -1) {
            return false;
        }
        //we can check in scanners if the scanner state is not set to
        //terminating, we still have more events.
        return fEventType != XMLEvent.END_DOCUMENT;
    }

    /**
     * @return
     */
    public boolean hasValue() {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
                || fEventType == XMLEvent.ENTITY_REFERENCE || fEventType == XMLEvent.PROCESSING_INSTRUCTION
                || fEventType == XMLEvent.COMMENT || fEventType == XMLEvent.CHARACTERS) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * @return
     */
    public boolean isEndElement() {
        return fEventType == XMLEvent.END_ELEMENT;
    }

    /**
     * @return
     */
    public boolean isStandalone() {
        return fScanner.isStandAlone();
    }

    /**
     * @return
     */
    public boolean isStartElement() {
        return fEventType == XMLEvent.START_ELEMENT;
    }

    /**
     * Returns true if the cursor points to a character data event that consists
     * of all whitespace Application calling this method needs to cache the
     * value and avoid calling this method again for the same event.
     *
     * @return
     */
    public boolean isWhiteSpace() {
        if (isCharacters() || (fEventType == XMLStreamConstants.CDATA)) {
            char[] ch = this.getTextCharacters();
            final int start = this.getTextStart();
            final int end = start + this.getTextLength();
            for (int i = start; i < end; i++) {
                if (!XMLChar.isSpace(ch[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * @throws XMLStreamException
     * @return
     */
    public int next() throws XMLStreamException {
        if (!hasNext()) {
            if (fEventType != -1) {
                throw new java.util.NoSuchElementException(
                        "END_DOCUMENT reached: no more elements on the stream.");
            } else {
                throw new XMLStreamException(
                        "Error processing input source. The input stream is not complete.");
            }
        }
        try {
            fEventType = fScanner.next();

            if (versionStr == null) {
                versionStr = getVersion();
            }

            if (fEventType == XMLStreamConstants.START_DOCUMENT
                    && versionStr != null
                    && versionStr.equals("1.1")) {
                switchToXML11Scanner();
            }

            return fEventType;
        } catch (IOException ex) {
            // if this error occured trying to resolve the external DTD subset
            // and IS_VALIDATING == false, then this is not an XML error
            if (fScanner.fScannerState == XMLDocumentScannerImpl.SCANNER_STATE_DTD_EXTERNAL) {
                Boolean isValidating = (Boolean) fPropertyManager.getProperty(
                        XMLInputFactory.IS_VALIDATING);
                if (isValidating != null
                        && !isValidating.booleanValue()) {
                    // ignore the error, set scanner to known state
                    fEventType = XMLEvent.DTD;
                    fScanner.setScannerState(XMLDocumentScannerImpl.SCANNER_STATE_PROLOG);
                    fScanner.setDriver(fScanner.fPrologDriver);
                    if (fDTDDecl == null
                            || fDTDDecl.length() == 0) {
                        fDTDDecl = "<!-- "
                                + "Exception scanning External DTD Subset.  "
                                + "True contents of DTD cannot be determined.  "
                                + "Processing will continue as XMLInputFactory.IS_VALIDATING == false."
                                + " -->";
                    }
                    return XMLEvent.DTD;
                }
            }

            // else real error
            throw new XMLStreamException(ex.getMessage(), getLocation(), ex);
        } catch (XNIException ex) {
            throw new XMLStreamException(
                    ex.getMessage(),
                    getLocation(),
                    ex.getException());
        }
    } //next()

    private void switchToXML11Scanner() throws IOException {

        int oldEntityDepth = fScanner.fEntityDepth;
        com.sun.org.apache.xerces.internal.xni.NamespaceContext oldNamespaceContext
                = fScanner.fNamespaceContext;

        fScanner = new XML11NSDocumentScannerImpl();

        //get the new scanner state to old scanner's previous state
        fScanner.reset(fPropertyManager);
        fScanner.setPropertyManager(fPropertyManager);
        fEntityScanner = fEntityManager.getEntityScanner();
        fEntityScanner.registerListener(fScanner);
        fEntityManager.fCurrentEntity.mayReadChunks = true;
        fScanner.setScannerState(XMLEvent.START_DOCUMENT);

        fScanner.fEntityDepth = oldEntityDepth;
        fScanner.fNamespaceContext = oldNamespaceContext;
        fEventType = fScanner.next();
    }

    final static String getEventTypeString(int eventType) {
        switch (eventType) {
            case XMLEvent.START_ELEMENT:
                return "START_ELEMENT";
            case XMLEvent.END_ELEMENT:
                return "END_ELEMENT";
            case XMLEvent.PROCESSING_INSTRUCTION:
                return "PROCESSING_INSTRUCTION";
            case XMLEvent.CHARACTERS:
                return "CHARACTERS";
            case XMLEvent.COMMENT:
                return "COMMENT";
            case XMLEvent.START_DOCUMENT:
                return "START_DOCUMENT";
            case XMLEvent.END_DOCUMENT:
                return "END_DOCUMENT";
            case XMLEvent.ENTITY_REFERENCE:
                return "ENTITY_REFERENCE";
            case XMLEvent.ATTRIBUTE:
                return "ATTRIBUTE";
            case XMLEvent.DTD:
                return "DTD";
            case XMLEvent.CDATA:
                return "CDATA";
            case XMLEvent.SPACE:
                return "SPACE";
        }
        return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
    }

    /**
     * Returns the count of attributes on this START_ELEMENT, this method is
     * only valid on a START_ELEMENT or ATTRIBUTE. This count excludes namespace
     * definitions. Attribute indices are zero-based.
     *
     * @return returns the number of attributes
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public int getAttributeCount() {
        //xxx: recognize SAX properties namespace, namespace-prefix to get XML Namespace declarations
        //does length includes namespace declarations ?

        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getLength();
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeCount()");
        }
    }//getAttributeCount

    /**
     * Returns the localName of the attribute at the provided index
     *
     * @param index the position of the attribute
     * @return the localName of the attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public QName getAttributeName(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return convertXNIQNametoJavaxQName(fScanner.getAttributeIterator().getQualifiedName(index));
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeName()");
        }
    }//getAttributeName

    /**
     * @param index
     * @return
     */
    public String getAttributeLocalName(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getLocalName(index);
        } else {
            throw new java.lang.IllegalStateException();
        }
    }//getAttributeName

    /**
     * Returns the namespace of the attribute at the provided index
     *
     * @param index the position of the attribute
     * @return the namespace URI (can be null)
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public String getAttributeNamespace(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getURI(index);
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeNamespace()");
        }

    }//getAttributeNamespace

    /**
     * Returns the prefix of this attribute at the provided index
     *
     * @param index the position of the attribute
     * @return the prefix of the attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public String getAttributePrefix(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getPrefix(index);
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributePrefix()");
        }
    }//getAttributePrefix

    /**
     * Returns the qname of the attribute at the provided index
     *
     * @param index the position of the attribute
     * @return the QName of the attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public javax.xml.namespace.QName getAttributeQName(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            // create new object at runtime..
            String localName = fScanner.getAttributeIterator().getLocalName(index);
            String uri = fScanner.getAttributeIterator().getURI(index);
            return new javax.xml.namespace.QName(uri, localName);
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeQName()");
        }
    }//getAttributeQName

    /**
     * Returns the XML type of the attribute at the provided index
     *
     * @param index the position of the attribute
     * @return the XML type of the attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public String getAttributeType(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getType(index);
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeType()");
        }

    }//getAttributeType

    /**
     * Returns the value of the attribute at the index
     *
     * @param index the position of the attribute
     * @return the attribute value
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public String getAttributeValue(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getValue(index);
        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeValue()");
        }

    }//getAttributeValue

    /**
     * @param namespaceURI
     * @param localName
     * @return
     */
    public String getAttributeValue(String namespaceURI, String localName) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            XMLAttributesImpl attributes = fScanner.getAttributeIterator();
            if (namespaceURI == null) { //sjsxp issue 70
                return attributes.getValue(attributes.getIndexByLocalName(localName));
            } else {
                return fScanner.getAttributeIterator().getValue(
                        namespaceURI.length() == 0 ? null : namespaceURI, localName);
            }

        } else {
            throw new java.lang.IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for getAttributeValue()");
        }

    }

    /**
     * Reads the content of a text-only element. Precondition: the current event
     * is START_ELEMENT. Postcondition: The current event is the corresponding
     * END_ELEMENT.
     *
     * @throws XMLStreamException if the current event is not a START_ELEMENT or
     * if a non text element is encountered
     */
    public String getElementText() throws XMLStreamException {

        if (getEventType() != XMLStreamConstants.START_ELEMENT) {
            throw new XMLStreamException(
                    "parser must be on START_ELEMENT to read next text", getLocation());
        }
        int eventType = next();
        StringBuilder content = new StringBuilder();
        while (eventType != XMLStreamConstants.END_ELEMENT) {
            if (eventType == XMLStreamConstants.CHARACTERS
                    || eventType == XMLStreamConstants.CDATA
                    || eventType == XMLStreamConstants.SPACE
                    || eventType == XMLStreamConstants.ENTITY_REFERENCE) {
                content.append(getText());
            } else if (eventType == XMLStreamConstants.PROCESSING_INSTRUCTION
                    || eventType == XMLStreamConstants.COMMENT) {
                // skipping
            } else if (eventType == XMLStreamConstants.END_DOCUMENT) {
                throw new XMLStreamException(
                        "unexpected end of document when reading element text content");
            } else if (eventType == XMLStreamConstants.START_ELEMENT) {
                throw new XMLStreamException("elementGetText() function expects text "
                        + "only elment but START_ELEMENT was encountered.", getLocation());
            } else {
                throw new XMLStreamException(
                        "Unexpected event type " + eventType, getLocation());
            }
            eventType = next();
        }
        return content.toString();
    }

    /**
     * Return the current location of the processor. If the Location is unknown
     * the processor should return an implementation of Location that returns -1
     * for the location and null for the publicId and systemId. The location
     * information is only valid until next() is called.
     */
    public Location getLocation() {
        return new Location() {
            String _systemId = fEntityScanner.getExpandedSystemId();
            String _publicId = fEntityScanner.getPublicId();
            int _offset = fEntityScanner.getCharacterOffset();
            int _columnNumber = fEntityScanner.getColumnNumber();
            int _lineNumber = fEntityScanner.getLineNumber();

            public String getLocationURI() {
                return _systemId;
            }

            public int getCharacterOffset() {
                return _offset;
            }

            public int getColumnNumber() {
                return _columnNumber;
            }

            public int getLineNumber() {
                return _lineNumber;
            }

            public String getPublicId() {
                return _publicId;
            }

            public String getSystemId() {
                return _systemId;
            }

            public String toString() {
                StringBuilder sbuffer = new StringBuilder();
                sbuffer.append("Line number = " + getLineNumber());
                sbuffer.append("\n");
                sbuffer.append("Column number = " + getColumnNumber());
                sbuffer.append("\n");
                sbuffer.append("System Id = " + getSystemId());
                sbuffer.append("\n");
                sbuffer.append("Public Id = " + getPublicId());
                sbuffer.append("\n");
                sbuffer.append("Location Uri= " + getLocationURI());
                sbuffer.append("\n");
                sbuffer.append("CharacterOffset = " + getCharacterOffset());
                sbuffer.append("\n");
                return sbuffer.toString();
            }
        };

    }

    /**
     * Returns a QName for the current START_ELEMENT or END_ELEMENT event
     *
     * @return the QName for the current START_ELEMENT or END_ELEMENT event
     */
    public javax.xml.namespace.QName getName() {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT) {
            return convertXNIQNametoJavaxQName(fScanner.getElementQName());
        } else {
            throw new java.lang.IllegalStateException("Illegal to call getName() "
                    + "when event type is " + getEventTypeString(fEventType) + "."
                    + " Valid states are " + getEventTypeString(XMLEvent.START_ELEMENT) + ", "
                    + getEventTypeString(XMLEvent.END_ELEMENT));
        }
    }

    /**
     * Returns a read only namespace context for the current position. The
     * context is transient and only valid until a call to next() changes the
     * state of the reader.
     *
     * @return return a namespace context
     */
    public NamespaceContext getNamespaceContext() {
        return fNamespaceContextWrapper;
    }

    /**
     * Returns the count of namespaces declared on this START_ELEMENT or
     * END_ELEMENT, this method is only valid on a START_ELEMENT, END_ELEMENT or
     * NAMESPACE. On an END_ELEMENT the count is of the namespaces that are
     * about to go out of scope. This is the equivalent of the information
     * reported by SAX callback for an end element event.
     *
     * @return returns the number of namespace declarations on this specific
     * element
     * @throws IllegalStateException if this is not a START_ELEMENT, END_ELEMENT
     * or NAMESPACE
     */
    public int getNamespaceCount() {
        //namespaceContext is dynamic object.
        //REVISIT: check if it specifies all conditions mentioned in the javadoc
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
                || fEventType == XMLEvent.NAMESPACE) {
            return fScanner.getNamespaceContext().getDeclaredPrefixCount();
        } else {
            throw new IllegalStateException("Current event state is " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.START_ELEMENT)
                    + ", " + getEventTypeString(XMLEvent.END_ELEMENT) + ", "
                    + getEventTypeString(XMLEvent.NAMESPACE)
                    + " valid for getNamespaceCount().");
        }
    }

    /**
     * Returns the prefix for the namespace declared at the index. Returns null
     * if this is the default namespace declaration
     *
     * @param index the position of the namespace declaration
     * @return returns the namespace prefix
     * @throws IllegalStateException if this is not a START_ELEMENT, END_ELEMENT
     * or NAMESPACE
     */
    public String getNamespacePrefix(int index) {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
                || fEventType == XMLEvent.NAMESPACE) {
            //namespaceContext is dynamic object.
            String prefix = fScanner.getNamespaceContext().getDeclaredPrefixAt(index);
            return prefix.equals("") ? null : prefix;
        } else {
            throw new IllegalStateException("Current state " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.START_ELEMENT)
                    + ", " + getEventTypeString(XMLEvent.END_ELEMENT) + ", "
                    + getEventTypeString(XMLEvent.NAMESPACE)
                    + " valid for getNamespacePrefix().");
        }
    }

    /**
     * Returns the uri for the namespace declared at the index.
     *
     * @param index the position of the namespace declaration
     * @return returns the namespace uri
     * @throws IllegalStateException if this is not a START_ELEMENT, END_ELEMENT
     * or NAMESPACE
     */
    public String getNamespaceURI(int index) {
        if (fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
                || fEventType == XMLEvent.NAMESPACE) {
            //namespaceContext is dynamic object.
            return fScanner.getNamespaceContext().getURI(fScanner.getNamespaceContext()
                    .getDeclaredPrefixAt(index));
        } else {
            throw new IllegalStateException("Current state " + getEventTypeString(fEventType)
                    + " is not among the states " + getEventTypeString(XMLEvent.START_ELEMENT)
                    + ", " + getEventTypeString(XMLEvent.END_ELEMENT) + ", "
                    + getEventTypeString(XMLEvent.NAMESPACE)
                    + " valid for getNamespaceURI().");
        }

    }

    /**
     * Get the value of a feature/property from the underlying implementation
     *
     * @param name The name of the property, may not be null
     * @return The value of the property
     * @throws IllegalArgumentException if name is null
     */
    public Object getProperty(java.lang.String name) throws java.lang.IllegalArgumentException {
        if (name == null) {
            throw new java.lang.IllegalArgumentException();
        }
        if (fPropertyManager != null) {
            if (name.equals(PropertyManager.STAX_NOTATIONS)) {
                return getNotationDecls();
            } else if (name.equals(PropertyManager.STAX_ENTITIES)) {
                return getEntityDecls();
            } else {
                return fPropertyManager.getProperty(name);
            }
        }
        return null;
    }

    /**
     * Returns the current value of the parse event as a string, this returns
     * the string value of a CHARACTERS event, returns the value of a COMMENT,
     * the replacement value for an ENTITY_REFERENCE, or the String value of the
     * DTD
     *
     * @return the current text or null
     * @throws java.lang.IllegalStateException if this state is not a valid text
     * state.
     */
    public String getText() {
        if (fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE) {
            //this requires creation of new string
            //fEventType == XMLEvent.ENTITY_REFERENCE
            return fScanner.getCharacterData().toString();
        } else if (fEventType == XMLEvent.ENTITY_REFERENCE) {
            String name = fScanner.getEntityName();
            if (name != null) {
                if (fScanner.foundBuiltInRefs) {
                    return fScanner.getCharacterData().toString();
                }

                XMLEntityStorage entityStore = fEntityManager.getEntityStore();
                Entity en = entityStore.getEntity(name);
                if (en == null) {
                    return null;
                }
                if (en.isExternal()) {
                    return ((Entity.ExternalEntity) en).entityLocation.getExpandedSystemId();
                } else {
                    return ((Entity.InternalEntity) en).text;
                }
            } else {
                return null;
            }
        } else if (fEventType == XMLEvent.DTD) {
            if (fDTDDecl != null) {
                return fDTDDecl;
            }
            XMLStringBuffer tmpBuffer = fScanner.getDTDDecl();
            fDTDDecl = tmpBuffer.toString();
            return fDTDDecl;
        } else {
            throw new IllegalStateException("Current state " + getEventTypeString(fEventType)
                    + " is not among the states" + getEventTypeString(XMLEvent.CHARACTERS) + ", "
                    + getEventTypeString(XMLEvent.COMMENT) + ", "
                    + getEventTypeString(XMLEvent.CDATA) + ", "
                    + getEventTypeString(XMLEvent.SPACE) + ", "
                    + getEventTypeString(XMLEvent.ENTITY_REFERENCE) + ", "
                    + getEventTypeString(XMLEvent.DTD) + " valid for getText() ");
        }
    }//getText

    /**
     * Test if the current event is of the given type and if the namespace and
     * name match the current namespace and name of the current event. If the
     * namespaceURI is null it is not checked for equality, if the localName is
     * null it is not checked for equality.
     *
     * @param type the event type
     * @param namespaceURI the uri of the event, may be null
     * @param localName the localName of the event, may be null
     * @throws XMLStreamException if the required values are not matched.
     */
    public void require(int type, String namespaceURI, String localName) throws XMLStreamException {
        if (type != fEventType) {
            throw new XMLStreamException("Event type " + getEventTypeString(type) + " specified did "
                    + "not match with current parser event " + getEventTypeString(fEventType));
        }
        if (namespaceURI != null && !namespaceURI.equals(getNamespaceURI())) {
            throw new XMLStreamException("Namespace URI " + namespaceURI + " specified did not match "
                    + "with current namespace URI");
        }
        if (localName != null && !localName.equals(getLocalName())) {
            throw new XMLStreamException("LocalName " + localName + " specified did not match with "
                    + "current local name");
        }
        return;
    }

    /**
     * Gets the the text associated with a CHARACTERS, SPACE or CDATA event.
     * Text starting a "sourceStart" is copied into "destination" starting at
     * "targetStart". Up to "length" characters are copied. The number of
     * characters actually copied is returned.
     *
     * The "sourceStart" argument must be greater or equal to 0 and less than or
     * equal to the number of characters associated with the event. Usually, one
     * requests text starting at a "sourceStart" of 0. If the number of
     * characters actually copied is less than the "length", then there is no
     * more text. Otherwise, subsequent calls need to be made until all text has
     * been retrieved. For example:
     *
     * <code>
     * int length = 1024;
     * char[] myBuffer = new char[ length ];
     *
     * for ( int sourceStart = 0 ; ; sourceStart += length )
     * {
     *    int nCopied = stream.getTextCharacters( sourceStart, myBuffer, 0, length );
     *
     *   if (nCopied < length)
     *       break;
     * }
     * </code> XMLStreamException may be thrown if there are any XML errors in
     * the underlying source. The "targetStart" argument must be greater than or
     * equal to 0 and less than the length of "target", Length must be greater
     * than 0 and "targetStart + length" must be less than or equal to length of
     * "target".
     *
     * @param sourceStart the index of the first character in the source array
     * to copy
     * @param target the destination array
     * @param targetStart the start offset in the target array
     * @param length the number of characters to copy
     * @return the number of characters actually copied
     * @throws XMLStreamException if the underlying XML source is not
     * well-formed
     * @throws IndexOutOfBoundsException if targetStart < 0 or > than the length
     * of target
     * @throws IndexOutOfBoundwhile(isCharacters()) ;sException if length < 0 or targetStart + length
     * > length of target
     * @throws UnsupportedOperationException if this method is not supported
     * @throws NullPointerException is if target is null
     */
    public int getTextCharacters(int sourceStart, char[] target, int targetStart, int length)
            throws XMLStreamException {

        if (target == null) {
            throw new NullPointerException("target char array can't be null");
        }

        if (targetStart < 0 || length < 0 || sourceStart < 0 || targetStart >= target.length
                || (targetStart + length) > target.length) {
            throw new IndexOutOfBoundsException();
        }

        //getTextStart() + sourceStart should not be greater than the lenght of number of characters
        //present
        int copiedLength = 0;
        //int presentDataLen = getTextLength() - (getTextStart()+sourceStart);
        int available = getTextLength() - sourceStart;
        if (available < 0) {
            throw new IndexOutOfBoundsException("sourceStart is greater than"
                    + "number of characters associated with this event");
        }
        if (available < length) {
            copiedLength = available;
        } else {
            copiedLength = length;
        }

        System.arraycopy(getTextCharacters(), getTextStart() + sourceStart, target, targetStart, copiedLength);
        return copiedLength;
    }

    /**
     * Return true if the current event has text, false otherwise The following
     * events have text: CHARACTERS,DTD ,ENTITY_REFERENCE, COMMENT
     */
    public boolean hasText() {
        if (DEBUG) {
            pr("XMLReaderImpl#EVENT TYPE = " + fEventType);
        }
        if (fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                || fEventType == XMLEvent.CDATA) {
            return fScanner.getCharacterData().length > 0;
        } else if (fEventType == XMLEvent.ENTITY_REFERENCE) {
            String name = fScanner.getEntityName();
            if (name != null) {
                if (fScanner.foundBuiltInRefs) {
                    return true;
                }

                XMLEntityStorage entityStore = fEntityManager.getEntityStore();
                Entity en = entityStore.getEntity(name);
                if (en == null) {
                    return false;
                }
                if (en.isExternal()) {
                    return ((Entity.ExternalEntity) en).entityLocation.getExpandedSystemId() != null;
                } else {
                    return ((Entity.InternalEntity) en).text != null;
                }
            } else {
                return false;
            }
        } else if (fEventType == XMLEvent.DTD) {
            return fScanner.fSeenDoctypeDecl;
        }
        return false;
    }

    /**
     * Returns a boolean which indicates if this attribute was created by
     * default
     *
     * @param index the position of the attribute
     * @return true if this is a default attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public boolean isAttributeSpecified(int index) {
        //check that current state should be either START_ELEMENT or ATTRIBUTE
        if ((fEventType == XMLEvent.START_ELEMENT) || (fEventType == XMLEvent.ATTRIBUTE)) {
            return fScanner.getAttributeIterator().isSpecified(index);
        } else {
            throw new IllegalStateException("Current state is not among the states "
                    + getEventTypeString(XMLEvent.START_ELEMENT) + " , "
                    + getEventTypeString(XMLEvent.ATTRIBUTE)
                    + "valid for isAttributeSpecified()");
        }
    }

    /**
     * Returns true if the cursor points to a character data event
     *
     * @return true if the cursor points to character data, false otherwise
     */
    public boolean isCharacters() {
        return fEventType == XMLEvent.CHARACTERS;
    }

    /**
     * Skips any insignificant events (COMMENT and PROCESSING_INSTRUCTION) until
     * a START_ELEMENT or END_ELEMENT is reached. If other than space characters
     * are encountered, an exception is thrown. This method should be used when
     * processing element-only content because the parser is not able to
     * recognize ignorable whitespace if then DTD is missing or not interpreted.
     *
     * @return the event type of the element read
     * @throws XMLStreamException if the current event is not white space
     */
    public int nextTag() throws XMLStreamException {

        int eventType = next();
        while ((eventType == XMLStreamConstants.CHARACTERS && isWhiteSpace()) // skip whitespace
                || (eventType == XMLStreamConstants.CDATA && isWhiteSpace())
                // skip whitespace
                || eventType == XMLStreamConstants.SPACE
                || eventType == XMLStreamConstants.PROCESSING_INSTRUCTION
                || eventType == XMLStreamConstants.COMMENT) {
            eventType = next();
        }

        if (eventType != XMLStreamConstants.START_ELEMENT && eventType != XMLStreamConstants.END_ELEMENT) {
            throw new XMLStreamException(
                    "found: " + getEventTypeString(eventType)
                    + ", expected " + getEventTypeString(XMLStreamConstants.START_ELEMENT)
                    + " or " + getEventTypeString(XMLStreamConstants.END_ELEMENT),
                    getLocation());
        }

        return eventType;
    }

    /**
     * Checks if standalone was set in the document
     *
     * @return true if standalone was set in the document, or false otherwise
     */
    public boolean standaloneSet() {
        //xxx: it requires if the standalone was set in the document ? This is different that if the document
        // is standalone
        return fScanner.standaloneSet();
    }

    /**
     * @param qname
     * @return
     */
    public javax.xml.namespace.QName convertXNIQNametoJavaxQName(
            com.sun.org.apache.xerces.internal.xni.QName qname) {
        if (qname == null) {
            return null;
        }
        //xxx: prefix definition ?
        if (qname.prefix == null) {
            return new javax.xml.namespace.QName(qname.uri, qname.localpart);
        } else {
            return new javax.xml.namespace.QName(qname.uri, qname.localpart, qname.prefix);
        }
    }

    /**
     * Return the uri for the given prefix. The uri returned depends on the
     * current state of the processor.
     *
     * <p>
     * <strong>NOTE:</strong>The 'xml' prefix is bound as defined in
     * <a href="http://www.w3.org/TR/REC-xml-names/#ns-using">Namespaces in
     * XML</a>
     * specification to "http://www.w3.org/XML/1998/namespace".
     *
     * <p>
     * <strong>NOTE:</strong> The 'xmlns' prefix must be resolved to following
     * namespace
     * <a href="http://www.w3.org/2000/xmlns/">http://www.w3.org/2000/xmlns/</a>
     *
     * @return the uri bound to the given prefix or null if it is not bound
     * @param prefix The prefix to lookup, may not be null
     * @throws IllegalStateException - if the prefix is null
     */
    public String getNamespaceURI(String prefix) {
        if (prefix == null) {
            throw new java.lang.IllegalArgumentException("prefix cannot be null.");
        }

        //first add the string to symbol table.. since internally identity comparisons are done.
        return fScanner.getNamespaceContext().getURI(fSymbolTable.addSymbol(prefix));
    }

    //xxx: this function is not being used.
    protected void setPropertyManager(PropertyManager propertyManager) {
        fPropertyManager = propertyManager;
        //REVISIT: we were supplying hashmap ealier
        fScanner.setProperty("stax-properties", propertyManager);
        fScanner.setPropertyManager(propertyManager);
    }

    /**
     * @return returns the reference to property manager.
     */
    protected PropertyManager getPropertyManager() {
        return fPropertyManager;
    }

    static void pr(String str) {
        System.out.println(str);
    }

    protected List<EntityDeclaration> getEntityDecls() {
        if (fEventType == XMLStreamConstants.DTD) {
            XMLEntityStorage entityStore = fEntityManager.getEntityStore();
            ArrayList<EntityDeclaration> list = null;
            Map<String, Entity> entities = entityStore.getEntities();
            if (entities.size() > 0) {
                EntityDeclarationImpl decl = null;
                list = new ArrayList<>(entities.size());
                for (Map.Entry<String, Entity> entry : entities.entrySet()) {
                    String key = entry.getKey();
                    Entity en = entry.getValue();
                    decl = new EntityDeclarationImpl();
                    decl.setEntityName(key);
                    if (en.isExternal()) {
                        decl.setXMLResourceIdentifier(((Entity.ExternalEntity) en).entityLocation);
                        decl.setNotationName(((Entity.ExternalEntity) en).notation);
                    } else {
                        decl.setEntityReplacementText(((Entity.InternalEntity) en).text);
                    }
                    list.add(decl);
                }
            }
            return list;
        }
        return null;
    }

    protected List<NotationDeclaration> getNotationDecls() {
        if (fEventType == XMLStreamConstants.DTD) {
            if (fScanner.fDTDScanner == null) {
                return null;
            }
            DTDGrammar grammar = ((XMLDTDScannerImpl) (fScanner.fDTDScanner)).getGrammar();
            if (grammar == null) {
                return null;
            }
            List<XMLNotationDecl> notations = grammar.getNotationDecls();
            ArrayList<NotationDeclaration> list = new ArrayList<>();
            for (XMLNotationDecl notation : notations) {
                if (notation != null) {
                    list.add(new NotationDeclarationImpl(notation));
                }
            }
            return list;
        }
        return null;
    }

}//XMLReaderImpl