Some of the methods on this class are intended for applications to * use directly. Those methods access the JavaBeans properties (used * to enable XHTML format output, or pretty printing), * or are the SAX properties which write out various kinds * of XML information. Subclasses are expected to add new behaviors, * not to modify current behavior, so many such methods are final.
* *To reuse an EchoHandler you must provide it with a new Writer, since * this handler closes the writer it was given as part of its endDocument() * handling. (XML documents have an end of input, and the way to encode * that on a stream is to close it.)
* *Note that any relative URIs in the source document, as found in * entity and notation declarations, ought to have been fully resolved by * the parser providing events to this handler. This means that the * output text should only have fully resolved URIs, which may not be * the desired behavior in cases where later binding is desired. In * such cases, you may wish to investigate using PUBLIC identifiers * and a catalog, or URNs and some other scheme.
* *Users should note that SAX2 has problems with * how it reports the beginning and end of entities, where those entities are * used to construct other elements such as declarations in a DTD, attribute * values, or conditional sections. This handler will not attempt * to recreate such entity references.
* *Also, declarations for attributes of type NOTATION are not fully * reported by SAX2; the particular notations which are legal * are not yet reported. This class reports the permitted notations as * being the single _unknown_ notation name (which will likely * produce errors if the output is validated, regardless of whether the * original document was valid).
* *Note that due to SAX2 defaults, you need to manually * ensure that the input events are XML-conformant with respect to namespace * prefixes and declarations. {@link xml.pipeline.NSFilter} is * a solution to this problem, in the context of processing pipelines. * Something as simple as connecting this handler to a parser may no longer * generate the correct output. Another workaround is to ensure that the * namespace-prefixes feature is always set to true. * * @author David Brownell * @version $Date: 2002/09/30 15:08:51 $ */ public class EchoHandler implements ContentHandler, LexicalHandler, DTDHandler, DeclHandler { // text prints/escapes differently depending on context // CTX_ENTITY ... entity literal value // CTX_ATTRIBUTE ... attribute literal value // CTX_CONTENT ... content of an element // CTX_UNPARSED ... CDATA, comment, PI, names, etc // CTX_NAME ... name or nmtoken, no escapes possible private static final int CTX_ENTITY = 1; private static final int CTX_ATTRIBUTE = 2; private static final int CTX_CONTENT = 3; private static final int CTX_UNPARSED = 4; private static final int CTX_NAME = 5; // XXX names (element, attribute, PI, notation, etc) are not // currently written out with range checks (escapeChars). // In non-XHTML, some names can't be directly written; panic! private static String eol; static { try { eol = System.getProperty ("line.separator", "\n"); } catch (SecurityException e) { eol = "\n"; } } private Writer out; private boolean inCDATA; private int elementNestLevel; private short dangerMask; private StringBuffer stringBuf; private Locator locator; private ErrorHandler errHandler; private boolean expandingEntities; private int entityNestLevel; private boolean xhtml; private boolean startedDoctype; private String encoding; // pretty printing controls private boolean prettyPrinting; private int column; private boolean noWrap; private Stack space = new Stack (); // this is not a hard'n'fast rule -- longer lines are OK, // but are to be avoided. Here, prettyprinting is more to // show structure "cleanly" than to be precise about it. // better to have ragged layout than one line 24Kb long. private static final int lineLength = 75; /** * Constructs this handler with System.out used to write SAX events * using the UTF-8 encoding. Avoid using this except when you know * it's safe to close System.out at the end of the document. */ public EchoHandler () throws IOException { this (System.out); } /** * Constructs a handler which writes all input to the output stream * in the UTF-8 encoding, and closes it when endDocument is called. * (Yes it's annoying that this throws an exception -- but there's * really no way around it, since it's barely possible a JDK may * exist somewhere that doesn't know how to emit UTF-8.) */ public EchoHandler (OutputStream out) throws IOException { this (new OutputStreamWriter (out, "UTF8")); } /** * Constructs a handler which writes all input to the writer, and then * closes the writer when the document ends. If an XML declaration is * written onto the output, and this class can determine the name of * the character encoding for this writer, that encoding name will be * included in the XML declaration. * *
See the description of the constructor which takes an encoding * name for imporant information about selection of encodings. * * @param writer XML text is written to this writer. */ public EchoHandler (Writer writer) { this (writer, null); } /** * Constructs a handler which writes all input to the writer, and then * closes the writer when the document ends. If an XML declaration is * written onto the output, this class will use the specified encoding * name in that declaration. If no encoding name is specified, no * encoding name will be declared unless this class can otherwise * determine the name of the character encoding for this writer. * *
At this time, only the UTF-8 ("UTF8") and UTF-16 ("Unicode") * output encodings are fully lossless with respect to XML data. If you * use any other encoding you risk having your data be silently mangled * on output, as the standard Java character encoding subsystem silently * maps non-encodable characters to a question mark ("?") and will not * report such errors to applications. * *
For a few other encodings the risk can be reduced. If the writer is * a java.io.OutputStreamWriter, and uses either the ISO-8859-1 ("8859_1", * "ISO8859_1", etc) or US-ASCII ("ASCII") encodings, content which * can't be encoded in those encodings will be written safely. Where * relevant, the XHTML entity names will be used; otherwise, numeric * character references will be emitted. * *
However, there remain a number of cases where substituting such * entity or character references is not an option. Such references are * not usable within a DTD, comment, PI, or CDATA section. Neither may * they be used when element, attribute, entity, or notation names have * the problematic characters. * * @param writer XML text is written to this writer. * @param encoding if non-null, and an XML declaration is written, * this is the name that will be used for the character encoding. */ public EchoHandler (Writer writer, String encoding) { setWriter (writer); if (out != null) setEncoding (encoding); } private void setEncoding (String encoding) { if (encoding == null && out instanceof OutputStreamWriter) encoding = ((OutputStreamWriter)out).getEncoding (); if (encoding != null) { encoding = encoding.toUpperCase (); // Use official encoding names where we know them, // avoiding the Java-only names. When using common // encodings where we can easily tell if characters // are out of range, we'll escape out-of-range // characters using character refs for safety. // I _think_ these are all the main synonyms for these! if ("UTF8".equals (encoding)) { encoding = "UTF-8"; } else if ("US-ASCII".equals (encoding) || "ASCII".equals (encoding)) { dangerMask = (short) 0xff80; encoding = "US-ASCII"; } else if ("ISO-8859-1".equals (encoding) || "8859_1".equals (encoding) || "ISO8859_1".equals (encoding)) { dangerMask = (short) 0xff00; encoding = "ISO-8859-1"; } else if ("UNICODE".equals (encoding) || "UNICODE-BIG".equals (encoding) || "UNICODE-LITTLE".equals (encoding)) { encoding = "UTF-16"; // TODO: UTF-16BE, UTF-16LE ... no BOM; what // release of JDK supports those Unicode names? } if (dangerMask != 0) stringBuf = new StringBuffer (); } this.encoding = encoding; } /** * Resets the handler to write a new text document. * @exception IllegalStateException if the current * document hasn't yet ended */ final public void setWriter (Writer writer) { if (out != null) throw new IllegalStateException ( "can't change stream in mid course"); out = writer; if (out != null) setEncoding (null); space.push ("default"); } /** * Assigns the error handler to be used to present most fatal * errors. */ public void setErrorHandler (ErrorHandler handler) { errHandler = handler; } /** * Used internally and by subclasses, this encapsulates the logic * involved in reporting fatal errors. It uses locator information * for good diagnostics, if available, and gives the application's * ErrorHandler the opportunity to handle the error before throwing * an exception. */ protected void fatal (String message, Exception e) throws SAXException { SAXParseException x; if (locator == null) x = new SAXParseException (message, null, null, -1, -1, e); else x = new SAXParseException (message, locator, e); if (errHandler != null) errHandler.fatalError (x); throw x; } // JavaBeans properties /** * Controls whether the output should attempt to follow the "transitional" * XHTML rules so that it meets the "HTML Compatibility Guidelines" * appendix in the XHTML specification. A "transitional" Document Type * Declaration (DTD) is placed near the beginning of the output document, * instead of whatever DTD would otherwise have been placed there, and * XHTML empty elements are printed specially. When writing text in * US-ASCII or ISO-8859-1 encodings, the predefined XHTML internal * entity names are used (in preference to character references) when * writing content characters which can't be expressed in those encodings. * *
When this option is enabled, it is the caller's responsibility * to ensure that the input is otherwise valid as XHTML. Things to * be careful of in all cases, as described in the appendix referenced * above, include:
Additionally, some of the oldest browsers have additional * quirks, to address with guidelines such as:
Also, some characteristics of the resulting output may be * a function of whether the document is later given a MIME * content type of text/html rather than one indicating * XML (application/xml or text/xml). Worse, * some browsers ignore MIME content types and prefer to rely URI * name suffixes -- so an "index.xml" could always be XML, never * XHTML, no matter its MIME type. */ final public void setXhtml (boolean value) { if (locator != null) throw new IllegalStateException ("started parsing"); xhtml = value; } /** * Returns true if the output attempts to echo the input following * "transitional" XHTML rules and matching the "HTML Compatibility * Guidelines" so that an HTML version 3 browser can read the output * as HTML; returns false (the default) othewise. */ final public boolean isXhtml () { return xhtml; } /** * Controls whether the output text contains references to * entities (the default), or instead contains the expanded * values of those entities. */ final public void setExpandingEntities (boolean value) { if (locator != null) throw new IllegalStateException ("started parsing"); expandingEntities = value; } /** * Returns true if the output will have no entity references; * returns false (the default) otherwise. */ final public boolean isExpandingEntities () { return expandingEntities; } /** * Controls pretty-printing, which by default is not enabled * (and currently is mostly useful for XHTML output). * Pretty printing enables structural indentation, sorting of attributes * by name, line wrapping, and potentially other mechanisms for making * output more or less readable. * *
At this writing, structural indentation and line wrapping are * enabled when pretty printing is enabled and the xml:space * attribute has the value default (its other legal value is * preserve, as defined in the XML specification). The three * XHTML element types which use another value are recognized by their * names (namespaces are ignored). * *
Also, for the record, the "pretty" aspect of printing here
* is more to provide basic structure on outputs that would otherwise
* risk being a single long line of text. For now, expect the
* structure to be ragged ... unless you'd like to submit a patch
* to make this be more strictly formatted!
*
* @exception IllegalStateException thrown if this method is invoked
* after output has begun.
*/
final public void setPrettyPrinting (boolean value)
{
if (locator != null)
throw new IllegalStateException ("started parsing");
prettyPrinting = value;
}
/**
* Returns value of flag controlling pretty printing.
*/
final public boolean isPrettyPrinting ()
{
return prettyPrinting;
}
/**
* Flushes the output stream. When this handler is used in long lived
* pipelines, it can be important to flush buffered state, for example
* so that it can reach the disk as part of a state checkpoint.
*/
final public void flush ()
throws IOException
{
if (out != null)
out.flush ();
}
/**
* Writes the string as if characters() had been called on the contents
* of the string. This is particularly useful when applications act as
* producers and write data directly to event consumers.
*/
final public void write (String data)
throws SAXException
{
char buf [] = data.toCharArray ();
characters (buf, 0, buf.length);
}
// SAX1 ContentHandler
/** SAX1: provides parser status information */
final public void setDocumentLocator (Locator l)
{
locator = l;
}
// URL for dtd that validates against all normal HTML constructs
private static final String xhtmlFullDTD =
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd";
/**
* SAX1: indicates the beginning of a document parse.
* If you're writing (well formed) fragments of XML, neither
* this nor endDocument should be called.
*/
// NOT final
public void startDocument ()
throws SAXException
{
try {
if (out == null)
throw new IllegalStateException (
"null Writer given to EchoHandler");
// Not all parsers provide the locator we want; this also
// flags whether events are being sent to this object yet.
// We could only have this one call if we only printed whole
// documents ... but we also print fragments, so most of the
// callbacks here replicate this test.
if (locator == null)
locator = new LocatorImpl ();
// Unless the data is in US-ASCII, we always write the XML
// declaration when we know the encoding. US-ASCII won't
// normally get mangled by web server confusion about the
// character encodings used. Plus, it's an easy way to
// ensure we can write ASCII that's unlikely to confuse
// elderly HTML parsers.
if (dangerMask != (short) 0xff80 && encoding != null) {
rawWrite ("");
newline ();
}
if (xhtml) {
rawWrite ("");
newline ();
newline ();
// fake the rest of the handler into ignoring
// everything until the root element, so any
// XHTML DTD comments, PIs, etc are ignored
startedDoctype = true;
}
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: indicates the completion of a parse */
// NOT final
public void endDocument ()
throws SAXException
{
try {
newline ();
newline ();
out.close ();
out = null;
locator = null;
} catch (IOException e) {
fatal ("can't write", e);
}
}
// XHTML elements declared as EMPTY print differently
final private static boolean isEmptyElementTag (String tag)
{
switch (tag.charAt (0)) {
case 'a': return "area".equals (tag);
case 'b': return "base".equals (tag)
|| "basefont".equals (tag)
|| "br".equals (tag);
case 'c': return "col".equals (tag);
case 'f': return "frame".equals (tag);
case 'h': return "hr".equals (tag);
case 'i': return "img".equals (tag)
|| "input".equals (tag)
|| "isindex".equals (tag);
case 'l': return "link".equals (tag);
case 'm': return "meta".equals (tag);
case 'p': return "param".equals (tag);
}
return false;
}
private static boolean indentBefore (String tag)
{
// basically indent before block content
// and within structure like tables, lists
switch (tag.charAt (0)) {
case 'a': return "applet".equals (tag);
case 'b': return "body".equals (tag)
|| "blockquote".equals (tag);
case 'c': return "center".equals (tag);
case 'f': return "frame".equals (tag)
|| "frameset".equals (tag);
case 'h': return "head".equals (tag);
case 'm': return "meta".equals (tag);
case 'o': return "object".equals (tag);
case 'p': return "param".equals (tag)
|| "pre".equals (tag);
case 's': return "style".equals (tag);
case 't': return "title".equals (tag)
|| "td".equals (tag)
|| "th".equals (tag);
}
// ... but not inline elements like "em", "b", "font"
return false;
}
private static boolean spaceBefore (String tag)
{
// blank line AND INDENT before certain structural content
switch (tag.charAt (0)) {
case 'h': return "h1".equals (tag)
|| "h2".equals (tag)
|| "h3".equals (tag)
|| "h4".equals (tag)
|| "h5".equals (tag)
|| "h6".equals (tag)
|| "hr".equals (tag);
case 'l': return "li".equals (tag);
case 'o': return "ol".equals (tag);
case 'p': return "p".equals (tag);
case 't': return "table".equals (tag)
|| "tr".equals (tag);
case 'u': return "ul".equals (tag);
}
return false;
}
// XHTML DTDs say these three have xml:space="preserve"
private static boolean spacePreserve (String tag)
{
return "pre".equals (tag)
|| "style".equals (tag)
|| "script".equals (tag);
}
/**
* SAX2: ignored.
*/
final public void startPrefixMapping (String prefix, String uri)
{}
/**
* SAX2: ignored.
*/
final public void endPrefixMapping (String prefix)
{}
/**
* SAX2: indicates the start of an element.
* When XHTML is in use, avoid attribute values with
* line breaks or multiple whitespace characters, since
* not all user agents handle them correctly.
*/
final public void startElement (
String uri,
String local,
String name,
Attributes atts
) throws SAXException
{
startedDoctype = false;
if (locator == null)
locator = new LocatorImpl ();
if (name == null || "".equals (name))
throw new IllegalArgumentException ("no XML name");
try {
elementNestLevel++;
if (entityNestLevel != 0)
return;
if (prettyPrinting) {
String whitespace = null;
if (xhtml && spacePreserve (name))
whitespace = "preserve";
else if (atts != null)
whitespace = atts.getValue ("xml:space");
if (whitespace == null)
whitespace = (String) space.peek ();
space.push (whitespace);
if ("default".equals (whitespace)) {
if (xhtml) {
if (spaceBefore (name)) {
newline ();
doIndent ();
} else if (indentBefore (name))
doIndent ();
// else it's inlined, modulo line length
// XXX don't increment element nest level!
} else
doIndent ();
}
}
rawWrite ('<');
rawWrite (name);
// write out attributes ... sorting is particularly useful
// with output that's been heavily defaulted.
if (atts != null && atts.getLength () != 0) {
// Set up to write, with optional sorting
int indices [] = new int [atts.getLength ()];
for (int i= 0; i < indices.length; i++)
indices [i] = i;
// optionally sort
if (prettyPrinting) {
// insertion sort by attribute name
for (int i = 1; i < indices.length; i++) {
int n = indices [i], j;
String s = atts.getQName (n);
for (j = i - 1; j >= 0; j--) {
if (s.compareTo (atts.getQName (indices [j]))
>= 0)
break;
indices [j + 1] = indices [j];
}
indices [j + 1] = n;
}
}
// write, sorted or no
for (int i= 0; i < indices.length; i++) {
String s = atts.getQName (indices [i]);
if (s == null || "".equals (s))
throw new IllegalArgumentException ("no XML name");
rawWrite (" ");
rawWrite (s);
rawWrite ("=");
writeQuotedValue (atts.getValue (indices [i]),
CTX_ATTRIBUTE);
}
}
if (xhtml && isEmptyElementTag (name))
rawWrite (" /");
rawWrite ('>');
if (xhtml) {
// XXX if this is an XHTML "pre" element, turn
// off automatic wrapping.
}
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX2: indicates the end of an element */
final public void endElement (String uri, String local, String name)
throws SAXException
{
if (name == null || "".equals (name))
throw new IllegalArgumentException ("no XML name");
try {
elementNestLevel--;
if (entityNestLevel != 0)
return;
if (xhtml && isEmptyElementTag (name))
return;
rawWrite ("');
if (prettyPrinting) {
if (!space.empty ())
space.pop ();
else
fatal ("stack discipline", null);
}
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: reports content characters */
final public void characters (char buf [], int off, int len)
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
try {
if (entityNestLevel != 0)
return;
if (inCDATA)
escapeChars (buf, off, len, CTX_UNPARSED);
else
escapeChars (buf, off, len, CTX_CONTENT);
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: reports ignorable whitespace */
final public void ignorableWhitespace (char buf [], int off, int len)
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
try {
if (entityNestLevel != 0)
return;
// don't forget to map NL to CRLF, CR, etc
escapeChars (buf, off, len, CTX_CONTENT);
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: reports a PI */
final public void processingInstruction (String name, String value)
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
// don't print internal subset for XHTML
if (xhtml && startedDoctype)
return;
// ancient HTML browsers might render these ... their loss.
// to prevent: "if (xhtml) return;".
try {
if (entityNestLevel != 0)
return;
rawWrite ("");
if (elementNestLevel == 0)
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: indicates a non-expanded entity reference */
public void skippedEntity (String name)
throws SAXException
{
try {
rawWrite ("&");
rawWrite (name);
rawWrite (";");
} catch (IOException e) {
fatal ("can't write", e);
}
}
// SAX2 LexicalHandler
/** SAX2: called before parsing CDATA characters */
final public void startCDATA ()
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
try {
inCDATA = true;
if (entityNestLevel == 0)
rawWrite ("SAX2: called after parsing CDATA characters */
final public void endCDATA ()
throws SAXException
{
try {
inCDATA = false;
if (entityNestLevel == 0)
rawWrite ("]]>");
} catch (IOException e) {
fatal ("can't write", e);
}
}
/**
* SAX2: called when the doctype is partially parsed
* Note that this, like other doctype related calls, is ignored
* when XHTML is in use.
*/
final public void startDTD (String root, String pubid, String sysid)
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
if (xhtml)
return;
try {
startedDoctype = true;
rawWrite ("SAX2: called after the doctype is parsed */
final public void endDTD ()
throws SAXException
{
if (xhtml)
return;
try {
rawWrite ("]>");
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/**
* SAX2: called before parsing a general entity in content
*/
final public void startEntity (String name)
throws SAXException
{
try {
boolean writeEOL = true;
// Predefined XHTML entities (for characters) will get
// mapped back later. No other entities should be written.
if (xhtml || expandingEntities)
return;
entityNestLevel++;
if (name.equals ("[dtd]"))
return;
if (entityNestLevel != 1)
return;
if (!name.startsWith ("%")) {
writeEOL = false;
rawWrite ('&');
}
rawWrite (name);
rawWrite (';');
if (writeEOL)
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/**
* SAX2: called after parsing a general entity in content
*/
final public void endEntity (String name)
throws SAXException
{
if (xhtml || expandingEntities)
return;
entityNestLevel--;
}
/**
* SAX2: called when comments are parsed.
* When XHTML is used, the old HTML tradition of using comments
* to for inline CSS, or for JavaScript code is discouraged.
* This is because XML processors are encouraged to discard, on
* the grounds that comments are for users (and perhaps text
* editors) not programs. Instead, use external scripts
*/
final public void comment (char buf [], int off, int len)
throws SAXException
{
if (locator == null)
locator = new LocatorImpl ();
// don't print internal subset for XHTML
if (xhtml && startedDoctype)
return;
try {
boolean indent;
// XXX if "comment" has "--" ... die!
if (prettyPrinting && space.empty ())
fatal ("stack discipline", null);
indent = prettyPrinting && "default".equals (space.peek ());
if (entityNestLevel != 0)
return;
if (indent)
doIndent ();
rawWrite ("");
if (indent)
doIndent ();
if (elementNestLevel == 0)
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
// SAX1 DTDHandler
/** SAX1: called on notation declarations */
final public void notationDecl (String name, String pubid, String sysid)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype) {
// XXX write to temporary buffer, and make the start
// of the root element write these declarations.
// Normal form puts notations first, in alpha order;
// followed by unparsed entities, in alpha order.
return;
}
if (entityNestLevel != 0)
return;
rawWrite ("");
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX1: called on unparsed entity declarations */
final public void unparsedEntityDecl (String name,
String pubid, String sysid,
String notation)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype) {
// XXX write to temporary buffer, and make the start
// of the root element write these declarations.
return;
}
if (entityNestLevel != 0)
return;
rawWrite ("");
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
// SAX2 DeclHandler
/** SAX2: called on attribute declarations */
final public void attributeDecl (String element, String name,
String type, String defaultType, String defaultValue)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype)
return;
if (entityNestLevel != 0)
return;
rawWrite ("');
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX2: called on element declarations */
final public void elementDecl (String name, String model)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype)
return;
if (entityNestLevel != 0)
return;
rawWrite ("');
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX2: called on external entity declarations */
final public void externalEntityDecl (
String name,
String pubid,
String sysid)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype)
return;
if (entityNestLevel != 0)
return;
rawWrite ("");
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
/** SAX2: called on internal entity declarations */
final public void internalEntityDecl (String name, String value)
throws SAXException
{
if (xhtml)
return;
try {
// At this time, only SAX2 callbacks start these.
if (!startedDoctype)
return;
if (entityNestLevel != 0)
return;
rawWrite ("');
newline ();
} catch (IOException e) {
fatal ("can't write", e);
}
}
private void writeQuotedValue (String value, int code)
throws SAXException, IOException
{
char buf [] = value.toCharArray ();
int off = 0, len = buf.length;
// we can't add line breaks to attribute/entity/... values
noWrap = true;
rawWrite ('"');
escapeChars (buf, off, len, code);
rawWrite ('"');
noWrap = false;
}
// From "HTMLlat1x.ent" ... names of entities for ISO-8859-1
// (Latin/1) characters, all codes: 160-255 (0xA0-0xFF).
// Codes 128-159 have no assigned values.
private static final String HTMLlat1x [] = {
// 160
"nbsp", "iexcl", "cent", "pound", "curren",
"yen", "brvbar", "sect", "uml", "copy",
// 170
"ordf", "laquo", "not", "shy", "reg",
"macr", "deg", "plusmn", "sup2", "sup3",
// 180
"acute", "micro", "para", "middot", "cedil",
"sup1", "ordm", "raquo", "frac14", "frac12",
// 190
"frac34", "iquest", "Agrave", "Aacute", "Acirc",
"Atilde", "Auml", "Aring", "AElig", "Ccedil",
// 200
"Egrave", "Eacute", "Ecirc", "Euml", "Igrave",
"Iacute", "Icirc", "Iuml", "ETH", "Ntilde",
// 210
"Ograve", "Oacute", "Ocirc", "Otilde", "Ouml",
"times", "Oslash", "Ugrave", "Uacute", "Ucirc",
// 220
"Uuml", "Yacute", "THORN", "szlig", "agrave",
"aacute", "acirc", "atilde", "auml", "aring",
// 230
"aelig", "ccedil", "egrave", "eacute", "ecirc",
"euml", "igrave", "iacute", "icirc", "iuml",
// 240
"eth", "ntilde", "ograve", "oacute", "ocirc",
"otilde", "ouml", "divide", "oslash", "ugrave",
// 250
"uacute", "ucirc", "uuml", "yacute", "thorn",
"yuml"
};
// From "HTMLsymbolx.ent" ... some of the symbols that
// we can conveniently handle. Entities for the Greek.
// alphabet (upper and lower cases) are compact.
private static final String HTMLsymbolx_GR [] = {
// 913
"Alpha", "Beta", "Gamma", "Delta", "Epsilon",
"Zeta", "Eta", "Theta", "Iota", "Kappa",
// 923
"Lambda", "Mu", "Nu", "Xi", "Omicron",
"Pi", "Rho", null, "Sigma", "Tau",
// 933
"Upsilon", "Phi", "Chi", "Psi", "Omega"
};
private static final String HTMLsymbolx_gr [] = {
// 945
"alpha", "beta", "gamma", "delta", "epsilon",
"zeta", "eta", "theta", "iota", "kappa",
// 955
"lambda", "mu", "nu", "xi", "omicron",
"pi", "rho", "sigmaf", "sigma", "tau",
// 965
"upsilon", "phi", "chi", "psi", "omega"
};
// General routine to write text and substitute predefined
// entities (XML, and a special case for XHTML) as needed.
private void escapeChars (char buf [], int off, int len, int code)
throws SAXException, IOException
{
int first = 0;
if (off < 0) {
off = 0;
len = buf.length;
}
for (int i = 0; i < len; i++) {
String esc;
char c = buf [off + i];
switch (c) {
// Note that CTX_ATTRIBUTE isn't explicitly tested here;
// all syntax delimiters are escaped in CTX_ATTRIBUTE,
// otherwise it's similar to CTX_CONTENT
// ampersand flags entity references; entity replacement
// text has unexpanded references, other text doesn't.
case '&':
if (code == CTX_ENTITY || code == CTX_UNPARSED)
continue;
esc = "amp";
break;
// attributes and text may NOT have literal '<', but
// entities may have markup constructs
case '<':
if (code == CTX_ENTITY || code == CTX_UNPARSED)
continue;
esc = "lt";
break;
// as above re markup constructs; but otherwise
// this is just for consistency
case '>':
if (code == CTX_ENTITY || code == CTX_UNPARSED)
continue;
esc = "gt";
break;
// needed when printing quoted attribute/entity values
case '"':
if (code == CTX_CONTENT || code == CTX_UNPARSED)
continue;
esc = "quot";
break;
case '\'':
if (code == CTX_CONTENT || code == CTX_UNPARSED)
continue;
esc = "apos";
break;
// make line ends work per host OS convention
case '\n':
esc = eol;
break;
//
// No other characters NEED special treatment ... except
// for encoding-specific issues, like whether the character
// can really be represented in that encoding.
//
default:
//
// There are characters we can never write safely; getting
// them is an error.
//
// (a) They're never legal in XML ... detected by range
// checks, and (eventually) by remerging surrogate
// pairs on output. (Easy error for apps to prevent.)
//
// (b) This encoding can't represent them, and we
// can't make reference substitution (e.g. inside
// CDATA sections, names, PI data, etc). (Hard for
// apps to prevent, except by using UTF-8 or UTF-16
// as their output encoding.)
//
// We know a very little bit about what characters
// the US-ASCII and ISO-8859-1 encodings support. For
// other encodings we can't detect the second type of
// error at all. (Never an issue for UTF-8 or UTF-16.)
//
if ((c > 0xfffd)
|| ((c < 0x0020) && !((c == 0x0009)
|| (c == 0x000A) || (c == 0x000D)))
|| (((c & dangerMask) != 0)
&& (code == CTX_UNPARSED))) {
// if !CTX_UNPARSED, we could kluge up a string
// that prints as "