jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/fastinfoset/stax/StAXDocumentParser.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/fastinfoset/stax/StAXDocumentParser.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/fastinfoset/stax/StAXDocumentParser.java

Thu, 31 Aug 2017 15:18:52 +0800

author: aoqi
date: Thu, 31 Aug 2017 15:18:52 +0800
changeset 637: 9c07ef4934dd
parent 384: 8f2986ff0235
parent 0: 373ffda63c9a
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 2004, 2013, 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.
  *
  * THIS FILE WAS MODIFIED BY SUN MICROSYSTEMS, INC.
  */
 package com.sun.xml.internal.fastinfoset.stax;
 import com.sun.xml.internal.fastinfoset.Decoder;
 import com.sun.xml.internal.fastinfoset.DecoderStateTables;
 import com.sun.xml.internal.fastinfoset.EncodingConstants;
 import com.sun.xml.internal.fastinfoset.OctetBufferListener;
 import com.sun.xml.internal.fastinfoset.QualifiedName;
 import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithmFactory;
 import com.sun.xml.internal.fastinfoset.sax.AttributesHolder;
 import com.sun.xml.internal.fastinfoset.util.CharArray;
 import com.sun.xml.internal.fastinfoset.util.CharArrayString;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import javax.xml.namespace.NamespaceContext;
 import javax.xml.namespace.QName;
 import javax.xml.stream.Location;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithm;
 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmException;
 import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmIndexes;
 import com.sun.xml.internal.org.jvnet.fastinfoset.FastInfosetException;
 import com.sun.xml.internal.fastinfoset.CommonResourceBundle;
 import com.sun.xml.internal.fastinfoset.org.apache.xerces.util.XMLChar;
 import com.sun.xml.internal.fastinfoset.util.DuplicateAttributeVerifier;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import com.sun.xml.internal.org.jvnet.fastinfoset.stax.FastInfosetStreamReader;
 /**
  * The Fast Infoset StAX parser.
  * <p>
  * Instantiate this parser to parse a fast infoset document in accordance
  * with the StAX API.
  *
  * <p>
  * More than one fast infoset document may be decoded from the
  * {@link java.io.InputStream}.
  */
 public class StAXDocumentParser extends Decoder
         implements XMLStreamReader, FastInfosetStreamReader, OctetBufferListener {
     private static final Logger logger = Logger.getLogger(StAXDocumentParser.class.getName());
     protected static final int INTERNAL_STATE_START_DOCUMENT = 0;
     protected static final int INTERNAL_STATE_START_ELEMENT_TERMINATE = 1;
     protected static final int INTERNAL_STATE_SINGLE_TERMINATE_ELEMENT_WITH_NAMESPACES = 2;
     protected static final int INTERNAL_STATE_DOUBLE_TERMINATE_ELEMENT = 3;
     protected static final int INTERNAL_STATE_END_DOCUMENT = 4;
     protected static final int INTERNAL_STATE_VOID = -1;
     protected int _internalState;
     /**
      * Current event
      */
     protected int _eventType;
     /**
      * Stack of qualified names and namespaces
      */
     protected QualifiedName[] _qNameStack = new QualifiedName[32];
     protected int[] _namespaceAIIsStartStack = new int[32];
     protected int[] _namespaceAIIsEndStack = new int[32];
     protected int _stackCount = -1;
     protected String[] _namespaceAIIsPrefix = new String[32];
     protected String[] _namespaceAIIsNamespaceName = new String[32];
     protected int[] _namespaceAIIsPrefixIndex = new int[32];
     protected int _namespaceAIIsIndex;
     /**
      * Namespaces associated with START_ELEMENT or END_ELEMENT
      */
     protected int _currentNamespaceAIIsStart;
     protected int _currentNamespaceAIIsEnd;
     /**
      * Qualified name associated with START_ELEMENT or END_ELEMENT.
      */
     protected QualifiedName _qualifiedName;
     /**
      * List of attributes
      */
     protected AttributesHolder _attributes = new AttributesHolder();
     protected boolean _clearAttributes = false;
     /**
      * Characters associated with event.
      */
     protected char[] _characters;
     protected int _charactersOffset;
     protected String _algorithmURI;
     protected int _algorithmId;
     protected boolean _isAlgorithmDataCloned;
     protected byte[] _algorithmData;
     protected int _algorithmDataOffset;
     protected int _algorithmDataLength;
     /**
      * State for processing instruction
      */
     protected String _piTarget;
     protected String _piData;
     protected NamespaceContextImpl _nsContext = new NamespaceContextImpl();
     protected String _characterEncodingScheme;
     protected StAXManager _manager;
     public StAXDocumentParser() {
         reset();
         _manager = new StAXManager(StAXManager.CONTEXT_READER);
     }
     public StAXDocumentParser(InputStream s) {
         this();
         setInputStream(s);
         _manager = new StAXManager(StAXManager.CONTEXT_READER);
     }
     public StAXDocumentParser(InputStream s, StAXManager manager) {
         this(s);
         _manager = manager;
     }
     @Override
     public void setInputStream(InputStream s) {
         super.setInputStream(s);
         reset();
     }
     @Override
     public void reset() {
         super.reset();
         if (_internalState != INTERNAL_STATE_START_DOCUMENT &&
                 _internalState != INTERNAL_STATE_END_DOCUMENT) {
             for (int i = _namespaceAIIsIndex - 1; i >= 0; i--) {
                 _prefixTable.popScopeWithPrefixEntry(_namespaceAIIsPrefixIndex[i]);
             }
             _stackCount = -1;
             _namespaceAIIsIndex = 0;
             _characters = null;
             _algorithmData = null;
         }
         _characterEncodingScheme = "UTF-8";
         _eventType = START_DOCUMENT;
         _internalState = INTERNAL_STATE_START_DOCUMENT;
     }
     protected void resetOnError() {
         super.reset();
         if (_v != null) {
             _prefixTable.clearCompletely();
         }
         _duplicateAttributeVerifier.clear();
         _stackCount = -1;
         _namespaceAIIsIndex = 0;
         _characters = null;
         _algorithmData = null;
         _eventType = START_DOCUMENT;
         _internalState = INTERNAL_STATE_START_DOCUMENT;
     }
     // -- XMLStreamReader Interface -------------------------------------------
     public Object getProperty(java.lang.String name)
     throws java.lang.IllegalArgumentException {
         if (_manager != null) {
             return _manager.getProperty(name);
         }
         return null;
     }
     public int next() throws XMLStreamException {
         try {
             if (_internalState != INTERNAL_STATE_VOID) {
                 switch (_internalState) {
                     case INTERNAL_STATE_START_DOCUMENT:
                         decodeHeader();
                         processDII();
                         _internalState = INTERNAL_STATE_VOID;
                         break;
                     case INTERNAL_STATE_START_ELEMENT_TERMINATE:
                         if (_currentNamespaceAIIsEnd > 0) {
                             for (int i = _currentNamespaceAIIsEnd - 1; i >= _currentNamespaceAIIsStart; i--) {
                                 _prefixTable.popScopeWithPrefixEntry(_namespaceAIIsPrefixIndex[i]);
                             }
                             _namespaceAIIsIndex = _currentNamespaceAIIsStart;
                         }
                         // Pop information off the stack
                         popStack();
                         _internalState = INTERNAL_STATE_VOID;
                         return _eventType = END_ELEMENT;
                     case INTERNAL_STATE_SINGLE_TERMINATE_ELEMENT_WITH_NAMESPACES:
                         // Undeclare namespaces
                         for (int i = _currentNamespaceAIIsEnd - 1; i >= _currentNamespaceAIIsStart; i--) {
                             _prefixTable.popScopeWithPrefixEntry(_namespaceAIIsPrefixIndex[i]);
                         }
                         _namespaceAIIsIndex = _currentNamespaceAIIsStart;
                         _internalState = INTERNAL_STATE_VOID;
                         break;
                     case INTERNAL_STATE_DOUBLE_TERMINATE_ELEMENT:
                         // Undeclare namespaces
                         if (_currentNamespaceAIIsEnd > 0) {
                             for (int i = _currentNamespaceAIIsEnd - 1; i >= _currentNamespaceAIIsStart; i--) {
                                 _prefixTable.popScopeWithPrefixEntry(_namespaceAIIsPrefixIndex[i]);
                             }
                             _namespaceAIIsIndex = _currentNamespaceAIIsStart;
                         }
                         if (_stackCount == -1) {
                             _internalState = INTERNAL_STATE_END_DOCUMENT;
                             return _eventType = END_DOCUMENT;
                         }
                         // Pop information off the stack
                         popStack();
                         _internalState = (_currentNamespaceAIIsEnd > 0) ?
                             INTERNAL_STATE_SINGLE_TERMINATE_ELEMENT_WITH_NAMESPACES :
                             INTERNAL_STATE_VOID;
                         return _eventType = END_ELEMENT;
                     case INTERNAL_STATE_END_DOCUMENT:
                         throw new NoSuchElementException(CommonResourceBundle.getInstance().getString("message.noMoreEvents"));
                 }
             }
             // Reset internal state
             _characters = null;
             _algorithmData = null;
             _currentNamespaceAIIsEnd = 0;
             // Process information item
             final int b = read();
             switch(DecoderStateTables.EII(b)) {
                 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL:
                     processEII(_elementNameTable._array[b], false);
                     return _eventType;
                 case DecoderStateTables.EII_AIIS_INDEX_SMALL:
                     processEII(_elementNameTable._array[b & EncodingConstants.INTEGER_3RD_BIT_SMALL_MASK], true);
                     return _eventType;
                 case DecoderStateTables.EII_INDEX_MEDIUM:
                     processEII(processEIIIndexMedium(b), (b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0);
                     return _eventType;
                 case DecoderStateTables.EII_INDEX_LARGE:
                     processEII(processEIIIndexLarge(b), (b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0);
                     return _eventType;
                 case DecoderStateTables.EII_LITERAL:
                 {
                     final QualifiedName qn = processLiteralQualifiedName(
                             b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK,
                             _elementNameTable.getNext());
                     _elementNameTable.add(qn);
                     processEII(qn, (b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0);
                     return _eventType;
                 }
                 case DecoderStateTables.EII_NAMESPACES:
                     processEIIWithNamespaces((b & EncodingConstants.ELEMENT_ATTRIBUTE_FLAG) > 0);
                     return _eventType;
                 case DecoderStateTables.CII_UTF8_SMALL_LENGTH:
                     _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK)
                     + 1;
                     processUtf8CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_UTF8_MEDIUM_LENGTH:
                     _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT;
                     processUtf8CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_UTF8_LARGE_LENGTH:
                     _octetBufferLength = ((read() << 24) |
                             (read() << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT;
                     processUtf8CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_UTF16_SMALL_LENGTH:
                     _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_MASK)
                     + 1;
                     processUtf16CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_UTF16_MEDIUM_LENGTH:
                     _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_SMALL_LIMIT;
                     processUtf16CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_UTF16_LARGE_LENGTH:
                     _octetBufferLength = ((read() << 24) |
                             (read() << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.OCTET_STRING_LENGTH_7TH_BIT_MEDIUM_LIMIT;
                     processUtf16CharacterString(b);
                     return _eventType = CHARACTERS;
                 case DecoderStateTables.CII_RA:
                 {
                     final boolean addToTable = (b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0;
                     _identifier = (b & 0x02) << 6;
                     final int b2 = read();
                     _identifier |= (b2 & 0xFC) >> 2;
                     decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(b2);
                     decodeRestrictedAlphabetAsCharBuffer();
                     if (addToTable) {
                         _charactersOffset = _characterContentChunkTable.add(_charBuffer, _charBufferLength);
                         _characters = _characterContentChunkTable._array;
                     } else {
                         _characters = _charBuffer;
                         _charactersOffset = 0;
                     }
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.CII_EA:
                 {
                     final boolean addToTable = (b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0;
                     // Decode encoding algorithm integer
                     _algorithmId = (b & 0x02) << 6;
                     final int b2 = read();
                     _algorithmId |= (b2 & 0xFC) >> 2;
                     decodeOctetsOnSeventhBitOfNonIdentifyingStringOnThirdBit(b2);
                     processCIIEncodingAlgorithm(addToTable);
                     if (_algorithmId == EncodingAlgorithmIndexes.CDATA) {
                         return _eventType = CDATA;
                     }
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.CII_INDEX_SMALL:
                 {
                     final int index = b & EncodingConstants.INTEGER_4TH_BIT_SMALL_MASK;
                     _characterContentChunkTable._cachedIndex = index;
                     _characters = _characterContentChunkTable._array;
                     _charactersOffset = _characterContentChunkTable._offset[index];
                     _charBufferLength = _characterContentChunkTable._length[index];
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.CII_INDEX_MEDIUM:
                 {
                     final int index = (((b & EncodingConstants.INTEGER_4TH_BIT_MEDIUM_MASK) << 8) | read())
                     + EncodingConstants.INTEGER_4TH_BIT_SMALL_LIMIT;
                     _characterContentChunkTable._cachedIndex = index;
                     _characters = _characterContentChunkTable._array;
                     _charactersOffset = _characterContentChunkTable._offset[index];
                     _charBufferLength = _characterContentChunkTable._length[index];
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.CII_INDEX_LARGE:
                 {
                     final int index = (((b & EncodingConstants.INTEGER_4TH_BIT_LARGE_MASK) << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.INTEGER_4TH_BIT_MEDIUM_LIMIT;
                     _characterContentChunkTable._cachedIndex = index;
                     _characters = _characterContentChunkTable._array;
                     _charactersOffset = _characterContentChunkTable._offset[index];
                     _charBufferLength = _characterContentChunkTable._length[index];
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.CII_INDEX_LARGE_LARGE:
                 {
                     final int index = ((read() << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.INTEGER_4TH_BIT_LARGE_LIMIT;
                     _characterContentChunkTable._cachedIndex = index;
                     _characters = _characterContentChunkTable._array;
                     _charactersOffset = _characterContentChunkTable._offset[index];
                     _charBufferLength = _characterContentChunkTable._length[index];
                     return _eventType = CHARACTERS;
                 }
                 case DecoderStateTables.COMMENT_II:
                     processCommentII();
                     return _eventType;
                 case DecoderStateTables.PROCESSING_INSTRUCTION_II:
                     processProcessingII();
                     return _eventType;
                 case DecoderStateTables.UNEXPANDED_ENTITY_REFERENCE_II:
                 {
                     processUnexpandedEntityReference(b);
                     // Skip the reference
                     return next();
                 }
                 case DecoderStateTables.TERMINATOR_DOUBLE:
                     if (_stackCount != -1) {
                         // Pop information off the stack
                         popStack();
                         _internalState = INTERNAL_STATE_DOUBLE_TERMINATE_ELEMENT;
                         return _eventType = END_ELEMENT;
                     }
                     _internalState = INTERNAL_STATE_END_DOCUMENT;
                     return _eventType = END_DOCUMENT;
                 case DecoderStateTables.TERMINATOR_SINGLE:
                     if (_stackCount != -1) {
                         // Pop information off the stack
                         popStack();
                         if (_currentNamespaceAIIsEnd > 0) {
                             _internalState = INTERNAL_STATE_SINGLE_TERMINATE_ELEMENT_WITH_NAMESPACES;
                         }
                         return _eventType = END_ELEMENT;
                     }
                     _internalState = INTERNAL_STATE_END_DOCUMENT;
                     return _eventType = END_DOCUMENT;
                 default:
                     throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEII"));
             }
         } catch (IOException e) {
             resetOnError();
             logger.log(Level.FINE, "next() exception", e);
             throw new XMLStreamException(e);
         } catch (FastInfosetException e) {
             resetOnError();
             logger.log(Level.FINE, "next() exception", e);
             throw new XMLStreamException(e);
         } catch (RuntimeException e) {
             resetOnError();
             logger.log(Level.FINE, "next() exception", e);
             throw e;
         }
     }
     private final void processUtf8CharacterString(final int b) throws IOException {
         if ((b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) {
             _characterContentChunkTable.ensureSize(_octetBufferLength);
             _characters = _characterContentChunkTable._array;
             _charactersOffset = _characterContentChunkTable._arrayIndex;
             decodeUtf8StringAsCharBuffer(_characterContentChunkTable._array, _charactersOffset);
             _characterContentChunkTable.add(_charBufferLength);
         } else {
             decodeUtf8StringAsCharBuffer();
             _characters = _charBuffer;
             _charactersOffset = 0;
         }
     }
     private final void processUtf16CharacterString(final int b) throws IOException {
         decodeUtf16StringAsCharBuffer();
         if ((b & EncodingConstants.CHARACTER_CHUNK_ADD_TO_TABLE_FLAG) > 0) {
             _charactersOffset = _characterContentChunkTable.add(_charBuffer, _charBufferLength);
             _characters = _characterContentChunkTable._array;
         } else {
             _characters = _charBuffer;
             _charactersOffset = 0;
         }
     }
     private void popStack() {
         // Pop information off the stack
         _qualifiedName = _qNameStack[_stackCount];
         _currentNamespaceAIIsStart = _namespaceAIIsStartStack[_stackCount];
         _currentNamespaceAIIsEnd = _namespaceAIIsEndStack[_stackCount];
         _qNameStack[_stackCount--] = null;
     }
     /** 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 final void require(int type, String namespaceURI, String localName)
     throws XMLStreamException {
         if( type != _eventType)
             throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.eventTypeNotMatch", new Object[]{getEventTypeString(type)}));
         if( namespaceURI != null && !namespaceURI.equals(getNamespaceURI()) )
             throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.namespaceURINotMatch", new Object[]{namespaceURI}));
         if(localName != null && !localName.equals(getLocalName()))
             throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.localNameNotMatch", new Object[]{localName}));
     }
     /** 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 final String getElementText() throws XMLStreamException {
         if(getEventType() != START_ELEMENT) {
             throw new XMLStreamException(
                     CommonResourceBundle.getInstance().getString("message.mustBeOnSTARTELEMENT"), getLocation());
         }
         //current is StartElement, move to the next
         next();
         return getElementText(true);
     }
     /**
      * @param startElementRead flag if start element has already been read
      */
     public final String getElementText(boolean startElementRead) throws XMLStreamException {
         if (!startElementRead) {
             throw new XMLStreamException(
                     CommonResourceBundle.getInstance().getString("message.mustBeOnSTARTELEMENT"), getLocation());
         }
         int eventType = getEventType();
         StringBuilder content = new StringBuilder();
         while(eventType != END_ELEMENT ) {
             if(eventType == CHARACTERS
                     || eventType == CDATA
                     || eventType == SPACE
                     || eventType == ENTITY_REFERENCE) {
                 content.append(getText());
             } else if(eventType == PROCESSING_INSTRUCTION
                     || eventType == COMMENT) {
                 // skipping
             } else if(eventType == END_DOCUMENT) {
                 throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.unexpectedEOF"));
             } else if(eventType == START_ELEMENT) {
                 throw new XMLStreamException(
                         CommonResourceBundle.getInstance().getString("message.getElementTextExpectTextOnly"), getLocation());
             } else {
                 throw new XMLStreamException(
                         CommonResourceBundle.getInstance().getString("message.unexpectedEventType")+ getEventTypeString(eventType), getLocation());
             }
             eventType = next();
         }
         return content.toString();
     }
     /** Skips any white space (isWhiteSpace() returns true), COMMENT,
      * or PROCESSING_INSTRUCTION,
      * until a START_ELEMENT or END_ELEMENT is reached.
      * If other than white space characters, COMMENT, PROCESSING_INSTRUCTION, START_ELEMENT, END_ELEMENT
      * are encountered, an exception is thrown. This method should
      * be used when processing element-only content seperated by white space.
      * 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 final int nextTag() throws XMLStreamException {
         next();
         return nextTag(true);
     }
     /** if the current tag has already read, such as in the case EventReader's
      * peek() has been called, the current cursor should not move before the loop
      */
     public final int nextTag(boolean currentTagRead) throws XMLStreamException {
         int eventType = getEventType();
         if (!currentTagRead) {
             eventType = next();
         }
         while((eventType == CHARACTERS && isWhiteSpace()) // skip whitespace
         || (eventType == CDATA && isWhiteSpace())
         || eventType == SPACE
                 || eventType == PROCESSING_INSTRUCTION
                 || eventType == COMMENT) {
             eventType = next();
         }
         if (eventType != START_ELEMENT && eventType != END_ELEMENT) {
             throw new XMLStreamException(CommonResourceBundle.getInstance().getString("message.expectedStartOrEnd"), getLocation());
         }
         return eventType;
     }
     public final boolean hasNext() throws XMLStreamException {
         return (_eventType != END_DOCUMENT);
     }
     public void close() throws XMLStreamException {
         try {
             super.closeIfRequired();
         } catch (IOException ex) {
         }
     }
     public final String getNamespaceURI(String prefix) {
         String namespace = getNamespaceDecl(prefix);
         if (namespace == null) {
             if (prefix == null) {
                 throw new IllegalArgumentException(CommonResourceBundle.getInstance().getString("message.nullPrefix"));
             }
             return null;  // unbound
         }
         return namespace;
     }
     public final boolean isStartElement() {
         return (_eventType == START_ELEMENT);
     }
     public final boolean isEndElement() {
         return (_eventType == END_ELEMENT);
     }
     public final boolean isCharacters() {
         return (_eventType == CHARACTERS);
     }
     /**
      *  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 true if the cursor points to all whitespace, false otherwise
      */
     public final boolean isWhiteSpace() {
         if(isCharacters() || (_eventType == CDATA)){
             char [] ch = this.getTextCharacters();
             int start = this.getTextStart();
             int length = this.getTextLength();
             for (int i = start; i < start + length; i++){
                 if(!XMLChar.isSpace(ch[i])){
                     return false;
                 }
             }
             return true;
         }
         return false;
     }
     public final String getAttributeValue(String namespaceURI, String localName) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         if (localName == null)
             throw new IllegalArgumentException();
         // Search for the attributes in _attributes
         if (namespaceURI != null) {
             for (int i = 0; i < _attributes.getLength(); i++) {
                 if (_attributes.getLocalName(i).equals(localName) &&
                         _attributes.getURI(i).equals(namespaceURI)) {
                     return _attributes.getValue(i);
                 }
             }
         } else {
             for (int i = 0; i < _attributes.getLength(); i++) {
                 if (_attributes.getLocalName(i).equals(localName)) {
                     return _attributes.getValue(i);
                 }
             }
         }
         return null;
     }
     public final int getAttributeCount() {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getLength();
     }
     public final javax.xml.namespace.QName getAttributeName(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getQualifiedName(index).getQName();
     }
     public final String getAttributeNamespace(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getURI(index);
     }
     public final String getAttributeLocalName(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getLocalName(index);
     }
     public final String getAttributePrefix(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getPrefix(index);
     }
     public final String getAttributeType(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getType(index);
     }
     public final String getAttributeValue(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getValue(index);
     }
     public final boolean isAttributeSpecified(int index) {
         return false;   // non-validating parser
     }
     public final int getNamespaceCount() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return (_currentNamespaceAIIsEnd > 0) ? (_currentNamespaceAIIsEnd - _currentNamespaceAIIsStart) : 0;
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetNamespaceCount"));
         }
     }
     public final String getNamespacePrefix(int index) {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _namespaceAIIsPrefix[_currentNamespaceAIIsStart + index];
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetNamespacePrefix"));
         }
     }
     public final String getNamespaceURI(int index) {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _namespaceAIIsNamespaceName[_currentNamespaceAIIsStart + index];
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetNamespacePrefix"));
         }
     }
     public final NamespaceContext getNamespaceContext() {
         return _nsContext;
     }
     public final int getEventType() {
         return _eventType;
     }
     public final String getText() {
         if (_characters == null) {
             checkTextState();
         }
         if (_characters == _characterContentChunkTable._array) {
             return _characterContentChunkTable.getString(_characterContentChunkTable._cachedIndex);
         } else {
             return new String(_characters, _charactersOffset, _charBufferLength);
         }
     }
     public final char[] getTextCharacters() {
         if (_characters == null) {
             checkTextState();
         }
         return _characters;
     }
     public final int getTextStart() {
         if (_characters == null) {
             checkTextState();
         }
         return _charactersOffset;
     }
     public final int getTextLength() {
         if (_characters == null) {
             checkTextState();
         }
         return _charBufferLength;
     }
     public final int getTextCharacters(int sourceStart, char[] target,
             int targetStart, int length) throws XMLStreamException {
         if (_characters == null) {
             checkTextState();
         }
         try {
             int bytesToCopy = Math.min(_charBufferLength, length);
             System.arraycopy(_characters, _charactersOffset + sourceStart,
                     target, targetStart, bytesToCopy);
             return bytesToCopy;
         } catch (IndexOutOfBoundsException e) {
             throw new XMLStreamException(e);
         }
     }
     protected final void checkTextState() {
         if (_algorithmData == null) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.InvalidStateForText"));
         }
         try {
             convertEncodingAlgorithmDataToCharacters();
         } catch (Exception e) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.InvalidStateForText"));
         }
     }
     public final String getEncoding() {
         return _characterEncodingScheme;
     }
     public final boolean hasText() {
         return (_characters != null);
     }
     public final Location getLocation() {
         //location should be created in next()
         //returns a nil location for now
         return EventLocation.getNilLocation();
     }
     public final QName getName() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _qualifiedName.getQName();
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetName"));
         }
     }
     public final String getLocalName() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _qualifiedName.localName;
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetLocalName"));
         }
     }
     public final boolean hasName() {
         return (_eventType == START_ELEMENT || _eventType == END_ELEMENT);
     }
     public final String getNamespaceURI() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _qualifiedName.namespaceName;
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetNamespaceURI"));
         }
     }
     public final String getPrefix() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _qualifiedName.prefix;
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetPrefix"));
         }
     }
     public final String getVersion() {
         return null;
     }
     public final boolean isStandalone() {
         return false;
     }
     public final boolean standaloneSet() {
         return false;
     }
     public final String getCharacterEncodingScheme() {
         return null;
     }
     public final String getPITarget() {
         if (_eventType != PROCESSING_INSTRUCTION) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetPITarget"));
         }
         return _piTarget;
     }
     public final String getPIData() {
         if (_eventType != PROCESSING_INSTRUCTION) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetPIData"));
         }
         return _piData;
     }
     public final String getNameString() {
         if (_eventType == START_ELEMENT || _eventType == END_ELEMENT) {
             return _qualifiedName.getQNameString();
         } else {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetName"));
         }
     }
     public final String getAttributeNameString(int index) {
         if (_eventType != START_ELEMENT) {
             throw new IllegalStateException(CommonResourceBundle.getInstance().getString("message.invalidCallingGetAttributeValue"));
         }
         return _attributes.getQualifiedName(index).getQNameString();
     }
     public final String getTextAlgorithmURI() {
         return _algorithmURI;
     }
     public final int getTextAlgorithmIndex() {
         return _algorithmId;
     }
     public final boolean hasTextAlgorithmBytes() {
         return _algorithmData != null;
     }
     /**
      * Returns the byte[], which represents text algorithms.
      * @deprecated was deprecated due to security reasons. Now the method return cloned byte[].
      *
      * @return
      */
     public final byte[] getTextAlgorithmBytes() {
         // Do not return the actual _algorithmData due to security reasons
 //        return _algorithmData;
         if (_algorithmData == null) {
             return null;
         }
         final byte[] algorithmData = new byte[_algorithmData.length];
         System.arraycopy(_algorithmData, 0, algorithmData, 0, _algorithmData.length);
         return algorithmData;
     }
     public final byte[] getTextAlgorithmBytesClone() {
         if (_algorithmData == null) {
             return null;
         }
         byte[] algorithmData = new byte[_algorithmDataLength];
         System.arraycopy(_algorithmData, _algorithmDataOffset, algorithmData, 0, _algorithmDataLength);
         return algorithmData;
     }
     public final int getTextAlgorithmStart() {
         return _algorithmDataOffset;
     }
     public final int getTextAlgorithmLength() {
         return _algorithmDataLength;
     }
     public final int getTextAlgorithmBytes(int sourceStart, byte[] target,
             int targetStart, int length) throws XMLStreamException {
         try {
             System.arraycopy(_algorithmData, sourceStart, target,
                     targetStart, length);
             return length;
         } catch (IndexOutOfBoundsException e) {
             throw new XMLStreamException(e);
         }
     }
     // FastInfosetStreamReader impl
     public final int peekNext() throws XMLStreamException {
         try {
             switch(DecoderStateTables.EII(peek(this))) {
                 case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL:
                 case DecoderStateTables.EII_AIIS_INDEX_SMALL:
                 case DecoderStateTables.EII_INDEX_MEDIUM:
                 case DecoderStateTables.EII_INDEX_LARGE:
                 case DecoderStateTables.EII_LITERAL:
                 case DecoderStateTables.EII_NAMESPACES:
                     return START_ELEMENT;
                 case DecoderStateTables.CII_UTF8_SMALL_LENGTH:
                 case DecoderStateTables.CII_UTF8_MEDIUM_LENGTH:
                 case DecoderStateTables.CII_UTF8_LARGE_LENGTH:
                 case DecoderStateTables.CII_UTF16_SMALL_LENGTH:
                 case DecoderStateTables.CII_UTF16_MEDIUM_LENGTH:
                 case DecoderStateTables.CII_UTF16_LARGE_LENGTH:
                 case DecoderStateTables.CII_RA:
                 case DecoderStateTables.CII_EA:
                 case DecoderStateTables.CII_INDEX_SMALL:
                 case DecoderStateTables.CII_INDEX_MEDIUM:
                 case DecoderStateTables.CII_INDEX_LARGE:
                 case DecoderStateTables.CII_INDEX_LARGE_LARGE:
                     return CHARACTERS;
                 case DecoderStateTables.COMMENT_II:
                     return COMMENT;
                 case DecoderStateTables.PROCESSING_INSTRUCTION_II:
                     return PROCESSING_INSTRUCTION;
                 case DecoderStateTables.UNEXPANDED_ENTITY_REFERENCE_II:
                     return ENTITY_REFERENCE;
                 case DecoderStateTables.TERMINATOR_DOUBLE:
                 case DecoderStateTables.TERMINATOR_SINGLE:
                     return (_stackCount != -1) ? END_ELEMENT : END_DOCUMENT;
                 default:
                     throw new FastInfosetException(
                             CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEII"));
             }
         } catch (IOException e) {
             throw new XMLStreamException(e);
         } catch (FastInfosetException e) {
             throw new XMLStreamException(e);
         }
     }
     public void onBeforeOctetBufferOverwrite() {
         if (_algorithmData != null) {
             _algorithmData = getTextAlgorithmBytesClone();
             _algorithmDataOffset = 0;
             _isAlgorithmDataCloned = true;
         }
     }
     // Faster access methods without checks
     public final int accessNamespaceCount() {
         return (_currentNamespaceAIIsEnd > 0) ? (_currentNamespaceAIIsEnd - _currentNamespaceAIIsStart) : 0;
     }
     public final String accessLocalName() {
         return _qualifiedName.localName;
     }
     public final String accessNamespaceURI() {
         return _qualifiedName.namespaceName;
     }
     public final String accessPrefix() {
         return _qualifiedName.prefix;
     }
     public final char[] accessTextCharacters() {
         if (_characters == null) return null;
         // we return a cloned version of _characters
         final char[] clonedCharacters = new char[_characters.length];
         System.arraycopy(_characters, 0, clonedCharacters, 0, _characters.length);
         return clonedCharacters;
     }
     public final int accessTextStart() {
         return _charactersOffset;
     }
     public final int accessTextLength() {
         return _charBufferLength;
     }
     //
     protected final void processDII() throws FastInfosetException, IOException {
         final int b = read();
         if (b > 0) {
             processDIIOptionalProperties(b);
         }
     }
     protected final void processDIIOptionalProperties(int b) throws FastInfosetException, IOException {
         // Optimize for the most common case
         if (b == EncodingConstants.DOCUMENT_INITIAL_VOCABULARY_FLAG) {
             decodeInitialVocabulary();
             return;
         }
         if ((b & EncodingConstants.DOCUMENT_ADDITIONAL_DATA_FLAG) > 0) {
             decodeAdditionalData();
             /*
              * TODO
              * how to report the additional data?
              */
         }
         if ((b & EncodingConstants.DOCUMENT_INITIAL_VOCABULARY_FLAG) > 0) {
             decodeInitialVocabulary();
         }
         if ((b & EncodingConstants.DOCUMENT_NOTATIONS_FLAG) > 0) {
             decodeNotations();
             /*
                 try {
                     _dtdHandler.notationDecl(name, public_identifier, system_identifier);
                 } catch (SAXException e) {
                     throw new IOException("NotationsDeclarationII");
                 }
              */
         }
         if ((b & EncodingConstants.DOCUMENT_UNPARSED_ENTITIES_FLAG) > 0) {
             decodeUnparsedEntities();
             /*
                 try {
                     _dtdHandler.unparsedEntityDecl(name, public_identifier, system_identifier, notation_name);
                 } catch (SAXException e) {
                     throw new IOException("UnparsedEntitiesII");
                 }
              */
         }
         if ((b & EncodingConstants.DOCUMENT_CHARACTER_ENCODING_SCHEME) > 0) {
             _characterEncodingScheme = decodeCharacterEncodingScheme();
         }
         if ((b & EncodingConstants.DOCUMENT_STANDALONE_FLAG) > 0) {
             boolean standalone = (read() > 0) ? true : false ;
             /*
              * TODO
              * how to report the standalone flag?
              */
         }
         if ((b & EncodingConstants.DOCUMENT_VERSION_FLAG) > 0) {
             decodeVersion();
             /*
              * TODO
              * how to report the standalone flag?
              */
         }
     }
     protected final void resizeNamespaceAIIs() {
         final String[] namespaceAIIsPrefix = new String[_namespaceAIIsIndex * 2];
         System.arraycopy(_namespaceAIIsPrefix, 0, namespaceAIIsPrefix, 0, _namespaceAIIsIndex);
         _namespaceAIIsPrefix = namespaceAIIsPrefix;
         final String[] namespaceAIIsNamespaceName = new String[_namespaceAIIsIndex * 2];
         System.arraycopy(_namespaceAIIsNamespaceName, 0, namespaceAIIsNamespaceName, 0, _namespaceAIIsIndex);
         _namespaceAIIsNamespaceName = namespaceAIIsNamespaceName;
         final int[] namespaceAIIsPrefixIndex = new int[_namespaceAIIsIndex * 2];
         System.arraycopy(_namespaceAIIsPrefixIndex, 0, namespaceAIIsPrefixIndex, 0, _namespaceAIIsIndex);
         _namespaceAIIsPrefixIndex = namespaceAIIsPrefixIndex;
     }
     protected final void processEIIWithNamespaces(boolean hasAttributes) throws FastInfosetException, IOException {
         if (++_prefixTable._declarationId == Integer.MAX_VALUE) {
             _prefixTable.clearDeclarationIds();
         }
         _currentNamespaceAIIsStart = _namespaceAIIsIndex;
         String prefix = "", namespaceName = "";
         int b = read();
         while ((b & EncodingConstants.NAMESPACE_ATTRIBUTE_MASK) == EncodingConstants.NAMESPACE_ATTRIBUTE) {
             if (_namespaceAIIsIndex == _namespaceAIIsPrefix.length) {
                 resizeNamespaceAIIs();
             }
             switch (b & EncodingConstants.NAMESPACE_ATTRIBUTE_PREFIX_NAME_MASK) {
                 // no prefix, no namespace
                 // Undeclaration of default namespace
                 case 0:
                     prefix = namespaceName =
                             _namespaceAIIsPrefix[_namespaceAIIsIndex] =
                             _namespaceAIIsNamespaceName[_namespaceAIIsIndex] = "";
                     _namespaceNameIndex = _prefixIndex = _namespaceAIIsPrefixIndex[_namespaceAIIsIndex++] = -1;
                     break;
                     // no prefix, namespace
                     // Declaration of default namespace
                 case 1:
                     prefix = _namespaceAIIsPrefix[_namespaceAIIsIndex] = "";
                     namespaceName = _namespaceAIIsNamespaceName[_namespaceAIIsIndex] =
                             decodeIdentifyingNonEmptyStringOnFirstBitAsNamespaceName(false);
                     _prefixIndex = _namespaceAIIsPrefixIndex[_namespaceAIIsIndex++] = -1;
                     break;
                     // prefix, no namespace
                     // Undeclaration of namespace
                 case 2:
                     prefix = _namespaceAIIsPrefix[_namespaceAIIsIndex] =
                             decodeIdentifyingNonEmptyStringOnFirstBitAsPrefix(false);
                     namespaceName = _namespaceAIIsNamespaceName[_namespaceAIIsIndex] = "";
                     _namespaceNameIndex = -1;
                     _namespaceAIIsPrefixIndex[_namespaceAIIsIndex++] = _prefixIndex;
                     break;
                     // prefix, namespace
                     // Declaration of prefixed namespace
                 case 3:
                     prefix = _namespaceAIIsPrefix[_namespaceAIIsIndex] =
                             decodeIdentifyingNonEmptyStringOnFirstBitAsPrefix(true);
                     namespaceName = _namespaceAIIsNamespaceName[_namespaceAIIsIndex] =
                             decodeIdentifyingNonEmptyStringOnFirstBitAsNamespaceName(true);
                     _namespaceAIIsPrefixIndex[_namespaceAIIsIndex++] = _prefixIndex;
                     break;
             }
             // Push namespace declarations onto the stack
             _prefixTable.pushScopeWithPrefixEntry(prefix, namespaceName, _prefixIndex, _namespaceNameIndex);
             b = read();
         }
         if (b != EncodingConstants.TERMINATOR) {
             throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.EIInamespaceNameNotTerminatedCorrectly"));
         }
         _currentNamespaceAIIsEnd = _namespaceAIIsIndex;
         b = read();
         switch(DecoderStateTables.EII(b)) {
             case DecoderStateTables.EII_NO_AIIS_INDEX_SMALL:
                 processEII(_elementNameTable._array[b], hasAttributes);
                 break;
             case DecoderStateTables.EII_INDEX_MEDIUM:
                 processEII(processEIIIndexMedium(b), hasAttributes);
                 break;
             case DecoderStateTables.EII_INDEX_LARGE:
                 processEII(processEIIIndexLarge(b), hasAttributes);
                 break;
             case DecoderStateTables.EII_LITERAL:
             {
                 final QualifiedName qn = processLiteralQualifiedName(
                         b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK,
                         _elementNameTable.getNext());
                 _elementNameTable.add(qn);
                 processEII(qn, hasAttributes);
                 break;
             }
             default:
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.IllegalStateDecodingEIIAfterAIIs"));
         }
     }
     protected final void processEII(QualifiedName name, boolean hasAttributes) throws FastInfosetException, IOException {
         if (_prefixTable._currentInScope[name.prefixIndex] != name.namespaceNameIndex) {
             throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.qnameOfEIINotInScope"));
         }
         _eventType = START_ELEMENT;
         _qualifiedName = name;
         if (_clearAttributes) {
             _attributes.clear();
             _clearAttributes = false;
         }
         if (hasAttributes) {
             processAIIs();
         }
         // Push element holder onto the stack
         _stackCount++;
         if (_stackCount == _qNameStack.length) {
             QualifiedName[] qNameStack = new QualifiedName[_qNameStack.length * 2];
             System.arraycopy(_qNameStack, 0, qNameStack, 0, _qNameStack.length);
             _qNameStack = qNameStack;
             int[] namespaceAIIsStartStack = new int[_namespaceAIIsStartStack.length * 2];
             System.arraycopy(_namespaceAIIsStartStack, 0, namespaceAIIsStartStack, 0, _namespaceAIIsStartStack.length);
             _namespaceAIIsStartStack = namespaceAIIsStartStack;
             int[] namespaceAIIsEndStack = new int[_namespaceAIIsEndStack.length * 2];
             System.arraycopy(_namespaceAIIsEndStack, 0, namespaceAIIsEndStack, 0, _namespaceAIIsEndStack.length);
             _namespaceAIIsEndStack = namespaceAIIsEndStack;
         }
         _qNameStack[_stackCount] = _qualifiedName;
         _namespaceAIIsStartStack[_stackCount] = _currentNamespaceAIIsStart;
         _namespaceAIIsEndStack[_stackCount] = _currentNamespaceAIIsEnd;
     }
     protected final void processAIIs() throws FastInfosetException, IOException {
         QualifiedName name;
         int b;
         String value;
         if (++_duplicateAttributeVerifier._currentIteration == Integer.MAX_VALUE) {
             _duplicateAttributeVerifier.clear();
         }
         _clearAttributes = true;
         boolean terminate = false;
         do {
             // AII qualified name
             b = read();
             switch (DecoderStateTables.AII(b)) {
                 case DecoderStateTables.AII_INDEX_SMALL:
                     name = _attributeNameTable._array[b];
                     break;
                 case DecoderStateTables.AII_INDEX_MEDIUM:
                 {
                     final int i = (((b & EncodingConstants.INTEGER_2ND_BIT_MEDIUM_MASK) << 8) | read())
                     + EncodingConstants.INTEGER_2ND_BIT_SMALL_LIMIT;
                     name = _attributeNameTable._array[i];
                     break;
                 }
                 case DecoderStateTables.AII_INDEX_LARGE:
                 {
                     final int i = (((b & EncodingConstants.INTEGER_2ND_BIT_LARGE_MASK) << 16) | (read() << 8) | read())
                     + EncodingConstants.INTEGER_2ND_BIT_MEDIUM_LIMIT;
                     name = _attributeNameTable._array[i];
                     break;
                 }
                 case DecoderStateTables.AII_LITERAL:
                     name = processLiteralQualifiedName(
                             b & EncodingConstants.LITERAL_QNAME_PREFIX_NAMESPACE_NAME_MASK,
                             _attributeNameTable.getNext());
                     name.createAttributeValues(DuplicateAttributeVerifier.MAP_SIZE);
                     _attributeNameTable.add(name);
                     break;
                 case DecoderStateTables.AII_TERMINATOR_DOUBLE:
                     _internalState = INTERNAL_STATE_START_ELEMENT_TERMINATE;
                 case DecoderStateTables.AII_TERMINATOR_SINGLE:
                     terminate = true;
                     // AIIs have finished break out of loop
                     continue;
                 default:
                     throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.decodingAIIs"));
             }
             // [normalized value] of AII
             if (name.prefixIndex > 0 && _prefixTable._currentInScope[name.prefixIndex] != name.namespaceNameIndex) {
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.AIIqNameNotInScope"));
             }
             _duplicateAttributeVerifier.checkForDuplicateAttribute(name.attributeHash, name.attributeId);
             b = read();
             switch(DecoderStateTables.NISTRING(b)) {
                 case DecoderStateTables.NISTRING_UTF8_SMALL_LENGTH:
                     _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_MASK) + 1;
                     value = decodeUtf8StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_UTF8_MEDIUM_LENGTH:
                     _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_LIMIT;
                     value = decodeUtf8StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_UTF8_LARGE_LENGTH:
                     _octetBufferLength = ((read() << 24) |
                             (read() << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_MEDIUM_LIMIT;
                     value = decodeUtf8StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_UTF16_SMALL_LENGTH:
                     _octetBufferLength = (b & EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_MASK) + 1;
                     value = decodeUtf16StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_UTF16_MEDIUM_LENGTH:
                     _octetBufferLength = read() + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_SMALL_LIMIT;
                     value = decodeUtf16StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_UTF16_LARGE_LENGTH:
                     _octetBufferLength = ((read() << 24) |
                             (read() << 16) |
                             (read() << 8) |
                             read())
                             + EncodingConstants.OCTET_STRING_LENGTH_5TH_BIT_MEDIUM_LIMIT;
                     value = decodeUtf16StringAsString();
                     if ((b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 case DecoderStateTables.NISTRING_RA:
                 {
                     final boolean addToTable = (b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0;
                     // Decode resitricted alphabet integer
                     _identifier = (b & 0x0F) << 4;
                     b = read();
                     _identifier |= (b & 0xF0) >> 4;
                     decodeOctetsOnFifthBitOfNonIdentifyingStringOnFirstBit(b);
                     value = decodeRestrictedAlphabetAsString();
                     if (addToTable) {
                         _attributeValueTable.add(value);
                     }
                     _attributes.addAttribute(name, value);
                     break;
                 }
                 case DecoderStateTables.NISTRING_EA:
                 {
                     final boolean addToTable = (b & EncodingConstants.NISTRING_ADD_TO_TABLE_FLAG) > 0;
                     // Decode encoding algorithm integer
                     _identifier = (b & 0x0F) << 4;
                     b = read();
                     _identifier |= (b & 0xF0) >> 4;
                     decodeOctetsOnFifthBitOfNonIdentifyingStringOnFirstBit(b);
                     processAIIEncodingAlgorithm(name, addToTable);
                     break;
                 }
                 case DecoderStateTables.NISTRING_INDEX_SMALL:
                     _attributes.addAttribute(name,
                             _attributeValueTable._array[b & EncodingConstants.INTEGER_2ND_BIT_SMALL_MASK]);
                     break;
                 case DecoderStateTables.NISTRING_INDEX_MEDIUM:
                 {
                     final int index = (((b & EncodingConstants.INTEGER_2ND_BIT_MEDIUM_MASK) << 8) | read())
                     + EncodingConstants.INTEGER_2ND_BIT_SMALL_LIMIT;
                     _attributes.addAttribute(name,
                             _attributeValueTable._array[index]);
                     break;
                 }
                 case DecoderStateTables.NISTRING_INDEX_LARGE:
                 {
                     final int index = (((b & EncodingConstants.INTEGER_2ND_BIT_LARGE_MASK) << 16) | (read() << 8) | read())
                     + EncodingConstants.INTEGER_2ND_BIT_MEDIUM_LIMIT;
                     _attributes.addAttribute(name,
                             _attributeValueTable._array[index]);
                     break;
                 }
                 case DecoderStateTables.NISTRING_EMPTY:
                     _attributes.addAttribute(name, "");
                     break;
                 default:
                     throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.decodingAIIValue"));
             }
         } while (!terminate);
         // Reset duplication attribute verfifier
         _duplicateAttributeVerifier._poolCurrent = _duplicateAttributeVerifier._poolHead;
     }
     protected final QualifiedName processEIIIndexMedium(int b) throws FastInfosetException, IOException {
         final int i = (((b & EncodingConstants.INTEGER_3RD_BIT_MEDIUM_MASK) << 8) | read())
         + EncodingConstants.INTEGER_3RD_BIT_SMALL_LIMIT;
         return _elementNameTable._array[i];
     }
     protected final QualifiedName processEIIIndexLarge(int b) throws FastInfosetException, IOException {
         int i;
         if ((b & EncodingConstants.INTEGER_3RD_BIT_LARGE_LARGE_FLAG) == 0x20) {
             // EII large index
             i = (((b & EncodingConstants.INTEGER_3RD_BIT_LARGE_MASK) << 16) | (read() << 8) | read())
             + EncodingConstants.INTEGER_3RD_BIT_MEDIUM_LIMIT;
         } else {
             // EII large large index
             i = (((read() & EncodingConstants.INTEGER_3RD_BIT_LARGE_LARGE_MASK) << 16) | (read() << 8) | read())
             + EncodingConstants.INTEGER_3RD_BIT_LARGE_LIMIT;
         }
         return _elementNameTable._array[i];
     }
     protected final QualifiedName processLiteralQualifiedName(int state, QualifiedName q)
     throws FastInfosetException, IOException {
         if (q == null) q = new QualifiedName();
         switch (state) {
             // no prefix, no namespace
             case 0:
                 return q.set(
                         "",
                         "",
                         decodeIdentifyingNonEmptyStringOnFirstBit(_v.localName),
                         "",
 ,
                         -1,
                         -1,
                         _identifier);
                 // no prefix, namespace
             case 1:
                 return q.set(
                         "",
                         decodeIdentifyingNonEmptyStringIndexOnFirstBitAsNamespaceName(false),
                         decodeIdentifyingNonEmptyStringOnFirstBit(_v.localName),
                         "",
 ,
                         -1,
                         _namespaceNameIndex,
                         _identifier);
                 // prefix, no namespace
             case 2:
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.qNameMissingNamespaceName"));
                 // prefix, namespace
             case 3:
                 return q.set(
                         decodeIdentifyingNonEmptyStringIndexOnFirstBitAsPrefix(true),
                         decodeIdentifyingNonEmptyStringIndexOnFirstBitAsNamespaceName(true),
                         decodeIdentifyingNonEmptyStringOnFirstBit(_v.localName),
                         "",
 ,
                         _prefixIndex,
                         _namespaceNameIndex,
                         _identifier);
             default:
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.decodingEII"));
         }
     }
     protected final void processCommentII() throws FastInfosetException, IOException {
         _eventType = COMMENT;
         switch(decodeNonIdentifyingStringOnFirstBit()) {
             case NISTRING_STRING:
                 if (_addToTable) {
                     _v.otherString.add(new CharArray(_charBuffer, 0, _charBufferLength, true));
                 }
                 _characters = _charBuffer;
                 _charactersOffset = 0;
                 break;
             case NISTRING_ENCODING_ALGORITHM:
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.commentIIAlgorithmNotSupported"));
             case NISTRING_INDEX:
                 final CharArray ca = _v.otherString.get(_integer);
                 _characters = ca.ch;
                 _charactersOffset = ca.start;
                 _charBufferLength = ca.length;
                 break;
             case NISTRING_EMPTY_STRING:
                 _characters = _charBuffer;
                 _charactersOffset = 0;
                 _charBufferLength = 0;
                 break;
         }
     }
     protected final void processProcessingII() throws FastInfosetException, IOException {
         _eventType = PROCESSING_INSTRUCTION;
         _piTarget = decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherNCName);
         switch(decodeNonIdentifyingStringOnFirstBit()) {
             case NISTRING_STRING:
                 _piData = new String(_charBuffer, 0, _charBufferLength);
                 if (_addToTable) {
                     _v.otherString.add(new CharArrayString(_piData));
                 }
                 break;
             case NISTRING_ENCODING_ALGORITHM:
                 throw new FastInfosetException(CommonResourceBundle.getInstance().getString("message.processingIIWithEncodingAlgorithm"));
             case NISTRING_INDEX:
                 _piData = _v.otherString.get(_integer).toString();
                 break;
             case NISTRING_EMPTY_STRING:
                 _piData = "";
                 break;
         }
     }
     protected final void processUnexpandedEntityReference(final int b) throws FastInfosetException, IOException {
         _eventType = ENTITY_REFERENCE;
         /*
          * TODO
          * How does StAX report such events?
          */
         String entity_reference_name = decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherNCName);
         String system_identifier = ((b & EncodingConstants.UNEXPANDED_ENTITY_SYSTEM_IDENTIFIER_FLAG) > 0)
         ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : "";
         String public_identifier = ((b & EncodingConstants.UNEXPANDED_ENTITY_PUBLIC_IDENTIFIER_FLAG) > 0)
         ? decodeIdentifyingNonEmptyStringOnFirstBit(_v.otherURI) : "";
         if (logger.isLoggable(Level.FINEST)) {
             logger.log(Level.FINEST, "processUnexpandedEntityReference: entity_reference_name={0} system_identifier={1}public_identifier={2}",
                     new Object[]{entity_reference_name, system_identifier, public_identifier});
         }
     }
     protected final void processCIIEncodingAlgorithm(boolean addToTable) throws FastInfosetException, IOException {
         _algorithmData = _octetBuffer;
         _algorithmDataOffset = _octetBufferStart;
         _algorithmDataLength = _octetBufferLength;
         _isAlgorithmDataCloned = false;
         if (_algorithmId >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START) {
             _algorithmURI = _v.encodingAlgorithm.get(_algorithmId - EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START);
             if (_algorithmURI == null) {
                 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.URINotPresent", new Object[]{Integer.valueOf(_identifier)}));
             }
         } else if (_algorithmId > EncodingConstants.ENCODING_ALGORITHM_BUILTIN_END) {
             // Reserved built-in algorithms for future use
             // TODO should use sax property to decide if event will be
             // reported, allows for support through handler if required.
             throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.identifiers10to31Reserved"));
         }
         if (addToTable) {
             convertEncodingAlgorithmDataToCharacters();
             _characterContentChunkTable.add(_characters, _characters.length);
         }
     }
     protected final void processAIIEncodingAlgorithm(QualifiedName name, boolean addToTable) throws FastInfosetException, IOException {
         EncodingAlgorithm ea = null;
         String URI = null;
         if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START) {
             URI = _v.encodingAlgorithm.get(_identifier - EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START);
             if (URI == null) {
                 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.URINotPresent", new Object[]{Integer.valueOf(_identifier)}));
             } else if (_registeredEncodingAlgorithms != null) {
                 ea = (EncodingAlgorithm)_registeredEncodingAlgorithms.get(URI);
             }
         } else if (_identifier >= EncodingConstants.ENCODING_ALGORITHM_BUILTIN_END) {
             if (_identifier == EncodingAlgorithmIndexes.CDATA) {
                 throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.CDATAAlgorithmNotSupported"));
             }
             // Reserved built-in algorithms for future use
             // TODO should use sax property to decide if event will be
             // reported, allows for support through handler if required.
             throw new EncodingAlgorithmException(CommonResourceBundle.getInstance().getString("message.identifiers10to31Reserved"));
         } else {
             ea = BuiltInEncodingAlgorithmFactory.getAlgorithm(_identifier);
         }
         Object algorithmData;
         if (ea != null) {
             algorithmData = ea.decodeFromBytes(_octetBuffer, _octetBufferStart,
                     _octetBufferLength);
         } else {
             final byte[] data = new byte[_octetBufferLength];
             System.arraycopy(_octetBuffer, _octetBufferStart, data, 0,
                     _octetBufferLength);
             algorithmData = data;
         }
         _attributes.addAttributeWithAlgorithmData(name, URI, _identifier,
                 algorithmData);
         if (addToTable) {
             _attributeValueTable.add(_attributes.getValue(_attributes.getIndex(name.qName)));
         }
     }
     protected final void convertEncodingAlgorithmDataToCharacters() throws FastInfosetException, IOException {
         StringBuffer buffer = new StringBuffer();
         if (_algorithmId == EncodingAlgorithmIndexes.BASE64) {
             convertBase64AlorithmDataToCharacters(buffer);
         } else if (_algorithmId < EncodingConstants.ENCODING_ALGORITHM_BUILTIN_END) {
             Object array = BuiltInEncodingAlgorithmFactory.getAlgorithm(_algorithmId).
                     decodeFromBytes(_algorithmData, _algorithmDataOffset, _algorithmDataLength);
             BuiltInEncodingAlgorithmFactory.getAlgorithm(_algorithmId).convertToCharacters(array,  buffer);
         } else if (_algorithmId == EncodingAlgorithmIndexes.CDATA) {
             _octetBufferOffset -= _octetBufferLength;
             decodeUtf8StringIntoCharBuffer();
             _characters = _charBuffer;
             _charactersOffset = 0;
             return;
         } else if (_algorithmId >= EncodingConstants.ENCODING_ALGORITHM_APPLICATION_START) {
             final EncodingAlgorithm ea = (EncodingAlgorithm)_registeredEncodingAlgorithms.get(_algorithmURI);
             if (ea != null) {
                 final Object data = ea.decodeFromBytes(_octetBuffer, _octetBufferStart, _octetBufferLength);
                 ea.convertToCharacters(data, buffer);
             } else {
                 throw new EncodingAlgorithmException(
                         CommonResourceBundle.getInstance().getString("message.algorithmDataCannotBeReported"));
             }
         }
         _characters = new char[buffer.length()];
         buffer.getChars(0, buffer.length(), _characters, 0);
         _charactersOffset = 0;
         _charBufferLength = _characters.length;
     }
     /* If base64 data comes is chunks, bytes, which were cut to align 3,
      * from prev. base64 chunk are stored in this buffer */
     private byte[] base64TaleBytes = new byte[3];
     private int base64TaleLength;
     /*
      * Method converts _algorithmData to base64 encoded String
      * Counts with base64 data coming in chunks, aligning input chunks by 3,
      * avoiding double cloning, happening after possible peek, peek2 cloning by Base64 algorithm
      */
     protected void convertBase64AlorithmDataToCharacters(StringBuffer buffer) throws EncodingAlgorithmException, IOException {
         // How much new came data was serialized with prev. tale
         int afterTaleOffset = 0;
         if (base64TaleLength > 0) {
             // Serialize tale left from prev. chunk
             int bytesToCopy = Math.min(3 - base64TaleLength, _algorithmDataLength);
             System.arraycopy(_algorithmData, _algorithmDataOffset, base64TaleBytes, base64TaleLength, bytesToCopy);
             if (base64TaleLength + bytesToCopy == 3) {
                 base64DecodeWithCloning(buffer, base64TaleBytes, 0, 3);
             } else if (!isBase64Follows()) {
                 // End of text was read to temp array
                 base64DecodeWithCloning(buffer, base64TaleBytes, 0, base64TaleLength + bytesToCopy);
                 return;
             } else {
                 // If the end of chunk fit to tmp array, but next chunk is expected
                 base64TaleLength += bytesToCopy;
                 return;
             }
             afterTaleOffset = bytesToCopy;
             base64TaleLength = 0;
         }
         int taleBytesRemaining = isBase64Follows() ? (_algorithmDataLength - afterTaleOffset) % 3 : 0;
         if (_isAlgorithmDataCloned) {
             base64DecodeWithoutCloning(buffer, _algorithmData, _algorithmDataOffset + afterTaleOffset,
                     _algorithmDataLength - afterTaleOffset - taleBytesRemaining);
         } else {
             base64DecodeWithCloning(buffer, _algorithmData, _algorithmDataOffset + afterTaleOffset,
                     _algorithmDataLength - afterTaleOffset - taleBytesRemaining);
         }
         if (taleBytesRemaining > 0) {
             System.arraycopy(_algorithmData, _algorithmDataOffset + _algorithmDataLength - taleBytesRemaining,
                     base64TaleBytes, 0, taleBytesRemaining);
             base64TaleLength = taleBytesRemaining;
         }
     }
     /*
      * Encodes incoming data to Base64 string.
      * Method performs additional input data cloning
      */
     private void base64DecodeWithCloning(StringBuffer dstBuffer, byte[] data, int offset, int length) throws EncodingAlgorithmException {
         Object array = BuiltInEncodingAlgorithmFactory.base64EncodingAlgorithm.
                 decodeFromBytes(data, offset, length);
         BuiltInEncodingAlgorithmFactory.base64EncodingAlgorithm.convertToCharacters(array, dstBuffer);
     }
     /*
      * Encodes incoming data to Base64 string.
      * Avoids input data cloning
      */
     private void base64DecodeWithoutCloning(StringBuffer dstBuffer, byte[] data, int offset, int length) throws EncodingAlgorithmException {
         BuiltInEncodingAlgorithmFactory.base64EncodingAlgorithm.convertToCharacters(data, offset, length, dstBuffer);
     }
     /*
      * Looks ahead in InputStream, whether next data is Base64 chunk
      */
     public boolean isBase64Follows() throws IOException {
         // Process information item
         int b = peek(this);
         switch (DecoderStateTables.EII(b)) {
             case DecoderStateTables.CII_EA:
                 int algorithmId = (b & 0x02) << 6;
                 int b2 = peek2(this);
                 algorithmId |= (b2 & 0xFC) >> 2;
                 return algorithmId == EncodingAlgorithmIndexes.BASE64;
             default:
                 return false;
         }
     }
     protected class NamespaceContextImpl implements NamespaceContext {
         public final String getNamespaceURI(String prefix) {
             return _prefixTable.getNamespaceFromPrefix(prefix);
         }
         public final String getPrefix(String namespaceURI) {
             return _prefixTable.getPrefixFromNamespace(namespaceURI);
         }
         public final Iterator getPrefixes(String namespaceURI) {
             return _prefixTable.getPrefixesFromNamespace(namespaceURI);
         }
     }
     public final String getNamespaceDecl(String prefix) {
         return _prefixTable.getNamespaceFromPrefix(prefix);
     }
     public final String getURI(String prefix) {
         return getNamespaceDecl(prefix);
     }
     public final Iterator getPrefixes() {
         return _prefixTable.getPrefixes();
     }
     public final AttributesHolder getAttributesHolder() {
         return _attributes;
     }
     public final void setManager(StAXManager manager) {
         _manager = manager;
     }
     final static String getEventTypeString(int eventType) {
         switch (eventType){
             case START_ELEMENT:
                 return "START_ELEMENT";
             case END_ELEMENT:
                 return "END_ELEMENT";
             case PROCESSING_INSTRUCTION:
                 return "PROCESSING_INSTRUCTION";
             case CHARACTERS:
                 return "CHARACTERS";
             case COMMENT:
                 return "COMMENT";
             case START_DOCUMENT:
                 return "START_DOCUMENT";
             case END_DOCUMENT:
                 return "END_DOCUMENT";
             case ENTITY_REFERENCE:
                 return "ENTITY_REFERENCE";
             case ATTRIBUTE:
                 return "ATTRIBUTE";
             case DTD:
                 return "DTD";
             case CDATA:
                 return "CDATA";
         }
         return "UNKNOWN_EVENT_TYPE";
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/fastinfoset/stax/StAXDocumentParser.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/fastinfoset/stax/StAXDocumentParser.java