to.etc.syntaxer.XmlParser Maven / Gradle / Ivy

([80] to [82] are also significant.) *

(The <?xml and whitespace have already been read.) *

TODO: validate value of standalone. * @see #parseTextDecl * @see #checkEncoding */ void parseXMLDecl(boolean ignoreEncoding) throws java.lang.Exception { String version; String encodingName = null; // Read the version. require("version"); parseEq(); version = readLiteral(0); if(!version.equals("1.0")) { error("unsupported XML version", version, "1.0"); } // Try reading an encoding declaration. skipWhitespace(); if(tryRead("encoding")) { parseEq(); encodingName = readLiteral(0); checkEncoding(encodingName, ignoreEncoding); } // Try reading a standalone declaration skipWhitespace(); if(tryRead("standalone")) { parseEq(); readLiteral(0); } skipWhitespace(); require("?>"); } /** * Parse the Encoding PI. *

	 * [78] EncodingDecl ::= S 'encoding' Eq QEncoding
	 * [79] EncodingPI ::= '<?xml' S 'encoding' Eq QEncoding S? '?>'
	 * [80] QEncoding ::= '"' Encoding '"' | "'" Encoding "'"
	 * [81] Encoding ::= LatinName
	 * [82] LatinName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
	 * 

(The <?xml' and whitespace have already been read.) * @see #parseXMLDecl * @see #checkEncoding */ void parseTextDecl(boolean ignoreEncoding) throws java.lang.Exception { String encodingName = null; // Read an optional version. if(tryRead("version")) { String version; parseEq(); version = readLiteral(0); if(!version.equals("1.0")) { error("unsupported XML version", version, "1.0"); } requireWhitespace(); } // Read the encoding. require("encoding"); parseEq(); encodingName = readLiteral(0); checkEncoding(encodingName, ignoreEncoding); skipWhitespace(); require("?>"); } /** * Check that the encoding specified makes sense. *

Compare what the author has specified in the XML declaration * or encoding PI with what we have detected. *

This is also important for distinguishing among the various * 7- and 8-bit encodings, such as ISO-LATIN-1 (I cannot autodetect * those). * @param encodingName The name of the encoding specified by the user. * @see #parseXMLDecl * @see #parseTextDecl */ void checkEncoding(String encodingName, boolean ignoreEncoding) throws java.lang.Exception { encodingName = encodingName.toUpperCase(); if(ignoreEncoding) { return; } switch(m_encoding) { // 8-bit encodings case ENCODING_UTF_8: if(encodingName.equals("ISO-8859-1")) { m_encoding = ENCODING_ISO_8859_1; } else if(!encodingName.equals("UTF-8")) { error("unsupported 8-bit encoding", encodingName, "UTF-8 or ISO-8859-1"); } break; // 16-bit encodings case ENCODING_UCS_2_12: case ENCODING_UCS_2_21: if(!encodingName.equals("ISO-10646-UCS-2") && !encodingName.equals("UTF-16")) { error("unsupported 16-bit encoding", encodingName, "ISO-10646-UCS-2"); } break; // 32-bit encodings case ENCODING_UCS_4_1234: case ENCODING_UCS_4_4321: case ENCODING_UCS_4_2143: case ENCODING_UCS_4_3412: if(!encodingName.equals("ISO-10646-UCS-4")) { error("unsupported 32-bit encoding", encodingName, "ISO-10646-UCS-4"); } } } /** * Parse miscellaneous markup outside the document element and DOCTYPE * declaration. *

	 * [27] Misc ::= Comment | PI | S
	 * 

(The <!DOCTYPE has already been read.) */ void parseDoctypedecl() throws java.lang.Exception { String doctypeName, ids[]; // Read the document type name. requireWhitespace(); doctypeName = readNmtoken(true); // Read the ExternalIDs. skipWhitespace(); ids = readExternalIds(false); // Look for a declaration subset. skipWhitespace(); if(tryRead('[')) { // loop until the subset ends while(true) { m_context = CONTEXT_DTD; skipWhitespace(); m_context = CONTEXT_NONE; if(tryRead(']')) { break; // end of subset } else { m_context = CONTEXT_DTD; parseMarkupdecl(); m_context = CONTEXT_NONE; } } } // Read the external subset, if any if(ids[1] != null) { pushURL("[external subset]", ids[0], ids[1], null, null, null); // Loop until we end up back at '>' while(true) { m_context = CONTEXT_DTD; skipWhitespace(); m_context = CONTEXT_NONE; if(tryRead('>')) { break; } else { m_context = CONTEXT_DTD; parseMarkupdecl(); m_context = CONTEXT_NONE; } } } else { // No external subset. skipWhitespace(); require('>'); } if(m_handler != null) { m_handler.doctypeDecl(doctypeName, ids[0], ids[1]); } // Expand general entities in // default values of attributes. // (Do this after the doctypeDecl // event!). // expandAttributeDefaultValues(); } /** * Parse a markup declaration in the internal or external DTD subset. *

	 * [29] markupdecl ::= ( %elementdecl | %AttlistDecl | %EntityDecl |
	 *                       %NotationDecl | %PI | %S | %Comment |
	 *                       InternalPERef )
	 * [30] InternalPERef ::= PEReference
	 * [31] extSubset ::= (%markupdecl | %conditionalSect)*
	 * 

(The '<' has already been read.) *

NOTE: this method actually chains onto parseContent(), if necessary, * and parseContent() will take care of calling parseETag(). */ void parseElement() throws java.lang.Exception { String gi; char c; int oldElementContent = m_currentElementContent; String oldElement = m_currentElement; // This is the (global) counter for the // array of specified attributes. m_tagAttributePos = 0; // Read the element type name. gi = readNmtoken(true); // Determine the current content type. m_currentElement = gi; m_currentElementContent = getElementContentType(gi); if(m_currentElementContent == CONTENT_UNDECLARED) { m_currentElementContent = CONTENT_ANY; } // Read the attributes, if any. // After this loop, we should be just // in front of the closing delimiter. skipWhitespace(); c = readCh(); while(c != '/' && c != '>') { unread(c); parseAttribute(gi); skipWhitespace(); c = readCh(); } unread(c); // Supply any defaulted attributes. Enumeration atts = declaredAttributes(gi); if(atts != null) { String aname; loop : while(atts.hasMoreElements()) { aname = (String) atts.nextElement(); // See if it was specified. for(int i = 0; i < m_tagAttributePos; i++) { if(m_tagAttributes[i] == aname) { continue loop; } } // I guess not... if(m_handler != null) { m_handler.attribute(aname, getAttributeExpandedValue(gi, aname), false); } } } // Figure out if this is a start tag // or an empty element, and dispatch an // event accordingly. c = readCh(); switch(c) { case '>': if(m_handler != null) { m_handler.startElement(gi); } parseContent(); break; case '/': require('>'); if(m_handler != null) { m_handler.startElement(gi); m_handler.endElement(gi); } break; } // Restore the previous state. m_currentElement = oldElement; m_currentElementContent = oldElementContent; } /** * Parse an attribute assignment. *

	 * [34] Attribute ::= Name Eq AttValue
	 * 

	 * [16] PCData ::= [^<&]*
	 * 

The trick here is that the data stays in the dataBuffer without * necessarily being converted to a string right away. */ void parsePCData() throws java.lang.Exception { char c; // Start with a little cheat -- in most // cases, the entire sequence of // character data will already be in // the readBuffer; if not, fall through to // the normal approach. if(USE_CHEATS) { int lineAugment = 0; int columnAugment = 0; for(int i = m_rbpos; i < m_rblen; i++) { switch(m_readBuffer[i]) { case '\n': lineAugment++; columnAugment = 0; break; case '&': case '<': int start = m_rbpos; columnAugment++; m_rbpos = i; if(lineAugment > 0) { m_line += lineAugment; m_column = columnAugment; } else { m_column += columnAugment; } dataBufferAppend(m_readBuffer, start, i - start); return; default: columnAugment++; } } } // OK, the cheat didn't work; start over // and do it by the book. while(true) { c = readCh(); switch(c) { case '<': case '&': unread(c); return; default: dataBufferAppend(c); break; } } } ////////////////////////////////////////////////////////////////////// // High-level reading and scanning methods. ////////////////////////////////////////////////////////////////////// /** * Require whitespace characters. * [1] S ::= (#x20 | #x9 | #xd | #xa)+ */ void requireWhitespace() throws java.lang.Exception { char c = readCh(); if(isWhitespace(c)) { skipWhitespace(); } else { error("whitespace expected", c, null); } } /** * Parse whitespace characters, and leave them in the data buffer. */ void parseWhitespace() throws java.lang.Exception { char c = readCh(); while(isWhitespace(c)) { dataBufferAppend(c); c = readCh(); } unread(c); } /** * Skip whitespace characters. * [1] S ::= (#x20 | #x9 | #xd | #xa)+ */ void skipWhitespace() throws java.lang.Exception { // Start with a little cheat. Most of // the time, the white space will fall // within the current read buffer; if // not, then fall through. if(USE_CHEATS) { int lineAugment = 0; int columnAugment = 0; loop : for(int i = m_rbpos; i < m_rblen; i++) { switch(m_readBuffer[i]) { case ' ': case '\t': case '\r': columnAugment++; break; case '\n': lineAugment++; columnAugment = 0; break; case '%': if(m_context == CONTEXT_DTD || m_context == CONTEXT_ENTITYVALUE) { break loop; } // else fall through... default: m_rbpos = i; if(lineAugment > 0) { m_line += lineAugment; m_column = columnAugment; } else { m_column += columnAugment; } return; } } } // OK, do it by the book. char c = readCh(); while(isWhitespace(c)) { c = readCh(); } unread(c); } /** * Read a name or name token. * [5] Name ::= (Letter | '_' | ':') (NameChar)* * [7] Nmtoken ::= (NameChar)+ * *NOTE: [6] is implemented implicitly where required. */ String readNmtoken(boolean isName) throws java.lang.Exception { char c; if(USE_CHEATS) { loop : for(int i = m_rbpos; i < m_rblen; i++) { switch(m_readBuffer[i]) { case '%': if(m_context == CONTEXT_DTD || m_context == CONTEXT_ENTITYVALUE) { break loop; } // else fall through... case '<': case '>': case '&': case ',': case '|': case '*': case '+': case '?': case ')': case '=': case '\'': case '"': case '[': case ' ': case '\t': case '\r': case '\n': case ';': case '/': case '#': int start = m_rbpos; if(i == start) { error("name expected", m_readBuffer[i], null); } m_rbpos = i; return intern(m_readBuffer, start, i - start); } } } m_nameBufferPos = 0; // Read the first character. while(true) { c = readCh(); switch(c) { case '%': case '<': case '>': case '&': case ',': case '|': case '*': case '+': case '?': case ')': case '=': case '\'': case '"': case '[': case ' ': case '\t': case '\n': case '\r': case ';': case '/': unread(c); if(m_nameBufferPos == 0) { error("name expected", null, null); } String s = intern(m_nameBuffer, 0, m_nameBufferPos); m_nameBufferPos = 0; return s; default: m_nameBuffer = (char[]) extendArray(m_nameBuffer, m_nameBuffer.length, m_nameBufferPos); m_nameBuffer[m_nameBufferPos++] = c; } } } /** * Read a literal. * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' * | "'" ([^<&'] | Reference)* "'" * [11] SystemLiteral ::= '"' URLchar* '"' | "'" (URLchar - "'")* "'" * [13] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' * | "'" ([^%&'] | PEReference | Reference)* "'" */ String readLiteral(int flags) throws java.lang.Exception { char delim, c; int startLine = m_line; // Find the delimiter. delim = readCh(); if(delim != '"' && delim != '\'' && delim != (char) 0) { error("expected '\"' or \"'\"", delim, null); return null; } // Read the literal. try { c = readCh(); loop : while(c != delim) { switch(c) { // Literals never have line ends case '\n': case '\r': c = ' '; break; // References may be allowed case '&': if((flags & LIT_CHAR_REF) > 0) { c = readCh(); if(c == '#') { parseCharRef(); c = readCh(); continue loop; // check the next character } else if((flags & LIT_ENTITY_REF) > 0) { unread(c); parseEntityRef(false); c = readCh(); continue loop; } else { dataBufferAppend('&'); } } break; default: break; } dataBufferAppend(c); c = readCh(); } } catch(EOFException e) { error("end of input while looking for delimiter (started on line " + startLine + ')', null, new Character(delim).toString()); } // Normalise whitespace if necessary. if((flags & LIT_NORMALIZE) > 0) { dataBufferNormalize(); } // Return the value. return dataBufferToString(); } /** * Try reading external identifiers. *

The system identifier is not required for notations. * @param inNotation Are we in a notation? * @return A two-member String array containing the identifiers. */ String[] readExternalIds(boolean inNotation) throws java.lang.Exception { String ids[] = new String[2]; if(tryRead("PUBLIC")) { requireWhitespace(); ids[0] = readLiteral(LIT_NORMALIZE); // public id if(inNotation) { skipWhitespace(); if(tryRead('"') || tryRead('\'')) { ids[1] = readLiteral(0); } } else { requireWhitespace(); ids[1] = readLiteral(0); // system id } } else if(tryRead("SYSTEM")) { requireWhitespace(); ids[1] = readLiteral(0); // system id } return ids; } /** * Test if a character is whitespace. *

	 * [1] S ::= (#x20 | #x9 | #xd | #xa)+
	 * 

Ælfred uses this method to create an internalised version * of all names and attribute values, so that it can test equality * with == instead of String.equals(). *

If you want to be able to test for equality in the same way, * you can use this method to internalise your own strings first: *

	 * String PARA = handler.intern("PARA");
	 * 

Note that this will not return the same results as String.intern(). * @param s The string to internalise. * @return An internalised version of the string. * @see #intern(char[],int,int) * @see java.lang.String#intern */ public String intern(String s) { char ch[] = s.toCharArray(); return intern(ch, 0, ch.length); } /** * Create an internalised string from a character array. *

This is much more efficient than constructing a non-internalised * string first, and then internalising it. *

Note that this will not return the same results as String.intern(). * @param ch an array of characters for building the string. * @param start the starting position in the array. * @param length the number of characters to place in the string. * @return an internalised string. * @see #intern(String) * @see java.lang.String#intern */ public String intern(char ch[], int start, int length) { int index; int hash = 0; // Generate a hash code. for(int i = start; i < start + length; i++) { hash = ((hash << 1) & 0xffffff) + ch[i]; } hash = hash % SYMBOL_TABLE_LENGTH; // Get the bucket. Object bucket[] = (Object[]) m_symbolTable[hash]; if(bucket == null) { m_symbolTable[hash] = bucket = new Object[8]; } // Search for a matching tuple, and // return the string if we find one. for(index = 0; index < bucket.length; index += 2) { char chFound[] = (char[]) bucket[index]; // Stop when we hit a null index. if(chFound == null) { break; } // If they're the same length, // check for a match. // If the loop finishes, 'index' will // contain the current bucket // position. if(chFound.length == length) { for(int i = 0; i < chFound.length; i++) { // Stop if there are no more tuples. if(ch[start + i] != chFound[i]) { break; } else if(i == length - 1) { // That's it, we have a match! return (String) bucket[index + 1]; } } } } // Not found -- we'll have to add it. // Do we have to grow the bucket? bucket = (Object[]) extendArray(bucket, bucket.length, index); // OK, add it to the end of the // bucket. String s = new String(ch, start, length); bucket[index] = s.toCharArray(); bucket[index + 1] = s; m_symbolTable[hash] = bucket; return s; } /** * Ensure the capacity of an array, allocating a new one if * necessary. */ Object extendArray(Object array, int currentSize, int requiredSize) { if(requiredSize < currentSize) { return array; } else { Object newArray = null; int newSize = currentSize * 2; if(newSize <= requiredSize) { newSize = requiredSize + 1; } if(array instanceof char[]) { newArray = new char[newSize]; } else if(array instanceof Object[]) { newArray = new Object[newSize]; } System.arraycopy(array, 0, newArray, 0, currentSize); return newArray; } } ////////////////////////////////////////////////////////////////////// // XML query routines. ////////////////////////////////////////////////////////////////////// // // Elements // /** * Get the declared elements for an XML document. *

The results will be valid only after the DTD (if any) has been * parsed. * @return An enumeration of all element types declared for this * document (as Strings). * @see #getElementContentType * @see #getElementContentModel */ public Enumeration declaredElements() { return m_elementInfo.keys(); } /** * Look up the content type of an element. * @param name The element type name. * @return An integer constant representing the content type. * @see #getElementContentModel * @see #CONTENT_UNDECLARED * @see #CONTENT_ANY * @see #CONTENT_EMPTY * @see #CONTENT_MIXED * @see #CONTENT_ELEMENTS */ public int getElementContentType(String name) { Object element[] = (Object[]) m_elementInfo.get(name); if(element == null) { return CONTENT_UNDECLARED; } else { return ((Integer) element[0]).intValue(); } } /** * Look up the content model of an element. *

The result will always be null unless the content type is * CONTENT_ELEMENTS or CONTENT_MIXED. * @param name The element type name. * @return The normalised content model, as a string. * @see #getElementContentType */ public String getElementContentModel(String name) { Object element[] = (Object[]) m_elementInfo.get(name); if(element == null) { return null; } else { return (String) element[1]; } } /** * Register an element. * Array format: * element type * attribute hash table */ void setElement(String name, int contentType, String contentModel, Hashtable attributes) throws java.lang.Exception { Object element[]; // Try looking up the element element = (Object[]) m_elementInfo.get(name); // Make a new one if necessary. if(element == null) { element = new Object[3]; element[0] = new Integer(CONTENT_UNDECLARED); element[1] = null; element[2] = null; } else if(contentType != CONTENT_UNDECLARED && ((Integer) element[0]).intValue() != CONTENT_UNDECLARED) { error("multiple declarations for element type", name, null); return; } // Insert the content type, if any. if(contentType != CONTENT_UNDECLARED) { element[0] = new Integer(contentType); } // Insert the content model, if any. if(contentModel != null) { element[1] = contentModel; } // Insert the attributes, if any. if(attributes != null) { element[2] = attributes; } // Save the element info. m_elementInfo.put(name, element); } /** * Look up the attribute hash table for an element. * The hash table is the second item in the element array. */ Hashtable getElementAttributes(String name) { Object element[] = (Object[]) m_elementInfo.get(name); if(element == null) { return null; } else { return (Hashtable) element[2]; } } // // Attributes // /** * Get the declared attributes for an element type. * @param elname The name of the element type. * @return An Enumeration of all the attributes declared for * a specific element type. The results will be valid only * after the DTD (if any) has been parsed. * @see #getAttributeType * @see #getAttributeEnumeration * @see #getAttributeDefaultValueType * @see #getAttributeDefaultValue * @see #getAttributeExpandedValue */ public Enumeration declaredAttributes(String elname) { Hashtable attlist = getElementAttributes(elname); if(attlist == null) { return null; } else { return attlist.keys(); } } /** * Retrieve the declared type of an attribute. * @param name The name of the associated element. * @param aname The name of the attribute. * @return An integer constant representing the attribute type. * @see #ATTRIBUTE_UNDECLARED * @see #ATTRIBUTE_CDATA * @see #ATTRIBUTE_ID * @see #ATTRIBUTE_IDREF * @see #ATTRIBUTE_IDREFS * @see #ATTRIBUTE_ENTITY * @see #ATTRIBUTE_ENTITIES * @see #ATTRIBUTE_NMTOKEN * @see #ATTRIBUTE_NMTOKENS * @see #ATTRIBUTE_ENUMERATED * @see #ATTRIBUTE_NOTATION */ public int getAttributeType(String name, String aname) { Object attribute[] = getAttribute(name, aname); if(attribute == null) { return ATTRIBUTE_UNDECLARED; } else { return ((Integer) attribute[0]).intValue(); } } /** * Retrieve the allowed values for an enumerated attribute type. * @param name The name of the associated element. * @param aname The name of the attribute. * @return A string containing the token list. * @see #ATTRIBUTE_ENUMERATED * @see #ATTRIBUTE_NOTATION */ public String getAttributeEnumeration(String name, String aname) { Object attribute[] = getAttribute(name, aname); if(attribute == null) { return null; } else { return (String) attribute[3]; } } /** * Retrieve the default value of a declared attribute. * @param name The name of the associated element. * @param aname The name of the attribute. * @return The default value, or null if the attribute was * #IMPLIED or simply undeclared and unspecified. * @see #getAttributeExpandedValue */ public String getAttributeDefaultValue(String name, String aname) { Object attribute[] = getAttribute(name, aname); if(attribute == null) { return null; } else { return (String) attribute[1]; } } /** * Retrieve the expanded value of a declared attribute. *

All general entities will be expanded. * @param name The name of the associated element. * @param aname The name of the attribute. * @return The expanded default value, or null if the attribute was * #IMPLIED or simply undeclared * @see #getAttributeDefaultValue */ public String getAttributeExpandedValue(String name, String aname) { Object attribute[] = getAttribute(name, aname); if(attribute == null) { return null; } else if(attribute[4] == null && attribute[1] != null) { try { pushString(null, (char) 0 + (String) attribute[1] + (char) 0); attribute[4] = readLiteral(LIT_NORMALIZE | LIT_CHAR_REF | LIT_ENTITY_REF); } catch(Exception e) {} } return (String) attribute[4]; } /** * Retrieve the default value type of a declared attribute. * @see #ATTRIBUTE_DEFAULT_SPECIFIED * @see #ATTRIBUTE_DEFAULT_IMPLIED * @see #ATTRIBUTE_DEFAULT_REQUIRED * @see #ATTRIBUTE_DEFAULT_FIXED */ public int getAttributeDefaultValueType(String name, String aname) { Object attribute[] = getAttribute(name, aname); if(attribute == null) { return ATTRIBUTE_DEFAULT_UNDECLARED; } else { return ((Integer) attribute[2]).intValue(); } } /** * Register an attribute declaration for later retrieval. * Format: * - String type * - String default value * - int value type * *TODO: do something with attribute types. */ void setAttribute(String elName, String name, int type, String enumeration, String value, int valueType) throws java.lang.Exception { Hashtable attlist; Object attribute[]; // Create a new hashtable if necessary. attlist = getElementAttributes(elName); if(attlist == null) { attlist = new Hashtable(); } // Check that the attribute doesn't // already exist! if(attlist.get(name) != null) { return; } else { attribute = new Object[5]; attribute[0] = new Integer(type); attribute[1] = value; attribute[2] = new Integer(valueType); attribute[3] = enumeration; attribute[4] = null; attlist.put(name.intern(), attribute); // Use CONTENT_UNDECLARED to avoid overwriting // existing element declaration. setElement(elName, CONTENT_UNDECLARED, null, attlist); } } /** * Retrieve the three-member array representing an * attribute declaration. */ Object[] getAttribute(String elName, String name) { Hashtable attlist; Object attribute[]; attlist = getElementAttributes(elName); if(attlist == null) { return null; } attribute = (Object[]) attlist.get(name); return attribute; } // // Entities // /** * Get declared entities. * @return An Enumeration of all the entities declared for * this XML document. The results will be valid only * after the DTD (if any) has been parsed. * @see #getEntityType * @see #getEntityPublicId * @see #getEntitySystemId * @see #getEntityValue * @see #getEntityNotationName */ public Enumeration declaredEntities() { return m_entityInfo.keys(); } /** * Find the type of an entity. * @returns An integer constant representing the entity type. * @see #ENTITY_UNDECLARED * @see #ENTITY_INTERNAL * @see #ENTITY_NDATA * @see #ENTITY_TEXT */ public int getEntityType(String ename) { Object entity[] = (Object[]) m_entityInfo.get(ename); if(entity == null) { return ENTITY_UNDECLARED; } else { return ((Integer) entity[0]).intValue(); } } /** * Return an external entity's public identifier, if any. * @param ename The name of the external entity. * @return The entity's system identifier, or null if the * entity was not declared, if it is not an * external entity, or if no public identifier was * provided. * @see #getEntityType */ public String getEntityPublicId(String ename) { Object entity[] = (Object[]) m_entityInfo.get(ename); if(entity == null) { return null; } else { return (String) entity[1]; } } /** * Return an external entity's system identifier. * @param ename The name of the external entity. * @return The entity's system identifier, or null if the * entity was not declared, or if it is not an * external entity. * @see #getEntityType */ public String getEntitySystemId(String ename) { Object entity[] = (Object[]) m_entityInfo.get(ename); if(entity == null) { return null; } else { return (String) entity[2]; } } /** * Return the value of an internal entity. * @param ename The name of the internal entity. * @return The entity's value, or null if the entity was * not declared, or if it is not an internal entity. * @see #getEntityType */ public String getEntityValue(String ename) { Object entity[] = (Object[]) m_entityInfo.get(ename); if(entity == null) { return null; } else { return (String) entity[3]; } } /** * Get the notation name associated with an NDATA entity. * @param ename The NDATA entity name. * @return The associated notation name, or null if the * entity was not declared, or if it is not an * NDATA entity. * @see #getEntityType */ public String getEntityNotationName(String eName) { Object entity[] = (Object[]) m_entityInfo.get(eName); if(entity == null) { return null; } else { return (String) entity[4]; } } /** * Register an entity declaration for later retrieval. */ void setInternalEntity(String eName, String value) { setEntity(eName, ENTITY_INTERNAL, null, null, value, null); } /** * Register an external data entity. */ void setExternalDataEntity(String eName, String pubid, String sysid, String nName) { setEntity(eName, ENTITY_NDATA, pubid, sysid, null, nName); } /** * Register an external text entity. */ void setExternalTextEntity(String eName, String pubid, String sysid) { setEntity(eName, ENTITY_TEXT, pubid, sysid, null, null); } /** * Register an entity declaration for later retrieval. */ void setEntity(String eName, int eClass, String pubid, String sysid, String value, String nName) { Object entity[]; if(m_entityInfo.get(eName) == null) { entity = new Object[5]; entity[0] = new Integer(eClass); entity[1] = pubid; entity[2] = sysid; entity[3] = value; entity[4] = nName; m_entityInfo.put(eName, entity); } } // // Notations. // /** * Get declared notations. * @return An Enumeration of all the notations declared for * this XML document. The results will be valid only * after the DTD (if any) has been parsed. * @see #getNotationPublicId * @see #getNotationSystemId */ public Enumeration declaredNotations() { return m_notationInfo.keys(); } /** * Look up the public identifier for a notation. * You will normally use this method to look up a notation * that was provided as an attribute value or for an NDATA entity. * @param nname The name of the notation. * @return A string containing the public identifier, or null * if none was provided or if no such notation was * declared. * @see #getNotationSystemId */ public String getNotationPublicId(String nname) { Object notation[] = (Object[]) m_notationInfo.get(nname); if(notation == null) { return null; } else { return (String) notation[0]; } } /** * Look up the system identifier for a notation. * You will normally use this method to look up a notation * that was provided as an attribute value or for an NDATA entity. * @param nname The name of the notation. * @return A string containing the system identifier, or null * if no such notation was declared. * @see #getNotationPublicId */ public String getNotationSystemId(String nname) { Object notation[] = (Object[]) m_notationInfo.get(nname); if(notation == null) { return null; } else { return (String) notation[1]; } } /** * Register a notation declaration for later retrieval. * Format: * - public id * - system id */ void setNotation(String nname, String pubid, String sysid) throws java.lang.Exception { Object notation[]; if(m_notationInfo.get(nname) == null) { notation = new Object[2]; notation[0] = pubid; notation[1] = sysid; m_notationInfo.put(nname, notation); } else { error("multiple declarations of notation", nname, null); } } // // Location. // /** * Return the current line number. */ public int getLineNumber() { return m_line; } /** * Return the current column number. */ public int getColumnNumber() { return m_column; } ////////////////////////////////////////////////////////////////////// // High-level I/O. ////////////////////////////////////////////////////////////////////// /** * Read a single character from the readBuffer. *

The readDataChunk() method maintains the buffer. *

If we hit the end of an entity, try to pop the stack and * keep going. *

(This approach doesn't really enforce XML's rules about * entity boundaries, but this is not currently a validating * parser). *

This routine also attempts to keep track of the current * position in external entities, but it's not entirely accurate. * @return The next available input character. * @see #unread(char) * @see #unread(String) * @see #readDataChunk * @see #m_readBuffer * @see #m_line * @return The next character from the current input source. */ char readCh() throws java.lang.Exception { char c; // As long as there's nothing in the // read buffer, try reading more data // (for an external entity) or popping // the entity stack (for either). while(m_rbpos >= m_rblen) { switch(m_sourceType) { case INPUT_READER: case INPUT_EXTERNAL: case INPUT_STREAM: readDataChunk(); while(m_rblen < 1) { popInput(); if(m_rblen < 1) { readDataChunk(); } } break; default: popInput(); break; } } c = m_readBuffer[m_rbpos++]; // This is a particularly nasty bit // of code, that checks for a parameter // entity reference but peeks ahead to // catch the '%' in parameter entity // declarations. if(c == '%' && (m_context == CONTEXT_DTD || m_context == CONTEXT_ENTITYVALUE)) { char c2 = readCh(); unread(c2); if(!isWhitespace(c2)) { parsePEReference(m_context == CONTEXT_ENTITYVALUE); return readCh(); } } if(c == '\n') { m_line++; m_column = 0; } else { m_column++; } return c; } /** * Push a single character back onto the current input stream. *

This method usually pushes the character back onto * the readBuffer, while the unread(String) method treats the * string as a new internal entity. *

I don't think that this would ever be called with * readBufferPos = 0, because the methods always reads a character * before unreading it, but just in case, I've added a boundary * condition. * @param c The character to push back. * @see #readCh * @see #unread(String) * @see #unread(char[]) * @see #m_readBuffer */ void unread(char c) throws java.lang.Exception { // Normal condition. if(c == '\n') { m_line--; m_column = -1; } if(m_rbpos > 0) { m_readBuffer[--m_rbpos] = c; } else { pushString(null, new Character(c).toString()); } } /** * Push a char array back onto the current input stream. *

NOTE: you must never push back characters that you * haven't actually read: use pushString() instead. * @see #readCh * @see #unread(char) * @see #unread(String) * @see #m_readBuffer * @see #pushString */ void unread(char ch[], int length) throws java.lang.Exception { for(int i = 0; i < length; i++) { if(ch[i] == '\n') { m_line--; m_column = -1; } } if(length < m_rbpos) { m_rbpos -= length; } else { pushCharArray(null, ch, 0, length); m_sourceType = INPUT_BUFFER; } } /** * Push a new external input source. *

The source will be either an external text entity, or the DTD * external subset. *

TO DO: Right now, this method always attempts to autodetect * the encoding; in the future, it should allow the caller to * request an encoding explicitly, and it should also look at the * headers with an HTTP connection. * @param url The java.net.URL object for the entity. * @see XmlHandler#resolveEntity * @see #pushString * @see #m_sourceType * @see #pushInput * @see #detectEncoding * @see #m_sourceType * @see #m_readBuffer */ void pushURL(String ename, String publicId, String systemId, Reader reader, InputStream stream, String encoding) throws java.lang.Exception { URL url; boolean ignoreEncoding = false; // Push the existing status. pushInput(ename); // Create a new read buffer. // (Note the four-character margin) m_readBuffer = new char[READ_BUFFER_MAX + 4]; m_rbpos = 0; m_rblen = 0; m_rboverflow = -1; m_is = null; m_line = 1; m_currentByteCount = 0; // Flush any remaining data. dataBufferFlush(); // Make the URL absolute. if(systemId != null && m_externalEntity != null) { systemId = new URL(m_externalEntity.getURL(), systemId).toString(); } else if(m_baseURI != null) { try { systemId = new URL(new URL(m_baseURI), systemId).toString(); } catch(Exception e) {} } // See if the application wants to // redirect the system ID and/or // supply its own character stream. if(systemId != null && m_handler != null) { Object input = m_handler.resolveEntity(publicId, systemId); if(input != null) { if(input instanceof String) { systemId = (String) input; } else if(input instanceof InputStream) { stream = (InputStream) input; } else if(input instanceof Reader) { reader = (Reader) input; } } } // Start the entity. if(m_handler != null) { if(systemId != null) { m_handler.startExternalEntity(systemId); } else { m_handler.startExternalEntity("[external stream]"); } } // Figure out what we're reading from. if(reader != null) { // There's an explicit character stream. m_sourceType = INPUT_READER; this.m_reader = reader; tryEncodingDecl(true); return; } else if(stream != null) { m_sourceType = INPUT_STREAM; m_is = stream; } else { // We have to open our own stream // to the URL. // Set the new status m_sourceType = INPUT_EXTERNAL; url = new URL(systemId); m_externalEntity = url.openConnection(); m_externalEntity.connect(); m_is = m_externalEntity.getInputStream(); } // If we get to here, there must be // an InputStream available. if(!m_is.markSupported()) { m_is = new BufferedInputStream(m_is); } // Attempt to detect the encoding. if(encoding == null && m_externalEntity != null) { encoding = m_externalEntity.getContentEncoding(); } if(encoding != null) { checkEncoding(encoding, false); ignoreEncoding = true; } else { detectEncoding(); ignoreEncoding = false; } // Read an XML or text declaration. tryEncodingDecl(ignoreEncoding); } /** * Check for an encoding declaration. */ void tryEncodingDecl(boolean ignoreEncoding) throws java.lang.Exception { // Read the XML/Encoding declaration. if(tryRead(" 0) { parseTextDecl(ignoreEncoding); } else { parseXMLDecl(ignoreEncoding); } } else { unread("xml".toCharArray(), 3); parsePI(); } } } /** * Attempt to detect the encoding of an entity. *

The trick here (as suggested in the XML standard) is that * any entity not in UTF-8, or in UCS-2 with a byte-order mark, * must begin with an XML declaration or an encoding * declaration; we simply have to look for "<?XML" in various * encodings. *

This method has no way to distinguish among 8-bit encodings. * Instead, it assumes UTF-8, then (possibly) revises its assumption * later in checkEncoding(). Any ASCII-derived 8-bit encoding * should work, but most will be rejected later by checkEncoding(). *

I don't currently detect EBCDIC, since I'm concerned that it * could also be a valid UTF-8 sequence; I'll have to do more checking * later. * @see #tryEncoding(byte[], byte, byte, byte, byte) * @see #tryEncoding(byte[], byte, byte) * @see #checkEncoding * @see #read8bitEncodingDeclaration */ void detectEncoding() throws java.lang.Exception { byte signature[] = new byte[4]; // Read the first four bytes for // autodetection. m_is.mark(4); m_is.read(signature); m_is.reset(); // Look for a known signature. if(tryEncoding(signature, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x3c)) { // UCS-4 must begin with "Utility routine for detectEncoding(). *

Always looks for some part of "Looks for a UCS-2 byte-order mark. *

Utility routine for detectEncoding(). * @param sig The first four bytes read. * @param b1 The first byte of the signature * @param b2 The second byte of the signature * @see #detectEncoding */ boolean tryEncoding(byte sig[], byte b1, byte b2) { return ((sig[0] == b1) && (sig[1] == b2)); } /** * This method pushes a string back onto input. *

It is useful either as the expansion of an internal entity, * or for backtracking during the parse. *

Call pushCharArray() to do the actual work. * @param s The string to push back onto input. * @see #pushCharArray */ void pushString(String ename, String s) throws java.lang.Exception { char ch[] = s.toCharArray(); pushCharArray(ename, ch, 0, ch.length); } /** * Push a new internal input source. *

This method is useful for expanding an internal entity, * or for unreading a string of characters. It creates a new * readBuffer containing the characters in the array, instead * of characters converted from an input byte stream. *

I've added a couple of optimisations: don't push zero- * length strings, and just push back a single character * for 1-character strings; this should save some time and memory. * @param ch The char array to push. * @see #pushString * @see #pushURL * @see #m_readBuffer * @see #m_sourceType * @see #pushInput */ void pushCharArray(String ename, char ch[], int start, int length) throws java.lang.Exception { // Push the existing status pushInput(ename); m_sourceType = INPUT_INTERNAL; m_readBuffer = ch; m_rbpos = start; m_rblen = length; m_rboverflow = -1; } /** * Save the current input source onto the stack. *

This method saves all of the global variables associated with * the current input source, so that they can be restored when a new * input source has finished. It also tests for entity recursion. *

The method saves the following global variables onto a stack * using a fixed-length array: *

*
1. sourceType *
2. externalEntity *
3. readBuffer *
4. readBufferPos *
5. readBufferLength *
6. line *
7. encoding *

This method restores all of the global variables associated with * the current input source. * @exception java.io.EOFException * If there are no more entries on the input stack. * @see #pushInput * @see #m_sourceType * @see #m_externalEntity * @see #m_readBuffer * @see #m_rbpos * @see #m_rblen * @see #m_line * @see #m_encoding */ void popInput() throws java.lang.Exception { Object input[]; switch(m_sourceType) { case INPUT_EXTERNAL: dataBufferFlush(); if(m_handler != null && m_externalEntity != null) { m_handler.endExternalEntity(m_externalEntity.getURL().toString()); } break; case INPUT_STREAM: dataBufferFlush(); if(m_baseURI != null) { if(m_handler != null) { m_handler.endExternalEntity(m_baseURI); } } break; case INPUT_READER: dataBufferFlush(); if(m_baseURI != null) { if(m_handler != null) { m_handler.endExternalEntity(m_baseURI); } } break; } // Throw an EOFException if there // is nothing else to pop. if(m_inputStack.isEmpty()) { throw new EOFException(); } else { input = (Object[]) m_inputStack.pop(); m_entityStack.pop(); } m_sourceType = ((Integer) input[0]).intValue(); m_externalEntity = (URLConnection) input[1]; m_readBuffer = (char[]) input[2]; m_rbpos = ((Integer) input[3]).intValue(); m_rblen = ((Integer) input[4]).intValue(); m_line = ((Integer) input[5]).intValue(); m_encoding = ((Integer) input[6]).intValue(); m_rboverflow = ((Integer) input[7]).intValue(); m_is = (InputStream) input[8]; m_currentByteCount = ((Integer) input[9]).intValue(); m_column = ((Integer) input[10]).intValue(); m_reader = (Reader) input[11]; } /** * Return true if we can read the expected character. *

Note that the character will be removed from the input stream * on success, but will be put back on failure. Do not attempt to * read the character again if the method succeeds. * @param delim The character that should appear next. For a * insensitive match, you must supply this in upper-case. * @return true if the character was successfully read, or false if * it was not. * @see #tryRead(String) */ boolean tryRead(char delim) throws java.lang.Exception { char c; // Read the character c = readCh(); // Test for a match, and push the character // back if the match fails. if(c == delim) { return true; } else { unread(c); return false; } } /** * Return true if we can read the expected string. *

This is simply a convenience method. *

Note that the string will be removed from the input stream * on success, but will be put back on failure. Do not attempt to * read the string again if the method succeeds. *

This method will push back a character rather than an * array whenever possible (probably the majority of cases). *

NOTE: This method currently has a hard-coded limit * of 100 characters for the delimiter. * @param delim The string that should appear next. * @return true if the string was successfully read, or false if * it was not. * @see #tryRead(char) */ boolean tryRead(String delim) throws java.lang.Exception { char ch[] = delim.toCharArray(); char c; // Compare the input, character- // by character. for(int i = 0; i < ch.length; i++) { c = readCh(); if(c != ch[i]) { unread(c); if(i != 0) { unread(ch, i); } return false; } } return true; } /** * Return true if we can read some whitespace. *

This is simply a convenience method. *

This method will push back a character rather than an * array whenever possible (probably the majority of cases). * @return true if whitespace was found. */ boolean tryWhitespace() throws java.lang.Exception { char c; c = readCh(); if(isWhitespace(c)) { skipWhitespace(); return true; } else { unread(c); return false; } } /** * Read all data until we find the specified string. *

This is especially useful for scanning marked sections. *

This is a a little inefficient right now, since it calls tryRead() * for every character. * @param delim The string delimiter * @see #tryRead(String, boolean) * @see #readCh */ void parseUntil(String delim) throws java.lang.Exception { char c; int startLine = m_line; try { while(!tryRead(delim)) { c = readCh(); dataBufferAppend(c); } } catch(EOFException e) { error("end of input while looking for delimiter (started on line " + startLine + ')', null, delim); } } /** * Skip all data until we find the specified string. *

This is especially useful for scanning comments. *

This is a a little inefficient right now, since it calls tryRead() * for every character. * @param delim The string delimiter * @see #tryRead(String, boolean) * @see #readCh */ void skipUntil(String delim) throws java.lang.Exception { while(!tryRead(delim)) { readCh(); } } /** * Read just the encoding declaration (or XML declaration) at the * start of an external entity. * When this method is called, we know that the declaration is * present (or appears to be). We also know that the entity is * in some sort of ASCII-derived 8-bit encoding. * The idea of this is to let us read what the 8-bit encoding is * before we've committed to converting any more of the file; the * XML or encoding declaration must be in 7-bit ASCII, so we're * safe as long as we don't go past it. */ void read8bitEncodingDeclaration() throws java.lang.Exception { int ch; m_rbpos = m_rblen = 0; while(true) { ch = m_is.read(); m_readBuffer[m_rblen++] = (char) ch; switch(ch) { case '>': return; case -1: error("end of file before end of XML or encoding declaration.", null, "?>"); return; } if(m_readBuffer.length == m_rblen) { error("unfinished XML or encoding declaration", null, null); } } } ////////////////////////////////////////////////////////////////////// // Low-level I/O. ////////////////////////////////////////////////////////////////////// /** * Read a chunk of data from an external input source. *

This is simply a front-end that fills the rawReadBuffer * with bytes, then calls the appropriate encoding handler. * @see #m_encoding * @see #m_rawReadBuffer * @see #m_readBuffer * @see #filterCR * @see #copyUtf8ReadBuffer * @see #copyIso8859_1ReadBuffer * @see #copyUcs_2ReadBuffer * @see #copyUcs_4ReadBuffer */ void readDataChunk() throws java.lang.Exception { int count; // See if we have any overflow. if(m_rboverflow > -1) { m_readBuffer[0] = (char) m_rboverflow; m_rboverflow = -1; m_rbpos = 1; m_sawCR = true; } else { m_rbpos = 0; m_sawCR = false; } // Special situation -- we're taking // input from a character stream. if(m_sourceType == INPUT_READER) { count = m_reader.read(m_readBuffer, m_rbpos, READ_BUFFER_MAX - 1); if(count < 0) { m_rblen = -1; } else { m_rblen = m_rbpos + count; filterCR(); m_sawCR = false; } return; } // Read as many bytes as possible // into the read buffer. count = m_is.read(m_rawReadBuffer, 0, READ_BUFFER_MAX); // Dispatch to an encoding-specific // reader method to populate the // readBuffer. switch(m_encoding) { case ENCODING_UTF_8: copyUtf8ReadBuffer(count); break; case ENCODING_ISO_8859_1: copyIso8859_1ReadBuffer(count); break; case ENCODING_UCS_2_12: copyUcs2ReadBuffer(count, 8, 0); break; case ENCODING_UCS_2_21: copyUcs2ReadBuffer(count, 0, 8); break; case ENCODING_UCS_4_1234: copyUcs4ReadBuffer(count, 24, 16, 8, 0); break; case ENCODING_UCS_4_4321: copyUcs4ReadBuffer(count, 0, 8, 16, 24); break; case ENCODING_UCS_4_2143: copyUcs4ReadBuffer(count, 16, 24, 0, 8); break; case ENCODING_UCS_4_3412: copyUcs4ReadBuffer(count, 8, 0, 24, 16); break; } // Filter out all carriage returns // if we've seen any. if(m_sawCR) { filterCR(); m_sawCR = false; } // Reset the position. m_rbpos = 0; m_currentByteCount += count; } /** * Filter carriage returns in the read buffer. *

CRLF becomes LF; CR becomes LF. * @see #readDataChunk * @see #m_readBuffer * @see #m_rboverflow */ void filterCR() { int i, j; m_rboverflow = -1; loop : for(i = 0, j = 0; j < m_rblen; i++, j++) { switch(m_readBuffer[j]) { case '\r': if(j == m_rblen - 1) { m_rboverflow = '\r'; m_rblen--; break loop; } else if(m_readBuffer[j + 1] == '\n') { j++; } m_readBuffer[i] = '\n'; break; case '\n': default: m_readBuffer[i] = m_readBuffer[j]; break; } } m_rblen = i; } /** * Convert a buffer of UTF-8-encoded bytes into UTF-16 characters. *

When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. *

The tricky part of this is dealing with UTF-8 multi-byte * sequences, but it doesn't seem to slow things down too much. * @param count The number of bytes to convert. * @see #readDataChunk * @see #m_rawReadBuffer * @see #m_readBuffer * @see #getNextUtf8Byte */ void copyUtf8ReadBuffer(int count) throws java.lang.Exception { int i = 0; int j = m_rbpos; int b1; // boolean isSurrogate = false; while(i < count) { b1 = m_rawReadBuffer[i++]; // isSurrogate = false; // Determine whether we are dealing // with a one-, two-, three-, or four- // byte sequence. if((b1 & 0x80) == 0) { // 1-byte sequence: 000000000xxxxxxx = 0xxxxxxx m_readBuffer[j++] = (char) b1; } else if((b1 & 0xe0) == 0xc0) { // 2-byte sequence: 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx m_readBuffer[j++] = (char) (((b1 & 0x1f) << 6) | getNextUtf8Byte(i++, count)); } else if((b1 & 0xf0) == 0xe0) { // 3-byte sequence: zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx m_readBuffer[j++] = (char) (((b1 & 0x0f) << 12) | (getNextUtf8Byte(i++, count) << 6) | getNextUtf8Byte(i++, count)); } else if((b1 & 0xf8) == 0xf0) { // 4-byte sequence: 11101110wwwwzzzzyy + 110111yyyyxxxxxx // = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx // (uuuuu = wwww + 1) // isSurrogate = true; int b2 = getNextUtf8Byte(i++, count); int b3 = getNextUtf8Byte(i++, count); int b4 = getNextUtf8Byte(i++, count); m_readBuffer[j++] = (char) (0xd800 | ((((b1 & 0x07) << 2) | ((b2 & 0x30) >> 4) - 1) << 6) | ((b2 & 0x0f) << 2) | ((b3 & 0x30) >> 4)); m_readBuffer[j++] = (char) (0xdc | ((b3 & 0x0f) << 6) | b4); // TODO: test that surrogate value is legal. } else { // Otherwise, the 8th bit may not be set in UTF-8 encodingError("bad start for UTF-8 multi-byte sequence", b1, i); } if(m_readBuffer[j - 1] == '\r') { m_sawCR = true; } } // How many characters have we read? m_rblen = j; } /** * Return the next byte value in a UTF-8 sequence. * If it is not possible to get a byte from the current * entity, throw an exception. * @param pos The current position in the rawReadBuffer. * @param count The number of bytes in the rawReadBuffer * @return The significant six bits of a non-initial byte in * a UTF-8 sequence. * @exception EOFException If the sequence is incomplete. */ int getNextUtf8Byte(int pos, int count) throws java.lang.Exception { int val; // Take a character from the buffer // or from the actual input stream. if(pos < count) { val = m_rawReadBuffer[pos]; } else { val = m_is.read(); if(val == -1) { encodingError("unfinished multi-byte UTF-8 sequence at EOF", -1, pos); } } // Check for the correct bits at the // start. if((val & 0xc0) != 0x80) { encodingError("bad continuation of multi-byte UTF-8 sequence", val, pos + 1); } // Return the significant bits. return (val & 0x3f); } /** * Convert a buffer of ISO-8859-1-encoded bytes into UTF-16 characters. *

When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. *

This is a direct conversion, with no tricks. * @param count The number of bytes to convert. * @see #readDataChunk * @see #m_rawReadBuffer * @see #m_readBuffer */ void copyIso8859_1ReadBuffer(int count) { int i, j; for(i = 0, j = m_rbpos; i < count; i++, j++) { m_readBuffer[j] = (char) (m_rawReadBuffer[i] & 0xff); if(m_readBuffer[j] == '\r') { m_sawCR = true; } } m_rblen = j; } /** * Convert a buffer of UCS-2-encoded bytes into UTF-16 characters. *

When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. * @param count The number of bytes to convert. * @param shift1 The number of bits to shift byte 1. * @param shift2 The number of bits to shift byte 2 * @see #readDataChunk * @see #m_rawReadBuffer * @see #m_readBuffer */ void copyUcs2ReadBuffer(int count, int shift1, int shift2) throws java.lang.Exception { int j = m_rbpos; if(count > 0 && (count % 2) != 0) { encodingError("odd number of bytes in UCS-2 encoding", -1, count); } for(int i = 0; i < count; i += 2) { m_readBuffer[j++] = (char) (((m_rawReadBuffer[i] & 0xff) << shift1) | ((m_rawReadBuffer[i + 1] & 0xff) << shift2)); if(m_readBuffer[j - 1] == '\r') { m_sawCR = true; } } m_rblen = j; } /** * Convert a buffer of UCS-4-encoded bytes into UTF-16 characters. *

When readDataChunk() calls this method, the raw bytes are in * rawReadBuffer, and the final characters will appear in * readBuffer. *