/*
    * Copyright (c) 2002 Extreme! Lab, Indiana University. All rights reserved.
    *
    * This software is open source. See the bottom of this file for the licence.
    *
    */
   
   package com.bea.xml.stream;
   
  import java.io.EOFException;
  import java.io.IOException;
  import java.io.Reader;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Vector;
  import java.util.Enumeration;
  import java.util.Iterator;
  
  import javax.xml.namespace.NamespaceContext;
  
  import com.bea.xml.stream.util.EmptyIterator;
  import com.bea.xml.stream.util.ElementTypeNames;
  import javax.xml.stream.events.XMLEvent;
  import javax.xml.stream.Location;
  import javax.xml.namespace.QName;
  import javax.xml.stream.XMLStreamReader;
  import javax.xml.stream.XMLStreamException;
  import com.wutka.dtd.DTDParser;
  import com.wutka.dtd.DTD;
  import com.wutka.dtd.DTDEntity;
  import com.wutka.dtd.DTDAttlist;
  import com.wutka.dtd.DTDAttribute;
  
  
  
  public class MXParser
    implements XMLStreamReader, Location
  {
      protected final static String XML_URI = "http://www.w3.org/XML/1998/namespace";
      protected final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
      protected static final String FEATURE_XML_ROUNDTRIP=
          "http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
      protected static final String FEATURE_NAMES_INTERNED =
          "http://xmlpull.org/v1/doc/features.html#names-interned";
  
      public static final String FEATURE_PROCESS_DOCDECL =
          "http://xmlpull.org/v1/doc/features.html#process-docdecl";
  
      public static final String [] TYPES = {
          "START_DOCUMENT",
          "END_DOCUMENT",
          "START_ELEMENT",
          "END_ELEMENT",
          "CHARACTERS", // "TEXT",
          "CDATA",
          "ENTITY_REFERENCE",
          "SPACE", // "IGNORABLE_WHITESPACE",
          "PROCESSING_INSTRUCTION",
          "XML_DECLARATION",
          "COMMENT",
          "DOCDECL"
      };
      
      // TODO - cwitt : split TEXT into CHARACTERS and WHITESPACE
      private static final int TEXT=0x00004000;
      // TODO - cwitt : remove DOCDECL ?
      private static final int DOCDECL=0x00008000;
      // TODO - cwitt : move to XMLEvent ?
      // will not be available in event interface (info under start_document
      // in that case), just in cursor
    //private static final int XML_DECLARATION=0x00010000;
      // NOTE - cwitt : from XmlPullParser interface
      public static final String NO_NAMESPACE = "";
      
      /***
       * 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!
       */
      protected boolean allStringsInterned;
  
      protected void resetStringCache() {
          //System.out.println("resetStringCache() minimum called");
      }
  
      protected String newString(char[] cbuf, int off, int len) {
          return new String(cbuf, off, len);
      }
  
      protected 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 typicaly defaults to false ...
     // TODO - cwitt : we always want to set these to true, so the featues
     // don't need to be defined in the factory, will remove them later here
     public static final String FEATURE_PROCESS_NAMESPACES =
         "http://xmlpull.org/v1/doc/features.html#process-namespaces";
     protected boolean processNamespaces = true;
     protected boolean roundtripSupported = true;
 
     // global parser state
     protected int lineNumber;
     protected int columnNumber;
     protected boolean seenRoot;
     protected boolean reachedEnd;
     protected int eventType;
     protected boolean emptyElementTag;
     // element stack
     protected int depth;
     protected char[] elRawName[];
     protected int elRawNameEnd[];
     //pnrotected int elRawNameEnd[];
     protected String elName[];
     protected String elPrefix[];
     protected String elUri[];
     //protected String elValue[];
     protected int elNamespaceCount[];
 
     protected String xmlVersion;
     protected boolean standalone=true;
     protected boolean standaloneSet=false;
     protected String charEncodingScheme;
 
   protected String piTarget;
   protected String piData;
 
   protected HashMap defaultAttributes;
     /***
      * Make sure that we have enough space to keep element stack if passed size.
      * It will always create one additional slot then current depth
      */
     protected void ensureElementsCapacity() {
         int elStackSize = elName != null ? elName.length : 0;
         if( (depth + 1) >= elStackSize) {
             // we add at least one extra slot ...
             int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25
             if(TRACE_SIZING) {
                 System.err.println("elStackSize "+elStackSize+" ==> "+newSize);
             }
             boolean needsCopying = elStackSize > 0;
             String[] arr = null;
             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;
 
             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;
         }
     }
 
 
     // nameStart / name lookup tables based on XML 1.1 http://www.w3.org/TR/2001/WD-xml11-20011213/
     protected static final int LOOKUP_MAX = 0x400;
     protected static final char LOOKUP_MAX_CHAR = (char)LOOKUP_MAX;
     //    protected static int lookupNameStartChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
     //    protected static int lookupNameChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
     protected static boolean lookupNameStartChar[] = new boolean[ LOOKUP_MAX ];
     protected static boolean lookupNameChar[] = new boolean[ LOOKUP_MAX ];
 
     private static final void setName(char ch)
         //{ lookupNameChar[ (int)ch / 32 ] |= (1 << (ch % 32)); }
     { lookupNameChar[ ch ] = true; }
     private static final 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);
     }
 
     //private final static boolean isNameStartChar(char ch) {
     protected boolean isNameStartChar(char ch) {
         return (ch < LOOKUP_MAX_CHAR && lookupNameStartChar[ ch ])
             || (ch >= LOOKUP_MAX_CHAR && 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 pairts [#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') ...
     }
 
     //private final static boolean isNameChar(char ch) {
     protected 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 >= LOOKUP_MAX_CHAR && 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 pairts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF]
         //        else if(ch < '\u2800') return false;
         //        else if(ch <= '\uFFEF') return true;
         //else return false;
     }
 
     protected 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'
 
 
     // attribute stack
     protected int attributeCount;
     protected String attributeName[];
     protected int attributeNameHash[];
     //protected int attributeNameStart[];
     //protected int attributeNameEnd[];
     protected String attributePrefix[];
     protected String attributeUri[];
     protected String attributeValue[];
     //protected int attributeValueStart[];
     //protected int attributeValueEnd[];
 
 
     /***
      * Make sure that in attributes temporary array is enough space.
      */
     protected  void ensureAttributesCapacity(int size) {
         int attrPosSize = attributeName != null ? attributeName.length : 0;
         if(size >= attrPosSize) {
             int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
             if(TRACE_SIZING) {
                 System.err.println("attrPosSize "+attrPosSize+" ==> "+newSize);
             }
             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 ) {
                 int[] iarr = new int[newSize];
                 if(needsCopying) System.arraycopy(attributeNameHash, 0, iarr, 0, attrPosSize);
                 attributeNameHash = iarr;
             }
 
             arr = null;
             // //assert attrUri.length > size
         }
     }
 
     // namespace stack
     protected int namespaceEnd;
     protected String namespacePrefix[];
     protected int namespacePrefixHash[];
     protected String namespaceUri[];
 
     protected void ensureNamespacesCapacity(int size) {
         int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
         if(size >= namespaceSize) {
             int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
             if(TRACE_SIZING) {
                 System.err.println("namespaceSize "+namespaceSize+" ==> "+newSize);
             }
             String[] newNamespacePrefix = new String[newSize];
             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 ) {
                 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
         }
     }
 
   // local namespace stack
   protected int localNamespaceEnd;
   protected String localNamespacePrefix[];
   protected int localNamespacePrefixHash[];
   protected String localNamespaceUri[];
   
   protected void ensureLocalNamespacesCapacity(int size) {
     int localNamespaceSize = localNamespacePrefix != null ? localNamespacePrefix.length : 0;
     if(size >= localNamespaceSize) {
       int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
       if(TRACE_SIZING) {
         System.err.println("localNamespaceSize "+localNamespaceSize+" ==> "+newSize);
       }
       String[] newLocalNamespacePrefix = new String[newSize];
       String[] newLocalNamespaceUri = new String[newSize];
       if(localNamespacePrefix != null) {
         System.arraycopy(
                          localNamespacePrefix, 0, newLocalNamespacePrefix, 0, localNamespaceEnd);
         System.arraycopy(
                          localNamespaceUri, 0, newLocalNamespaceUri, 0, localNamespaceEnd);
       }
       localNamespacePrefix = newLocalNamespacePrefix;
       localNamespaceUri = newLocalNamespaceUri;
       
       
       if( ! allStringsInterned ) {
         int[] newLocalNamespacePrefixHash = new int[newSize];
         if(localNamespacePrefixHash != null) {
           System.arraycopy(
                            localNamespacePrefixHash, 0, newLocalNamespacePrefixHash, 0, localNamespaceEnd);
         }
         localNamespacePrefixHash = newLocalNamespacePrefixHash;
       }
       //prefixesSize = newSize;
       // //assert nsPrefixes.length > size && nsPrefixes.length == newSize
     }
   }
   
   public int getLocalNamespaceCount() {
     int startNs = elNamespaceCount[ depth - 1 ];
     return namespaceEnd-startNs;
   }
   
   // This returns an array of all the namespaces uris defined
   // in the scope of this element
   // To index into it you need to add the namespaceCount from
   // the previous depth
   private String getLocalNamespaceURI(int pos) {
     return namespaceUri[pos];
   }
   
 
   // This returns an array of all the namespaces prefixes defined
   // in the scope of this element
   // the prefix for the default ns is bound to null
   // To index into it you need to add the namespaceCount from
   // the previous depth
   private String getLocalNamespacePrefix(int pos){
     return namespacePrefix[pos];
   }
   
     /***
      * 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 ...
      */
     protected static final int fastHash( char ch[], int off, int len ) {
         if(len == 0) return 0;
         //assert len >0
         int hash = ch[off]; // hash at beginnig
         //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
     protected int entityEnd;
     protected String entityName[];
     protected char[] entityNameBuf[];
     protected int entityNameHash[];
     protected char[] entityReplacementBuf[];
     protected String entityReplacement[];
 
 
     protected void ensureEntityCapacity() {
         int entitySize = entityReplacementBuf != null ? entityReplacementBuf.length : 0;
         if(entityEnd >= entitySize) {
             int newSize = entityEnd > 7 ? 2 * entityEnd : 8; // = lucky 7 + 1 //25
             if(TRACE_SIZING) {
                 System.err.println("entitySize "+entitySize+" ==> "+newSize);
             }
             String[] newEntityName = new String[newSize];
             char[] newEntityNameBuf[] = new char[newSize][];
             String[] newEntityReplacement = new String[newSize];
             char[] newEntityReplacementBuf[] = new char[newSize][];
             if(entityName != null) {
                 System.arraycopy(entityName, 0, newEntityName, 0, entityEnd);
                 System.arraycopy(entityReplacementBuf, 0, newEntityReplacement, 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 ) {
                 int[] newEntityNameHash = new int[newSize];
                 if(entityNameHash != null) {
                     System.arraycopy(entityNameHash, 0, newEntityNameHash, 0, entityEnd);
                 }
                 entityNameHash = newEntityNameHash;
             }
         }
     }
 
     // input buffer management
     protected static final int READ_CHUNK_SIZE = 8*1024; //max data chars in one read() call
     protected Reader reader;
     protected String inputEncoding;
 
 
     protected int bufLoadFactor = 95;  // 99%
     //protected int bufHardLimit;  // only matters when expanding
 
     protected char buf[] = new char[
         Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 256 ];
     protected int bufSoftLimit = ( bufLoadFactor * buf.length ) /100; // desirable size of buffer
 
 
     protected int bufAbsoluteStart; // this is buf
     protected int bufStart;
     protected int bufEnd;
     protected int pos;
     protected int posStart;
     protected int posEnd;
 
     protected char pc[] = new char[
         Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 64 ];
     protected int pcStart;
     protected int pcEnd;
 
 
     // parsing state
     //protected boolean needsMore;
     //protected boolean seenMarkup;
     protected boolean usePC;
 
 
     protected boolean seenStartTag;
     protected boolean seenEndTag;
     protected boolean pastEndTag;
     protected boolean seenAmpersand;
     protected boolean seenMarkup;
     protected boolean seenDocdecl;
 
     // transient variable set during each call to next/Token()
     protected boolean tokenize;
     protected String text;
     protected String entityRefName;
 
 
     private void reset() {
         //System.out.println("reset() called");
         lineNumber = 1;
         columnNumber = 0;
         seenRoot = false;
         reachedEnd = false;
         eventType = XMLEvent.START_DOCUMENT;
         emptyElementTag = false;
 
         depth = 0;
 
         attributeCount = 0;
 
         namespaceEnd = 0;
         localNamespaceEnd = 0;
 
         entityEnd = 0;
 
         reader = null;
         inputEncoding = null;
 
         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;
         resetStringCache();
 
     }
 
 
     public MXParser() {
     }
 
     /***
      * Method setFeature
      *
      * @param    name                a  String
      * @param    state               a  boolean
      *
      * @throws   XMLStreamException
      *
      */
     public void setFeature(String name,
                            boolean state) throws XMLStreamException
     {
         if(name == null) throw new IllegalArgumentException("feature name should not be nulll");
         if(FEATURE_PROCESS_NAMESPACES.equals(name)) {
             if(eventType != XMLEvent.START_DOCUMENT) throw new XMLStreamException(
                     "namespace processing feature can only be changed before parsing",
                     getLocation());
             processNamespaces = state;
             //        } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
             //      if(type != XMLEvent.START_DOCUMENT) throw new XMLStreamException(
             //              "namespace reporting feature can only be changed before parsing",
             // getLineNumber(), getColumnNumber(), getPositionDescription(), null);
             //            reportNsAttribs = state;
         } else if(FEATURE_NAMES_INTERNED.equals(name)) {
             if(state != false) {
                 throw new XMLStreamException(
                     "interning names in this implementation is not supported");
             }
         } else if(FEATURE_PROCESS_DOCDECL.equals(name)) {
             if(state != false) {
                 throw new XMLStreamException(
                     "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 XMLStreamException(
                     "roundtrip feature can not be switched off");
             }
         } else {
             throw new XMLStreamException("unknown feature "+name);
         }
     }
 
     /*** Unknown properties are <string>always</strong> returned as false */
     public boolean getFeature(String name)
     {
         if(name == null) throw new IllegalArgumentException("feature name should not be nulll");
         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; //roundtripSupported;
         }
         return false;
     }
 
     public void setProperty(String name,
                             Object value)
         throws XMLStreamException
     {
         throw new XMLStreamException("unsupported property: '"+name+"'");
     }
 
 
   public boolean checkForXMLDecl()
     throws XMLStreamException
   {
     try {
       BufferedReader breader = new BufferedReader(reader,7);
       reader = breader;
       breader.mark(7);
       if (breader.read() == '<' &&
           breader.read() == '?' &&
           breader.read() == 'x' &&
           breader.read() == 'm' &&
           breader.read() == 'l') {
         breader.reset();
         return true;
       }
       breader.reset();
       return false;
     } catch (IOException e) {
       throw new XMLStreamException(e);
     }
   }
 
     public void setInput(Reader in)
       throws XMLStreamException
     {
         reset();
         reader = in;
         if(checkForXMLDecl()) {
           next();
         }
     }
   public void setInput(java.io.InputStream in)
     throws XMLStreamException
     {
       try {
       setInput(com.bea.xml.stream.reader.XmlReader.createReader(in));
       } catch (Exception e) {
         throw new XMLStreamException(e);
       }
     }
 
     public void setInput(java.io.InputStream inputStream, String inputEncoding)
         throws XMLStreamException
     {
         if(inputStream == null) {
             throw new IllegalArgumentException("input stream can not be null");
         }
         Reader reader;
         if(inputEncoding != null) {
             try {
                 if(inputEncoding != null) {
                     reader = new InputStreamReader(inputStream, inputEncoding);
                 } else {
                     reader = new InputStreamReader(inputStream);
                 }
             } catch (UnsupportedEncodingException une) {
                 throw new XMLStreamException(
                     "could not create reader for encoding "+inputEncoding+" : "+une,
                     getLocation(), une);
             }
         } else {
             reader = new InputStreamReader(inputStream);
         }
         setInput(reader);
         //must be  here as reest() was called in setInput() and has set this.inputEncoding to null ...
         this.inputEncoding = inputEncoding;
     }
 
     public String getInputEncoding() {
         return inputEncoding;
     }
 
     public void defineEntityReplacementText(String entityName,
                                             String replacementText)
         throws XMLStreamException
     {
         //      throw new XMLStreamException("not allowed");
 
         //protected char[] entityReplacement[];
         ensureEntityCapacity();
 
         // this is to make sure that if interning works we wil take advatage of it ...
         this.entityName[entityEnd] = newString(entityName.toCharArray(), 0, entityName.length());
         entityNameBuf[entityEnd] = entityName.toCharArray();
 
         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 ...
     }
 
 
   public int getNamespaceCount()
   {
     return getNamespaceCount(depth);
   }
 
   public int getNamespaceCount(int depth)
   {
     if(processNamespaces == false || depth == 0) {
       return 0;
     }
     //int maxDepth = eventType == XMLEvent.END_ELEMENT ? this.depth + 1 : this.depth;
     //if(depth < 0 || depth > maxDepth) throw new IllegalArgumentException(
     if(depth < 0) throw new IllegalArgumentException("namespace count may be 0.."+this.depth+" not "+depth);
     return elNamespaceCount[ depth ]-elNamespaceCount[depth-1];
   }
   
   public String getNamespacePrefix(int pos)
   {
     int currentDepth = depth;
     int end = getNamespaceCount(currentDepth);//eventType == XMLEvent.END_ELEMENT ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
     int newpos = pos + elNamespaceCount[currentDepth-1];
     if(pos < end) {
       return namespacePrefix[ newpos ];
     } else {
       throw new ArrayIndexOutOfBoundsException(
                                                "position "+pos+" exceeded number of available namespaces "+end);
     }
   }
 
     public String getNamespaceURI(int pos)
     {
       int currentDepth = depth;
       int end = getNamespaceCount(currentDepth); //eventType == XMLEvent.END_ELEMENT ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
       int newpos = pos + elNamespaceCount[currentDepth-1];
       if(pos < end) {
         return namespaceUri[ newpos ];
        } else {
          throw new ArrayIndexOutOfBoundsException(
                                               "position "+pos+" exceedded number of available namespaces "+end);
        }
     }
 
     public String getNamespaceURI( String prefix )
         //throws XMLStreamException
     {
         //int count = namespaceCount[ depth ];
         if(prefix != null && !"".equals(prefix)) {
             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 ) {
                     return namespaceUri[ i ];
                 }
             }
 
         }
         return null;
     }
  
     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;
             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'.
      */
     public String getPositionDescription ()
     {
         String fragment = null;
         if(posStart <= pos) {
             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)+"..." : "")+
             " @"+getLineNumber()+":"+getColumnNumber();
     }
 
     public int getLineNumber()
     {
         return lineNumber;
     }
 
     public int getColumnNumber()
     {
         return columnNumber;
     }
 
   public String getLocationURI() { return null; }
 
     public boolean isWhiteSpace()
     // throws XMLStreamException
     {
         if(eventType == XMLEvent.CHARACTERS || eventType == XMLEvent.CDATA) {
             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 == /* XMLEvent.IGNORABLE_WHITESPACE */ XMLEvent.SPACE) {
             return true;
 
         // COMMENT - cwitt : our interface doesn't define this
         // (and is 'meant to be slightly different anyway' - quote cfry)
         // throw new XMLStreamException("no content available to check for whitespaces");
 
         } else {
             return false;
         }
     }
   
     public String getText()
     {
         if(eventType == XMLEvent.START_DOCUMENT || eventType == XMLEvent.END_DOCUMENT) {
             //throw new XMLStreamException("no content available to read");
             //      if(roundtripSupported) {
             //          text = new String(buf, posStart, posEnd - posStart);
             //      } else {
             return null;
             //      }
         } else if(eventType == XMLEvent.ENTITY_REFERENCE) {
             return text;
         }
 
         if(usePC) {
           text = new String(pc, pcStart, pcEnd - pcStart);
         } else {
           text = new String(buf, posStart, posEnd - posStart);
         }
         return text;
     }
 
     public String getNamespaceURI()
     {
         if(eventType == XMLEvent.START_ELEMENT ||
            eventType == XMLEvent.END_ELEMENT) {
             return processNamespaces ? elUri[ depth  ] : NO_NAMESPACE;
         }
         return null;
     }
 
     public String getLocalName()
     {
         if(eventType == XMLEvent.START_ELEMENT) {
             //return elName[ depth - 1 ] ;
             return elName[ depth ] ;
         } else if(eventType == XMLEvent.END_ELEMENT) {
             return elName[ depth ] ;
         } else if(eventType == XMLEvent.ENTITY_REFERENCE) {
             if(entityRefName == null) {
                 entityRefName = newString(buf, posStart, posEnd - posStart);
             }
             return entityRefName;
         } else {
             return null;
         }
     }
 
     public String getPrefix()
     {
         if(eventType == XMLEvent.START_ELEMENT ||
            eventType == XMLEvent.END_ELEMENT) {
             return elPrefix[ depth ] ;
         }
         return null;
      }
 
 
     public boolean isEmptyElementTag() throws XMLStreamException
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new XMLStreamException(
                 "parser must be on XMLEvent.START_ELEMENT to check for empty element",
                 getLocation());
         return emptyElementTag;
     }
 
     public int getAttributeCount()
     {
         if(eventType != XMLEvent.START_ELEMENT) return -1;
         return attributeCount;
     }
 
     public String getAttributeNamespace(int index)
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(processNamespaces == false) return NO_NAMESPACE;
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return attributeUri[ index ];
     }
 
     public String getAttributeLocalName(int index)
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return attributeName[ index ];
     }
 
     public String getAttributePrefix(int index)
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(processNamespaces == false) return null;
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return attributePrefix[ index ];
     }
 
     public String getAttributeType(int index) {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return "CDATA";
     }
 
     public boolean isAttributeSpecified(int index) {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return false;
     }
 
     public String getAttributeValue(int index)
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
                 "attribute position must be 0.."+(attributeCount-1)+" and not "+index);
         return attributeValue[ index ];
     }
 
     public String getAttributeValue(String namespace,
                                     String name)
     {
         if(eventType != XMLEvent.START_ELEMENT) throw new IndexOutOfBoundsException(
                 "only XMLEvent.START_ELEMENT can have attributes");
         if(name == null) {
             throw new IllegalArgumentException("attribute name can not be null");
         }
         // TODO make check if namespace is interned!!! etc. for names!!!
         if(namespace != null) {
             for(int i = 0; i < attributeCount; ++i) {
                 if(namespace.equals(attributeUri[i])
                    && name.equals(attributeName[i]))
                 {
                     return attributeValue[i];
                 }
             }
         } else {
             for(int i = 0; i < attributeCount; ++i) {
                 if(name.equals(attributeName[i]))
                 {
                     return attributeValue[i];
                 }
             }
         }
         return null;
     }
   
  
 
     public int getEventType() {
         return eventType;
     }
 
     public void require(int type, String namespace, String name)
         throws XMLStreamException
     {
         if (type != getEventType()
             || (namespace != null && !namespace.equals (getNamespaceURI()))
             || (name != null && !name.equals (getLocalName ())) )
         {
             throw new XMLStreamException (
                 "expected event "+ElementTypeNames.getEventTypeString(type)
                     +(name != null ? " with name '"+name+"'" : "")
                     +(namespace != null && name != null ? " and" : "")
                     +(namespace != null ? " with namespace '"+namespace+"'" : "")
                     +" but got"
                     +(type != getEventType() ? " "+ElementTypeNames.getEventTypeString(getEventType()) : "")
                     +(name != null && getLocalName() != null && !name.equals (getName ())
                           ? " name '"+getLocalName()+"'" : "")
                     +(namespace != null && name != null
                           && getLocalName() != null && !name.equals (getName ())
                           && getNamespaceURI() != null && !namespace.equals (getNamespaceURI())
                           ? " and" : "")
                     +(namespace != null && getNamespaceURI() != null && !namespace.equals (getNamespaceURI())
                           ? " namespace '"+getNamespaceURI()+"'" : "")
                     +(" (postion:"+ getPositionDescription())+")");
         }
     }
 
     public String nextText() throws XMLStreamException
     {
         if(getEventType() != XMLEvent.START_ELEMENT) {
             throw new XMLStreamException(
                 "parser must be on XMLEvent.START_ELEMENT to read next text",
                 getLocation());
         }
         int eventType = next();
         if(eventType == XMLEvent.CHARACTERS) {
             String result = getText();
             eventType = next();
             if(eventType != XMLEvent.END_ELEMENT) {
                 throw new XMLStreamException(
                     "TEXT must be immediately followed by XMLEvent.END_ELEMENT and not "
                     +ElementTypeNames.getEventTypeString(getEventType()),
                     getLocation());
             }
             return result;
         } else if(eventType == XMLEvent.END_ELEMENT) {
             return "";
         } else {
             throw new XMLStreamException(
                 "parser must be on XMLEvent.START_ELEMENT or TEXT to read text",
                 getLocation());
         }
     }
 
   public int nextTag()
     throws XMLStreamException
   {
     next();
     if((eventType == XMLEvent.CHARACTERS && isWhiteSpace())||
        eventType == XMLEvent.COMMENT) {  // skip whitespace
       next();
     }
     if (eventType != XMLEvent.START_ELEMENT && eventType != XMLEvent.END_ELEMENT) {
       throw new XMLStreamException("expected XMLEvent.START_ELEMENT or XMLEvent.END_ELEMENT not "
                                    +ElementTypeNames.getEventTypeString(getEventType()),
                                    getLocation());
     }
     return eventType;
   }
 
   public String getElementText()
     throws XMLStreamException
   {
     StringBuffer buf = new StringBuffer();
     if(getEventType() != START_ELEMENT)
       throw new XMLStreamException(
         "Precondition for readText is getEventType() == START_ELEMENT");
     do {
       if(next() == END_DOCUMENT)
         throw new XMLStreamException("Unexpected end of Document");
       if(isStartElement())
         throw new XMLStreamException("Unexpected Element start");
       if(isCharacters() || getEventType() == XMLEvent.ENTITY_REFERENCE)
         buf.append(getText());
     } while(!isEndElement());
     return buf.toString();
   }
 
   public int next() throws XMLStreamException {
     tokenize = true;
     pcEnd = pcStart = 0;
     usePC = false;
     return nextImpl();
   }
   
   public int nextToken() throws XMLStreamException {
     tokenize = true;
     return nextImpl();
   }
   
   public int nextElement() throws XMLStreamException {
     return nextTag();
   }
   
   public boolean hasNext() throws XMLStreamException {
     return !(eventType == XMLEvent.END_DOCUMENT);
   }
 
   public void skip() throws XMLStreamException {
     nextToken();
   }
 
   public void close() throws XMLStreamException {
 
   }
   
   public boolean isStartElement() {
     return (eventType == XMLEvent.START_ELEMENT);
   }
   
   public boolean isEndElement() {
     return (eventType == XMLEvent.END_ELEMENT);
   }
   
   public boolean isCharacters() {
     return (eventType == XMLEvent.CHARACTERS);
   }
   
   public boolean isEOF() {
     return (eventType == XMLEvent.END_DOCUMENT);
   }
   
   public boolean moveToStartElement() throws XMLStreamException {
     if (isStartElement()) return true;
     while(hasNext()) {
       if (isStartElement()) return true;
       else
         next();
     }
     return false;
   }
   
   public boolean moveToStartElement(String localName)
     throws XMLStreamException
   {
     if (localName == null) return false;
     while( moveToStartElement() ) {
       if (localName.equals(getLocalName())) return true;
       if (!hasNext()) return false;
       next();
     }
     return false;
   }
   
   public boolean moveToStartElement(String localName, String namespaceUri)
     throws XMLStreamException
   {
     if (localName == null || namespaceUri == null) return false;
     while(moveToStartElement(localName)) {
       if(namespaceUri.equals(getNamespaceURI())) return true;
       if (!hasNext()) return false;
       next();
     }
     return false;
   }
   
   public boolean moveToEndElement() throws XMLStreamException {
     if (isEndElement()) return true;
     while (hasNext()) {
       if (isEndElement()) return true;
       else
         next();
     }
     return false;
   }
   
   public boolean moveToEndElement(String localName)
     throws XMLStreamException
   {
     if (localName == null) return false;
     while( moveToEndElement() ) {
       if (localName.equals(getLocalName())) return true;
       if (!hasNext()) return false;
       next();
     }
     return false;
   }
   
   public boolean moveToEndElement(String localName, String namespaceUri)
     throws XMLStreamException
   {
     if (localName == null || namespaceUri == null) return false;
     while(moveToEndElement(localName)) {
       if(namespaceUri.equals(getNamespaceURI())) return true;
       if (!hasNext()) return false;
       next();
     }
     return false;
   }
   
   public boolean hasAttributes() {
     if (getAttributeCount() > 0)
       return true;
     return false;
   }
   
   public boolean hasNamespaces() {
     if(getNamespaceCount() > 0)
       return true;
     return false;
   }
 
   public Iterator getAttributes() {
     if (!hasAttributes()) return EmptyIterator.emptyIterator;
     int attributeCount = getAttributeCount();
     ArrayList atts = new ArrayList();
     for (int i = 0; i < attributeCount; i++){
       atts.add(new AttributeBase(getAttributePrefix(i),
                                  getAttributeNamespace(i),
                                  getAttributeLocalName(i),
                                  getAttributeValue(i),
                                  getAttributeType(i)));
     }
     return atts.iterator();
   }
 
   public Iterator internalGetNamespaces(int depth,
                                                  int namespaceCount) {
     ArrayList ns = new ArrayList();
     int startNs = elNamespaceCount[ depth - 1 ];
     for (int i = 0; i < namespaceCount; i++){
       String prefix = getLocalNamespacePrefix(i+startNs);
       if(prefix == null){
         ns.add(new NamespaceBase(getLocalNamespaceURI(i+startNs)));
       } else {
         ns.add(new NamespaceBase(prefix,
                                  getLocalNamespaceURI(i+startNs)));
       }
     }
     return ns.iterator();
   }
 
 
   public Iterator getNamespaces() {
     if (!hasNamespaces()) return EmptyIterator.emptyIterator;
     int namespaceCount = getLocalNamespaceCount();
     return internalGetNamespaces(depth,namespaceCount);
   }
 
   public Iterator getOutOfScopeNamespaces() {
     int startNs = elNamespaceCount[ depth-1  ];
     int endNs = elNamespaceCount[depth];
     int namespaceCount = endNs-startNs;
     return internalGetNamespaces(depth,
                                  namespaceCount);
   }
   
   public XMLStreamReader subReader() throws XMLStreamException {
     return new SubReader(this);
   }
   
   public void recycle() throws XMLStreamException {
     reset();
   }
   
   public Reader getTextStream() {
     throw new UnsupportedOperationException();
   }
 
   public int getTextCharacters(int sourceStart, char[] target, int targetStart, int length)
     throws XMLStreamException {
     if (getTextStart()+sourceStart >= getTextLength())
       throw new ArrayIndexOutOfBoundsException();
     int numCopy;
     if (getTextStart()+sourceStart+length < getTextLength())
       numCopy = length;
     else
       numCopy = getTextLength() - (getTextStart()+sourceStart);
     System.arraycopy(getTextCharacters(), getTextStart() + sourceStart, target, targetStart, numCopy);
     return numCopy;
   }
                                
   public char[] getTextCharacters() {
     if( eventType == XMLEvent.CHARACTERS ) {
       if(usePC) {
         return pc;
       } else {
         return buf;
       }
     } else if( eventType == XMLEvent.START_ELEMENT
                || eventType == XMLEvent.END_ELEMENT
                || eventType == XMLEvent.CDATA
                || eventType == XMLEvent.COMMENT
                || eventType == XMLEvent.ENTITY_REFERENCE
                || eventType == XMLEvent.PROCESSING_INSTRUCTION
                || eventType == /* XMLEvent.IGNORABLE_WHITESPACE */ XMLEvent.SPACE
                || eventType == XMLEvent.DTD)
       {
         return buf;
       } else if(eventType == XMLEvent.START_DOCUMENT
                 || eventType == XMLEvent.END_DOCUMENT) {
         return null;
       } else {
         throw new IllegalArgumentException("unknown text eventType: "+eventType);
       }
   }
 
   
   public int getTextStart() {
     if(usePC) {
       return pcStart;
     } else {
       return posStart;
     }
   }
 
   public int getTextLength() {
     if(usePC) {
       return pcEnd - pcStart;
     } else {
       return  posEnd - posStart;
     }
   }
 
   public boolean hasText() {
     return (0 != (eventType & (XMLEvent.CHARACTERS |
                                XMLEvent.DTD |
                                XMLEvent.COMMENT |
                                XMLEvent.ENTITY_REFERENCE)));
   }
   
   public String getValue() {
     return getText();
   }
   
   public String getEncoding() {
     return getInputEncoding();
   }
   
   public int getCharacterOffset() {
     // TODO - cwitt : which buffer are we using?
     return posEnd;
   }
 
   private static final String checkNull(String s) {
     if (s != null) return s;
     else return "";
   }
 
   public QName getAttributeName(int index) {
     return new QName(checkNull(getAttributeNamespace(index)),
                      getAttributeLocalName(index),
                      checkNull(getAttributePrefix(index)));
   }
 
 
 
   public QName getName() {
     return new QName(checkNull(getNamespaceURI()),
                      getLocalName(),
                      checkNull(getPrefix()));
   }
   
   public boolean hasName() {
     return (0 != (eventType  & (XMLEvent.START_ELEMENT
                             | XMLEvent.END_ELEMENT
                             | XMLEvent.ENTITY_REFERENCE)));
   }
   
   public String getVersion() {
     return xmlVersion;
   }
   
   public boolean isStandalone() {
     return standalone;
   }
      public boolean standaloneSet() {
     return standaloneSet;
   }
 
   public String getCharacterEncodingScheme() {
     return charEncodingScheme;
   }
   
   // COMMENT - cwitt : end of added XMLStreamReader impl
   
   protected int nextImpl() throws XMLStreamException
   {