/**
* Scans a processing data. This is needed to handle the situation where a document starts with a
* processing instruction whose target name <em>starts with</em> "xml". (e.g. xmlfoo)
*
* <p><strong>Note:</strong> This method uses fStringBuffer, anything in it at the time of calling
* is lost.
*
* @param target The PI target
* @param data The string to fill in with the data
*/
protected void scanPIData(String target, XMLString data) throws IOException, XNIException {
// check target
if (target.length() == 3) {
char c0 = Character.toLowerCase(target.charAt(0));
char c1 = Character.toLowerCase(target.charAt(1));
char c2 = Character.toLowerCase(target.charAt(2));
if (c0 == 'x' && c1 == 'm' && c2 == 'l') {
reportFatalError("ReservedPITarget", null);
}
}
// spaces
if (!fEntityScanner.skipSpaces()) {
if (fEntityScanner.skipString("?>")) {
// we found the end, there is no data
data.clear();
return;
} else {
if (fNamespaces && fEntityScanner.peekChar() == ':') {
fEntityScanner.scanChar();
XMLStringBuffer colonName = new XMLStringBuffer(target);
colonName.append(":");
String str = fEntityScanner.scanName();
if (str != null) colonName.append(str);
reportFatalError("ColonNotLegalWithNS", new Object[] {colonName.toString()});
fEntityScanner.skipSpaces();
} else {
// if there is data there should be some space
reportFatalError("SpaceRequiredInPI", null);
}
}
}
fStringBuffer.clear();
// data
if (fEntityScanner.scanData("?>", fStringBuffer)) {
do {
int c = fEntityScanner.peekChar();
if (c != -1) {
if (XMLChar.isHighSurrogate(c)) {
scanSurrogates(fStringBuffer);
} else if (isInvalidLiteral(c)) {
reportFatalError("InvalidCharInPI", new Object[] {Integer.toHexString(c)});
fEntityScanner.scanChar();
}
}
} while (fEntityScanner.scanData("?>", fStringBuffer));
}
data.setValues(fStringBuffer);
} // scanPIData(String,XMLString)
/**
* Scans a comment.
*
* <p>
*
* <pre>
* [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
* </pre>
*
* <p><strong>Note:</strong> Called after scanning past '<!--' <strong>Note:</strong> This
* method uses fString, anything in it at the time of calling is lost.
*
* @param text The buffer to fill in with the text.
*/
protected void scanComment(XMLStringBuffer text) throws IOException, XNIException {
// text
// REVISIT: handle invalid character, eof
text.clear();
while (fEntityScanner.scanData("--", text)) {
int c = fEntityScanner.peekChar();
if (c != -1) {
if (XMLChar.isHighSurrogate(c)) {
scanSurrogates(text);
} else if (isInvalidLiteral(c)) {
reportFatalError("InvalidCharInComment", new Object[] {Integer.toHexString(c)});
fEntityScanner.scanChar();
}
}
}
if (!fEntityScanner.skipChar('>')) {
reportFatalError("DashDashInComment", null);
}
} // scanComment()
/**
* Scans a pseudo attribute.
*
* @param scanningTextDecl True if scanning this pseudo-attribute for a TextDecl; false if
* scanning XMLDecl. This flag is needed to report the correct type of error.
* @param value The string to fill in with the attribute value.
* @return The name of the attribute
* <p><strong>Note:</strong> This method uses fStringBuffer2, anything in it at the time of
* calling is lost.
*/
public String scanPseudoAttribute(boolean scanningTextDecl, XMLString value)
throws IOException, XNIException {
// REVISIT: This method is used for generic scanning of
// pseudo attributes, but since there are only three such
// attributes: version, encoding, and standalone there are
// for performant ways of scanning them. Every decl must
// have a version, and in TextDecls this version must
// be followed by an encoding declaration. Also the
// methods we invoke on the scanners allow non-ASCII
// characters to be parsed in the decls, but since
// we don't even know what the actual encoding of the
// document is until we scan the encoding declaration
// you cannot reliably read any characters outside
// of the ASCII range here. -- mrglavas
String name = fEntityScanner.scanName();
XMLEntityManager.print(fEntityManager.getCurrentEntity());
if (name == null) {
reportFatalError("PseudoAttrNameExpected", null);
}
fEntityScanner.skipDeclSpaces();
if (!fEntityScanner.skipChar('=')) {
reportFatalError(
scanningTextDecl ? "EqRequiredInTextDecl" : "EqRequiredInXMLDecl", new Object[] {name});
}
fEntityScanner.skipDeclSpaces();
int quote = fEntityScanner.peekChar();
if (quote != '\'' && quote != '"') {
reportFatalError(
scanningTextDecl ? "QuoteRequiredInTextDecl" : "QuoteRequiredInXMLDecl",
new Object[] {name});
}
fEntityScanner.scanChar();
int c = fEntityScanner.scanLiteral(quote, value);
if (c != quote) {
fStringBuffer2.clear();
do {
fStringBuffer2.append(value);
if (c != -1) {
if (c == '&' || c == '%' || c == '<' || c == ']') {
fStringBuffer2.append((char) fEntityScanner.scanChar());
}
// REVISIT: Even if you could reliably read non-ASCII chars
// why bother scanning for surrogates here? Only ASCII chars
// match the productions in XMLDecls and TextDecls. -- mrglavas
else if (XMLChar.isHighSurrogate(c)) {
scanSurrogates(fStringBuffer2);
} else if (isInvalidLiteral(c)) {
String key = scanningTextDecl ? "InvalidCharInTextDecl" : "InvalidCharInXMLDecl";
reportFatalError(key, new Object[] {Integer.toString(c, 16)});
fEntityScanner.scanChar();
}
}
c = fEntityScanner.scanLiteral(quote, value);
} while (c != quote);
fStringBuffer2.append(value);
value.setValues(fStringBuffer2);
}
if (!fEntityScanner.skipChar(quote)) {
reportFatalError(
scanningTextDecl ? "CloseQuoteMissingInTextDecl" : "CloseQuoteMissingInXMLDecl",
new Object[] {name});
}
// return
return name;
} // scanPseudoAttribute(XMLString):String