| Methods Summary |
|---|
| public void | adup(char[] buff, int offset, int length)
// needs to support chars past U+FFFF
if (theNewElement == null || theAttributeName == null) return;
theNewElement.setAttribute(theAttributeName, null, theAttributeName);
theAttributeName = null;
|
| public void | aname(char[] buff, int offset, int length)
if (theNewElement == null) return;
// Currently we don't rely on Schema to canonicalize
// attribute names.
theAttributeName = makeName(buff, offset, length).toLowerCase();
// System.err.println("%% Attribute name " + theAttributeName);
|
| public void | aval(char[] buff, int offset, int length)
if (theNewElement == null || theAttributeName == null) return;
String value = new String(buff, offset, length);
// System.err.println("%% Attribute value [" + value + "]");
value = expandEntities(value);
theNewElement.setAttribute(theAttributeName, null, value);
theAttributeName = null;
// System.err.println("%% Aval done");
|
| public void | cdsect(char[] buff, int offset, int length)
theLexicalHandler.startCDATA();
pcdata(buff, offset, length);
theLexicalHandler.endCDATA();
|
| private java.lang.String | cleanPublicid(java.lang.String src)
if (src == null) return null;
int len = src.length();
StringBuffer dst = new StringBuffer(len);
boolean suppressSpace = true;
for (int i = 0; i < len; i++) {
char ch = src.charAt(i);
if (legal.indexOf(ch) != -1) { // legal but not whitespace
dst.append(ch);
suppressSpace = false;
}
else if (suppressSpace) { // normalizable whitespace or junk
;
}
else {
dst.append(' ");
suppressSpace = true;
}
}
// System.err.println("%% Publicid [" + dst.toString().trim() + "]");
return dst.toString().trim(); // trim any final junk whitespace
|
| public void | cmnt(char[] buff, int offset, int length)
theLexicalHandler.comment(buff, offset, length);
|
| public void | comment(char[] ch, int start, int length)
|
| public void | decl(char[] buff, int offset, int length)Parsing the complete XML Document Type Definition is way too complex,
but for many simple cases we can extract something useful from it.
doctypedecl ::= ''
DeclSep ::= PEReference | S
intSubset ::= (markupdecl | DeclSep)*
markupdecl ::= elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment
ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral
String s = new String(buff, offset, length);
String name = null;
String systemid = null;
String publicid = null;
String[] v = split(s);
if (v.length > 0 && "DOCTYPE".equals(v[0])) {
if (theDoctypeIsPresent) return; // one doctype only!
theDoctypeIsPresent = true;
if (v.length > 1) {
name = v[1];
if (v.length>3 && "SYSTEM".equals(v[2])) {
systemid = v[3];
}
else if (v.length > 3 && "PUBLIC".equals(v[2])) {
publicid = v[3];
if (v.length > 4) {
systemid = v[4];
}
else {
systemid = "";
}
}
}
}
publicid = trimquotes(publicid);
systemid = trimquotes(systemid);
if (name != null) {
publicid = cleanPublicid(publicid);
theLexicalHandler.startDTD(name, publicid, systemid);
theLexicalHandler.endDTD();
theDoctypeName = name;
theDoctypePublicId = publicid;
if (theScanner instanceof Locator) { // Must resolve systemid
theDoctypeSystemId = ((Locator)theScanner).getSystemId();
try {
theDoctypeSystemId = new URL(new URL(theDoctypeSystemId), systemid).toString();
} catch (Exception e) {}
}
}
|
| public void | endCDATA()
|
| public void | endDTD()
|
| public void | endEntity(java.lang.String name)
|
| public void | entity(char[] buff, int offset, int length)
theEntity = lookupEntity(buff, offset, length);
|
| public void | eof(char[] buff, int offset, int length)
if (virginStack) rectify(thePCDATA);
while (theStack.next() != null) {
pop();
}
if (!(theSchema.getURI().equals("")))
theContentHandler.endPrefixMapping(theSchema.getPrefix());
theContentHandler.endDocument();
|
| public void | etag(char[] buff, int offset, int length)
if (etag_cdata(buff, offset, length)) return;
etag_basic(buff, offset, length);
|
| public void | etag_basic(char[] buff, int offset, int length)
theNewElement = null;
String name;
if (length != 0) {
// Canonicalize case of name
name = makeName(buff, offset, length);
// System.err.println("got etag [" + name + "]");
ElementType type = theSchema.getElementType(name);
if (type == null) return; // mysterious end-tag
name = type.name();
}
else {
name = theStack.name();
}
// System.err.println("%% Got end of " + name);
Element sp;
boolean inNoforce = false;
for (sp = theStack; sp != null; sp = sp.next()) {
if (sp.name().equals(name)) break;
if ((sp.flags() & Schema.F_NOFORCE) != 0) inNoforce = true;
}
if (sp == null) return; // Ignore unknown etags
if (sp.next() == null || sp.next().next() == null) return;
if (inNoforce) { // inside an F_NOFORCE element?
sp.preclose(); // preclose the matching element
}
else { // restartably pop everything above us
while (theStack != sp) {
restartablyPop();
}
pop();
}
// pop any preclosed elements now at the top
while (theStack.isPreclosed()) {
pop();
}
restart(null);
|
| public boolean | etag_cdata(char[] buff, int offset, int length)
String currentName = theStack.name();
// If this is a CDATA element and the tag doesn't match,
// or isn't properly formed (junk after the name),
// restart CDATA mode and process the tag as characters.
if (CDATAElements && (theStack.flags() & Schema.F_CDATA) != 0) {
boolean realTag = (length == currentName.length());
if (realTag) {
for (int i = 0; i < length; i++) {
if (Character.toLowerCase(buff[offset + i]) != Character.toLowerCase(currentName.charAt(i))) {
realTag = false;
break;
}
}
}
if (!realTag) {
theContentHandler.characters(etagchars, 0, 2);
theContentHandler.characters(buff, offset, length);
theContentHandler.characters(etagchars, 2, 1);
theScanner.startCDATA();
return true;
}
}
return false;
|
| private java.lang.String | expandEntities(java.lang.String src)
int refStart = -1;
int len = src.length();
char[] dst = new char[len];
int dstlen = 0;
for (int i = 0; i < len; i++) {
char ch = src.charAt(i);
dst[dstlen++] = ch;
// System.err.print("i = " + i + ", d = " + dstlen + ", ch = [" + ch + "] ");
if (ch == '&" && refStart == -1) {
// start of a ref excluding &
refStart = dstlen;
// System.err.println("start of ref");
}
else if (refStart == -1) {
// not in a ref
// System.err.println("not in ref");
}
else if (Character.isLetter(ch) ||
Character.isDigit(ch) ||
ch == '#") {
// valid entity char
// System.err.println("valid");
}
else if (ch == ';") {
// properly terminated ref
// System.err.print("got [" + new String(dst, refStart, dstlen-refStart-1) + "]");
int ent = lookupEntity(dst, refStart, dstlen - refStart - 1);
// System.err.println(" = " + ent);
if (ent > 0xFFFF) {
ent -= 0x10000;
dst[refStart - 1] = (char)((ent>>10) + 0xD800);
dst[refStart] = (char)((ent&0x3FF) + 0xDC00);
dstlen = refStart + 1;
}
else if (ent != 0) {
dst[refStart - 1] = (char)ent;
dstlen = refStart;
}
refStart = -1;
}
else {
// improperly terminated ref
// System.err.println("end of ref");
refStart = -1;
}
}
return new String(dst, 0, dstlen);
|
| private boolean | foreign(java.lang.String prefix, java.lang.String namespace)
// System.err.print("%% Testing " + prefix + " and " + namespace + " for foreignness -- ");
boolean foreign = !(prefix.equals("") || namespace.equals("") ||
namespace.equals(theSchema.getURI()));
// System.err.println(foreign);
return foreign;
|
| public org.xml.sax.ContentHandler | getContentHandler()
return (theContentHandler == this) ? null : theContentHandler;
|
| public org.xml.sax.DTDHandler | getDTDHandler()
return (theDTDHandler == this) ? null : theDTDHandler;
|
| public int | getEntity()
return theEntity;
|
| public org.xml.sax.EntityResolver | getEntityResolver()
return (theEntityResolver == this) ? null : theEntityResolver;
|
| public org.xml.sax.ErrorHandler | getErrorHandler()
return (theErrorHandler == this) ? null : theErrorHandler;
|
| public boolean | getFeature(java.lang.String name)
Boolean b = (Boolean)theFeatures.get(name);
if (b == null) {
throw new SAXNotRecognizedException("Unknown feature " + name);
}
return b.booleanValue();
|
| private java.io.InputStream | getInputStream(java.lang.String publicid, java.lang.String systemid)
URL basis = new URL("file", "", System.getProperty("user.dir") + "/.");
URL url = new URL(basis, systemid);
URLConnection c = url.openConnection();
return c.getInputStream();
|
| public java.lang.Object | getProperty(java.lang.String name)
if (name.equals(lexicalHandlerProperty)) {
return theLexicalHandler == this ? null : theLexicalHandler;
}
else if (name.equals(scannerProperty)) {
return theScanner;
}
else if (name.equals(schemaProperty)) {
return theSchema;
}
else if (name.equals(autoDetectorProperty)) {
return theAutoDetector;
}
else {
throw new SAXNotRecognizedException("Unknown property " + name);
}
|
| private java.io.Reader | getReader(org.xml.sax.InputSource s)
Reader r = s.getCharacterStream();
InputStream i = s.getByteStream();
String encoding = s.getEncoding();
String publicid = s.getPublicId();
String systemid = s.getSystemId();
if (r == null) {
if (i == null) i = getInputStream(publicid, systemid);
// i = new BufferedInputStream(i);
if (encoding == null) {
r = theAutoDetector.autoDetectingReader(i);
}
else {
try {
r = new InputStreamReader(i, encoding);
}
catch (UnsupportedEncodingException e) {
r = new InputStreamReader(i);
}
}
}
// r = new BufferedReader(r);
return r;
|
| public void | gi(char[] buff, int offset, int length)
if (theNewElement != null) return;
String name = makeName(buff, offset, length);
if (name == null) return;
ElementType type = theSchema.getElementType(name);
if (type == null) {
// Suppress unknown elements if ignore-bogons is on
if (ignoreBogons) return;
int bogonModel = bogonsEmpty ? Schema.M_EMPTY : Schema.M_ANY;
int bogonMemberOf = rootBogons ? Schema.M_ANY : (Schema.M_ANY & ~ Schema.M_ROOT);
theSchema.elementType(name, bogonModel, bogonMemberOf, 0);
if (!rootBogons) theSchema.parent(name, theSchema.rootElementType().name());
type = theSchema.getElementType(name);
}
theNewElement = new Element(type, defaultAttributes);
// System.err.println("%% Got GI " + theNewElement.name());
|
| private int | lookupEntity(char[] buff, int offset, int length)
int result = 0;
if (length < 1) return result;
// System.err.println("%% Entity at " + offset + " " + length);
// System.err.println("%% Got entity [" + new String(buff, offset, length) + "]");
if (buff[offset] == '#") {
if (length > 1 && (buff[offset+1] == 'x"
|| buff[offset+1] == 'X")) {
try {
return Integer.parseInt(new String(buff, offset + 2, length - 2), 16);
}
catch (NumberFormatException e) { return 0; }
}
try {
return Integer.parseInt(new String(buff, offset + 1, length - 1), 10);
}
catch (NumberFormatException e) { return 0; }
}
return theSchema.getEntity(new String(buff, offset, length));
|
| private java.lang.String | makeName(char[] buff, int offset, int length)
StringBuffer dst = new StringBuffer(length + 2);
boolean seenColon = false;
boolean start = true;
// String src = new String(buff, offset, length); // DEBUG
for (; length-- > 0; offset++) {
char ch = buff[offset];
if (Character.isLetter(ch) || ch == '_") {
start = false;
dst.append(ch);
}
else if (Character.isDigit(ch) || ch == '-" || ch == '.") {
if (start) dst.append('_");
start = false;
dst.append(ch);
}
else if (ch == ':" && !seenColon) {
seenColon = true;
if (start) dst.append('_");
start = true;
dst.append(translateColons ? '_" : ch);
}
}
int dstLength = dst.length();
if (dstLength == 0 || dst.charAt(dstLength - 1) == ':") dst.append('_");
// System.err.println("Made name \"" + dst + "\" from \"" + src + "\"");
return dst.toString().intern();
|
| public void | parse(org.xml.sax.InputSource input)
setup();
Reader r = getReader(input);
theContentHandler.startDocument();
theScanner.resetDocumentLocator(input.getPublicId(), input.getSystemId());
if (theScanner instanceof Locator) {
theContentHandler.setDocumentLocator((Locator)theScanner);
}
if (!(theSchema.getURI().equals("")))
theContentHandler.startPrefixMapping(theSchema.getPrefix(),
theSchema.getURI());
theScanner.scan(r, this);
|
| public void | parse(java.lang.String systemid)
parse(new InputSource(systemid));
|
| public void | pcdata(char[] buff, int offset, int length)
if (length == 0) return;
boolean allWhite = true;
for (int i = 0; i < length; i++) {
if (!Character.isWhitespace(buff[offset+i])) {
allWhite = false;
}
}
if (allWhite && !theStack.canContain(thePCDATA)) {
if (ignorableWhitespace) {
theContentHandler.ignorableWhitespace(buff, offset, length);
}
}
else {
rectify(thePCDATA);
theContentHandler.characters(buff, offset, length);
}
|
| public void | pi(char[] buff, int offset, int length)
if (theNewElement != null || thePITarget == null) return;
if ("xml".equalsIgnoreCase(thePITarget)) return;
// if (length > 0 && buff[length - 1] == '?') System.err.println("%% Removing ? from PI");
if (length > 0 && buff[length - 1] == '?") length--; // remove trailing ?
theContentHandler.processingInstruction(thePITarget,
new String(buff, offset, length));
thePITarget = null;
|
| public void | pitarget(char[] buff, int offset, int length)
if (theNewElement != null) return;
thePITarget = makeName(buff, offset, length).replace(':", '_");
|
| private void | pop()
if (theStack == null) return; // empty stack
String name = theStack.name();
String localName = theStack.localName();
String namespace = theStack.namespace();
String prefix = prefixOf(name);
// System.err.println("%% Popping " + name);
if (!namespaces) namespace = localName = "";
theContentHandler.endElement(namespace, localName, name);
if (foreign(prefix, namespace)) {
theContentHandler.endPrefixMapping(prefix);
// System.err.println("%% Unmapping [" + prefix + "] for elements to " + namespace);
}
Attributes atts = theStack.atts();
for (int i = atts.getLength() - 1; i >= 0; i--) {
String attNamespace = atts.getURI(i);
String attPrefix = prefixOf(atts.getQName(i));
if (foreign(attPrefix, attNamespace)) {
theContentHandler.endPrefixMapping(attPrefix);
// System.err.println("%% Unmapping [" + attPrefix + "] for attributes to " + attNamespace);
}
}
theStack = theStack.next();
|
| private java.lang.String | prefixOf(java.lang.String name)
int i = name.indexOf(':");
String prefix = "";
if (i != -1) prefix = name.substring(0, i);
// System.err.println("%% " + prefix + " is prefix of " + name);
return prefix;
|
| private void | push(Element e)
String name = e.name();
String localName = e.localName();
String namespace = e.namespace();
String prefix = prefixOf(name);
// System.err.println("%% Pushing " + name);
e.clean();
if (!namespaces) namespace = localName = "";
if (virginStack && localName.equalsIgnoreCase(theDoctypeName)) {
try {
theEntityResolver.resolveEntity(theDoctypePublicId, theDoctypeSystemId);
} catch (IOException ew) { } // Can't be thrown for root I believe.
}
if (foreign(prefix, namespace)) {
theContentHandler.startPrefixMapping(prefix, namespace);
// System.err.println("%% Mapping [" + prefix + "] for elements to " + namespace);
}
Attributes atts = e.atts();
int len = atts.getLength();
for (int i = 0; i < len; i++) {
String attNamespace = atts.getURI(i);
String attPrefix = prefixOf(atts.getQName(i));
if (foreign(attPrefix, attNamespace)) {
theContentHandler.startPrefixMapping(attPrefix, attNamespace);
// System.err.println("%% Mapping [" + attPrefix + "] for attributes to " + attNamespace);
}
}
theContentHandler.startElement(namespace, localName, name, e.atts());
e.setNext(theStack);
theStack = e;
virginStack = false;
if (CDATAElements && (theStack.flags() & Schema.F_CDATA) != 0) {
theScanner.startCDATA();
}
|
| private void | rectify(Element e)
Element sp;
while (true) {
for (sp = theStack; sp != null; sp = sp.next()) {
if (sp.canContain(e)) break;
}
if (sp != null) break;
ElementType parentType = e.parent();
if (parentType == null) break;
Element parent = new Element(parentType, defaultAttributes);
// System.err.println("%% Ascending from " + e.name() + " to " + parent.name());
parent.setNext(e);
e = parent;
}
if (sp == null) return; // don't know what to do
while (theStack != sp) {
if (theStack == null || theStack.next() == null ||
theStack.next().next() == null) break;
restartablyPop();
}
while (e != null) {
Element nexte = e.next();
if (!e.name().equals("<pcdata>")) push(e);
e = nexte;
restart(e);
}
theNewElement = null;
|
| private void | restart(Element e)
while (theSaved != null && theStack.canContain(theSaved) &&
(e == null || theSaved.canContain(e))) {
Element next = theSaved.next();
push(theSaved);
theSaved = next;
}
|
| private void | restartablyPop()
Element popped = theStack;
pop();
if (restartElements && (popped.flags() & Schema.F_RESTART) != 0) {
popped.anonymize();
popped.setNext(theSaved);
theSaved = popped;
}
|
| public void | setContentHandler(org.xml.sax.ContentHandler handler)
theContentHandler = (handler == null) ? this : handler;
|
| public void | setDTDHandler(org.xml.sax.DTDHandler handler)
theDTDHandler = (handler == null) ? this : handler;
|
| public void | setEntityResolver(org.xml.sax.EntityResolver resolver)
theEntityResolver = (resolver == null) ? this : resolver;
|
| public void | setErrorHandler(org.xml.sax.ErrorHandler handler)
theErrorHandler = (handler == null) ? this : handler;
|
| public void | setFeature(java.lang.String name, boolean value)
Boolean b = (Boolean)theFeatures.get(name);
if (b == null) {
throw new SAXNotRecognizedException("Unknown feature " + name);
}
if (value) theFeatures.put(name, Boolean.TRUE);
else theFeatures.put(name, Boolean.FALSE);
if (name.equals(namespacesFeature)) namespaces = value;
else if (name.equals(ignoreBogonsFeature)) ignoreBogons = value;
else if (name.equals(bogonsEmptyFeature)) bogonsEmpty = value;
else if (name.equals(rootBogonsFeature)) rootBogons = value;
else if (name.equals(defaultAttributesFeature)) defaultAttributes = value;
else if (name.equals(translateColonsFeature)) translateColons = value;
else if (name.equals(restartElementsFeature)) restartElements = value;
else if (name.equals(ignorableWhitespaceFeature)) ignorableWhitespace = value;
else if (name.equals(CDATAElementsFeature)) CDATAElements = value;
|
| public void | setProperty(java.lang.String name, java.lang.Object value)
if (name.equals(lexicalHandlerProperty)) {
if (value == null) {
theLexicalHandler = this;
}
else if (value instanceof LexicalHandler) {
theLexicalHandler = (LexicalHandler)value;
}
else {
throw new SAXNotSupportedException("Your lexical handler is not a LexicalHandler");
}
}
else if (name.equals(scannerProperty)) {
if (value instanceof Scanner) {
theScanner = (Scanner)value;
}
else {
throw new SAXNotSupportedException("Your scanner is not a Scanner");
}
}
else if (name.equals(schemaProperty)) {
if (value instanceof Schema) {
theSchema = (Schema)value;
}
else {
throw new SAXNotSupportedException("Your schema is not a Schema");
}
}
else if (name.equals(autoDetectorProperty)) {
if (value instanceof AutoDetector) {
theAutoDetector = (AutoDetector)value;
}
else {
throw new SAXNotSupportedException("Your auto-detector is not an AutoDetector");
}
}
else {
throw new SAXNotRecognizedException("Unknown property " + name);
}
|
| private void | setup()
if (theSchema == null) theSchema = new HTMLSchema();
if (theScanner == null) theScanner = new HTMLScanner();
if (theAutoDetector == null) {
theAutoDetector = new AutoDetector() {
public Reader autoDetectingReader(InputStream i) {
return new InputStreamReader(i);
}
};
}
theStack = new Element(theSchema.getElementType("<root>"), defaultAttributes);
thePCDATA = new Element(theSchema.getElementType("<pcdata>"), defaultAttributes);
theNewElement = null;
theAttributeName = null;
thePITarget = null;
theSaved = null;
theEntity = 0;
virginStack = true;
theDoctypeName = theDoctypePublicId = theDoctypeSystemId = null;
|
| private static java.lang.String[] | split(java.lang.String val)
val = val.trim();
if (val.length() == 0) {
return new String[0];
}
else {
ArrayList l = new ArrayList();
int s = 0;
int e = 0;
boolean sq = false; // single quote
boolean dq = false; // double quote
char lastc = 0;
int len = val.length();
for (e=0; e < len; e++) {
char c = val.charAt(e);
if (!dq && c == '\'" && lastc != '\\") {
sq = !sq;
if (s < 0) s = e;
}
else if (!sq && c == '\"" && lastc != '\\") {
dq = !dq;
if (s < 0) s = e;
}
else if (!sq && !dq) {
if (Character.isWhitespace(c)) {
if (s >= 0) l.add(val.substring(s, e));
s = -1;
}
else if (s < 0 && c != ' ") {
s = e;
}
}
lastc = c;
}
l.add(val.substring(s, e));
return (String[])l.toArray(new String[0]);
}
|
| public void | stagc(char[] buff, int offset, int length)
// System.err.println("%% Start-tag");
if (theNewElement == null) return;
rectify(theNewElement);
if (theStack.model() == Schema.M_EMPTY) {
// Force an immediate end tag
etag_basic(buff, offset, length);
}
|
| public void | stage(char[] buff, int offset, int length)
// System.err.println("%% Empty-tag");
if (theNewElement == null) return;
rectify(theNewElement);
// Force an immediate end tag
etag_basic(buff, offset, length);
|
| public void | startCDATA()
|
| public void | startDTD(java.lang.String name, java.lang.String publicid, java.lang.String systemid)
|
| public void | startEntity(java.lang.String name)
|
| private static java.lang.String | trimquotes(java.lang.String in)
if (in == null) return in;
int length = in.length();
if (length == 0) return in;
char s = in.charAt(0);
char e = in.charAt(length - 1);
if (s == e && (s == '\'" || s == '"")) {
in = in.substring(1, in.length() - 1);
}
return in;
|
| private static java.lang.Boolean | truthValue(boolean b)
theFeatures.put(namespacesFeature, truthValue(DEFAULT_NAMESPACES));
theFeatures.put(namespacePrefixesFeature, Boolean.FALSE);
theFeatures.put(externalGeneralEntitiesFeature, Boolean.FALSE);
theFeatures.put(externalParameterEntitiesFeature, Boolean.FALSE);
theFeatures.put(isStandaloneFeature, Boolean.FALSE);
theFeatures.put(lexicalHandlerParameterEntitiesFeature,
Boolean.FALSE);
theFeatures.put(resolveDTDURIsFeature, Boolean.TRUE);
theFeatures.put(stringInterningFeature, Boolean.TRUE);
theFeatures.put(useAttributes2Feature, Boolean.FALSE);
theFeatures.put(useLocator2Feature, Boolean.FALSE);
theFeatures.put(useEntityResolver2Feature, Boolean.FALSE);
theFeatures.put(validationFeature, Boolean.FALSE);
theFeatures.put(xmlnsURIsFeature, Boolean.FALSE);
theFeatures.put(xmlnsURIsFeature, Boolean.FALSE);
theFeatures.put(XML11Feature, Boolean.FALSE);
theFeatures.put(ignoreBogonsFeature, truthValue(DEFAULT_IGNORE_BOGONS));
theFeatures.put(bogonsEmptyFeature, truthValue(DEFAULT_BOGONS_EMPTY));
theFeatures.put(rootBogonsFeature, truthValue(DEFAULT_ROOT_BOGONS));
theFeatures.put(defaultAttributesFeature, truthValue(DEFAULT_DEFAULT_ATTRIBUTES));
theFeatures.put(translateColonsFeature, truthValue(DEFAULT_TRANSLATE_COLONS));
theFeatures.put(restartElementsFeature, truthValue(DEFAULT_RESTART_ELEMENTS));
theFeatures.put(ignorableWhitespaceFeature, truthValue(DEFAULT_IGNORABLE_WHITESPACE));
theFeatures.put(CDATAElementsFeature, truthValue(DEFAULT_CDATA_ELEMENTS));
return b ? Boolean.TRUE : Boolean.FALSE;
|
