package gnu.xml.dom;
import java.util.Iterator;
import javax.xml.XMLConstants;
import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.DocumentType;
import org.w3c.dom.DOMConfiguration;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.DOMException;
import org.w3c.dom.Element;
import org.w3c.dom.Entity;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.Notation;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;
import org.w3c.dom.UserDataHandler;
import org.w3c.dom.traversal.DocumentTraversal;
import org.w3c.dom.traversal.NodeFilter;
import org.w3c.dom.traversal.NodeIterator;
import org.w3c.dom.traversal.TreeWalker;
import org.w3c.dom.xpath.XPathEvaluator;
import org.w3c.dom.xpath.XPathException;
import org.w3c.dom.xpath.XPathExpression;
import org.w3c.dom.xpath.XPathNSResolver;
public class DomDocument
extends DomNode
implements Document, DocumentTraversal, XPathEvaluator
{
private final DOMImplementation implementation;
private boolean checkingCharacters = true;
boolean checkingWellformedness = true;
boolean building;
DomDocumentConfiguration config;
String inputEncoding;
String encoding;
String version = "1.0";
boolean standalone;
String systemId;
public DomDocument()
{
this(new DomImpl());
}
protected DomDocument(DOMImplementation impl)
{
super(DOCUMENT_NODE, null);
implementation = impl;
}
public void setBuilding(boolean flag)
{
building = flag;
}
public void setCheckWellformedness(boolean flag)
{
checkingWellformedness = flag;
}
final public String getNodeName()
{
return "#document";
}
final public Element getDocumentElement()
{
for (DomNode ctx = first; ctx != null; ctx = ctx.next)
{
if (ctx.nodeType == ELEMENT_NODE)
{
return (Element) ctx;
}
}
return null;
}
final public DocumentType getDoctype()
{
for (DomNode ctx = first; ctx != null; ctx = ctx.next)
{
if (ctx.nodeType == DOCUMENT_TYPE_NODE)
{
return (DocumentType) ctx;
}
}
return null;
}
final public DOMImplementation getImplementation()
{
return implementation;
}
public Element getElementById(String id)
{
DomDoctype doctype = (DomDoctype) getDoctype();
if (doctype == null || !doctype.hasIds()
|| id == null || id.length() == 0)
{
return null;
}
Node current = getDocumentElement();
Node temp;
if (current == null)
{
return null;
}
while (current != this)
{
if (current.getNodeType() == ELEMENT_NODE)
{
DomElement element = (DomElement) current;
DTDElementTypeInfo info =
doctype.getElementTypeInfo(current.getNodeName());
if (info != null &&
id.equals(element.getAttribute(info.idAttrName)))
{
return element;
}
else if (element.userIdAttrs != null)
{
for (Iterator i = element.userIdAttrs.iterator();
i.hasNext(); )
{
Node idAttr = (Node) i.next();
if (id.equals(idAttr.getNodeValue()))
{
return element;
}
}
}
}
if (current.hasChildNodes())
{
current = current.getFirstChild();
continue;
}
temp = current.getNextSibling();
if (temp != null)
{
current = temp;
continue;
}
do
{
temp = current.getParentNode();
if (temp == null)
{
return null;
}
current = temp;
temp = current.getNextSibling();
}
while (temp == null);
current = temp;
}
return null;
}
private void checkNewChild(Node newChild)
{
if (newChild.getNodeType() == ELEMENT_NODE
&& getDocumentElement() != null)
{
throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR,
"document element already present: " +
getDocumentElement(), newChild, 0);
}
if (newChild.getNodeType() == DOCUMENT_TYPE_NODE
&& getDoctype() != null)
{
throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR,
"document type already present: " +
getDoctype(), newChild, 0);
}
}
public Node appendChild(Node newChild)
{
if (checkingWellformedness)
{
checkNewChild(newChild);
}
return super.appendChild(newChild);
}
public Node insertBefore(Node newChild, Node refChild)
{
if (checkingWellformedness)
{
checkNewChild(newChild);
}
return super.insertBefore(newChild, refChild);
}
public Node replaceChild(Node newChild, Node refChild)
{
if (checkingWellformedness &&
((newChild.getNodeType() == ELEMENT_NODE &&
refChild.getNodeType() != ELEMENT_NODE) ||
(newChild.getNodeType() == DOCUMENT_TYPE_NODE &&
refChild.getNodeType() != DOCUMENT_TYPE_NODE)))
{
checkNewChild(newChild);
}
return super.replaceChild(newChild, refChild);
}
public static void verifyXmlName(String name)
{
checkName(name, false);
}
static void checkName(String name, boolean xml11)
{
if (name == null)
{
throw new DomDOMException(DOMException.NAMESPACE_ERR, name, null, 0);
}
int len = name.length();
if (len == 0)
{
throw new DomDOMException(DOMException.NAMESPACE_ERR, name, null, 0);
}
char c = name.charAt(0);
if (xml11)
{
if ((c < 0x0041 || c > 0x005a) &&
(c < 0x0061 || c > 0x007a) &&
c != ':' && c != '_' &&
(c < 0x00c0 || c > 0x00d6) &&
(c < 0x00d8 || c > 0x00f6) &&
(c < 0x00f8 || c > 0x02ff) &&
(c < 0x0370 || c > 0x037d) &&
(c < 0x037f || c > 0x1fff) &&
(c < 0x200c || c > 0x200d) &&
(c < 0x2070 || c > 0x218f) &&
(c < 0x2c00 || c > 0x2fef) &&
(c < 0x3001 || c > 0xd7ff) &&
(c < 0xf900 || c > 0xfdcf) &&
(c < 0xfdf0 || c > 0xfffd) &&
(c < 0x10000 || c > 0xeffff))
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
name, null, c);
}
}
else
{
int type = Character.getType(c);
switch (type)
{
case Character.LOWERCASE_LETTER: case Character.UPPERCASE_LETTER: case Character.OTHER_LETTER: case Character.TITLECASE_LETTER: case Character.LETTER_NUMBER: if ((c > 0xf900 && c < 0xfffe) ||
(c >= 0x20dd && c <= 0x20e0))
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
name, null, c);
}
break;
default:
if (c != ':' && c != '_' && (c < 0x02bb || c > 0x02c1) &&
c != 0x0559 && c != 0x06e5 && c != 0x06e6)
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
name, null, c);
}
}
}
for (int i = 1; i < len; i++)
{
c = name.charAt(i);
if (xml11)
{
if ((c < 0x0041 || c > 0x005a) &&
(c < 0x0061 || c > 0x007a) &&
(c < 0x0030 || c > 0x0039) &&
c != ':' && c != '_' && c != '-' && c != '.' &&
(c < 0x00c0 || c > 0x00d6) &&
(c < 0x00d8 || c > 0x00f6) &&
(c < 0x00f8 || c > 0x02ff) &&
(c < 0x0370 || c > 0x037d) &&
(c < 0x037f || c > 0x1fff) &&
(c < 0x200c || c > 0x200d) &&
(c < 0x2070 || c > 0x218f) &&
(c < 0x2c00 || c > 0x2fef) &&
(c < 0x3001 || c > 0xd7ff) &&
(c < 0xf900 || c > 0xfdcf) &&
(c < 0xfdf0 || c > 0xfffd) &&
(c < 0x10000 || c > 0xeffff) &&
c != 0x00b7 &&
(c < 0x0300 || c > 0x036f) &&
(c < 0x203f || c > 0x2040))
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR, name,
null, c);
}
}
else
{
int type = Character.getType(c);
switch (type)
{
case Character.LOWERCASE_LETTER: case Character.UPPERCASE_LETTER: case Character.DECIMAL_DIGIT_NUMBER: case Character.OTHER_LETTER: case Character.TITLECASE_LETTER: case Character.LETTER_NUMBER: case Character.COMBINING_SPACING_MARK: case Character.ENCLOSING_MARK: case Character.NON_SPACING_MARK: case Character.MODIFIER_LETTER: if ((c > 0xf900 && c < 0xfffe) ||
(c >= 0x20dd && c <= 0x20e0))
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
name, null, c);
}
break;
default:
if (c != '-' && c != '.' && c != ':' && c != '_' &&
c != 0x0387 && (c < 0x02bb || c > 0x02c1) &&
c != 0x0559 && c != 0x06e5 && c != 0x06e6 && c != 0x00b7)
{
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
name, null, c);
}
}
}
}
}
static void checkNCName(String name, boolean xml11)
{
checkName(name, xml11);
int len = name.length();
int index = name.indexOf(':');
if (index != -1)
{
if (index == 0 || index == (len - 1) ||
name.lastIndexOf(':') != index)
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
name, null, 0);
}
}
}
static void checkChar(String value, boolean xml11)
{
char[] chars = value.toCharArray();
checkChar(chars, 0, chars.length, xml11);
}
static void checkChar(char[] buf, int off, int len, boolean xml11)
{
for (int i = 0; i < len; i++)
{
char c = buf[i];
if ((c >= 0x0020 && c <= 0xd7ff) ||
(c == 0x000a || c == 0x000d || c == 0x0009) ||
(c >= 0xe000 && c <= 0xfffd) ||
(c >= 0x10000 && c <= 0x10ffff))
{
continue;
}
if (xml11)
{
if ((c >= 0x0001 && c <= 0x001f) ||
(c >= 0x007f && c <= 0x0084) ||
(c >= 0x0086 && c <= 0x009f))
{
continue;
}
}
throw new DomDOMException(DOMException.INVALID_CHARACTER_ERR,
new String(buf, off, len), null, c);
}
}
public Element createElement(String name)
{
Element element;
if (checkingCharacters)
{
checkName(name, "1.1".equals(version));
}
if (name.startsWith("xml:"))
{
element = createElementNS(null, name);
}
else
{
element = new DomElement(this, null, name);
}
defaultAttributes(element, name);
return element;
}
public Element createElementNS(String namespaceURI, String name)
{
if (checkingCharacters)
{
checkNCName(name, "1.1".equals(version));
}
if ("".equals(namespaceURI))
{
namespaceURI = null;
}
if (name.startsWith("xml:"))
{
if (namespaceURI != null
&& !XMLConstants.XML_NS_URI.equals(namespaceURI))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xml namespace is always " +
XMLConstants.XML_NS_URI, this, 0);
}
namespaceURI = XMLConstants.XML_NS_URI;
}
else if (XMLConstants.XMLNS_ATTRIBUTE.equals(name) ||
name.startsWith("xmlns:"))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xmlns is reserved", this, 0);
}
else if (namespaceURI == null && name.indexOf(':') != -1)
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"prefixed name '" + name +
"' needs a URI", this, 0);
}
Element element = new DomElement(this, namespaceURI, name);
defaultAttributes(element, name);
return element;
}
private void defaultAttributes(Element element, String name)
{
DomDoctype doctype = (DomDoctype) getDoctype();
if (doctype == null)
{
return;
}
DTDElementTypeInfo info = doctype.getElementTypeInfo(name);
if (info != null)
{
for (Iterator i = info.attributes(); i != null && i.hasNext(); )
{
DTDAttributeTypeInfo attr = (DTDAttributeTypeInfo) i.next();
DomAttr node = (DomAttr) createAttribute(attr.name);
String value = attr.value;
if (value == null)
{
value = "";
}
node.setValue(value);
node.setSpecified(false);
element.setAttributeNode(node);
}
}
}
public DocumentFragment createDocumentFragment()
{
return new DomDocumentFragment(this);
}
public Text createTextNode(String value)
{
if (checkingCharacters)
{
checkChar(value, "1.1".equals(version));
}
return new DomText(this, value);
}
public Text createTextNode(char[] buf, int off, int len)
{
if (checkingCharacters)
{
checkChar(buf, off, len, "1.1".equals(version));
}
return new DomText(this, buf, off, len);
}
public Comment createComment(String value)
{
if (checkingCharacters)
{
checkChar(value, "1.1".equals(version));
}
return new DomComment(this, value);
}
public CDATASection createCDATASection(String value)
{
if (checkingCharacters)
{
checkChar(value, "1.1".equals(version));
}
return new DomCDATASection(this, value);
}
public CDATASection createCDATASection(char[] buf, int off, int len)
{
if (checkingCharacters)
{
checkChar(buf, off, len, "1.1".equals(version));
}
return new DomCDATASection(this, buf, off, len);
}
public ProcessingInstruction createProcessingInstruction(String target,
String data)
{
if (checkingCharacters)
{
boolean xml11 = "1.1".equals(version);
checkName(target, xml11);
if ("xml".equalsIgnoreCase(target))
{
throw new DomDOMException(DOMException.SYNTAX_ERR,
"illegal PI target name",
this, 0);
}
checkChar(data, xml11);
}
return new DomProcessingInstruction(this, target, data);
}
public Attr createAttribute(String name)
{
if (checkingCharacters)
{
checkName(name, "1.1".equals(version));
}
if (name.startsWith("xml:"))
{
return createAttributeNS(XMLConstants.XML_NS_URI, name);
}
else if (XMLConstants.XMLNS_ATTRIBUTE.equals(name) ||
name.startsWith("xmlns:"))
{
return createAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, name);
}
else
{
return new DomAttr(this, null, name);
}
}
public Attr createAttributeNS(String namespaceURI, String name)
{
if (checkingCharacters)
{
checkNCName(name, "1.1".equals(version));
}
if ("".equals(namespaceURI))
{
namespaceURI = null;
}
if (name.startsWith ("xml:"))
{
if (namespaceURI == null)
{
namespaceURI = XMLConstants.XML_NS_URI;
}
else if (!XMLConstants.XML_NS_URI.equals(namespaceURI))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xml namespace is always " +
XMLConstants.XML_NS_URI,
this, 0);
}
}
else if (XMLConstants.XMLNS_ATTRIBUTE.equals(name) ||
name.startsWith("xmlns:"))
{
if (namespaceURI == null)
{
namespaceURI = XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
}
else if (!XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xmlns namespace must be " +
XMLConstants.XMLNS_ATTRIBUTE_NS_URI,
this, 0);
}
}
else if (namespaceURI == null && name.indexOf(':') != -1)
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"prefixed name needs a URI: " + name, this, 0);
}
return new DomAttr(this, namespaceURI, name);
}
public EntityReference createEntityReference(String name)
{
DomEntityReference ret = new DomEntityReference(this, name);
DocumentType doctype = getDoctype();
if (doctype != null)
{
DomEntity ent = (DomEntity) doctype.getEntities().getNamedItem(name);
if (ent != null)
{
for (DomNode ctx = ent.first; ctx != null; ctx = ctx.next)
{
ret.appendChild(ctx.cloneNode(true));
}
}
}
ret.makeReadonly();
return ret;
}
public Node importNode(Node src, boolean deep)
{
Node dst = null;
switch (src.getNodeType())
{
case TEXT_NODE:
dst = createTextNode(src.getNodeValue());
break;
case CDATA_SECTION_NODE:
dst = createCDATASection(src.getNodeValue());
break;
case COMMENT_NODE:
dst = createComment(src.getNodeValue());
break;
case PROCESSING_INSTRUCTION_NODE:
dst = createProcessingInstruction(src.getNodeName(),
src.getNodeValue());
break;
case NOTATION_NODE:
Notation notation = (Notation) src;
dst = new DomNotation(this, notation.getNodeName(),
notation.getPublicId(),
notation.getSystemId());
break;
case ENTITY_NODE:
Entity entity = (Entity) src;
dst = new DomEntity(this, entity.getNodeName(),
entity.getPublicId(),
entity.getSystemId(),
entity.getNotationName());
if (deep)
{
for (Node ctx = src.getFirstChild(); ctx != null;
ctx = ctx.getNextSibling())
{
dst.appendChild(importNode(ctx, deep));
}
}
break;
case ENTITY_REFERENCE_NODE:
dst = createEntityReference(src.getNodeName());
break;
case DOCUMENT_FRAGMENT_NODE:
dst = new DomDocumentFragment(this);
if (deep)
{
for (Node ctx = src.getFirstChild(); ctx != null;
ctx = ctx.getNextSibling())
{
dst.appendChild(importNode(ctx, deep));
}
}
break;
case ATTRIBUTE_NODE:
String attr_nsuri = src.getNamespaceURI();
if (attr_nsuri != null)
{
dst = createAttributeNS(attr_nsuri, src.getNodeName());
}
else
{
dst = createAttribute(src.getNodeName());
}
for (Node ctx = src.getFirstChild(); ctx != null;
ctx = ctx.getNextSibling())
{
dst.appendChild(importNode(ctx, false));
}
break;
case ELEMENT_NODE:
String elem_nsuri = src.getNamespaceURI();
if (elem_nsuri != null)
{
dst = createElementNS(elem_nsuri, src.getNodeName());
}
else
{
dst = createElement(src.getNodeName());
}
NamedNodeMap srcAttrs = src.getAttributes();
NamedNodeMap dstAttrs = dst.getAttributes();
int len = srcAttrs.getLength();
for (int i = 0; i < len; i++)
{
Attr a = (Attr) srcAttrs.item(i);
Attr dflt;
dflt = (Attr) dstAttrs.getNamedItem(a.getNodeName());
if (dflt != null)
{
String newval = a.getNodeValue();
if (!dflt.getNodeValue().equals(newval)
|| a.getSpecified () == true)
{
dflt.setNodeValue (newval);
}
continue;
}
dstAttrs.setNamedItem((Attr) importNode(a, false));
}
if (deep)
{
for (Node ctx = src.getFirstChild(); ctx != null;
ctx = ctx.getNextSibling())
{
dst.appendChild(importNode(ctx, true));
}
}
break;
case DOCUMENT_NODE:
case DOCUMENT_TYPE_NODE:
default:
throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR, null, src, 0);
}
if (src instanceof DomNode)
{
((DomNode) src).notifyUserDataHandlers(UserDataHandler.NODE_IMPORTED,
src, dst);
}
return dst;
}
public NodeIterator createNodeIterator(Node root,
int whatToShow,
NodeFilter filter,
boolean expandEntities)
{
return new DomNodeIterator(root, whatToShow, filter, expandEntities,
false);
}
public TreeWalker createTreeWalker(Node root,
int whatToShow,
NodeFilter filter,
boolean expandEntities)
{
return new DomNodeIterator(root, whatToShow, filter, expandEntities,
true);
}
public String getInputEncoding()
{
return inputEncoding;
}
public void setInputEncoding(String inputEncoding)
{
this.inputEncoding = inputEncoding;
}
public String getXmlEncoding()
{
return encoding;
}
public void setXmlEncoding(String encoding)
{
this.encoding = encoding;
}
public boolean getXmlStandalone()
{
return standalone;
}
public void setXmlStandalone(boolean xmlStandalone)
{
standalone = xmlStandalone;
}
public String getXmlVersion()
{
return version;
}
public void setXmlVersion(String xmlVersion)
{
if (xmlVersion == null)
{
xmlVersion = "1.0";
}
if ("1.0".equals(xmlVersion) ||
"1.1".equals(xmlVersion))
{
version = xmlVersion;
}
else
{
throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR);
}
}
public boolean getStrictErrorChecking()
{
return checkingCharacters;
}
public void setStrictErrorChecking(boolean strictErrorChecking)
{
checkingCharacters = strictErrorChecking;
}
public String lookupPrefix(String namespaceURI)
{
Node root = getDocumentElement();
return (root == null) ? null : root.lookupPrefix(namespaceURI);
}
public boolean isDefaultNamespace(String namespaceURI)
{
Node root = getDocumentElement();
return (root == null) ? false : root.isDefaultNamespace(namespaceURI);
}
public String lookupNamespaceURI(String prefix)
{
Node root = getDocumentElement();
return (root == null) ? null : root.lookupNamespaceURI(prefix);
}
public String getBaseURI()
{
return getDocumentURI();
}
public String getDocumentURI()
{
return systemId;
}
public void setDocumentURI(String documentURI)
{
systemId = documentURI;
}
public Node adoptNode(Node source)
{
switch (source.getNodeType())
{
case DOCUMENT_NODE:
case DOCUMENT_TYPE_NODE:
throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR);
case ENTITY_NODE:
case NOTATION_NODE:
throw new DomDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
}
if (source instanceof DomNode)
{
DomNode src = (DomNode) source;
DomNode dst = src;
if (dst.parent != null)
{
dst = (DomNode) dst.cloneNode(true);
}
dst.setOwner(this);
src.notifyUserDataHandlers(UserDataHandler.NODE_ADOPTED, src, dst);
return dst;
}
return null;
}
public DOMConfiguration getDomConfig()
{
if (config == null)
{
config = new DomDocumentConfiguration();
}
return config;
}
public void normalizeDocument()
{
boolean save = building;
building = true;
normalizeNode(this);
building = save;
}
void normalizeNode(DomNode node)
{
node.normalize();
if (config != null)
{
switch (node.nodeType)
{
case CDATA_SECTION_NODE:
if (!config.cdataSections)
{
Text text = createTextNode(node.getNodeValue());
node.parent.insertBefore(text, node);
node.parent.removeChild(node);
String data = text.getWholeText();
node = (DomNode) text.replaceWholeText(data);
}
else if (config.splitCdataSections)
{
String value = node.getNodeValue();
int i = value.indexOf("]]>");
while (i != -1)
{
Node node2 = createCDATASection(value.substring(0, i));
node.parent.insertBefore(node2, node);
value = value.substring(i + 3);
node.setNodeValue(value);
i = value.indexOf("]]>");
}
}
break;
case COMMENT_NODE:
if (!config.comments)
{
node.parent.removeChild(node);
}
break;
case TEXT_NODE:
if (!config.elementContentWhitespace &&
((Text) node).isElementContentWhitespace())
{
node.parent.removeChild(node);
}
break;
case ENTITY_REFERENCE_NODE:
if (!config.entities)
{
for (DomNode ctx = node.first; ctx != null; )
{
DomNode ctxNext = ctx.next;
node.parent.insertBefore(ctx, node);
ctx = ctxNext;
}
node.parent.removeChild(node);
}
break;
case ELEMENT_NODE:
if (!config.namespaceDeclarations)
{
DomNamedNodeMap attrs =
(DomNamedNodeMap) node.getAttributes();
boolean aro = attrs.readonly;
attrs.readonly = false; int len = attrs.getLength();
for (int i = 0; i < len; i++)
{
Node attr = attrs.item(i);
String namespace = attr.getNamespaceURI();
if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespace))
{
attrs.removeNamedItemNS(namespace,
attr.getLocalName());
i--;
len--;
}
}
attrs.readonly = aro;
}
break;
}
}
for (DomNode ctx = node.first; ctx != null; )
{
DomNode ctxNext = ctx.next;
normalizeNode(ctx);
ctx = ctxNext;
}
}
public Node renameNode(Node n, String namespaceURI, String qualifiedName)
throws DOMException
{
if (n instanceof DomNsNode)
{
DomNsNode src = (DomNsNode) n;
if (src == null)
{
throw new DomDOMException(DOMException.NOT_FOUND_ERR);
}
if (src.owner != this)
{
throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR,
null, src, 0);
}
boolean xml11 = "1.1".equals(version);
checkName(qualifiedName, xml11);
int ci = qualifiedName.indexOf(':');
if ("".equals(namespaceURI))
{
namespaceURI = null;
}
if (namespaceURI != null)
{
checkNCName(qualifiedName, xml11);
String prefix = (ci == -1) ? "" :
qualifiedName.substring(0, ci);
if (XMLConstants.XML_NS_PREFIX.equals(prefix) &&
!XMLConstants.XML_NS_URI.equals(namespaceURI))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xml namespace must be " +
XMLConstants.XML_NS_URI, src, 0);
}
else if (src.nodeType == ATTRIBUTE_NODE &&
(XMLConstants.XMLNS_ATTRIBUTE.equals(prefix) ||
XMLConstants.XMLNS_ATTRIBUTE.equals(qualifiedName)) &&
!XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xmlns namespace must be " +
XMLConstants.XMLNS_ATTRIBUTE_NS_URI, src, 0);
}
if (XMLConstants.XML_NS_URI.equals(namespaceURI) &&
!XMLConstants.XML_NS_PREFIX.equals(prefix))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xml namespace must be " +
XMLConstants.XML_NS_URI, src, 0);
}
else if (src.nodeType == ATTRIBUTE_NODE &&
XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI) &&
!(XMLConstants.XMLNS_ATTRIBUTE.equals(prefix) ||
XMLConstants.XMLNS_ATTRIBUTE.equals(qualifiedName)))
{
throw new DomDOMException(DOMException.NAMESPACE_ERR,
"xmlns namespace must be " +
XMLConstants.XMLNS_ATTRIBUTE_NS_URI, src, 0);
}
}
src.setNodeName(qualifiedName);
src.setNamespaceURI(namespaceURI);
src.notifyUserDataHandlers(UserDataHandler.NODE_RENAMED, src, src);
return src;
}
throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR, null, n, 0);
}
public XPathExpression createExpression(String expression,
XPathNSResolver resolver)
throws XPathException, DOMException
{
return new DomXPathExpression(this, expression, resolver);
}
public XPathNSResolver createNSResolver(Node nodeResolver)
{
return new DomXPathNSResolver(nodeResolver);
}
public Object evaluate(String expression,
Node contextNode,
XPathNSResolver resolver,
short type,
Object result)
throws XPathException, DOMException
{
XPathExpression xpe =
new DomXPathExpression(this, expression, resolver);
return xpe.evaluate(contextNode, type, result);
}
}