/* -*-             c-basic-offset: 4; indent-tabs-mode: nil; -*-  //------100-columns-wide------>|*/
   /*
    * Copyright (c) 2003 Extreme! Lab, Indiana University. All rights reserved.
    *
    * This software is open source. See the bottom of this file for the licence.
    */
   
   package org.codehaus.plexus.util.xml.pull;
   
  import java.io.EOFException;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.UnsupportedEncodingException;
  
  import org.codehaus.plexus.util.ReaderFactory;
  import org.codehaus.plexus.util.xml.XmlReader;
  
  // import java.util.Hashtable;
  
  // TODO best handling of interning issues
  //   have isAllNewStringInterned ???
  
  // TODO handling surrogate pairs: http://www.unicode.org/unicode/faq/utf_bom.html#6
  
  // TODO review code for use of bufAbsoluteStart when keeping pos between next()/fillBuf()
  
  /**
   * Absolutely minimal implementation of XMLPULL V1 API. Encoding handling done with XmlReader
   *
   * @see org.codehaus.plexus.util.xml.XmlReader
   * @author <a href="http://www.extreme.indiana.edu/~aslom/">Aleksander Slominski</a>
   */
  public class MXParser implements XmlPullParser {
      // NOTE: no interning of those strings --> by Java leng spec they MUST be already interned
      private static final String XML_URI = "http://www.w3.org/XML/1998/namespace";
  
      private static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
  
      private static final String FEATURE_XML_ROUNDTRIP =
              // "http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
              "http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
  
      private static final String FEATURE_NAMES_INTERNED = "http://xmlpull.org/v1/doc/features.html#names-interned";
  
      private static final String PROPERTY_XMLDECL_VERSION = "http://xmlpull.org/v1/doc/properties.html#xmldecl-version";
  
      private static final String PROPERTY_XMLDECL_STANDALONE =
              "http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone";
  
      private static final String PROPERTY_XMLDECL_CONTENT = "http://xmlpull.org/v1/doc/properties.html#xmldecl-content";
  
      private static final String PROPERTY_LOCATION = "http://xmlpull.org/v1/doc/properties.html#location";
  
      /**
       * Implementation notice: the is instance variable that controls if newString() is interning.
       * <p>
       * <b>NOTE:</b> newStringIntern <b>always</b> returns interned strings and newString MAY return interned String
       * depending on this variable.
       * <p>
       * <b>NOTE:</b> by default in this minimal implementation it is false!
       */
      private boolean allStringsInterned;
  
      private void resetStringCache() {
          // System.out.println("resetStringCache() minimum called");
      }
  
      private String newString(char[] cbuf, int off, int len) {
          return new String(cbuf, off, len);
      }
  
      private String newStringIntern(char[] cbuf, int off, int len) {
          return (new String(cbuf, off, len)).intern();
      }
  
      private static final boolean TRACE_SIZING = false;
  
      // NOTE: features are not resetable and typically defaults to false ...
      private boolean processNamespaces;
  
      private boolean roundtripSupported;
  
      // global parser state
      private String location;
  
      private int lineNumber;
  
      private int columnNumber;
  
      private boolean seenRoot;
  
      private boolean reachedEnd;
  
      private int eventType;
  
      private boolean emptyElementTag;
  
      // element stack
     private int depth;
 
     private char[] elRawName[];
 
     private int elRawNameEnd[];
 
     private int elRawNameLine[];
 
     private String elName[];
 
     private String elPrefix[];
 
     private String elUri[];
 
     // private String elValue[];
     private int elNamespaceCount[];
 
     private String fileEncoding = null;
 
     /**
      * Make sure that we have enough space to keep element stack if passed size. It will always create one additional
      * slot then current depth
      */
     private void ensureElementsCapacity() {
         final int elStackSize = elName != null ? elName.length : 0;
         if ((depth + 1) >= elStackSize) {
             // we add at least one extra slot ...
             final int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25
             if (TRACE_SIZING) {
                 System.err.println("TRACE_SIZING elStackSize " + elStackSize + " ==> " + newSize);
             }
             final boolean needsCopying = elStackSize > 0;
             String[] arr = null;
             // resue arr local variable slot
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(elName, 0, arr, 0, elStackSize);
             elName = arr;
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(elPrefix, 0, arr, 0, elStackSize);
             elPrefix = arr;
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(elUri, 0, arr, 0, elStackSize);
             elUri = arr;
 
             int[] iarr = new int[newSize];
             if (needsCopying) {
                 System.arraycopy(elNamespaceCount, 0, iarr, 0, elStackSize);
             } else {
                 // special initialization
                 iarr[0] = 0;
             }
             elNamespaceCount = iarr;
 
             // TODO: avoid using element raw name ...
             iarr = new int[newSize];
             if (needsCopying) {
                 System.arraycopy(elRawNameEnd, 0, iarr, 0, elStackSize);
             }
             elRawNameEnd = iarr;
 
             iarr = new int[newSize];
             if (needsCopying) {
                 System.arraycopy(elRawNameLine, 0, iarr, 0, elStackSize);
             }
             elRawNameLine = iarr;
 
             final char[][] carr = new char[newSize][];
             if (needsCopying) {
                 System.arraycopy(elRawName, 0, carr, 0, elStackSize);
             }
             elRawName = carr;
             // arr = new String[newSize];
             // if(needsCopying) System.arraycopy(elLocalName, 0, arr, 0, elStackSize);
             // elLocalName = arr;
             // arr = new String[newSize];
             // if(needsCopying) System.arraycopy(elDefaultNs, 0, arr, 0, elStackSize);
             // elDefaultNs = arr;
             // int[] iarr = new int[newSize];
             // if(needsCopying) System.arraycopy(elNsStackPos, 0, iarr, 0, elStackSize);
             // for (int i = elStackSize; i < iarr.length; i++)
             // {
             // iarr[i] = (i > 0) ? -1 : 0;
             // }
             // elNsStackPos = iarr;
             // assert depth < elName.length;
         }
     }
 
     // attribute stack
     private int attributeCount;
 
     private String attributeName[];
 
     private int attributeNameHash[];
 
     // private int attributeNameStart[];
     // private int attributeNameEnd[];
     private String attributePrefix[];
 
     private String attributeUri[];
 
     private String attributeValue[];
     // private int attributeValueStart[];
     // private int attributeValueEnd[];
 
     // Make sure that in attributes temporary array is enough space.
     private void ensureAttributesCapacity(int size) {
         final int attrPosSize = attributeName != null ? attributeName.length : 0;
         if (size >= attrPosSize) {
             final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
             if (TRACE_SIZING) {
                 System.err.println("TRACE_SIZING attrPosSize " + attrPosSize + " ==> " + newSize);
             }
             final boolean needsCopying = attrPosSize > 0;
             String[] arr = null;
 
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(attributeName, 0, arr, 0, attrPosSize);
             attributeName = arr;
 
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(attributePrefix, 0, arr, 0, attrPosSize);
             attributePrefix = arr;
 
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(attributeUri, 0, arr, 0, attrPosSize);
             attributeUri = arr;
 
             arr = new String[newSize];
             if (needsCopying) System.arraycopy(attributeValue, 0, arr, 0, attrPosSize);
             attributeValue = arr;
 
             if (!allStringsInterned) {
                 final int[] iarr = new int[newSize];
                 if (needsCopying) System.arraycopy(attributeNameHash, 0, iarr, 0, attrPosSize);
                 attributeNameHash = iarr;
             }
 
             arr = null;
             // //assert attrUri.length > size
         }
     }
 
     // namespace stack
     private int namespaceEnd;
 
     private String namespacePrefix[];
 
     private int namespacePrefixHash[];
 
     private String namespaceUri[];
 
     private void ensureNamespacesCapacity(int size) {
         final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
         if (size >= namespaceSize) {
             final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
             if (TRACE_SIZING) {
                 System.err.println("TRACE_SIZING namespaceSize " + namespaceSize + " ==> " + newSize);
             }
             final String[] newNamespacePrefix = new String[newSize];
             final String[] newNamespaceUri = new String[newSize];
             if (namespacePrefix != null) {
                 System.arraycopy(namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
                 System.arraycopy(namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
             }
             namespacePrefix = newNamespacePrefix;
             namespaceUri = newNamespaceUri;
 
             if (!allStringsInterned) {
                 final int[] newNamespacePrefixHash = new int[newSize];
                 if (namespacePrefixHash != null) {
                     System.arraycopy(namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
                 }
                 namespacePrefixHash = newNamespacePrefixHash;
             }
             // prefixesSize = newSize;
             // //assert nsPrefixes.length > size && nsPrefixes.length == newSize
         }
     }
 
     // simplistic implementation of hash function that has <b>constant</b> time to compute - so it also means
     // diminishing hash quality for long strings but for XML parsing it should be good enough ...
 
     private static final int fastHash(char ch[], int off, int len) {
         if (len == 0) return 0;
         // assert len >0
         int hash = ch[off]; // hash at beginning
         // try {
         hash = (hash << 7) + ch[off + len - 1]; // hash at the end
         // } catch(ArrayIndexOutOfBoundsException aie) {
         // aie.printStackTrace(); //should never happen ...
         // throw new RuntimeException("this is violation of pre-condition");
         // }
         if (len > 16) hash = (hash << 7) + ch[off + (len / 4)]; // 1/4 from beginning
         if (len > 8) hash = (hash << 7) + ch[off + (len / 2)]; // 1/2 of string size ...
         // notice that hash is at most done 3 times <<7 so shifted by 21 bits 8 bit value
         // so max result == 29 bits so it is quite just below 31 bits for long (2^32) ...
         // assert hash >= 0;
         return hash;
     }
 
     // entity replacement stack
     private int entityEnd;
 
     private String entityName[];
 
     private char[] entityNameBuf[];
 
     private String entityReplacement[];
 
     private char[] entityReplacementBuf[];
 
     private int entityNameHash[];
 
     private final EntityReplacementMap replacementMapTemplate;
 
     private void ensureEntityCapacity() {
         final int entitySize = entityReplacementBuf != null ? entityReplacementBuf.length : 0;
         if (entityEnd >= entitySize) {
             final int newSize = entityEnd > 7 ? 2 * entityEnd : 8; // = lucky 7 + 1 //25
             if (TRACE_SIZING) {
                 System.err.println("TRACE_SIZING entitySize " + entitySize + " ==> " + newSize);
             }
             final String[] newEntityName = new String[newSize];
             final char[] newEntityNameBuf[] = new char[newSize][];
             final String[] newEntityReplacement = new String[newSize];
             final char[] newEntityReplacementBuf[] = new char[newSize][];
             if (entityName != null) {
                 System.arraycopy(entityName, 0, newEntityName, 0, entityEnd);
                 System.arraycopy(entityNameBuf, 0, newEntityNameBuf, 0, entityEnd);
                 System.arraycopy(entityReplacement, 0, newEntityReplacement, 0, entityEnd);
                 System.arraycopy(entityReplacementBuf, 0, newEntityReplacementBuf, 0, entityEnd);
             }
             entityName = newEntityName;
             entityNameBuf = newEntityNameBuf;
             entityReplacement = newEntityReplacement;
             entityReplacementBuf = newEntityReplacementBuf;
 
             if (!allStringsInterned) {
                 final int[] newEntityNameHash = new int[newSize];
                 if (entityNameHash != null) {
                     System.arraycopy(entityNameHash, 0, newEntityNameHash, 0, entityEnd);
                 }
                 entityNameHash = newEntityNameHash;
             }
         }
     }
 
     // input buffer management
     private static final int READ_CHUNK_SIZE = 8 * 1024; // max data chars in one read() call
 
     private Reader reader;
 
     private String inputEncoding;
 
     private int bufLoadFactor = 95; // 99%
     // private int bufHardLimit; // only matters when expanding
 
     private float bufferLoadFactor = bufLoadFactor / 100f;
 
     private char buf[] = new char[Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 256];
 
     private int bufSoftLimit = (int) (bufferLoadFactor * buf.length); // desirable size of buffer
 
     private boolean preventBufferCompaction;
 
     private int bufAbsoluteStart; // this is buf
 
     private int bufStart;
 
     private int bufEnd;
 
     private int pos;
 
     private int posStart;
 
     private int posEnd;
 
     private char pc[] = new char[Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 64];
 
     private int pcStart;
 
     private int pcEnd;
 
     // parsing state
     // private boolean needsMore;
     // private boolean seenMarkup;
     private boolean usePC;
 
     private boolean seenStartTag;
 
     private boolean seenEndTag;
 
     private boolean pastEndTag;
 
     private boolean seenAmpersand;
 
     private boolean seenMarkup;
 
     private boolean seenDocdecl;
 
     // transient variable set during each call to next/Token()
     private boolean tokenize;
 
     private String text;
 
     private String entityRefName;
 
     private String xmlDeclVersion;
 
     private Boolean xmlDeclStandalone;
 
     private String xmlDeclContent;
 
     private void reset() {
         // System.out.println("reset() called");
         location = null;
         lineNumber = 1;
         columnNumber = 1;
         seenRoot = false;
         reachedEnd = false;
         eventType = START_DOCUMENT;
         emptyElementTag = false;
 
         depth = 0;
 
         attributeCount = 0;
 
         namespaceEnd = 0;
 
         entityEnd = 0;
         setupFromTemplate();
 
         reader = null;
         inputEncoding = null;
 
         preventBufferCompaction = false;
         bufAbsoluteStart = 0;
         bufEnd = bufStart = 0;
         pos = posStart = posEnd = 0;
 
         pcEnd = pcStart = 0;
 
         usePC = false;
 
         seenStartTag = false;
         seenEndTag = false;
         pastEndTag = false;
         seenAmpersand = false;
         seenMarkup = false;
         seenDocdecl = false;
 
         xmlDeclVersion = null;
         xmlDeclStandalone = null;
         xmlDeclContent = null;
 
         resetStringCache();
     }
 
     public MXParser() {
         replacementMapTemplate = null;
     }
 
     public MXParser(EntityReplacementMap entityReplacementMap) {
         this.replacementMapTemplate = entityReplacementMap;
     }
 
     public void setupFromTemplate() {
         if (replacementMapTemplate != null) {
             int length = replacementMapTemplate.entityEnd;
 
             // This is a bit cheeky, since the EntityReplacementMap contains exact-sized arrays,
             // and elements are always added to the array, we can use the array from the template.
             // Kids; dont do this at home.
             entityName = replacementMapTemplate.entityName;
             entityNameBuf = replacementMapTemplate.entityNameBuf;
             entityReplacement = replacementMapTemplate.entityReplacement;
             entityReplacementBuf = replacementMapTemplate.entityReplacementBuf;
             entityNameHash = replacementMapTemplate.entityNameHash;
             entityEnd = length;
         }
     }
 
     /**
      * Method setFeature
      *
      * @param name a String
      * @param state a boolean
      * @throws XmlPullParserException issue
      */
     @Override
     public void setFeature(String name, boolean state) throws XmlPullParserException {
         if (name == null) throw new IllegalArgumentException("feature name should not be null");
         if (FEATURE_PROCESS_NAMESPACES.equals(name)) {
             if (eventType != START_DOCUMENT)
                 throw new XmlPullParserException(
                         "namespace processing feature can only be changed before parsing", this, null);
             processNamespaces = state;
             // } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
             // if(type != START_DOCUMENT) throw new XmlPullParserException(
             // "namespace reporting feature can only be changed before parsing", this, null);
             // reportNsAttribs = state;
         } else if (FEATURE_NAMES_INTERNED.equals(name)) {
             if (state != false) {
                 throw new XmlPullParserException("interning names in this implementation is not supported");
             }
         } else if (FEATURE_PROCESS_DOCDECL.equals(name)) {
             if (state != false) {
                 throw new XmlPullParserException("processing DOCDECL is not supported");
             }
             // } else if(REPORT_DOCDECL.equals(name)) {
             // paramNotifyDoctype = state;
         } else if (FEATURE_XML_ROUNDTRIP.equals(name)) {
             // if(state == false) {
             // throw new XmlPullParserException(
             // "roundtrip feature can not be switched off");
             // }
             roundtripSupported = state;
         } else {
             throw new XmlPullParserException("unsupported feature " + name);
         }
     }
 
     /**
      * Unknown properties are <strong>always</strong> returned as false
      */
     @Override
     public boolean getFeature(String name) {
         if (name == null) throw new IllegalArgumentException("feature name should not be null");
         if (FEATURE_PROCESS_NAMESPACES.equals(name)) {
             return processNamespaces;
             // } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
             // return reportNsAttribs;
         } else if (FEATURE_NAMES_INTERNED.equals(name)) {
             return false;
         } else if (FEATURE_PROCESS_DOCDECL.equals(name)) {
             return false;
             // } else if(REPORT_DOCDECL.equals(name)) {
             // return paramNotifyDoctype;
         } else if (FEATURE_XML_ROUNDTRIP.equals(name)) {
             // return true;
             return roundtripSupported;
         }
         return false;
     }
 
     @Override
     public void setProperty(String name, Object value) throws XmlPullParserException {
         if (PROPERTY_LOCATION.equals(name)) {
             location = (String) value;
         } else {
             throw new XmlPullParserException("unsupported property: '" + name + "'");
         }
     }
 
     @Override
     public Object getProperty(String name) {
         if (name == null) throw new IllegalArgumentException("property name should not be null");
         if (PROPERTY_XMLDECL_VERSION.equals(name)) {
             return xmlDeclVersion;
         } else if (PROPERTY_XMLDECL_STANDALONE.equals(name)) {
             return xmlDeclStandalone;
         } else if (PROPERTY_XMLDECL_CONTENT.equals(name)) {
             return xmlDeclContent;
         } else if (PROPERTY_LOCATION.equals(name)) {
             return location;
         }
         return null;
     }
 
     @Override
     public void setInput(Reader in) throws XmlPullParserException {
         reset();
         reader = in;
 
         if (reader instanceof XmlReader) {
             // encoding already detected
             XmlReader xsr = (XmlReader) reader;
             fileEncoding = xsr.getEncoding();
         } else if (reader instanceof InputStreamReader) {
             InputStreamReader isr = (InputStreamReader) reader;
             if (isr.getEncoding() != null) {
                 fileEncoding = isr.getEncoding().toUpperCase();
             }
         }
     }
 
     @Override
     public void setInput(java.io.InputStream inputStream, String inputEncoding) throws XmlPullParserException {
         if (inputStream == null) {
             throw new IllegalArgumentException("input stream can not be null");
         }
         Reader reader;
         try {
             if (inputEncoding != null) {
                 reader = ReaderFactory.newReader(inputStream, inputEncoding);
             } else {
                 reader = ReaderFactory.newXmlReader(inputStream);
             }
         } catch (UnsupportedEncodingException une) {
             throw new XmlPullParserException(
                     "could not create reader for encoding " + inputEncoding + " : " + une, this, une);
         } catch (IOException e) {
             throw new XmlPullParserException("could not create reader : " + e, this, e);
         }
         setInput(reader);
         // must be here as reset() was called in setInput() and has set this.inputEncoding to null ...
         this.inputEncoding = inputEncoding;
     }
 
     @Override
     public String getInputEncoding() {
         return inputEncoding;
     }
 
     @Override
     public void defineEntityReplacementText(String entityName, String replacementText) throws XmlPullParserException {
         // throw new XmlPullParserException("not allowed");
 
         if (!replacementText.startsWith("&#") && this.entityName != null && replacementText.length() > 1) {
             String tmp = replacementText.substring(1, replacementText.length() - 1);
             for (int i = 0; i < this.entityName.length; i++) {
                 if (this.entityName[i] != null && this.entityName[i].equals(tmp)) {
                     replacementText = this.entityReplacement[i];
                 }
             }
         }
 
         // private char[] entityReplacement[];
         ensureEntityCapacity();
 
         // this is to make sure that if interning works we will take advantage of it ...
         char[] entityNameCharData = entityName.toCharArray();
         this.entityName[entityEnd] = newString(entityNameCharData, 0, entityName.length());
         entityNameBuf[entityEnd] = entityNameCharData;
 
         entityReplacement[entityEnd] = replacementText;
         entityReplacementBuf[entityEnd] = replacementText.toCharArray();
         if (!allStringsInterned) {
             entityNameHash[entityEnd] = fastHash(entityNameBuf[entityEnd], 0, entityNameBuf[entityEnd].length);
         }
         ++entityEnd;
         // TODO disallow < or & in entity replacement text (or ]]>???)
         // TOOD keepEntityNormalizedForAttributeValue cached as well ...
     }
 
     @Override
     public int getNamespaceCount(int depth) throws XmlPullParserException {
         if (!processNamespaces || depth == 0) {
             return 0;
         }
         // int maxDepth = eventType == END_TAG ? this.depth + 1 : this.depth;
         // if(depth < 0 || depth > maxDepth) throw new IllegalArgumentException(
         if (depth < 0 || depth > this.depth)
             throw new IllegalArgumentException("namespace count may be for depth 0.." + this.depth + " not " + depth);
         return elNamespaceCount[depth];
     }
 
     @Override
     public String getNamespacePrefix(int pos) throws XmlPullParserException {
 
         // int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
         // if(pos < end) {
         if (pos < namespaceEnd) {
             return namespacePrefix[pos];
         } else {
             throw new XmlPullParserException(
                     "position " + pos + " exceeded number of available namespaces " + namespaceEnd);
         }
     }
 
     @Override
     public String getNamespaceUri(int pos) throws XmlPullParserException {
         // int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
         // if(pos < end) {
         if (pos < namespaceEnd) {
             return namespaceUri[pos];
         } else {
             throw new XmlPullParserException(
                     "position " + pos + " exceeded number of available namespaces " + namespaceEnd);
         }
     }
 
     @Override
     public String getNamespace(String prefix)
                 // throws XmlPullParserException
             {
         // int count = namespaceCount[ depth ];
         if (prefix != null) {
             for (int i = namespaceEnd - 1; i >= 0; i--) {
                 if (prefix.equals(namespacePrefix[i])) {
                     return namespaceUri[i];
                 }
             }
             if ("xml".equals(prefix)) {
                 return XML_URI;
             } else if ("xmlns".equals(prefix)) {
                 return XMLNS_URI;
             }
         } else {
             for (int i = namespaceEnd - 1; i >= 0; i--) {
                 if (namespacePrefix[i] == null) { // "") { //null ) { //TODO check FIXME Alek
                     return namespaceUri[i];
                 }
             }
         }
         return null;
     }
 
     @Override
     public int getDepth() {
         return depth;
     }
 
     private static int findFragment(int bufMinPos, char[] b, int start, int end) {
         // System.err.println("bufStart="+bufStart+" b="+printable(new String(b, start, end - start))+" start="+start+"
         // end="+end);
         if (start < bufMinPos) {
             start = bufMinPos;
             if (start > end) start = end;
             return start;
         }
         if (end - start > 65) {
             start = end - 10; // try to find good location
         }
         int i = start + 1;
         while (--i > bufMinPos) {
             if ((end - i) > 65) break;
             final char c = b[i];
             if (c == '<' && (start - i) > 10) break;
         }
         return i;
     }
 
     /**
      * Return string describing current position of parsers as text 'STATE [seen %s...] @line:column'.
      */
     @Override
     public String getPositionDescription() {
         String fragment = null;
         if (posStart <= pos) {
             final int start = findFragment(0, buf, posStart, pos);
             // System.err.println("start="+start);
             if (start < pos) {
                 fragment = new String(buf, start, pos - start);
             }
             if (bufAbsoluteStart > 0 || start > 0) fragment = "..." + fragment;
         }
         // return " at line "+tokenizerPosRow
         // +" and column "+(tokenizerPosCol-1)
         // +(fragment != null ? " seen "+printable(fragment)+"..." : "");
         return " " + TYPES[eventType] + (fragment != null ? " seen " + printable(fragment) + "..." : "") + " "
                 + (location != null ? location : "") + "@" + getLineNumber() + ":" + getColumnNumber();
     }
 
     @Override
     public int getLineNumber() {
         return lineNumber;
     }
 
     @Override
     public int getColumnNumber() {
         return columnNumber;
     }
 
     @Override
     public boolean isWhitespace() throws XmlPullParserException {
         if (eventType == TEXT || eventType == CDSECT) {
             if (usePC) {
                 for (int i = pcStart; i < pcEnd; i++) {
                     if (!isS(pc[i])) return false;
                 }
                 return true;
             } else {
                 for (int i = posStart; i < posEnd; i++) {
                     if (!isS(buf[i])) return false;
                 }
                 return true;
             }
         } else if (eventType == IGNORABLE_WHITESPACE) {
             return true;
         }
         throw new XmlPullParserException("no content available to check for whitespaces");
     }
 
     @Override
     public String getText() {
         if (eventType == START_DOCUMENT || eventType == END_DOCUMENT) {
             // throw new XmlPullParserException("no content available to read");
             // if(roundtripSupported) {
             // text = new String(buf, posStart, posEnd - posStart);
             // } else {
             return null;
             // }
         } else if (eventType == ENTITY_REF) {
             return text;
         }
         if (text == null) {
             if (!usePC || eventType == START_TAG || eventType == END_TAG) {
                 text = new String(buf, posStart, posEnd - posStart);
             } else {
                 text = new String(pc, pcStart, pcEnd - pcStart);
             }
         }
         return text;
     }
 
     @Override
     public char[] getTextCharacters(int[] holderForStartAndLength) {
         if (eventType == TEXT) {
             if (usePC) {
                 holderForStartAndLength[0] = pcStart;
                 holderForStartAndLength[1] = pcEnd - pcStart;
                 return pc;
             } else {
                 holderForStartAndLength[0] = posStart;
                 holderForStartAndLength[1] = posEnd - posStart;
                 return buf;
             }
         } else if (eventType == START_TAG
                 || eventType == END_TAG
                 || eventType == CDSECT
                 || eventType == COMMENT
                 || eventType == ENTITY_REF
                 || eventType == PROCESSING_INSTRUCTION
                 || eventType == IGNORABLE_WHITESPACE
                 || eventType == DOCDECL) {
             holderForStartAndLength[0] = posStart;
             holderForStartAndLength[1] = posEnd - posStart;
             return buf;
         } else if (eventType == START_DOCUMENT || eventType == END_DOCUMENT) {
             // throw new XmlPullParserException("no content available to read");
             holderForStartAndLength[0] = holderForStartAndLength[1] = -1;
             return null;
         } else {
             throw new IllegalArgumentException("unknown text eventType: " + eventType);
         }
         // String s = getText();
         // char[] cb = null;
         // if(s!= null) {
         // cb = s.toCharArray();
         // holderForStartAndLength[0] = 0;
         // holderForStartAndLength[1] = s.length();
         // } else {
         // }
         // return cb;
     }
 
     @Override
     public String getNamespace() {
         if (eventType == START_TAG) {
             // return processNamespaces ? elUri[ depth - 1 ] : NO_NAMESPACE;
             return processNamespaces ? elUri[depth] : NO_NAMESPACE;
         } else if (eventType == END_TAG) {
             return processNamespaces ? elUri[depth] : NO_NAMESPACE;
         }
         return null;
         // String prefix = elPrefix[ maxDepth ];
         // if(prefix != null) {
         // for( int i = namespaceEnd -1; i >= 0; i--) {
         // if( prefix.equals( namespacePrefix[ i ] ) ) {
         // return namespaceUri[ i ];
         // }
         // }
         // } else {
         // for( int i = namespaceEnd -1; i >= 0; i--) {
         // if( namespacePrefix[ i ] == null ) {
         // return namespaceUri[ i ];
         // }
         // }
         //
         // }
         // return "";
     }
 
     @Override
     public String getName() {
         if (eventType == START_TAG) {
             // return elName[ depth - 1 ] ;
             return elName[depth];
         } else if (eventType == END_TAG) {
             return elName[depth];
         } else if (eventType == ENTITY_REF) {
             if (entityRefName == null) {
                 entityRefName = newString(buf, posStart, posEnd - posStart);
             }
             return entityRefName;
         } else {
             return null;
         }
     }
 
     @Override
     public String getPrefix() {
         if (eventType == START_TAG) {
             // return elPrefix[ depth - 1 ] ;
             return elPrefix[depth];
         } else if (eventType == END_TAG) {
             return elPrefix[depth];
         }
         return null;
         // if(eventType != START_TAG && eventType != END_TAG) return null;
         // int maxDepth = eventType == END_TAG ? depth : depth - 1;
         // return elPrefix[ maxDepth ];
     }
 
     @Override
     public boolean isEmptyElementTag() throws XmlPullParserException {
         if (eventType != START_TAG)
             throw new XmlPullParserException("parser must be on START_TAG to check for empty element", this, null);
         return emptyElementTag;
     }
 
     @Override
     public int getAttributeCount() {
         if (eventType != START_TAG) return -1;
         return attributeCount;
     }
 
     @Override
     public String getAttributeNamespace(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (!processNamespaces) return NO_NAMESPACE;
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return attributeUri[index];
     }
 
     @Override
     public String getAttributeName(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return attributeName[index];
     }
 
     @Override
     public String getAttributePrefix(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (!processNamespaces) return null;
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return attributePrefix[index];
     }
 
     @Override
     public String getAttributeType(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return "CDATA";
     }
 
     @Override
     public boolean isAttributeDefault(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return false;
     }
 
     @Override
     public String getAttributeValue(int index) {
         if (eventType != START_TAG) throw new IndexOutOfBoundsException("only START_TAG can have attributes");
         if (index < 0 || index >= attributeCount)
             throw new IndexOutOfBoundsException(
                     "attribute position must be 0.." + (attributeCount - 1) + " and not " + index);
         return attributeValue[index];
     }
 
     @Override
     public String getAttributeValue(String namespace, String name) {
         if (eventType != START_TAG)
             throw new IndexOutOfBoundsException("only START_TAG can have attributes" + getPositionDescription());
         if (name == null) {
             throw new IllegalArgumentException("attribute name can not be null");
         }
         // TODO make check if namespace is interned!!! etc. for names!!!
         if (processNamespaces) {
             if (namespace == null) {
                 namespace = "";
             }
 
             for (int i = 0; i < attributeCount; ++i) {
                 if ((namespace == attributeUri[i] || namespace.equals(attributeUri[i]))
                         // (namespace != null && namespace.equals(attributeUri[ i ]))
                         // taking advantage of String.intern()
                         && name.equals(attributeName[i])) {
                     return attributeValue[i];
                 }
             }
         } else {
             if (namespace != null && namespace.length() == 0) {
                 namespace = null;
             }
             if (namespace != null)
                 throw new IllegalArgumentException(
                         "when namespaces processing is disabled attribute namespace must be null");
             for (int i = 0; i < attributeCount; ++i) {
                 if (name.equals(attributeName[i])) {
                     return attributeValue[i];
                 }
             }
         }
         return null;
     }
 
     @Override
     public int getEventType() throws XmlPullParserException {
         return eventType;
     }
 
     @Override
     public void require(int type, String namespace, String name) throws XmlPullParserException, IOException {
         if (!processNamespaces && namespace != null) {
             throw new XmlPullParserException("processing namespaces must be enabled on parser (or factory)"
                     + " to have possible namespaces declared on elements" + (" (position:" + getPositionDescription())
                     + ")");
         }
         if (type != getEventType()
                 || (namespace != null && !namespace.equals(getNamespace()))
                 || (name != null && !name.equals(getName()))) {
             throw new XmlPullParserException("expected event " + TYPES[type]
                     + (name != null ? " with name '" + name + "'" : "")
                     + (namespace != null && name != null ? " and" : "")
                     + (namespace != null ? " with namespace '" + namespace + "'" : "") + " but got"
                     + (type != getEventType() ? " " + TYPES[getEventType()] : "")
                     + (name != null && getName() != null && !name.equals(getName()) ? " name '" + getName() + "'" : "")
                     + (namespace != null
                                     && name != null
                                     && getName() != null
                                     && !name.equals(getName())
                                     && getNamespace() != null
                                     && !namespace.equals(getNamespace())
                             ? " and"
                             : "")
                     + (namespace != null && getNamespace() != null && !namespace.equals(getNamespace())
                             ? " namespace '" + getNamespace() + "'"
                             : "")
                     + (" (position:" + getPositionDescription()) + ")");
         }
     }
 
     /**
      * <p>Skip sub tree that is currently parser positioned on.</p>
      * NOTE: parser must be on START_TAG and when function returns parser will be positioned on corresponding END_TAG
      * @throws XmlPullParserException issue
      * @throws IOException io
      */
     public void skipSubTree() throws XmlPullParserException, IOException {
         require(START_TAG, null, null);
         int level = 1;
         while (level > 0) {
             int eventType = next();
             if (eventType == END_TAG) {
                 --level;
             } else if (eventType == START_TAG) {
                 ++level;
             }
         }
     }
 
     // public String readText() throws XmlPullParserException, IOException
     // {
     // if (getEventType() != TEXT) return "";
     // String result = getText();
     // next();
     // return result;
     // }
 
     @Override
     public String nextText() throws XmlPullParserException, IOException {
         // String result = null;
         // boolean onStartTag = false;
         // if(eventType == START_TAG) {
         // onStartTag = true;
         // next();
         // }
         // if(eventType == TEXT) {
         // result = getText();
         // next();
         // } else if(onStartTag && eventType == END_TAG) {
         // result = "";
         // } else {
         // throw new XmlPullParserException(
         // "parser must be on START_TAG or TEXT to read text", this, null);
         // }
         // if(eventType != END_TAG) {
         // throw new XmlPullParserException(
         // "event TEXT it must be immediately followed by END_TAG", this, null);
         // }
         // return result;
         if (getEventType() != START_TAG) {
             throw new XmlPullParserException("parser must be on START_TAG to read next text", this, null);
         }
         int eventType = next();
         if (eventType == TEXT) {
             final String result = getText();
             eventType = next();
             if (eventType != END_TAG) {
                 throw new XmlPullParserException(
                         "TEXT must be immediately followed by END_TAG and not " + TYPES[getEventType()], this, null);
             }
             return result;
         } else if (eventType == END_TAG) {
             return "";
         } else {
             throw new XmlPullParserException("parser must be on START_TAG or TEXT to read text", this, null);
         }
     }
 
     @Override
     public int nextTag() throws XmlPullParserException, IOException {
         next();
         if (eventType == TEXT && isWhitespace()) { // skip whitespace
             next();
         }
         if (eventType != START_TAG && eventType != END_TAG) {
             throw new XmlPullParserException("expected START_TAG or END_TAG not " + TYPES[getEventType()], this, null);
         }
         return eventType;
     }
 
     @Override
     public int next() throws XmlPullParserException, IOException {
         tokenize = false;
         return nextImpl();
     }
 
     @Override
     public int nextToken() throws XmlPullParserException, IOException {
         tokenize = true;
         return nextImpl();
     }
 
     private int nextImpl() throws XmlPullParserException, IOException {
         text = null;
         pcEnd = pcStart = 0;
         usePC = false;
         bufStart = posEnd;
         if (pastEndTag) {
             pastEndTag = false;
             --depth;
             namespaceEnd = elNamespaceCount[depth]; // less namespaces available
         }
         if (emptyElementTag) {
             emptyElementTag = false;
             pastEndTag = true;
             return eventType = END_TAG;
         }
 
         // [1] document ::= prolog element Misc*
         if (depth > 0) {
 
             if (seenStartTag) {
                 seenStartTag = false;
                 return eventType = parseStartTag();
             }
             if (seenEndTag) {
                 seenEndTag = false;
                 return eventType = parseEndTag();
             }
 
             // ASSUMPTION: we are _on_ first character of content or markup!!!!
             // [43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
             char ch;
             if (seenMarkup) { // we have read ahead ...
                 seenMarkup = false;
                 ch = '<';
             } else if (seenAmpersand) {
                 seenAmpersand = false;
                 ch = '&';
             } else {
                 ch = more();
             }
             posStart = pos - 1; // VERY IMPORTANT: this is correct start of event!!!
 
             // when true there is some potential event TEXT to return - keep gathering
             boolean hadCharData = false;
 
             // when true TEXT data is not continuous (like <![CDATA[text]]>) and requires PC merging
             boolean needsMerging = false;
 
             MAIN_LOOP:
             while (true) {
                 // work on MARKUP
                 if (ch == '<') {
                     if (hadCharData) {
                         // posEnd = pos - 1;
                         if (tokenize) {
                             seenMarkup = true;
                             return eventType = TEXT;
                         }
                     }
                     ch = more();
                     if (ch == '/') {
                         if (!tokenize && hadCharData) {
                             seenEndTag = true;
                             // posEnd = pos - 2;
                             return eventType = TEXT;
                         }
                         return eventType = parseEndTag();
                     } else if (ch == '!') {
                         ch = more();
                         if (ch == '-') {
                             // note: if(tokenize == false) posStart/End is NOT changed!!!!
                             parseComment();
                             if (tokenize) return eventType = COMMENT;
                             if (!usePC && hadCharData) {
                                 needsMerging = true;
                             } else {
                                 posStart = pos; // completely ignore comment
                             }
                         } else if (ch == '[') {
                             // posEnd = pos - 3;
                             // must remember previous posStart/End as it merges with content of CDATA
                             // int oldStart = posStart + bufAbsoluteStart;
                             // int oldEnd = posEnd + bufAbsoluteStart;
                             parseCDSect(hadCharData);
                             if (tokenize) return eventType = CDSECT;
                             final int cdStart = posStart;
                             final int cdEnd = posEnd;
                             final int cdLen = cdEnd - cdStart;
 
                             if (cdLen > 0) { // was there anything inside CDATA section?
                                 hadCharData = true;
                                 if (!usePC) {
                                     needsMerging = true;
                                 }
                             }
 
                             // posStart = oldStart;
                             // posEnd = oldEnd;
                             // if(cdLen > 0) { // was there anything inside CDATA section?
                             // if(hadCharData) {
                             // // do merging if there was anything in CDSect!!!!
                             // // if(!usePC) {
                             // // // posEnd is correct already!!!
                             // // if(posEnd > posStart) {
                             // // joinPC();
                             // // } else {
                             // // usePC = true;
                             // // pcStart = pcEnd = 0;
                             // // }
                             // // }
                             // // if(pcEnd + cdLen >= pc.length) ensurePC(pcEnd + cdLen);
                             // // // copy [cdStart..cdEnd) into PC
                             // // System.arraycopy(buf, cdStart, pc, pcEnd, cdLen);
                             // // pcEnd += cdLen;
                             // if(!usePC) {
                             // needsMerging = true;
                             // posStart = cdStart;
                             // posEnd = cdEnd;
                             // }
                             // } else {
                             // if(!usePC) {
                             // needsMerging = true;
                             // posStart = cdStart;
                             // posEnd = cdEnd;
                             // hadCharData = true;
                             // }
                             // }
                             // //hadCharData = true;
                             // } else {
                             // if( !usePC && hadCharData ) {
                             // needsMerging = true;
                             // }
                             // }
                         } else {
                             throw new XmlPullParserException(
                                     "unexpected character in markup " + printable(ch), this, null);
                         }
                     } else if (ch == '?') {
                         parsePI();
                         if (tokenize) return eventType = PROCESSING_INSTRUCTION;
                         if (!usePC && hadCharData) {
                             needsMerging = true;
                         } else {
                             posStart = pos; // completely ignore PI
                         }
 
                     } else if (isNameStartChar(ch)) {
                         if (!tokenize && hadCharData) {
                             seenStartTag = true;
                             // posEnd = pos - 2;
                             return eventType = TEXT;
                         }
                         return eventType = parseStartTag();
                     } else {
                         throw new XmlPullParserException("unexpected character in markup " + printable(ch), this, null);
                     }
                     // do content compaction if it makes sense!!!!
 
                 } else if (ch == '&') {
                     // work on ENTITY
                     // posEnd = pos - 1;
                     if (tokenize && hadCharData) {
                         seenAmpersand = true;
                         return eventType = TEXT;
                     }
                     final int oldStart = posStart + bufAbsoluteStart;
                     final int oldEnd = posEnd + bufAbsoluteStart;
                     parseEntityRef();
                     if (tokenize) return eventType = ENTITY_REF;
                     // check if replacement text can be resolved !!!
                     if (resolvedEntityRefCharBuf == BUF_NOT_RESOLVED) {
                         if (entityRefName == null) {
                             entityRefName = newString(buf, posStart, posEnd - posStart);
                         }
                         throw new XmlPullParserException(
                                 "could not resolve entity named '" + printable(entityRefName) + "'", this, null);
                     }
                     // int entStart = posStart;
                     // int entEnd = posEnd;
                     posStart = oldStart - bufAbsoluteStart;
                     posEnd = oldEnd - bufAbsoluteStart;
                     if (!usePC) {
                         if (hadCharData) {
                             joinPC(); // posEnd is already set correctly!!!
                             needsMerging = false;
                         } else {
                             usePC = true;
                             pcStart = pcEnd = 0;
                         }
                     }
                     // assert usePC == true;
                     // write into PC replacement text - do merge for replacement text!!!!
                     for (char aResolvedEntity : resolvedEntityRefCharBuf) {
                         if (pcEnd >= pc.length) {
                             ensurePC(pcEnd);
                         }
                         pc[pcEnd++] = aResolvedEntity;
                     }
                     hadCharData = true;
                     // assert needsMerging == false;
                 } else {
 
                     if (needsMerging) {
                         // assert usePC == false;
                         joinPC(); // posEnd is already set correctly!!!
                         // posStart = pos - 1;
                         needsMerging = false;
                     }
 
                     // no MARKUP not ENTITIES so work on character data ...
 
                     // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
 
                     hadCharData = true;
 
                     boolean normalizedCR = false;
                     final boolean normalizeInput = !tokenize || !roundtripSupported;
                     // use loop locality here!!!!
                     boolean seenBracket = false;
                     boolean seenBracketBracket = false;
                     do {
 
                         // check that ]]> does not show in
                         if (ch == ']') {
                             if (seenBracket) {
                                 seenBracketBracket = true;
                             } else {
                                 seenBracket = true;
                             }
                         } else if (seenBracketBracket && ch == '>') {
                             throw new XmlPullParserException("characters ]]> are not allowed in content", this, null);
                         } else {
                             if (seenBracket) {
                                 seenBracketBracket = seenBracket = false;
                             }
                             // assert seenTwoBrackets == seenBracket == false;
                         }
                         if (normalizeInput) {
                             // deal with normalization issues ...
                             if (ch == '\r') {
                                 normalizedCR = true;
                                 posEnd = pos - 1;
                                 // posEnd is already set
                                 if (!usePC) {
                                     if (posEnd > posStart) {
                                         joinPC();
                                     } else {
                                         usePC = true;
                                         pcStart = pcEnd = 0;
                                     }
                                 }
                                 // assert usePC == true;
                                 if (pcEnd >= pc.length) ensurePC(pcEnd);
                                 pc[pcEnd++] = '\n';
                             } else if (ch == '\n') {
                                 // if(!usePC) { joinPC(); } else { if(pcEnd >= pc.length) ensurePC(); }
                                 if (!normalizedCR && usePC) {
                                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                                     pc[pcEnd++] = '\n';
                                 }
                                 normalizedCR = false;
                             } else {
                                 if (usePC) {
                                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                                     pc[pcEnd++] = ch;
                                 }
                                 normalizedCR = false;
                             }
                         }
 
                         ch = more();
                     } while (ch != '<' && ch != '&');
                     posEnd = pos - 1;
                     continue MAIN_LOOP; // skip ch = more() from below - we are already ahead ...
                 }
                 ch = more();
             } // endless while(true)
         } else {
             if (seenRoot) {
                 return parseEpilog();
             } else {
                 return parseProlog();
             }
         }
     }
 
     private int parseProlog() throws XmlPullParserException, IOException {
         // [2] prolog: ::= XMLDecl? Misc* (doctypedecl Misc*)? and look for [39] element
 
         char ch;
         if (seenMarkup) {
             ch = buf[pos - 1];
         } else {
             ch = more();
         }
 
         if (eventType == START_DOCUMENT) {
             // bootstrap parsing with getting first character input!
             // deal with BOM
             // detect BOM and crop it (Unicode int Order Mark)
             if (ch == '\uFFFE') {
                 throw new XmlPullParserException(
                         "first character in input was UNICODE noncharacter (0xFFFE)" + "- input requires int swapping",
                         this,
                         null);
             }
             if (ch == '\uFEFF') {
                 // skipping UNICODE int Order Mark (so called BOM)
                 ch = more();
             } else if (ch == '\uFFFD') {
                 // UTF-16 BOM in an UTF-8 encoded file?
                 // This is a hack...not the best way to check for BOM in UTF-16
                 ch = more();
                 if (ch == '\uFFFD') {
                     throw new XmlPullParserException("UTF-16 BOM in a UTF-8 encoded file is incompatible", this, null);
                 }
             }
         }
         seenMarkup = false;
         boolean gotS = false;
         posStart = pos - 1;
         final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
         boolean normalizedCR = false;
         while (true) {
             // deal with Misc
             // [27] Misc ::= Comment | PI | S
             // deal with docdecl --> mark it!
             // else parseStartTag seen <[^/]
             if (ch == '<') {
                 if (gotS && tokenize) {
                     posEnd = pos - 1;
                     seenMarkup = true;
                     return eventType = IGNORABLE_WHITESPACE;
                 }
                 ch = more();
                 if (ch == '?') {
                     // check if it is 'xml'
                     // deal with XMLDecl
                     boolean isXMLDecl = parsePI();
                     if (tokenize) {
                         if (isXMLDecl) {
                             return eventType = START_DOCUMENT;
                         }
                         return eventType = PROCESSING_INSTRUCTION;
                     }
                 } else if (ch == '!') {
                     ch = more();
                     if (ch == 'D') {
                         if (seenDocdecl) {
                             throw new XmlPullParserException("only one docdecl allowed in XML document", this, null);
                         }
                         seenDocdecl = true;
                         parseDocdecl();
                         if (tokenize) return eventType = DOCDECL;
                     } else if (ch == '-') {
                         parseComment();
                         if (tokenize) return eventType = COMMENT;
                     } else {
                         throw new XmlPullParserException("unexpected markup <!" + printable(ch), this, null);
                     }
                 } else if (ch == '/') {
                     throw new XmlPullParserException("expected start tag name and not " + printable(ch), this, null);
                 } else if (isNameStartChar(ch)) {
                     seenRoot = true;
                     return parseStartTag();
                 } else {
                     throw new XmlPullParserException("expected start tag name and not " + printable(ch), this, null);
                 }
             } else if (isS(ch)) {
                 gotS = true;
                 if (normalizeIgnorableWS) {
                     if (ch == '\r') {
                         normalizedCR = true;
                         // posEnd = pos -1;
                         // joinPC();
                         // posEnd is already set
                         if (!usePC) {
                             posEnd = pos - 1;
                             if (posEnd > posStart) {
                                 joinPC();
                             } else {
                                 usePC = true;
                                 pcStart = pcEnd = 0;
                             }
                         }
                         // assert usePC == true;
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = '\n';
                     } else if (ch == '\n') {
                         if (!normalizedCR && usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = '\n';
                         }
                         normalizedCR = false;
                     } else {
                         if (usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = ch;
                         }
                         normalizedCR = false;
                     }
                 }
             } else {
                 throw new XmlPullParserException(
                         "only whitespace content allowed before start tag and not " + printable(ch), this, null);
             }
             ch = more();
         }
     }
 
     private int parseEpilog() throws XmlPullParserException, IOException {
         if (eventType == END_DOCUMENT) {
             throw new XmlPullParserException("already reached end of XML input", this, null);
         }
         if (reachedEnd) {
             return eventType = END_DOCUMENT;
         }
         boolean gotS = false;
         final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
         boolean normalizedCR = false;
         try {
             // epilog: Misc*
             char ch;
             if (seenMarkup) {
                 ch = buf[pos - 1];
             } else {
                 ch = more();
             }
             seenMarkup = false;
             posStart = pos - 1;
             if (!reachedEnd) {
                 while (true) {
                     // deal with Misc
                     // [27] Misc ::= Comment | PI | S
                     if (ch == '<') {
                         if (gotS && tokenize) {
                             posEnd = pos - 1;
                             seenMarkup = true;
                             return eventType = IGNORABLE_WHITESPACE;
                         }
                         ch = more();
                         if (reachedEnd) {
                             break;
                         }
                         if (ch == '?') {
                             // check if it is 'xml'
                             // deal with XMLDecl
                             parsePI();
                             if (tokenize) return eventType = PROCESSING_INSTRUCTION;
 
                         } else if (ch == '!') {
                             ch = more();
                             if (reachedEnd) {
                                 break;
                             }
                             if (ch == 'D') {
                                 parseDocdecl(); // FIXME
                                 if (tokenize) return eventType = DOCDECL;
                             } else if (ch == '-') {
                                 parseComment();
                                 if (tokenize) return eventType = COMMENT;
                             } else {
                                 throw new XmlPullParserException("unexpected markup <!" + printable(ch), this, null);
                             }
                         } else if (ch == '/') {
                             throw new XmlPullParserException(
                                     "end tag not allowed in epilog but got " + printable(ch), this, null);
                         } else if (isNameStartChar(ch)) {
                             throw new XmlPullParserException(
                                     "start tag not allowed in epilog but got " + printable(ch), this, null);
                         } else {
                             throw new XmlPullParserException(
                                     "in epilog expected ignorable content and not " + printable(ch), this, null);
                         }
                     } else if (isS(ch)) {
                         gotS = true;
                         if (normalizeIgnorableWS) {
                             if (ch == '\r') {
                                 normalizedCR = true;
                                 // posEnd = pos -1;
                                 // joinPC();
                                 // posEnd is already set
                                 if (!usePC) {
                                     posEnd = pos - 1;
                                     if (posEnd > posStart) {
                                         joinPC();
                                     } else {
                                         usePC = true;
                                         pcStart = pcEnd = 0;
                                     }
                                 }
                                 // assert usePC == true;
                                 if (pcEnd >= pc.length) ensurePC(pcEnd);
                                 pc[pcEnd++] = '\n';
                             } else if (ch == '\n') {
                                 if (!normalizedCR && usePC) {
                                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                                     pc[pcEnd++] = '\n';
                                 }
                                 normalizedCR = false;
                             } else {
                                 if (usePC) {
                                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                                     pc[pcEnd++] = ch;
                                 }
                                 normalizedCR = false;
                             }
                         }
                     } else {
                         throw new XmlPullParserException(
                                 "in epilog non whitespace content is not allowed but got " + printable(ch), this, null);
                     }
                     ch = more();
                     if (reachedEnd) {
                         break;
                     }
                 }
             }
 
             // throw Exception("unexpected content in epilog
             // catch EOFException return END_DOCUMENT
             // try {
         } catch (EOFException ex) {
             reachedEnd = true;
         }
         if (tokenize && gotS) {
             posEnd = pos; // well - this is LAST available character pos
             return eventType = IGNORABLE_WHITESPACE;
         }
         return eventType = END_DOCUMENT;
     }
 
     public int parseEndTag() throws XmlPullParserException, IOException {
         // ASSUMPTION ch is past "</"
         // [42] ETag ::= '</' Name S? '>'
         char ch = more();
         if (!isNameStartChar(ch)) {
             throw new XmlPullParserException("expected name start and not " + printable(ch), this, null);
         }
         posStart = pos - 3;
         final int nameStart = pos - 1 + bufAbsoluteStart;
         do {
             ch = more();
         } while (isNameChar(ch));
 
         // now we go one level down -- do checks
         // --depth; //FIXME
 
         // check that end tag name is the same as start tag
         // String name = new String(buf, nameStart - bufAbsoluteStart,
         // (pos - 1) - (nameStart - bufAbsoluteStart));
         // int last = pos - 1;
         int off = nameStart - bufAbsoluteStart;
         // final int len = last - off;
         final int len = (pos - 1) - off;
         final char[] cbuf = elRawName[depth];
         if (elRawNameEnd[depth] != len) {
             // construct strings for exception
             final String startname = new String(cbuf, 0, elRawNameEnd[depth]);
             final String endname = new String(buf, off, len);
             throw new XmlPullParserException(
                     "end tag name </" + endname + "> must match start tag name <" + startname + ">" + " from line "
                             + elRawNameLine[depth],
                     this,
                     null);
         }
         for (int i = 0; i < len; i++) {
             if (buf[off++] != cbuf[i]) {
                 // construct strings for exception
                 final String startname = new String(cbuf, 0, len);
                 final String endname = new String(buf, off - i - 1, len);
                 throw new XmlPullParserException(
                         "end tag name </" + endname + "> must be the same as start tag <" + startname + ">"
                                 + " from line " + elRawNameLine[depth],
                         this,
                         null);
             }
         }
 
         while (isS(ch)) {
             ch = more();
         } // skip additional white spaces
         if (ch != '>') {
             throw new XmlPullParserException(
                     "expected > to finsh end tag not " + printable(ch) + " from line " + elRawNameLine[depth],
                     this,
                     null);
         }
 
         // namespaceEnd = elNamespaceCount[ depth ]; //FIXME
 
         posEnd = pos;
         pastEndTag = true;
         return eventType = END_TAG;
     }
 
     public int parseStartTag() throws XmlPullParserException, IOException {
         // ASSUMPTION ch is past <T
         // [40] STag ::= '<' Name (S Attribute)* S? '>'
         // [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
         ++depth; // FIXME
 
         posStart = pos - 2;
 
         emptyElementTag = false;
         attributeCount = 0;
         // retrieve name
         final int nameStart = pos - 1 + bufAbsoluteStart;
         int colonPos = -1;
         char ch = buf[pos - 1];
         if (ch == ':' && processNamespaces)
             throw new XmlPullParserException(
                     "when namespaces processing enabled colon can not be at element name start", this, null);
         while (true) {
             ch = more();
             if (!isNameChar(ch)) break;
             if (ch == ':' && processNamespaces) {
                 if (colonPos != -1)
                     throw new XmlPullParserException(
                             "only one colon is allowed in name of element when namespaces are enabled", this, null);
                 colonPos = pos - 1 + bufAbsoluteStart;
             }
         }
 
         // retrieve name
         ensureElementsCapacity();
 
         // TODO check for efficient interning and then use elRawNameInterned!!!!
 
         int elLen = (pos - 1) - (nameStart - bufAbsoluteStart);
         if (elRawName[depth] == null || elRawName[depth].length < elLen) {
             elRawName[depth] = new char[2 * elLen];
         }
         System.arraycopy(buf, nameStart - bufAbsoluteStart, elRawName[depth], 0, elLen);
         elRawNameEnd[depth] = elLen;
         elRawNameLine[depth] = lineNumber;
 
         String name = null;
 
         // work on prefixes and namespace URI
         String prefix = null;
         if (processNamespaces) {
             if (colonPos != -1) {
                 prefix = elPrefix[depth] = newString(buf, nameStart - bufAbsoluteStart, colonPos - nameStart);
                 name = elName[depth] = newString(
                         buf,
                         colonPos + 1 - bufAbsoluteStart,
                         // (pos -1) - (colonPos + 1));
                         pos - 2 - (colonPos - bufAbsoluteStart));
             } else {
                 prefix = elPrefix[depth] = null;
                 name = elName[depth] = newString(buf, nameStart - bufAbsoluteStart, elLen);
             }
         } else {
 
             name = elName[depth] = newString(buf, nameStart - bufAbsoluteStart, elLen);
         }
 
         while (true) {
 
             while (isS(ch)) {
                 ch = more();
             } // skip additional white spaces
 
             if (ch == '>') {
                 break;
             } else if (ch == '/') {
                 if (emptyElementTag) throw new XmlPullParserException("repeated / in tag declaration", this, null);
                 emptyElementTag = true;
                 ch = more();
                 if (ch != '>')
                     throw new XmlPullParserException("expected > to end empty tag not " + printable(ch), this, null);
                 break;
             } else if (isNameStartChar(ch)) {
                 ch = parseAttribute();
                 ch = more();
             } else {
                 throw new XmlPullParserException("start tag unexpected character " + printable(ch), this, null);
             }
             // ch = more(); // skip space
         }
 
         // now when namespaces were declared we can resolve them
         if (processNamespaces) {
             String uri = getNamespace(prefix);
             if (uri == null) {
                 if (prefix == null) { // no prefix and no uri => use default namespace
                     uri = NO_NAMESPACE;
                 } else {
                     throw new XmlPullParserException(
                             "could not determine namespace bound to element prefix " + prefix, this, null);
                 }
             }
             elUri[depth] = uri;
 
             // String uri = getNamespace(prefix);
             // if(uri == null && prefix == null) { // no prefix and no uri => use default namespace
             // uri = "";
             // }
             // resolve attribute namespaces
             for (int i = 0; i < attributeCount; i++) {
                 final String attrPrefix = attributePrefix[i];
                 if (attrPrefix != null) {
                     final String attrUri = getNamespace(attrPrefix);
                     if (attrUri == null) {
                         throw new XmlPullParserException(
                                 "could not determine namespace bound to attribute prefix " + attrPrefix, this, null);
                     }
                     attributeUri[i] = attrUri;
                 } else {
                     attributeUri[i] = NO_NAMESPACE;
                 }
             }
 
             // TODO
             // [ WFC: Unique Att Spec ]
             // check namespaced attribute uniqueness constraint!!!
 
             for (int i = 1; i < attributeCount; i++) {
                 for (int j = 0; j < i; j++) {
                     if (attributeUri[j] == attributeUri[i]
                             && (allStringsInterned && attributeName[j].equals(attributeName[i])
                                     || (!allStringsInterned
                                             && attributeNameHash[j] == attributeNameHash[i]
                                             && attributeName[j].equals(attributeName[i])))) {
 
                         // prepare data for nice error message?
                         String attr1 = attributeName[j];
                         if (attributeUri[j] != null) attr1 = attributeUri[j] + ":" + attr1;
                         String attr2 = attributeName[i];
                         if (attributeUri[i] != null) attr2 = attributeUri[i] + ":" + attr2;
                         throw new XmlPullParserException(
                                 "duplicated attributes " + attr1 + " and " + attr2, this, null);
                     }
                 }
             }
 
         } else { // ! processNamespaces
 
             // [ WFC: Unique Att Spec ]
             // check raw attribute uniqueness constraint!!!
             for (int i = 1; i < attributeCount; i++) {
                 for (int j = 0; j < i; j++) {
                     if ((allStringsInterned && attributeName[j].equals(attributeName[i])
                             || (!allStringsInterned
                                     && attributeNameHash[j] == attributeNameHash[i]
                                     && attributeName[j].equals(attributeName[i])))) {
 
                         // prepare data for nice error message?
                         final String attr1 = attributeName[j];
                         final String attr2 = attributeName[i];
                         throw new XmlPullParserException(
                                 "duplicated attributes " + attr1 + " and " + attr2, this, null);
                     }
                 }
             }
         }
 
         elNamespaceCount[depth] = namespaceEnd;
         posEnd = pos;
         return eventType = START_TAG;
     }
 
     private char parseAttribute() throws XmlPullParserException, IOException {
         // parse attribute
         // [41] Attribute ::= Name Eq AttValue
         // [WFC: No External Entity References]
         // [WFC: No < in Attribute Values]
         final int prevPosStart = posStart + bufAbsoluteStart;
         final int nameStart = pos - 1 + bufAbsoluteStart;
         int colonPos = -1;
         char ch = buf[pos - 1];
         if (ch == ':' && processNamespaces)
             throw new XmlPullParserException(
                     "when namespaces processing enabled colon can not be at attribute name start", this, null);
 
         boolean startsWithXmlns = processNamespaces && ch == 'x';
         int xmlnsPos = 0;
 
         ch = more();
         while (isNameChar(ch)) {
             if (processNamespaces) {
                 if (startsWithXmlns && xmlnsPos < 5) {
                     ++xmlnsPos;
                     if (xmlnsPos == 1) {
                         if (ch != 'm') startsWithXmlns = false;
                     } else if (xmlnsPos == 2) {
                         if (ch != 'l') startsWithXmlns = false;
                     } else if (xmlnsPos == 3) {
                         if (ch != 'n') startsWithXmlns = false;
                     } else if (xmlnsPos == 4) {
                         if (ch != 's') startsWithXmlns = false;
                     } else if (xmlnsPos == 5) {
                         if (ch != ':')
                             throw new XmlPullParserException(
                                     "after xmlns in attribute name must be colon" + "when namespaces are enabled",
                                     this,
                                     null);
                         // colonPos = pos - 1 + bufAbsoluteStart;
                     }
                 }
                 if (ch == ':') {
                     if (colonPos != -1)
                         throw new XmlPullParserException(
                                 "only one colon is allowed in attribute name" + " when namespaces are enabled",
                                 this,
                                 null);
                     colonPos = pos - 1 + bufAbsoluteStart;
                 }
             }
             ch = more();
         }
 
         ensureAttributesCapacity(attributeCount);
 
         // --- start processing attributes
         String name = null;
         String prefix = null;
         // work on prefixes and namespace URI
         if (processNamespaces) {
             if (xmlnsPos < 4) startsWithXmlns = false;
             if (startsWithXmlns) {
                 if (colonPos != -1) {
                     // prefix = attributePrefix[ attributeCount ] = null;
                     final int nameLen = pos - 2 - (colonPos - bufAbsoluteStart);
                     if (nameLen == 0) {
                         throw new XmlPullParserException(
                                 "namespace prefix is required after xmlns: " + " when namespaces are enabled",
                                 this,
                                 null);
                     }
                     name = // attributeName[ attributeCount ] =
                             newString(buf, colonPos - bufAbsoluteStart + 1, nameLen);
                     // pos - 1 - (colonPos + 1 - bufAbsoluteStart)
                 }
             } else {
                 if (colonPos != -1) {
                     int prefixLen = colonPos - nameStart;
                     prefix = attributePrefix[attributeCount] = newString(buf, nameStart - bufAbsoluteStart, prefixLen);
                     // colonPos - (nameStart - bufAbsoluteStart));
                     int nameLen = pos - 2 - (colonPos - bufAbsoluteStart);
                     name = attributeName[attributeCount] = newString(buf, colonPos - bufAbsoluteStart + 1, nameLen);
                     // pos - 1 - (colonPos + 1 - bufAbsoluteStart));
 
                     // name.substring(0, colonPos-nameStart);
                 } else {
                     prefix = attributePrefix[attributeCount] = null;
                     name = attributeName[attributeCount] =
                             newString(buf, nameStart - bufAbsoluteStart, pos - 1 - (nameStart - bufAbsoluteStart));
                 }
                 if (!allStringsInterned) {
                     attributeNameHash[attributeCount] = name.hashCode();
                 }
             }
 
         } else {
             // retrieve name
             name = attributeName[attributeCount] =
                     newString(buf, nameStart - bufAbsoluteStart, pos - 1 - (nameStart - bufAbsoluteStart));
             //// assert name != null;
             if (!allStringsInterned) {
                 attributeNameHash[attributeCount] = name.hashCode();
             }
         }
 
         // [25] Eq ::= S? '=' S?
         while (isS(ch)) {
             ch = more();
         } // skip additional spaces
         if (ch != '=') throw new XmlPullParserException("expected = after attribute name", this, null);
         ch = more();
         while (isS(ch)) {
             ch = more();
         } // skip additional spaces
 
         // [10] AttValue ::= '"' ([^<&"] | Reference)* '"'
         // | "'" ([^<&'] | Reference)* "'"
         final char delimit = ch;
         if (delimit != '"' && delimit != '\'')
             throw new XmlPullParserException(
                     "attribute value must start with quotation or apostrophe not " + printable(delimit), this, null);
         // parse until delimit or < and resolve Reference
         // [67] Reference ::= EntityRef | CharRef
         // int valueStart = pos + bufAbsoluteStart;
 
         boolean normalizedCR = false;
         usePC = false;
         pcStart = pcEnd;
         posStart = pos;
 
         while (true) {
             ch = more();
             if (ch == delimit) {
                 break;
             }
             if (ch == '<') {
                 throw new XmlPullParserException("markup not allowed inside attribute value - illegal < ", this, null);
             }
             if (ch == '&') {
                 extractEntityRef();
             } else if (ch == '\t' || ch == '\n' || ch == '\r') {
                 // do attribute value normalization
                 // as described in http://www.w3.org/TR/REC-xml#AVNormalize
                 // TODO add test for it form spec ...
                 // handle EOL normalization ...
                 if (!usePC) {
                     posEnd = pos - 1;
                     if (posEnd > posStart) {
                         joinPC();
                     } else {
                         usePC = true;
                         pcEnd = pcStart = 0;
                     }
                 }
                 // assert usePC == true;
                 if (pcEnd >= pc.length) ensurePC(pcEnd);
                 if (ch != '\n' || !normalizedCR) {
                     pc[pcEnd++] = ' '; // '\n';
                 }
 
             } else {
                 if (usePC) {
                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                     pc[pcEnd++] = ch;
                 }
             }
             normalizedCR = ch == '\r';
         }
 
         if (processNamespaces && startsWithXmlns) {
             String ns = null;
             if (!usePC) {
                 ns = newStringIntern(buf, posStart, pos - 1 - posStart);
             } else {
                 ns = newStringIntern(pc, pcStart, pcEnd - pcStart);
             }
             ensureNamespacesCapacity(namespaceEnd);
             int prefixHash = -1;
             if (colonPos != -1) {
                 if (ns.length() == 0) {
                     throw new XmlPullParserException(
                             "non-default namespace can not be declared to be empty string", this, null);
                 }
                 // declare new namespace
                 namespacePrefix[namespaceEnd] = name;
                 if (!allStringsInterned) {
                     prefixHash = namespacePrefixHash[namespaceEnd] = name.hashCode();
                 }
             } else {
                 // declare new default namespace...
                 namespacePrefix[namespaceEnd] = null; // ""; //null; //TODO check FIXME Alek
                 if (!allStringsInterned) {
                     prefixHash = namespacePrefixHash[namespaceEnd] = -1;
                 }
             }
             namespaceUri[namespaceEnd] = ns;
 
             // detect duplicate namespace declarations!!!
             final int startNs = elNamespaceCount[depth - 1];
             for (int i = namespaceEnd - 1; i >= startNs; --i) {
                 if (((allStringsInterned || name == null) && namespacePrefix[i] == name)
                         || (!allStringsInterned
                                 && name != null
                                 && namespacePrefixHash[i] == prefixHash
                                 && name.equals(namespacePrefix[i]))) {
                     final String s = name == null ? "default" : "'" + name + "'";
                     throw new XmlPullParserException(
                             "duplicated namespace declaration for " + s + " prefix", this, null);
                 }
             }
 
             ++namespaceEnd;
 
         } else {
             if (!usePC) {
                 attributeValue[attributeCount] = new String(buf, posStart, pos - 1 - posStart);
             } else {
                 attributeValue[attributeCount] = new String(pc, pcStart, pcEnd - pcStart);
             }
             ++attributeCount;
         }
         posStart = prevPosStart - bufAbsoluteStart;
         return ch;
     }
 
     // state representing that no entity ref have been resolved
     private static final char[] BUF_NOT_RESOLVED = new char[0];
 
     // predefined entity refs
     private static final char[] BUF_LT = new char[] {'<'};
     private static final char[] BUF_AMP = new char[] {'&'};
     private static final char[] BUF_GT = new char[] {'>'};
     private static final char[] BUF_APO = new char[] {'\''};
     private static final char[] BUF_QUOT = new char[] {'"'};
 
     private char[] resolvedEntityRefCharBuf = BUF_NOT_RESOLVED;
 
     /**
      * parse Entity Ref, either a character entity or one of the predefined name entities.
      *
      * @return the length of the valid found character reference, which may be one of the predefined character reference
      *         names (resolvedEntityRefCharBuf contains the replaced chars). Returns the length of the not found entity
      *         name, otherwise.
      * @throws XmlPullParserException if invalid XML is detected.
      * @throws IOException if an I/O error is found.
      */
     private int parseCharOrPredefinedEntityRef() throws XmlPullParserException, IOException {
         // entity reference http://www.w3.org/TR/2000/REC-xml-20001006#NT-Reference
         // [67] Reference ::= EntityRef | CharRef
 
         // ASSUMPTION just after &
         entityRefName = null;
         posStart = pos;
         int len = 0;
         resolvedEntityRefCharBuf = BUF_NOT_RESOLVED;
         char ch = more();
         if (ch == '#') {
             // parse character reference
 
             char charRef = 0;
             ch = more();
             StringBuilder sb = new StringBuilder();
             boolean isHex = (ch == 'x');
 
             if (isHex) {
                 // encoded in hex
                 while (true) {
                     ch = more();
                     if (ch >= '0' && ch <= '9') {
                         charRef = (char) (charRef * 16 + (ch - '0'));
                         sb.append(ch);
                     } else if (ch >= 'a' && ch <= 'f') {
                         charRef = (char) (charRef * 16 + (ch - ('a' - 10)));
                         sb.append(ch);
                     } else if (ch >= 'A' && ch <= 'F') {
                         charRef = (char) (charRef * 16 + (ch - ('A' - 10)));
                         sb.append(ch);
                     } else if (ch == ';') {
                         break;
                     } else {
                         throw new XmlPullParserException(
                                 "character reference (with hex value) may not contain " + printable(ch), this, null);
                     }
                 }
             } else {
                 // encoded in decimal
                 while (true) {
                     if (ch >= '0' && ch <= '9') {
                         charRef = (char) (charRef * 10 + (ch - '0'));
                         sb.append(ch);
                     } else if (ch == ';') {
                         break;
                     } else {
                         throw new XmlPullParserException(
                                 "character reference (with decimal value) may not contain " + printable(ch),
                                 this,
                                 null);
                     }
                     ch = more();
                 }
             }
 
             boolean isValidCodePoint = true;
             try {
                 int codePoint = Integer.parseInt(sb.toString(), isHex ? 16 : 10);
                 isValidCodePoint = isValidCodePoint(codePoint);
                 if (isValidCodePoint) {
                     resolvedEntityRefCharBuf = Character.toChars(codePoint);
                 }
             } catch (IllegalArgumentException e) {
                 isValidCodePoint = false;
             }
 
             if (!isValidCodePoint) {
                 throw new XmlPullParserException(
                         "character reference (with " + (isHex ? "hex" : "decimal") + " value " + sb.toString()
                                 + ") is invalid",
                         this,
                         null);
             }
 
             if (tokenize) {
                 text = newString(resolvedEntityRefCharBuf, 0, resolvedEntityRefCharBuf.length);
             }
             len = resolvedEntityRefCharBuf.length;
         } else {
             // [68] EntityRef ::= '&' Name ';'
             // scan name until ;
             if (!isNameStartChar(ch)) {
                 throw new XmlPullParserException(
                         "entity reference names can not start with character '" + printable(ch) + "'", this, null);
             }
             while (true) {
                 ch = more();
                 if (ch == ';') {
                     break;
                 }
                 if (!isNameChar(ch)) {
                     throw new XmlPullParserException(
                             "entity reference name can not contain character " + printable(ch) + "'", this, null);
                 }
             }
             // determine what name maps to
             len = (pos - 1) - posStart;
             if (len == 2 && buf[posStart] == 'l' && buf[posStart + 1] == 't') {
                 if (tokenize) {
                     text = "<";
                 }
                 resolvedEntityRefCharBuf = BUF_LT;
                 // if(paramPC || isParserTokenizing) {
                 // if(pcEnd >= pc.length) ensurePC();
                 // pc[pcEnd++] = '<';
                 // }
             } else if (len == 3 && buf[posStart] == 'a' && buf[posStart + 1] == 'm' && buf[posStart + 2] == 'p') {
                 if (tokenize) {
                     text = "&";
                 }
                 resolvedEntityRefCharBuf = BUF_AMP;
             } else if (len == 2 && buf[posStart] == 'g' && buf[posStart + 1] == 't') {
                 if (tokenize) {
                     text = ">";
                 }
                 resolvedEntityRefCharBuf = BUF_GT;
             } else if (len == 4
                     && buf[posStart] == 'a'
                     && buf[posStart + 1] == 'p'
                     && buf[posStart + 2] == 'o'
                     && buf[posStart + 3] == 's') {
                 if (tokenize) {
                     text = "'";
                 }
                 resolvedEntityRefCharBuf = BUF_APO;
             } else if (len == 4
                     && buf[posStart] == 'q'
                     && buf[posStart + 1] == 'u'
                     && buf[posStart + 2] == 'o'
                     && buf[posStart + 3] == 't') {
                 if (tokenize) {
                     text = "\"";
                 }
                 resolvedEntityRefCharBuf = BUF_QUOT;
             }
         }
 
         posEnd = pos;
 
         return len;
     }
 
     /**
      * Parse an entity reference inside the DOCDECL section.
      *
      * @throws XmlPullParserException if invalid XML is detected.
      * @throws IOException if an I/O error is found.
      */
     private void parseEntityRefInDocDecl() throws XmlPullParserException, IOException {
         parseCharOrPredefinedEntityRef();
         if (usePC) {
             posStart--; // include in PC the starting '&' of the entity
             joinPC();
         }
 
         if (resolvedEntityRefCharBuf != BUF_NOT_RESOLVED) return;
         if (tokenize) text = null;
     }
 
     /**
      * Parse an entity reference inside a tag or attribute.
      *
      * @throws XmlPullParserException if invalid XML is detected.
      * @throws IOException if an I/O error is found.
      */
     private void parseEntityRef() throws XmlPullParserException, IOException {
         final int len = parseCharOrPredefinedEntityRef();
 
         posEnd--; // don't involve the final ';' from the entity in the search
 
         if (resolvedEntityRefCharBuf != BUF_NOT_RESOLVED) {
             return;
         }
 
         resolvedEntityRefCharBuf = lookuEntityReplacement(len);
         if (resolvedEntityRefCharBuf != BUF_NOT_RESOLVED) {
             return;
         }
         if (tokenize) text = null;
     }
 
     /**
      * Check if the provided parameter is a valid Char. According to
      * <a href="https://www.w3.org/TR/REC-xml/#NT-Char">https://www.w3.org/TR/REC-xml/#NT-Char</a>
      *
      * @param codePoint the numeric value to check
      * @return true if it is a valid numeric character reference. False otherwise.
      */
     private static boolean isValidCodePoint(int codePoint) {
         // Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
         return codePoint == 0x9
                 || codePoint == 0xA
                 || codePoint == 0xD
                 || (0x20 <= codePoint && codePoint <= 0xD7FF)
                 || (0xE000 <= codePoint && codePoint <= 0xFFFD)
                 || (0x10000 <= codePoint && codePoint <= 0x10FFFF);
     }
 
     private char[] lookuEntityReplacement(int entityNameLen) {
         if (!allStringsInterned) {
             final int hash = fastHash(buf, posStart, posEnd - posStart);
             LOOP:
             for (int i = entityEnd - 1; i >= 0; --i) {
                 if (hash == entityNameHash[i] && entityNameLen == entityNameBuf[i].length) {
                     final char[] entityBuf = entityNameBuf[i];
                     for (int j = 0; j < entityNameLen; j++) {
                         if (buf[posStart + j] != entityBuf[j]) continue LOOP;
                     }
                     if (tokenize) text = entityReplacement[i];
                     return entityReplacementBuf[i];
                 }
             }
         } else {
             entityRefName = newString(buf, posStart, posEnd - posStart);
             for (int i = entityEnd - 1; i >= 0; --i) {
                 // take advantage that interning for newString is enforced
                 if (entityRefName == entityName[i]) {
                     if (tokenize) text = entityReplacement[i];
                     return entityReplacementBuf[i];
                 }
             }
         }
         return BUF_NOT_RESOLVED;
     }
 
     private void parseComment() throws XmlPullParserException, IOException {
         // implements XML 1.0 Section 2.5 Comments
 
         // ASSUMPTION: seen <!-
         char cch = more();
         if (cch != '-') throw new XmlPullParserException("expected <!-- for comment start", this, null);
         if (tokenize) posStart = pos;
 
         final int curLine = lineNumber;
         final int curColumn = columnNumber - 4;
         try {
             final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
             boolean normalizedCR = false;
 
             boolean seenDash = false;
             boolean seenDashDash = false;
             while (true) {
                 // scan until it hits -->
                 cch = more();
                 int ch;
                 char cch2;
                 if (Character.isHighSurrogate(cch)) {
                     cch2 = more();
                     ch = Character.toCodePoint(cch, cch2);
                 } else {
                     cch2 = 0;
                     ch = cch;
                 }
                 if (seenDashDash && ch != '>') {
                     throw new XmlPullParserException(
                             "in comment after two dashes (--) next character must be >" + " not " + printable(ch),
                             this,
                             null);
                 }
                 if (ch == '-') {
                     if (!seenDash) {
                         seenDash = true;
                     } else {
                         seenDashDash = true;
                     }
                 } else if (ch == '>') {
                     if (seenDashDash) {
                         break; // found end sequence!!!!
                     }
                     seenDash = false;
                 } else if (isValidCodePoint(ch)) {
                     seenDash = false;
                 } else {
                     throw new XmlPullParserException(
                             "Illegal character 0x" + Integer.toHexString(ch) + " found in comment", this, null);
                 }
                 if (normalizeIgnorableWS) {
                     if (ch == '\r') {
                         normalizedCR = true;
                         // posEnd = pos -1;
                         // joinPC();
                         // posEnd is alreadys set
                         if (!usePC) {
                             posEnd = pos - 1;
                             if (posEnd > posStart) {
                                 joinPC();
                             } else {
                                 usePC = true;
                                 pcStart = pcEnd = 0;
                             }
                         }
                         // assert usePC == true;
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = '\n';
                     } else if (ch == '\n') {
                         if (!normalizedCR && usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = '\n';
                         }
                         normalizedCR = false;
                     } else {
                         if (usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = cch;
                             if (cch2 != 0) {
                                 pc[pcEnd++] = cch2;
                             }
                         }
                         normalizedCR = false;
                     }
                 }
             }
 
         } catch (EOFException ex) {
             // detect EOF and create meaningful error ...
             throw new XmlPullParserException(
                     "comment started on line " + curLine + " and column " + curColumn + " was not closed", this, ex);
         }
         if (tokenize) {
             posEnd = pos - 3;
             if (usePC) {
                 pcEnd -= 2;
             }
         }
     }
 
     private boolean parsePI() throws XmlPullParserException, IOException {
         // implements XML 1.0 Section 2.6 Processing Instructions
 
         // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
         // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
         // ASSUMPTION: seen <?
         if (tokenize) posStart = pos;
         final int curLine = lineNumber;
         final int curColumn = columnNumber - 2;
         int piTargetStart = pos;
         int piTargetEnd = -1;
         final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
         boolean normalizedCR = false;
 
         try {
             boolean seenPITarget = false;
             boolean seenInnerTag = false;
             boolean seenQ = false;
             char ch = more();
             if (isS(ch)) {
                 throw new XmlPullParserException(
                         "processing instruction PITarget must be exactly after <? and not white space character",
                         this,
                         null);
             }
             while (true) {
                 // scan until it hits ?>
                 // ch = more();
 
                 if (ch == '?') {
                     if (!seenPITarget) {
                         throw new XmlPullParserException("processing instruction PITarget name not found", this, null);
                     }
                     seenQ = true;
                 } else if (ch == '>') {
                     if (seenQ) {
                         break; // found end sequence!!!!
                     }
 
                     if (!seenPITarget) {
                         throw new XmlPullParserException("processing instruction PITarget name not found", this, null);
                     } else if (!seenInnerTag) {
                         // seenPITarget && !seenQ
                         throw new XmlPullParserException(
                                 "processing instruction started on line " + curLine + " and column " + curColumn
                                         + " was not closed",
                                 this,
                                 null);
                     } else {
                         seenInnerTag = false;
                     }
                 } else if (ch == '<') {
                     seenInnerTag = true;
                 } else {
                     if (piTargetEnd == -1 && isS(ch)) {
                         piTargetEnd = pos - 1;
 
                         // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
                         if ((piTargetEnd - piTargetStart) >= 3) {
                             if ((buf[piTargetStart] == 'x' || buf[piTargetStart] == 'X')
                                     && (buf[piTargetStart + 1] == 'm' || buf[piTargetStart + 1] == 'M')
                                     && (buf[piTargetStart + 2] == 'l' || buf[piTargetStart + 2] == 'L')) {
                                 if (piTargetStart > 3) { // <?xml is allowed as first characters in input ...
                                     throw new XmlPullParserException(
                                             "processing instruction can not have PITarget with reserved xml name",
                                             this,
                                             null);
                                 } else {
                                     if (buf[piTargetStart] != 'x'
                                             && buf[piTargetStart + 1] != 'm'
                                             && buf[piTargetStart + 2] != 'l') {
                                         throw new XmlPullParserException(
                                                 "XMLDecl must have xml name in lowercase", this, null);
                                     }
                                 }
                                 parseXmlDecl(ch);
                                 if (tokenize) posEnd = pos - 2;
                                 final int off = piTargetStart + 3;
                                 final int len = pos - 2 - off;
                                 xmlDeclContent = newString(buf, off, len);
                                 return false;
                             }
                         }
                     }
 
                     seenQ = false;
                 }
                 if (normalizeIgnorableWS) {
                     if (ch == '\r') {
                         normalizedCR = true;
                         // posEnd = pos -1;
                         // joinPC();
                         // posEnd is alreadys set
                         if (!usePC) {
                             posEnd = pos - 1;
                             if (posEnd > posStart) {
                                 joinPC();
                             } else {
                                 usePC = true;
                                 pcStart = pcEnd = 0;
                             }
                         }
                         // assert usePC == true;
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = '\n';
                     } else if (ch == '\n') {
                         if (!normalizedCR && usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = '\n';
                         }
                         normalizedCR = false;
                     } else {
                         if (usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = ch;
                         }
                         normalizedCR = false;
                     }
                 }
                 seenPITarget = true;
                 ch = more();
             }
         } catch (EOFException ex) {
             // detect EOF and create meaningful error ...
             throw new XmlPullParserException(
                     "processing instruction started on line " + curLine + " and column " + curColumn
                             + " was not closed",
                     this,
                     ex);
         }
         if (piTargetEnd == -1) {
             piTargetEnd = pos - 2 + bufAbsoluteStart;
             // throw new XmlPullParserException(
             // "processing instruction must have PITarget name", this, null);
         }
         if (tokenize) {
             posEnd = pos - 2;
             if (normalizeIgnorableWS) {
                 --pcEnd;
             }
         }
         return true;
     }
 
     // protected final static char[] VERSION = {'v','e','r','s','i','o','n'};
     // protected final static char[] NCODING = {'n','c','o','d','i','n','g'};
     // protected final static char[] TANDALONE = {'t','a','n','d','a','l','o','n','e'};
     // protected final static char[] YES = {'y','e','s'};
     // protected final static char[] NO = {'n','o'};
 
     private static final char[] VERSION = "version".toCharArray();
 
     private static final char[] NCODING = "ncoding".toCharArray();
 
     private static final char[] TANDALONE = "tandalone".toCharArray();
 
     private static final char[] YES = "yes".toCharArray();
 
     private static final char[] NO = "no".toCharArray();
 
     private void parseXmlDecl(char ch) throws XmlPullParserException, IOException {
         // [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
 
         // first make sure that relative positions will stay OK
         preventBufferCompaction = true;
         bufStart = 0; // necessary to keep pos unchanged during expansion!
 
         // --- parse VersionInfo
 
         // [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
         // parse is positioned just on first S past <?xml
         ch = skipS(ch);
         ch = requireInput(ch, VERSION);
         // [25] Eq ::= S? '=' S?
         ch = skipS(ch);
         if (ch != '=') {
             throw new XmlPullParserException(
                     "expected equals sign (=) after version and not " + printable(ch), this, null);
         }
         ch = more();
         ch = skipS(ch);
         if (ch != '\'' && ch != '"') {
             throw new XmlPullParserException(
                     "expected apostrophe (') or quotation mark (\") after version and not " + printable(ch),
                     this,
                     null);
         }
         final char quotChar = ch;
         // int versionStart = pos + bufAbsoluteStart; // required if preventBufferCompaction==false
         final int versionStart = pos;
         ch = more();
         // [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+
         while (ch != quotChar) {
             if ((ch < 'a' || ch > 'z')
                     && (ch < 'A' || ch > 'Z')
                     && (ch < '0' || ch > '9')
                     && ch != '_'
                     && ch != '.'
                     && ch != ':'
                     && ch != '-') {
                 throw new XmlPullParserException(
                         "<?xml version value expected to be in ([a-zA-Z0-9_.:] | '-')" + " not " + printable(ch),
                         this,
                         null);
             }
             ch = more();
         }
         final int versionEnd = pos - 1;
         parseXmlDeclWithVersion(versionStart, versionEnd);
         preventBufferCompaction = false; // allow again buffer compaction - pos MAY change
     }
     // private String xmlDeclVersion;
 
     private void parseXmlDeclWithVersion(int versionStart, int versionEnd) throws XmlPullParserException, IOException {
         // check version is "1.0"
         if ((versionEnd - versionStart != 3)
                 || buf[versionStart] != '1'
                 || buf[versionStart + 1] != '.'
                 || buf[versionStart + 2] != '0') {
             throw new XmlPullParserException(
                     "only 1.0 is supported as <?xml version not '"
                             + printable(new String(buf, versionStart, versionEnd - versionStart)) + "'",
                     this,
                     null);
         }
         xmlDeclVersion = newString(buf, versionStart, versionEnd - versionStart);
 
         String lastParsedAttr = "version";
 
         // [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" )
         char ch = more();
         char prevCh = ch;
         ch = skipS(ch);
 
         if (ch != 'e' && ch != 's' && ch != '?' && ch != '>') {
             throw new XmlPullParserException("unexpected character " + printable(ch), this, null);
         }
 
         if (ch == 'e') {
             if (!isS(prevCh)) {
                 throw new XmlPullParserException(
                         "expected a space after " + lastParsedAttr + " and not " + printable(ch), this, null);
             }
             ch = more();
             ch = requireInput(ch, NCODING);
             ch = skipS(ch);
             if (ch != '=') {
                 throw new XmlPullParserException(
                         "expected equals sign (=) after encoding and not " + printable(ch), this, null);
             }
             ch = more();
             ch = skipS(ch);
             if (ch != '\'' && ch != '"') {
                 throw new XmlPullParserException(
                         "expected apostrophe (') or quotation mark (\") after encoding and not " + printable(ch),
                         this,
                         null);
             }
             final char quotChar = ch;
             final int encodingStart = pos;
             ch = more();
             // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
             if ((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z')) {
                 throw new XmlPullParserException(
                         "<?xml encoding name expected to start with [A-Za-z]" + " not " + printable(ch), this, null);
             }
             ch = more();
             while (ch != quotChar) {
                 if ((ch < 'a' || ch > 'z')
                         && (ch < 'A' || ch > 'Z')
                         && (ch < '0' || ch > '9')
                         && ch != '.'
                         && ch != '_'
                         && ch != '-') {
                     throw new XmlPullParserException(
                             "<?xml encoding value expected to be in ([A-Za-z0-9._] | '-')" + " not " + printable(ch),
                             this,
                             null);
                 }
                 ch = more();
             }
             final int encodingEnd = pos - 1;
 
             // TODO reconcile with setInput encodingName
             inputEncoding = newString(buf, encodingStart, encodingEnd - encodingStart);
 
             if ("UTF8".equals(fileEncoding) && inputEncoding.toUpperCase().startsWith("ISO-")) {
                 throw new XmlPullParserException(
                         "UTF-8 BOM plus xml decl of " + inputEncoding + " is incompatible", this, null);
             } else if ("UTF-16".equals(fileEncoding) && inputEncoding.equalsIgnoreCase("UTF-8")) {
                 throw new XmlPullParserException(
                         "UTF-16 BOM plus xml decl of " + inputEncoding + " is incompatible", this, null);
             }
 
             lastParsedAttr = "encoding";
 
             ch = more();
             prevCh = ch;
             ch = skipS(ch);
         }
 
         // [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
         if (ch == 's') {
             if (!isS(prevCh)) {
                 throw new XmlPullParserException(
                         "expected a space after " + lastParsedAttr + " and not " + printable(ch), this, null);
             }
 
             ch = more();
             ch = requireInput(ch, TANDALONE);
             ch = skipS(ch);
             if (ch != '=') {
                 throw new XmlPullParserException(
                         "expected equals sign (=) after standalone and not " + printable(ch), this, null);
             }
             ch = more();
             ch = skipS(ch);
             if (ch != '\'' && ch != '"') {
                 throw new XmlPullParserException(
                         "expected apostrophe (') or quotation mark (\") after standalone and not " + printable(ch),
                         this,
                         null);
             }
             char quotChar = ch;
             ch = more();
             if (ch == 'y') {
                 ch = requireInput(ch, YES);
                 // Boolean standalone = new Boolean(true);
                 xmlDeclStandalone = true;
             } else if (ch == 'n') {
                 ch = requireInput(ch, NO);
                 // Boolean standalone = new Boolean(false);
                 xmlDeclStandalone = false;
             } else {
                 throw new XmlPullParserException(
                         "expected 'yes' or 'no' after standalone and not " + printable(ch), this, null);
             }
             if (ch != quotChar) {
                 throw new XmlPullParserException(
                         "expected " + quotChar + " after standalone value not " + printable(ch), this, null);
             }
             ch = more();
             ch = skipS(ch);
         }
 
         if (ch != '?') {
             throw new XmlPullParserException("expected ?> as last part of <?xml not " + printable(ch), this, null);
         }
         ch = more();
         if (ch != '>') {
             throw new XmlPullParserException("expected ?> as last part of <?xml not " + printable(ch), this, null);
         }
     }
 
     private void parseDocdecl() throws XmlPullParserException, IOException {
         // ASSUMPTION: seen <!D
         char ch = more();
         if (ch != 'O') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         ch = more();
         if (ch != 'C') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         ch = more();
         if (ch != 'T') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         ch = more();
         if (ch != 'Y') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         ch = more();
         if (ch != 'P') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         ch = more();
         if (ch != 'E') throw new XmlPullParserException("expected <!DOCTYPE", this, null);
         posStart = pos;
         // do simple and crude scanning for end of doctype
 
         // [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('['
         // (markupdecl | DeclSep)* ']' S?)? '>'
         int bracketLevel = 0;
         final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
         boolean normalizedCR = false;
         while (true) {
             ch = more();
             if (ch == '[') ++bracketLevel;
             else if (ch == ']') --bracketLevel;
             else if (ch == '>' && bracketLevel == 0) break;
             else if (ch == '&') {
                 extractEntityRefInDocDecl();
                 continue;
             }
             if (normalizeIgnorableWS) {
                 if (ch == '\r') {
                     normalizedCR = true;
                     // posEnd = pos -1;
                     // joinPC();
                     // posEnd is alreadys set
                     if (!usePC) {
                         posEnd = pos - 1;
                         if (posEnd > posStart) {
                             joinPC();
                         } else {
                             usePC = true;
                             pcStart = pcEnd = 0;
                         }
                     }
                     // assert usePC == true;
                     if (pcEnd >= pc.length) ensurePC(pcEnd);
                     pc[pcEnd++] = '\n';
                 } else if (ch == '\n') {
                     if (!normalizedCR && usePC) {
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = '\n';
                     }
                     normalizedCR = false;
                 } else {
                     if (usePC) {
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = ch;
                     }
                     normalizedCR = false;
                 }
             }
         }
         posEnd = pos - 1;
         text = null;
     }
 
     private void extractEntityRefInDocDecl() throws XmlPullParserException, IOException {
         // extractEntityRef
         posEnd = pos - 1;
 
         int prevPosStart = posStart;
         parseEntityRefInDocDecl();
 
         posStart = prevPosStart;
     }
 
     private void extractEntityRef() throws XmlPullParserException, IOException {
         // extractEntityRef
         posEnd = pos - 1;
         if (!usePC) {
             final boolean hadCharData = posEnd > posStart;
             if (hadCharData) {
                 // posEnd is already set correctly!!!
                 joinPC();
             } else {
                 usePC = true;
                 pcStart = pcEnd = 0;
             }
         }
         // assert usePC == true;
 
         parseEntityRef();
         // check if replacement text can be resolved !!!
         if (resolvedEntityRefCharBuf == BUF_NOT_RESOLVED) {
             if (entityRefName == null) {
                 entityRefName = newString(buf, posStart, posEnd - posStart);
             }
             throw new XmlPullParserException(
                     "could not resolve entity named '" + printable(entityRefName) + "'", this, null);
         }
         // write into PC replacement text - do merge for replacement text!!!!
         for (char aResolvedEntity : resolvedEntityRefCharBuf) {
             if (pcEnd >= pc.length) {
                 ensurePC(pcEnd);
             }
             pc[pcEnd++] = aResolvedEntity;
         }
     }
 
     private void parseCDSect(boolean hadCharData) throws XmlPullParserException, IOException {
         // implements XML 1.0 Section 2.7 CDATA Sections
 
         // [18] CDSect ::= CDStart CData CDEnd
         // [19] CDStart ::= '<![CDATA['
         // [20] CData ::= (Char* - (Char* ']]>' Char*))
         // [21] CDEnd ::= ']]>'
 
         // ASSUMPTION: seen <![
         char ch = more();
         if (ch != 'C') throw new XmlPullParserException("expected <[CDATA[ for comment start", this, null);
         ch = more();
         if (ch != 'D') throw new XmlPullParserException("expected <[CDATA[ for comment start", this, null);
         ch = more();
         if (ch != 'A') throw new XmlPullParserException("expected <[CDATA[ for comment start", this, null);
         ch = more();
         if (ch != 'T') throw new XmlPullParserException("expected <[CDATA[ for comment start", this, null);
         ch = more();
         if (ch != 'A') throw new XmlPullParserException("expected <[CDATA[ for comment start", this, null);
         ch = more();
         if (ch != '[') throw new XmlPullParserException("expected <![CDATA[ for comment start", this, null);
 
         // if(tokenize) {
         final int cdStart = pos + bufAbsoluteStart;
         final int curLine = lineNumber;
         final int curColumn = columnNumber;
         final boolean normalizeInput = !tokenize || !roundtripSupported;
         try {
             if (normalizeInput) {
                 if (hadCharData) {
                     if (!usePC) {
                         // posEnd is correct already!!!
                         if (posEnd > posStart) {
                             joinPC();
                         } else {
                             usePC = true;
                             pcStart = pcEnd = 0;
                         }
                     }
                 }
             }
             boolean seenBracket = false;
             boolean seenBracketBracket = false;
             boolean normalizedCR = false;
             while (true) {
                 // scan until it hits "]]>"
                 ch = more();
                 if (ch == ']') {
                     if (!seenBracket) {
                         seenBracket = true;
                     } else {
                         seenBracketBracket = true;
                         // seenBracket = false;
                     }
                 } else if (ch == '>') {
                     if (seenBracket && seenBracketBracket) {
                         break; // found end sequence!!!!
                     } else {
                         seenBracketBracket = false;
                     }
                     seenBracket = false;
                 } else {
                     if (seenBracket) {
                         seenBracket = false;
                     }
                 }
                 if (normalizeInput) {
                     // deal with normalization issues ...
                     if (ch == '\r') {
                         normalizedCR = true;
                         posStart = cdStart - bufAbsoluteStart;
                         posEnd = pos - 1; // posEnd is alreadys set
                         if (!usePC) {
                             if (posEnd > posStart) {
                                 joinPC();
                             } else {
                                 usePC = true;
                                 pcStart = pcEnd = 0;
                             }
                         }
                         // assert usePC == true;
                         if (pcEnd >= pc.length) ensurePC(pcEnd);
                         pc[pcEnd++] = '\n';
                     } else if (ch == '\n') {
                         if (!normalizedCR && usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = '\n';
                         }
                         normalizedCR = false;
                     } else {
                         if (usePC) {
                             if (pcEnd >= pc.length) ensurePC(pcEnd);
                             pc[pcEnd++] = ch;
                         }
                         normalizedCR = false;
                     }
                 }
             }
         } catch (EOFException ex) {
             // detect EOF and create meaningful error ...
             throw new XmlPullParserException(
                     "CDATA section started on line " + curLine + " and column " + curColumn + " was not closed",
                     this,
                     ex);
         }
         if (normalizeInput) {
             if (usePC) {
                 pcEnd = pcEnd - 2;
             }
         }
         posStart = cdStart - bufAbsoluteStart;
         posEnd = pos - 3;
     }
 
     private void fillBuf() throws IOException, XmlPullParserException {
         if (reader == null) throw new XmlPullParserException("reader must be set before parsing is started");
 
         // see if we are in compaction area
         if (bufEnd > bufSoftLimit) {
 
             // check if we need to compact or expand the buffer
             boolean compact = !preventBufferCompaction && (bufStart > bufSoftLimit || bufStart >= buf.length / 2);
 
             // if buffer almost full then compact it
             if (compact) {
                 // TODO: look on trashing
                 // //assert bufStart > 0
                 System.arraycopy(buf, bufStart, buf, 0, bufEnd - bufStart);
                 if (TRACE_SIZING)
                     System.out.println("TRACE_SIZING fillBuf() compacting " + bufStart + " bufEnd=" + bufEnd + " pos="
                             + pos + " posStart=" + posStart + " posEnd=" + posEnd + " buf first 100 chars:"
                             + new String(buf, bufStart, Math.min(bufEnd - bufStart, 100)));
 
             } else {
                 final int newSize = 2 * buf.length;
                 final char[] newBuf = new char[newSize];
                 if (TRACE_SIZING) System.out.println("TRACE_SIZING fillBuf() " + buf.length + " => " + newSize);
                 System.arraycopy(buf, bufStart, newBuf, 0, bufEnd - bufStart);
                 buf = newBuf;
                 if (bufLoadFactor > 0) {
                     // Include a fix for
                     // https://web.archive.org/web/20070831191548/http://www.extreme.indiana.edu/bugzilla/show_bug.cgi?id=228
                     bufSoftLimit = (int) (bufferLoadFactor * buf.length);
                 }
             }
             bufEnd -= bufStart;
             pos -= bufStart;
             posStart -= bufStart;
             posEnd -= bufStart;
             bufAbsoluteStart += bufStart;
             bufStart = 0;
             if (TRACE_SIZING)
                 System.out.println("TRACE_SIZING fillBuf() after bufEnd=" + bufEnd + " pos=" + pos + " posStart="
                         + posStart + " posEnd=" + posEnd + " buf first 100 chars:"
                         + new String(buf, 0, Math.min(bufEnd, 100)));
         }
         // at least one character must be read or error
         final int len = Math.min(buf.length - bufEnd, READ_CHUNK_SIZE);
         final int ret = reader.read(buf, bufEnd, len);
         if (ret > 0) {
             bufEnd += ret;
             if (TRACE_SIZING)
                 System.out.println("TRACE_SIZING fillBuf() after filling in buffer" + " buf first 100 chars:"
                         + new String(buf, 0, Math.min(bufEnd, 100)));
 
             return;
         }
         if (ret == -1) {
             if (bufAbsoluteStart == 0 && pos == 0) {
                 throw new EOFException("input contained no data");
             } else {
                 if (seenRoot && depth == 0) { // inside parsing epilog!!!
                     reachedEnd = true;
                     return;
                 } else {
                     StringBuilder expectedTagStack = new StringBuilder();
                     if (depth > 0) {
                         if (elRawName == null || elRawName[depth] == null) {
                             String tagName = new String(buf, posStart + 1, pos - posStart - 1);
                             expectedTagStack
                                     .append(" - expected the opening tag <")
                                     .append(tagName)
                                     .append("...>");
                         } else {
                             // final char[] cbuf = elRawName[depth];
                             // final String startname = new String(cbuf, 0, elRawNameEnd[depth]);
                             expectedTagStack.append(" - expected end tag");
                             if (depth > 1) {
                                 expectedTagStack.append("s"); // more than one end tag
                             }
                             expectedTagStack.append(" ");
 
                             for (int i = depth; i > 0; i--) {
                                 if (elRawName == null || elRawName[i] == null) {
                                     String tagName = new String(buf, posStart + 1, pos - posStart - 1);
                                     expectedTagStack
                                             .append(" - expected the opening tag <")
                                             .append(tagName)
                                             .append("...>");
                                 } else {
                                     String tagName = new String(elRawName[i], 0, elRawNameEnd[i]);
                                     expectedTagStack
                                             .append("</")
                                             .append(tagName)
                                             .append('>');
                                 }
                             }
                             expectedTagStack.append(" to close");
                             for (int i = depth; i > 0; i--) {
                                 if (i != depth) {
                                     expectedTagStack.append(" and"); // more than one end tag
                                 }
                                 if (elRawName == null || elRawName[i] == null) {
                                     String tagName = new String(buf, posStart + 1, pos - posStart - 1);
                                     expectedTagStack
                                             .append(" start tag <")
                                             .append(tagName)
                                             .append(">");
                                     expectedTagStack.append(" from line ").append(elRawNameLine[i]);
                                 } else {
                                     String tagName = new String(elRawName[i], 0, elRawNameEnd[i]);
                                     expectedTagStack
                                             .append(" start tag <")
                                             .append(tagName)
                                             .append(">");
                                     expectedTagStack.append(" from line ").append(elRawNameLine[i]);
                                 }
                             }
                             expectedTagStack.append(", parser stopped on");
                         }
                     }
                     throw new EOFException(
                             "no more data available" + expectedTagStack.toString() + getPositionDescription());
                 }
             }
         } else {
             throw new IOException("error reading input, returned " + ret);
         }
     }
 
     private char more() throws IOException, XmlPullParserException {
         if (pos >= bufEnd) {
             fillBuf();
             // this return value should be ignored as it is used in epilog parsing ...
             if (reachedEnd) throw new EOFException("no more data available" + getPositionDescription());
         }
         final char ch = buf[pos++];
         // line/columnNumber
         if (ch == '\n') {
             ++lineNumber;
             columnNumber = 1;
         } else {
             ++columnNumber;
         }
         // System.out.print(ch);
         return ch;
     }
 
     // /**
     // * This function returns position of parser in XML input stream
     // * (how many <b>characters</b> were processed.
     // * <p><b>NOTE:</b> this logical position and not byte offset as encodings
     // * such as UTF8 may use more than one byte to encode one character.
     // */
     // public int getCurrentInputPosition() {
     // return pos + bufAbsoluteStart;
     // }
 
     private void ensurePC(int end) {
         // assert end >= pc.length;
         final int newSize = end > READ_CHUNK_SIZE ? 2 * end : 2 * READ_CHUNK_SIZE;
         final char[] newPC = new char[newSize];
         if (TRACE_SIZING)
             System.out.println("TRACE_SIZING ensurePC() " + pc.length + " ==> " + newSize + " end=" + end);
         System.arraycopy(pc, 0, newPC, 0, pcEnd);
         pc = newPC;
         // assert end < pc.length;
     }
 
     private void joinPC() {
         // assert usePC == false;
         // assert posEnd > posStart;
         final int len = posEnd - posStart;
         final int newEnd = pcEnd + len + 1;
         if (newEnd >= pc.length) ensurePC(newEnd); // add 1 for extra space for one char
         // assert newEnd < pc.length;
         System.arraycopy(buf, posStart, pc, pcEnd, len);
         pcEnd += len;
         usePC = true;
     }
 
     private char requireInput(char ch, char[] input) throws XmlPullParserException, IOException {
         for (char anInput : input) {
             if (ch != anInput) {
                 throw new XmlPullParserException(
                         "expected " + printable(anInput) + " in " + new String(input) + " and not " + printable(ch),
                         this,
                         null);
             }
             ch = more();
         }
         return ch;
     }
 
     private char skipS(char ch) throws XmlPullParserException, IOException {
         while (isS(ch)) {
             ch = more();
         } // skip additional spaces
         return ch;
     }
 
     // nameStart / name lookup tables based on XML 1.1 http://www.w3.org/TR/2001/WD-xml11-20011213/
     private static final int LOOKUP_MAX = 0x400;
 
     private static final char LOOKUP_MAX_CHAR = (char) LOOKUP_MAX;
 
     // private static int lookupNameStartChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
     // private static int lookupNameChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
     private static final boolean[] lookupNameStartChar = new boolean[LOOKUP_MAX];
 
     private static final boolean[] lookupNameChar = new boolean[LOOKUP_MAX];
 
     private static void setName(char ch)
                 // { lookupNameChar[ (int)ch / 32 ] |= (1 << (ch % 32)); }
             {
         lookupNameChar[ch] = true;
     }
 
     private static void setNameStart(char ch)
                 // { lookupNameStartChar[ (int)ch / 32 ] |= (1 << (ch % 32)); setName(ch); }
             {
         lookupNameStartChar[ch] = true;
         setName(ch);
     }
 
     static {
         setNameStart(':');
         for (char ch = 'A'; ch <= 'Z'; ++ch) setNameStart(ch);
         setNameStart('_');
         for (char ch = 'a'; ch <= 'z'; ++ch) setNameStart(ch);
         for (char ch = '\u00c0'; ch <= '\u02FF'; ++ch) setNameStart(ch);
         for (char ch = '\u0370'; ch <= '\u037d'; ++ch) setNameStart(ch);
         for (char ch = '\u037f'; ch < '\u0400'; ++ch) setNameStart(ch);
 
         setName('-');
         setName('.');
         for (char ch = '0'; ch <= '9'; ++ch) setName(ch);
         setName('\u00b7');
         for (char ch = '\u0300'; ch <= '\u036f'; ++ch) setName(ch);
     }
 
     // protected boolean isNameStartChar( char ch )
     private static boolean isNameStartChar(char ch) {
         return ch < LOOKUP_MAX_CHAR
                 ? lookupNameStartChar[ch]
                 : (ch <= '\u2027') || (ch >= '\u202A' && ch <= '\u218F') || (ch >= '\u2800' && ch <= '\uFFEF');
 
         // if(ch < LOOKUP_MAX_CHAR) return lookupNameStartChar[ ch ];
         // else return ch <= '\u2027'
         // || (ch >= '\u202A' && ch <= '\u218F')
         // || (ch >= '\u2800' && ch <= '\uFFEF')
         // ;
         // return false;
         // return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':'
         // || (ch >= '0' && ch <= '9');
         // if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
         // if(ch <= '\u2027') return true;
         // //[#x202A-#x218F]
         // if(ch < '\u202A') return false;
         // if(ch <= '\u218F') return true;
         // // added parts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF]
         // if(ch < '\u2800') return false;
         // if(ch <= '\uFFEF') return true;
         // return false;
 
         // else return (supportXml11 && ( (ch < '\u2027') || (ch > '\u2029' && ch < '\u2200') ...
     }
 
     // protected boolean isNameChar( char ch )
     private static boolean isNameChar(char ch) {
         // return isNameStartChar(ch);
 
         // if(ch < LOOKUP_MAX_CHAR) return (lookupNameChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
 
         return ch < LOOKUP_MAX_CHAR
                 ? lookupNameChar[ch]
                 : (ch <= '\u2027') || (ch >= '\u202A' && ch <= '\u218F') || (ch >= '\u2800' && ch <= '\uFFEF');
         // return false;
         // return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':'
         // || (ch >= '0' && ch <= '9');
         // if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
 
         // else return
         // else if(ch <= '\u2027') return true;
         // //[#x202A-#x218F]
         // else if(ch < '\u202A') return false;
         // else if(ch <= '\u218F') return true;
         // // added parts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF]
         // else if(ch < '\u2800') return false;
         // else if(ch <= '\uFFEF') return true;
         // else return false;
     }
 
     private static boolean isS(char ch) {
         return (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t');
         // || (supportXml11 && (ch == '\u0085' || ch == '\u2028');
     }
 
     // protected boolean isChar(char ch) { return (ch < '\uD800' || ch > '\uDFFF')
     // ch != '\u0000' ch < '\uFFFE'
 
     // private char printable(char ch) { return ch; }
     private static String printable(int ch) {
         if (ch == '\n') {
             return "\\n";
         } else if (ch == '\r') {
             return "\\r";
         } else if (ch == '\t') {
             return "\\t";
         } else if (ch == '\'') {
             return "\\'";
         }
         if (ch > 127 || ch < 32) {
             return "\\u" + Integer.toHexString(ch);
         }
         if (Character.isBmpCodePoint(ch)) {
             return Character.toString((char) ch);
         } else {
             return new String(new char[] {Character.highSurrogate(ch), Character.lowSurrogate(ch)});
         }
     }
 
     private static String printable(String s) {
         if (s == null) return null;
         final int sLen = s.codePointCount(0, s.length());
         StringBuilder buf = new StringBuilder(sLen + 10);
         for (int i = 0; i < sLen; ++i) {
             buf.append(printable(s.codePointAt(i)));
         }
         s = buf.toString();
         return s;
     }
 }
 
 /*
  * Indiana University Extreme! Lab Software License, Version 1.2 Copyright (C) 2003 The Trustees of Indiana University.
  * All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted
  * provided that the following conditions are met: 1) All redistributions of source code must retain the above copyright
  * notice, the list of authors in the original source code, this list of conditions and the disclaimer listed in this
  * license; 2) All redistributions in binary form must reproduce the above copyright notice, this list of conditions and
  * the disclaimer listed in this license in the documentation and/or other materials provided with the distribution; 3)
  * Any documentation included with all redistributions must include the following acknowledgement: "This product
  * includes software developed by the Indiana University Extreme! Lab. For further information please visit
  * http://www.extreme.indiana.edu/" Alternatively, this acknowledgment may appear in the software itself, and wherever
  * such third-party acknowledgments normally appear. 4) The name "Indiana University" or "Indiana University Extreme!
  * Lab" shall not be used to endorse or promote products derived from this software without prior written permission
  * from Indiana University. For written permission, please contact http://www.extreme.indiana.edu/. 5) Products derived
  * from this software may not use "Indiana University" name nor may "Indiana University" appear in their name, without
  * prior written permission of the Indiana University. Indiana University provides no reassurances that the source code
  * provided does not infringe the patent or any other intellectual property rights of any other entity. Indiana
  * University disclaims any liability to any recipient for claims brought by any other entity based on infringement of
  * intellectual property rights or otherwise. LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO
  * WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES NO WARRANTIES AND MAKES NO
  * REPRESENTATION THAT SOFTWARE IS FREE OF INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS.
  * INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS", "VIRUSES", "TROJAN HORSES", "TRAP
  * DOORS", "WORMS", OR OTHER HARMFUL CODE. LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR
  * ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION GENERATED USING SOFTWARE.
  */