/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999-2002 The Apache Software Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.apache.org. For more
* information on the Apache Software Foundation, please see
*/
/**
* Implements the entity scanner methods in
* the context of XML 1.1.
*
* @xerces.internal
*
* @author Michael Glavassevich, IBM
* @author Neil Graham, IBM
*/
public class XML11EntityScanner
extends XMLEntityScanner {
//
// Constructors
//
/** Default constructor. */
public XML11EntityScanner() {
super();
} // <init>()
//
// XMLEntityScanner methods
//
/**
* Returns the next character on the input.
* <p>
* <strong>Note:</strong> The character is <em>not</em> consumed.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
// load more characters, if needed
load(0, true);
}
// peek at character
// return peeked character
if (fCurrentEntity.isExternal()) {
return (c != '\r' && c != 0x85 && c != 0x2028) ? c : '\n';
}
else {
return c;
}
} // peekChar():int
/**
* Returns the next character on the input.
* <p>
* <strong>Note:</strong> The character is consumed.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
// load more characters, if needed
load(0, true);
}
// scan character
boolean external = false;
if (c == '\n' ||
load(1, false);
}
if (c == '\r' && external) {
}
}
c = '\n';
}
// return character that was scanned
return c;
} // scanChar():int
/**
* Returns a string matching the NMTOKEN production appearing immediately
* on the input as a symbol, or null if NMTOKEN Name string is present.
* <p>
* <strong>Note:</strong> The NMTOKEN characters are consumed.
* <p>
* <strong>Note:</strong> The string returned must be a symbol. The
* SymbolTable can be used for this purpose.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*
* @see com.sun.org.apache.xerces.internal.util.SymbolTable
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11Name
*/
// load more characters, if needed
load(0, true);
}
// scan nmtoken
do {
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
break;
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
else {
break;
}
}
while (true);
// return nmtoken
if (length > 0) {
}
return symbol;
} // scanNmtoken():String
/**
* Returns a string matching the Name production appearing immediately
* on the input as a symbol, or null if no Name string is present.
* <p>
* <strong>Note:</strong> The Name characters are consumed.
* <p>
* <strong>Note:</strong> The string returned must be a symbol. The
* SymbolTable can be used for this purpose.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*
* @see com.sun.org.apache.xerces.internal.util.SymbolTable
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11Name
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11NameStart
*/
// load more characters, if needed
load(0, true);
}
// scan name
offset = 0;
if (load(1, false)) {
return symbol;
}
}
}
offset = 0;
if (load(1, false)) {
return null;
}
}
return null;
}
offset = 0;
if (load(2, false)) {
return symbol;
}
}
}
else {
return null;
}
do {
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
break;
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
else {
break;
}
}
while (true);
// return name
if (length > 0) {
}
return symbol;
} // scanName():String
/**
* Returns a string matching the NCName production appearing immediately
* on the input as a symbol, or null if no NCName string is present.
* <p>
* <strong>Note:</strong> The NCName characters are consumed.
* <p>
* <strong>Note:</strong> The string returned must be a symbol. The
* SymbolTable can be used for this purpose.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*
* @see com.sun.org.apache.xerces.internal.util.SymbolTable
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11NCName
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11NCNameStart
*/
// load more characters, if needed
load(0, true);
}
// scan name
offset = 0;
if (load(1, false)) {
return symbol;
}
}
}
offset = 0;
if (load(1, false)) {
return null;
}
}
return null;
}
offset = 0;
if (load(2, false)) {
return symbol;
}
}
}
else {
return null;
}
do {
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
break;
}
// bad luck we have to resize our buffer
}
else {
}
offset = 0;
break;
}
}
}
else {
break;
}
}
while (true);
// return name
if (length > 0) {
}
return symbol;
} // scanNCName():String
/**
* Scans a qualified name from the input, setting the fields of the
* QName structure appropriately.
* <p>
* <strong>Note:</strong> The qualified name characters are consumed.
* <p>
* <strong>Note:</strong> The strings used to set the values of the
* QName structure must be symbols. The SymbolTable can be used for
* this purpose.
*
* @param qname The qualified name structure to fill.
*
* @return Returns true if a qualified name appeared immediately on
* the input and was scanned, false otherwise.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*
* @see com.sun.org.apache.xerces.internal.util.SymbolTable
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11Name
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11NameStart
*/
// load more characters, if needed
load(0, true);
}
// scan qualified name
offset = 0;
if (load(1, false)) {
return true;
}
}
}
offset = 0;
if (load(1, false)) {
return false;
}
}
return false;
}
offset = 0;
if (load(2, false)) {
return true;
}
}
}
else {
return false;
}
int index = -1;
boolean sawIncompleteSurrogatePair = false;
do {
if (ch == ':') {
if (index != -1) {
break;
}
}
// bad luck we have to resize our buffer
}
else {
}
if (index != -1) {
}
offset = 0;
break;
}
}
}
// bad luck we have to resize our buffer
}
else {
}
if (index != -1) {
}
offset = 0;
sawIncompleteSurrogatePair = true;
break;
}
}
sawIncompleteSurrogatePair = true;
break;
}
// bad luck we have to resize our buffer
}
else {
}
if (index != -1) {
}
offset = 0;
break;
}
}
}
else {
break;
}
}
while (true);
if (length > 0) {
if (index != -1) {
"IllegalQName",
null,
}
}
else {
}
return true;
}
return false;
} // scanQName(QName):boolean
/**
* Scans a range of parsed character data, setting the fields of the
* XMLString structure, appropriately.
* <p>
* <strong>Note:</strong> The characters are consumed.
* <p>
* <strong>Note:</strong> This method does not guarantee to return
* the longest run of parsed character data. This method may return
* before markup due to reaching the end of the input buffer or any
* other reason.
* <p>
* <strong>Note:</strong> The fields contained in the XMLString
* structure are not guaranteed to remain valid upon subsequent calls
* to the entity scanner. Therefore, the caller is responsible for
* immediately using the returned character data or making a copy of
* the character data.
*
* @param content The content structure to fill.
*
* @return Returns the next character on the input, if known. This
* value may be -1 but this does <em>note</em> designate
* end of file.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
// load more characters, if needed
load(0, true);
}
load(1, false);
}
// normalize newlines
int newlines = 0;
do {
if ((c == '\r' ) && external) {
newlines++;
offset = 0;
break;
}
}
offset++;
}
/*** NEWLINE NORMALIZATION ***/
else {
newlines++;
}
}
newlines++;
offset = 0;
break;
}
}
}
else {
break;
}
}
return -1;
}
}
// inner loop, scanning for content
if (external) {
break;
}
}
}
else {
// In internal entities control characters are allowed to appear unescaped.
if (!XML11Char.isXML11InternalEntityContent(c)) {
break;
}
}
}
// return next character
// REVISIT: Does this need to be updated to fix the
// #x0D ^#x0A newline normalization problem? -Ac
c = '\n';
}
}
else {
c = -1;
}
return c;
} // scanContent(XMLString):int
/**
* Scans a range of attribute value data, setting the fields of the
* XMLString structure, appropriately.
* <p>
* <strong>Note:</strong> The characters are consumed.
* <p>
* <strong>Note:</strong> This method does not guarantee to return
* the longest run of attribute value data. This method may return
* before the quote character due to reaching the end of the input
* buffer or any other reason.
* <p>
* <strong>Note:</strong> The fields contained in the XMLString
* structure are not guaranteed to remain valid upon subsequent calls
* to the entity scanner. Therefore, the caller is responsible for
* immediately using the returned character data or making a copy of
* the character data.
*
* @param quote The quote character that signifies the end of the
* attribute value data.
* @param content The content structure to fill.
*
* @return Returns the next character on the input, if known. This
* value may be -1 but this does <em>note</em> designate
* end of file.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
throws IOException {
// load more characters, if needed
load(0, true);
}
load(1, false);
}
// normalize newlines
int newlines = 0;
do {
if ((c == '\r' ) && external) {
newlines++;
offset = 0;
break;
}
}
offset++;
}
/*** NEWLINE NORMALIZATION ***/
else {
newlines++;
}
}
newlines++;
offset = 0;
break;
}
}
}
else {
break;
}
}
return -1;
}
}
// scan literal value
if (external) {
|| c == 0x85 || c == 0x2028) {
break;
}
}
}
else {
// In internal entities control characters are allowed to appear unescaped.
break;
}
}
}
// return next character
// NOTE: We don't want to accidentally signal the
// end of the literal if we're expanding an
// entity appearing in the literal. -Ac
c = -1;
}
}
else {
c = -1;
}
return c;
} // scanLiteral(int,XMLString):int
/**
* Scans a range of character data up to the specicied delimiter,
* setting the fields of the XMLString structure, appropriately.
* <p>
* <strong>Note:</strong> The characters are consumed.
* <p>
* <strong>Note:</strong> This assumes that the internal buffer is
* at least the same size, or bigger, than the length of the delimiter
* and that the delimiter contains at least one character.
* <p>
* <strong>Note:</strong> This method does not guarantee to return
* the longest run of character data. This method may return before
* the delimiter due to reaching the end of the input buffer or any
* other reason.
* <p>
* <strong>Note:</strong> The fields contained in the XMLString
* structure are not guaranteed to remain valid upon subsequent calls
* to the entity scanner. Therefore, the caller is responsible for
* immediately using the returned character data or making a copy of
* the character data.
*
* @param delimiter The string that signifies the end of the character
* data to be scanned.
* @param data The data structure to fill.
*
* @return Returns true if there is more data to scan, false otherwise.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
throws IOException {
boolean done = false;
do {
// load more characters, if needed
load(0, true);
}
boolean bNextEntity = false;
&& (!bNextEntity))
{
0,
}
// something must be wrong with the input: e.g., file ends an unterminated comment
load(0,true);
return false;
}
// normalize newlines
int newlines = 0;
do {
if ((c == '\r' ) && external) {
newlines++;
offset = 0;
break;
}
}
offset++;
}
/*** NEWLINE NORMALIZATION ***/
else {
newlines++;
}
}
newlines++;
offset = 0;
break;
}
}
}
else {
break;
}
}
return true;
}
}
// iterate over buffer looking for delimiter
if (external) {
if (c == charAt0) {
// looks like we just hit the delimiter
for (int i = 1; i < delimLen; i++) {
fCurrentEntity.position -= i;
break OUTER;
}
break;
}
}
done = true;
break;
}
}
else if (c == '\n' || c == '\r' || c == 0x85 || c == 0x2028) {
break;
}
// In external entities control characters cannot appear
// as literals so do not skip over them.
else if (!XML11Char.isXML11ValidLiteral(c)) {
return true;
}
}
}
else {
if (c == charAt0) {
// looks like we just hit the delimiter
for (int i = 1; i < delimLen; i++) {
fCurrentEntity.position -= i;
break OUTER;
}
break;
}
}
done = true;
break;
}
}
else if (c == '\n') {
break;
}
// Control characters are allowed to appear as literals
// in internal entities.
else if (!XML11Char.isXML11Valid(c)) {
return true;
}
}
}
if (done) {
}
// return true if string was skipped
} while (!done);
return !done;
} // scanData(String,XMLString)
/**
* Skips a character appearing immediately on the input.
* <p>
* <strong>Note:</strong> The character is consumed only if it matches
* the specified character.
*
* @param c The character to skip.
*
* @return Returns true if the character was skipped.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
// load more characters, if needed
load(0, true);
}
// skip character
if (cc == c) {
if (c == '\n') {
}
else {
}
return true;
}
return true;
}
// handle newlines
load(1, false);
}
}
return true;
}
// character was not skipped
return false;
} // skipChar(int):boolean
/**
* Skips space characters appearing immediately on the input.
* <p>
* <strong>Note:</strong> The characters are consumed only if they are
* space characters.
*
* @return Returns true if at least one space character was skipped.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*
* @see com.sun.org.apache.xerces.internal.util.XMLChar#isSpace
* @see com.sun.org.apache.xerces.internal.util.XML11Char#isXML11Space
*/
// load more characters, if needed
load(0, true);
}
//we are doing this check only in skipSpace() because it is called by
//fMiscDispatcher and we want the parser to exit gracefully when document
//is well-formed.
//it is possible that end of document is reached and
//fCurrentEntity becomes null
//nothing was read so entity changed 'false' should be returned.
if(fCurrentEntity == null){
return false ;
}
// skip spaces
// External -- Match: S + 0x85 + 0x2028, and perform end of line normalization
if (fCurrentEntity.isExternal()) {
if (XML11Char.isXML11Space(c)) {
do {
boolean entityChanged = false;
// handle newlines
if (c == '\n' || c == '\r' || c == 0x85 || c == 0x2028) {
if (!entityChanged) {
// the load change the position to be 1,
// need to restore it when entity not changed
} else if(fCurrentEntity == null){
return true ;
}
}
if (c == '\r') {
// REVISIT: Does this need to be updated to fix the
// #x0D ^#x0A newline normalization problem? -Ac
}
}
}
else {
}
// load more characters, if needed
if (!entityChanged)
load(0, true);
if(fCurrentEntity == null){
return true ;
}
}
return true;
}
}
// Internal -- Match: S (only)
do {
boolean entityChanged = false;
// handle newlines
if (c == '\n') {
if (!entityChanged) {
// the load change the position to be 1,
// need to restore it when entity not changed
} else if(fCurrentEntity == null){
return true ;
}
}
}
else {
}
// load more characters, if needed
if (!entityChanged)
load(0, true);
if(fCurrentEntity == null){
return true ;
}
}
return true;
}
// no spaces were found
return false;
} // skipSpaces():boolean
/**
* Skips the specified string appearing immediately on the input.
* <p>
* <strong>Note:</strong> The characters are consumed only if they are
* space characters.
*
* @param s The string to skip.
*
* @return Returns true if the string was skipped.
*
* @throws IOException Thrown if i/o error occurs.
* @throws EOFException Thrown on end of file.
*/
// load more characters, if needed
load(0, true);
}
// skip string
for (int i = 0; i < length; i++) {
if (c != s.charAt(i)) {
return false;
}
// REVISIT: Can a string to be skipped cross an
// entity boundary? -Ac
if (load(i + 1, false)) {
return false;
}
}
}
return true;
} // skipString(String):boolean
} // class XML11EntityScanner