diff options
Diffstat (limited to 'libjava/classpath/native/jni/xmlj/xmlj_dom.c')
| -rw-r--r-- | libjava/classpath/native/jni/xmlj/xmlj_dom.c | 2617 |
1 files changed, 2617 insertions, 0 deletions
diff --git a/libjava/classpath/native/jni/xmlj/xmlj_dom.c b/libjava/classpath/native/jni/xmlj/xmlj_dom.c new file mode 100644 index 00000000000..b9bd372b17b --- /dev/null +++ b/libjava/classpath/native/jni/xmlj/xmlj_dom.c @@ -0,0 +1,2617 @@ +/* xmlj_dom.c - + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +#include "xmlj_dom.h" +#include "xmlj_error.h" +#include "xmlj_io.h" +#include "xmlj_node.h" +#include "xmlj_sax.h" +#include "xmlj_util.h" + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +JNIEnv *dom_cb_env; +jobject dom_cb_obj; + +typedef struct +{ + int index; + int count; + xmlNodePtr node; +} +xmljHashScanData; + +/* Prototypes for local functions */ + +void +xmljAddAttribute (xmlNodePtr node, xmlAttrPtr attr); + +void +xmljHashScanner (void *payload, void *vdata, xmlChar *name); + +xmlChar * +xmljGetNodeValue (xmlNodePtr node); + +/* + * Determines whether a child node is suitable for insertion in the list of + * children for a given parent node. + * Returns 0 on success, a DOMException code otherwise. + */ +void +xmljValidateChildNode (JNIEnv *env, xmlNodePtr parent, xmlNodePtr child) +{ + xmlNodePtr cur; + + if (child == NULL || parent == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return; + } + if (child->doc != parent->doc) + { + xmljThrowDOMException (env, 4, NULL); /* WRONG_DOCUMENT_ERR */ + return; + } + /* Check that new parent is of an allowed type */ + switch (parent->type) + { + case XML_CDATA_SECTION_NODE: + case XML_COMMENT_NODE: + case XML_TEXT_NODE: + case XML_ENTITY_NODE: + case XML_ENTITY_REF_NODE: + case XML_NOTATION_NODE: + case XML_PI_NODE: + /* these can't have any children */ + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "parent type does not allow children"); + return; + case XML_ATTRIBUTE_NODE: + if (child->type != XML_TEXT_NODE && + child->type != XML_ENTITY_REF_NODE) + { + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "attributes may only contain text or entity reference nodes"); + return; + } + break; + case XML_DOCUMENT_FRAG_NODE: + case XML_ELEMENT_NODE: + if (child->type == XML_DTD_NODE || + child->type == XML_DOCUMENT_TYPE_NODE || + child->type == XML_ENTITY_NODE || + child->type == XML_NOTATION_NODE || + child->type == XML_PI_NODE) + { + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "parent type does not allow child of this type"); + return; + } + /* fall through */ + default: + if (child->type == XML_ATTRIBUTE_NODE || + child->type == XML_DOCUMENT_NODE || + child->type == XML_DOCUMENT_FRAG_NODE) + { + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "node type may not be a child"); + return; + } + /* TODO others? */ + } + /* Check that new parent is not self or an ancestor */ + for (cur = parent; cur != NULL; cur = cur->parent) + { + if (cur == child) + { + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "child cannot be an ancestor of itself"); + return; + } + } + /* Check that new parent does not add a second doctype or root element + * to a document parent */ + if (parent->type == XML_DOCUMENT_NODE) + { + cur = parent->children; + while (cur != NULL) + { + if (cur->type == XML_DTD_NODE || + cur->type == XML_DOCUMENT_TYPE_NODE || + (cur->type == XML_ELEMENT_NODE && + parent->type == XML_DOCUMENT_NODE)) + { + if (child->type == cur->type && child != cur) + { + /* HIERARCHY_REQUEST_ERR */ + xmljThrowDOMException (env, 3, "cannot add a second doctype or root element"); + return; + } + } + cur = cur->next; + } + } +} + +/* + * Adds the specified attribute node to the list of attributes for the given + * element. + */ +void +xmljAddAttribute (xmlNodePtr node, xmlAttrPtr attr) +{ + xmlAttrPtr cur = node->properties; + + if (cur == NULL) + { + node->properties = attr; + attr->prev = NULL; + attr->next = NULL; + attr->parent = node; + attr->doc = node->doc; + } + else + { + while (cur->next != NULL) + { + cur = cur->next; + } + cur->next = attr; + attr->prev = cur; + attr->next = NULL; + attr->parent = node; + attr->doc = node->doc; + } +} + +/* -- GnomeAttr -- */ + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeAttr_getSpecified (JNIEnv * env, jobject self) +{ + xmlAttrPtr attr; + + attr = (xmlAttrPtr) xmljGetNodeID (env, self); + return (attr->atype != 0); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeAttr_getValue (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + xmlChar *text; + jstring ret; + + node = xmljGetNodeID (env, self); + text = xmlNodeGetContent (node); + ret = xmljNewString (env, (const xmlChar *) text); + if (text != NULL) + { + xmlFree (text); + } + return ret; +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeAttr_setValue (JNIEnv * env, + jobject self, jstring value) +{ + xmlNodePtr node; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_value = xmljGetStringChars (env, value); + xmlNodeSetContent (node, s_value); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeAttr_xmljIsId (JNIEnv * env, jobject self) +{ + xmlAttrPtr attr; + + attr = (xmlAttrPtr) xmljGetNodeID (env, self); + return (attr->atype == XML_ATTRIBUTE_ID); +} + +/* -- GnomeDocument -- */ + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_free (JNIEnv * env, + jobject self + __attribute__ ((__unused__)), + jobject id) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljAsPointer (env, id); + xmljFreeDoc (env, doc); + xmlFree (doc); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getDoctype (JNIEnv * env, jobject self) +{ + xmlDocPtr doc; + xmlDtdPtr dtd; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + dtd = doc->extSubset; + if (dtd == NULL) + { + dtd = doc->intSubset; + } + return xmljGetNodeInstance (env, (xmlNodePtr) dtd); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getDocumentElement (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, xmlDocGetRootElement (doc)); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createDocumentType (JNIEnv * env, + jobject self, + jstring name, + jstring publicId, + jstring systemId) +{ + xmlDocPtr doc; + xmlDtdPtr dtd; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + dtd = xmlNewDtd (doc, + xmljGetStringChars (env, name), + xmljGetStringChars (env, publicId), + xmljGetStringChars (env, systemId)); + return xmljGetNodeInstance (env, (xmlNodePtr) dtd); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createDocumentFragment (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, xmlNewDocFragment (doc)); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createTextNode (JNIEnv * env, + jobject self, + jstring data) +{ + xmlDocPtr doc; + xmlNodePtr text; + const xmlChar *s_data; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_data = xmljGetStringChars (env, data); + text = xmlNewDocText (doc, s_data); + return xmljGetNodeInstance (env, text); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createComment (JNIEnv * env, + jobject self, + jstring data) +{ + xmlDocPtr doc; + xmlNodePtr comment; + const xmlChar *s_data; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_data = xmljGetStringChars (env, data); + comment = xmlNewDocComment (doc, s_data); + return xmljGetNodeInstance (env, comment); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createCDATASection (JNIEnv * env, + jobject self, + jstring data) +{ + xmlDocPtr doc; + xmlNodePtr cdata; + const xmlChar *s_data; + int len; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_data = xmljGetStringChars (env, data); + len = xmlStrlen (s_data); + cdata = xmlNewCDataBlock (doc, s_data, len); + return xmljGetNodeInstance (env, cdata); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createProcessingInstruction (JNIEnv * + env, + jobject + self, + jstring + target, + jstring + data) +{ + xmlDocPtr doc; + xmlNodePtr pi; + const xmlChar *s_target; + const xmlChar *s_data; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_target = xmljGetStringChars (env, target); + s_data = xmljGetStringChars (env, data); + pi = xmlNewPI (s_target, s_data); + pi->doc = doc; + return xmljGetNodeInstance (env, pi); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createEntityReference (JNIEnv * env, + jobject self, + jstring name) +{ + xmlDocPtr doc; + xmlNodePtr ref; + const xmlChar *s_name; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_name = xmljGetStringChars (env, name); + ref = xmlNewReference (doc, s_name); + return xmljGetNodeInstance (env, ref); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_xmljImportNode (JNIEnv * env, + jobject self, + jobject importedNode, + jboolean deep) +{ + xmlDocPtr doc; + xmlNodePtr node; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + node = xmljGetNodeID (env, importedNode); + if (node == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + if (node->type == XML_DOCUMENT_NODE || + node->type == XML_DOCUMENT_TYPE_NODE) + { + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return NULL; + } + node = xmlDocCopyNode (node, doc, deep); + return xmljGetNodeInstance (env, node); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createElementNS (JNIEnv * env, + jobject self, + jstring uri, + jstring qName) +{ + xmlDocPtr doc; + xmlNodePtr element; + xmlNsPtr ns = NULL; + const xmlChar *s_uri; + const xmlChar *s_qName; + const xmlChar *s_prefix; + const xmlChar *s_localName; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_qName = xmljGetStringChars (env, qName); + if (xmlValidateQName (s_qName, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + return NULL; + } + if (uri != NULL) + { + s_uri = xmljGetStringChars (env, uri); + s_prefix = xmljGetPrefix (s_qName); + s_localName = xmljGetLocalName (s_qName); + ns = xmlNewNs ((xmlNodePtr) doc, s_uri, s_prefix); + } + element = xmlNewDocNode (doc, ns, s_qName, NULL); + return xmljGetNodeInstance (env, element); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_createAttributeNS (JNIEnv * env, + jobject self, + jstring uri, + jstring qName) +{ + xmlDocPtr doc; + xmlNodePtr attr; + xmlNsPtr ns = NULL; + const xmlChar *s_uri; + const xmlChar *s_qName; + const xmlChar *s_prefix; + const xmlChar *s_localName; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + s_qName = xmljGetStringChars (env, qName); + if (xmlValidateQName (s_qName, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + return NULL; + } + if (uri != NULL) + { + s_uri = xmljGetStringChars (env, uri); + s_prefix = xmljGetPrefix (s_qName); + s_localName = xmljGetLocalName (s_qName); + ns = xmlNewNs ((xmlNodePtr) doc, s_uri, s_prefix); + } + attr = (xmlNodePtr) xmlNewNsProp ((xmlNodePtr) doc, ns, s_qName, NULL); + attr->parent = NULL; + return xmljGetNodeInstance (env, attr); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_xmljGetElementById (JNIEnv * env, + jobject self, + jstring elementId) +{ + xmlDocPtr doc; + xmlNodePtr ctx, tmp; + xmlAttrPtr attr; + const xmlChar *id; + const xmlChar *val; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + id = xmljGetStringChars (env, elementId); + + ctx = xmlDocGetRootElement (doc); + while (ctx && ctx != (xmlNodePtr) doc) + { + if (ctx->type == XML_ELEMENT_NODE) + { + for (attr = ctx->properties; attr; + attr = (xmlAttrPtr) attr->next) + { + if (xmlIsID (doc, ctx, attr)) + { + val = xmlGetProp (ctx, attr->name); + if (val && xmlStrEqual (id, val)) + { + return xmljGetNodeInstance (env, ctx); + } + } + } + } + if (ctx->children) + { + ctx = ctx->children; + } + else + { + tmp = ctx->next; + if (tmp) + { + ctx = tmp; + } + else + { + do + { + tmp = ctx->parent; + if (!tmp) + { + return NULL; + } + ctx = tmp; + tmp = ctx->next; + } + while (!tmp); + ctx = tmp; + } + } + } + return NULL; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getInputEncoding (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + if (doc->encoding) + { + return xmljNewString (env, doc->encoding); + } + switch (doc->charset) + { + case XML_CHAR_ENCODING_ASCII: + return xmljNewString (env, BAD_CAST "US-ASCII"); + case XML_CHAR_ENCODING_UTF16LE: + return xmljNewString (env, BAD_CAST "UTF-16LE"); + case XML_CHAR_ENCODING_UTF16BE: + return xmljNewString (env, BAD_CAST "UTF-16BE"); + case XML_CHAR_ENCODING_8859_1: + return xmljNewString (env, BAD_CAST "ISO-8859-1"); + /* TODO others */ + default: + return xmljNewString (env, BAD_CAST "UTF-8"); + } +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getXmlEncoding (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return (doc->encoding == NULL) ? + xmljNewString (env, BAD_CAST "UTF-8") : + xmljNewString (env, doc->encoding); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getXmlStandalone (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return doc->standalone; +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_setXmlStandalone (JNIEnv * env, + jobject self, + jboolean xmlStandalone) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + doc->standalone = xmlStandalone; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getXmlVersion (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return (doc->version == NULL) ? + xmljNewString (env, BAD_CAST "1.0") : + xmljNewString (env, doc->version); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_setXmlVersion (JNIEnv * env, + jobject self, + jstring xmlVersion) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + if (xmlVersion == NULL) + { + doc->version = NULL; + } + else + { + const xmlChar *version = xmljGetStringChars (env, xmlVersion); + if (!xmlStrEqual (version, BAD_CAST "1.0") && + !xmlStrEqual (version, BAD_CAST "1.1")) + { + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return; + } + doc->version = version; + } +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_getDocumentURI (JNIEnv * env, + jobject self) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + return (doc->name == NULL) ? NULL : + xmljNewString (env, (const xmlChar *) doc->URL); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_setDocumentURI (JNIEnv * env, + jobject self, + jstring documentURI) +{ + xmlDocPtr doc; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + if (documentURI == NULL) + { + doc->URL = NULL; + } + else + { + doc->URL = xmljGetStringChars (env, documentURI); + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_xmljAdoptNode (JNIEnv *env, + jobject self, + jobject jnode) +{ + xmlDocPtr doc; + xmlNodePtr node; + + doc = (xmlDocPtr) xmljGetNodeID (env, self); + node = xmljGetNodeID (env, jnode); + + if (node == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + if (node->type == XML_DOCUMENT_NODE || + node->type == XML_DOCUMENT_TYPE_NODE || + node->type == XML_ENTITY_NODE || + node->type == XML_NOTATION_NODE) + { + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return NULL; + } + xmlUnlinkNode (node); + node = xmlDocCopyNode (node, doc, 1); + return xmljGetNodeInstance (env, node); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocument_renameNode (JNIEnv * env, + jobject self + __attribute__ ((__unused__)), + jobject n + __attribute__ ((__unused__)), + jstring namespaceURI + __attribute__ ((__unused__)), + jstring qName + __attribute__ ((__unused__))) +{ + xmlNodePtr node; + xmlNsPtr ns; + const xmlChar *s_qName; + const xmlChar *href; + const xmlChar *prefix; + int *len; + + node = xmljGetNodeID (env, n); + if (node == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + s_qName = xmljGetStringChars (env, qName); + if (xmlValidateQName (s_qName, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + return NULL; + } + xmlNodeSetName (node, s_qName); + + href = xmljGetStringChars (env, namespaceURI); + len = (int *) malloc (sizeof (int)); + prefix = xmlSplitQName3 (s_qName, len); + ns = node->ns; + if (ns == NULL) + { + if (href != NULL) + { + ns = xmlNewNs (node, href, prefix); + xmlSetNs (node, ns); + } + } + else + { + node->ns = NULL; + /*xmlFreeNs (ns); FIXME this can segfault (?) */ + if (href != NULL) + { + ns = xmlNewNs (node, href, prefix); + xmlSetNs (node, ns); + } + } + free (len); + return n; +} + +/* -- GnomeDocumentBuilder -- */ + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocumentBuilder_parseStream (JNIEnv * env, + jobject self, + jobject in, + jbyteArray + detectBuffer, + jstring publicId, + jstring systemId, + jstring base, + jboolean validate, + jboolean coalesce, + jboolean + expandEntities, + jboolean + entityResolver, + jboolean + errorHandler) +{ + xmlDocPtr doc; + + doc = xmljParseDocument(env, + self, + in, + detectBuffer, + publicId, + systemId, + base, + validate, + coalesce, + expandEntities, + 0, + 0, + entityResolver, + errorHandler, + 0, + 0, + 1); + return xmljCreateDocument (env, self, doc); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocumentBuilder_createDocument +(JNIEnv * env, + jobject self, + jstring namespaceURI, + jstring qualifiedName, + jobject doctype) +{ + xmlDocPtr doc; + xmlNodePtr root; + xmlNsPtr ns; + const xmlChar *href; + const xmlChar *prefix; + const xmlChar *qName; + + qName = xmljGetStringChars (env, qualifiedName); + href = xmljGetStringChars (env, namespaceURI); + if (qName == NULL) + { + prefix = NULL; + } + else + { + int *len; + + len = (int *) malloc (sizeof (int)); + prefix = xmlSplitQName3 (qName, len); + free (len); + } + + /* Create the document node */ + doc = xmlNewDoc (BAD_CAST "1.0"); + + /* doctype */ + if (doctype != NULL) + { + jclass cls; + jmethodID method; + jstring ret; + const xmlChar *name; + const xmlChar *publicId; + const xmlChar *systemId; + const xmlChar *internalSubset; + xmlDtdPtr dtd; + + cls = (*env)->FindClass (env, "org/w3c/dom/DocumentType"); + if (cls == NULL) + { + return NULL; + } + /* name */ + method = (*env)->GetMethodID (env, cls, "getName", + "()Ljava/lang/String;"); + if (method == NULL) + { + return NULL; + } + ret = (jstring) (*env)->CallObjectMethod (env, doctype, method); + name = xmljGetStringChars (env, ret); + + /* publicId */ + method = (*env)->GetMethodID (env, cls, "getPublicId", + "()Ljava/lang/String;"); + if (method == NULL) + { + return NULL; + } + ret = (jstring) (*env)->CallObjectMethod (env, doctype, method); + publicId = xmljGetStringChars (env, ret); + + /* systemId */ + method = (*env)->GetMethodID (env, cls, "getSystemId", + "()Ljava/lang/String;"); + if (method == NULL) + { + return NULL; + } + ret = (jstring) (*env)->CallObjectMethod (env, doctype, method); + systemId = xmljGetStringChars (env, ret); + + /* internalSubset */ + method = (*env)->GetMethodID (env, cls, "getInternalSubset", + "()Ljava/lang/String;"); + if (method == NULL) + { + return NULL; + } + ret = (jstring) (*env)->CallObjectMethod (env, doctype, method); + internalSubset = xmljGetStringChars (env, ret); + + /* TODO notations */ + /* TODO entities */ + if (internalSubset == NULL) + { + dtd = xmlNewDtd (doc, name, publicId, systemId); + } + else + { + dtd = xmlCreateIntSubset (doc, name, publicId, systemId); + /* TODO parse internal subset? */ + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return NULL; + } + } + + /* Create the root element */ + root = xmlNewNode (NULL, qName); + xmlDocSetRootElement (doc, root); + ns = xmlNewNs (root, href, prefix); + xmlSetNs (root, ns); + + return xmljCreateDocument (env, self, doc); +} + +/* -- GnomeDocumentType -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocumentType_getPublicId (JNIEnv * env, + jobject self) +{ + xmlDtdPtr dtd; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + return xmljNewString (env, dtd->ExternalID); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocumentType_getSystemId (JNIEnv * env, + jobject self) +{ + xmlDtdPtr dtd; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + return xmljNewString (env, dtd->SystemID); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeDocumentType_getInternalSubset (JNIEnv * env, + jobject self + __attribute__ ((__unused__))) +{ + /* TODO */ + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return NULL; +} + +/* -- GnomeElement -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_getAttribute (JNIEnv * env, + jobject self, + jstring name) +{ + xmlNodePtr node; + const xmlChar *s_name; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_name = xmljGetStringChars (env, name); + s_value = xmlGetProp (node, s_name); + xmlFree ((xmlChar *) s_name); + return (s_value == NULL) ? + xmljNewString (env, BAD_CAST "") : + xmljNewString (env, s_value); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_setAttribute (JNIEnv * env, + jobject self, + jstring name, + jstring value) +{ + xmlNodePtr node; + const xmlChar *s_name; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_name = xmljGetStringChars (env, name); + if (xmlValidateName (s_name, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + return; + } + s_value = xmljGetStringChars (env, value); + xmlSetProp (node, s_name, s_value); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_getAttributeNode (JNIEnv * env, + jobject self, + jstring name) +{ + xmlNodePtr node; + const xmlChar *s_name; + xmlAttrPtr attr; + + node = xmljGetNodeID (env, self); + s_name = xmljGetStringChars (env, name); + attr = xmlHasProp (node, s_name); + if (attr == NULL) + { + return NULL; + } + xmlFree ((xmlChar *) s_name); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_setAttributeNode (JNIEnv * env, + jobject self, + jobject newAttr) +{ + xmlNodePtr node; + xmlAttrPtr new_attr; + xmlAttrPtr old_attr; + + node = xmljGetNodeID (env, self); + new_attr = (xmlAttrPtr) xmljGetNodeID (env, newAttr); + if (new_attr->parent != NULL) + { + xmljThrowDOMException (env, 10, NULL); /* INUSE_ATTRIBUTE_ERR */ + return NULL; + } + if (new_attr->doc != node->doc) + { + xmljThrowDOMException (env, 4, NULL); /* WRONG_DOCUMENT_ERR */ + return NULL; + } + old_attr = xmlHasProp (node, new_attr->name); + if (old_attr) + { + xmlUnlinkNode ((xmlNodePtr) old_attr); + } + xmljAddAttribute (node, new_attr); + return xmljGetNodeInstance (env, (xmlNodePtr) old_attr); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_removeAttributeNode (JNIEnv * env, + jobject self + __attribute__ ((__unused__)), + jobject oldAttr) +{ + xmlNodePtr attr; + + attr = xmljGetNodeID (env, oldAttr); + xmlUnlinkNode (attr); + return oldAttr; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_getAttributeNS (JNIEnv * env, + jobject self, + jstring uri, + jstring localName) +{ + xmlNodePtr node; + const xmlChar *s_uri; + const xmlChar *s_localName; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_localName = xmljGetStringChars (env, localName); + if (uri == NULL) + { + s_value = xmlGetNoNsProp (node, s_localName); + } + else + { + s_uri = xmljGetStringChars (env, uri); + s_value = xmlGetNsProp (node, s_localName, s_uri); + xmlFree ((xmlChar *) s_uri); + } + xmlFree ((xmlChar *) s_localName); + return (s_value == NULL) ? + xmljNewString (env, BAD_CAST "") : + xmljNewString (env, s_value); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_setAttributeNS (JNIEnv * env, + jobject self, + jstring uri, + jstring qName, + jstring value) +{ + xmlNodePtr node; + xmlNsPtr ns; + const xmlChar *s_uri; + const xmlChar *s_qName; + const xmlChar *s_prefix; + const xmlChar *s_localName; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_qName = xmljGetStringChars (env, qName); + if (xmlValidateQName (s_qName, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + return; + } + s_value = xmljGetStringChars (env, value); + if (uri == NULL) + { + xmlSetProp (node, s_qName, s_value); + } + else + { + s_prefix = xmljGetPrefix (s_qName); + s_localName = xmljGetLocalName (s_qName); + s_uri = xmljGetStringChars (env, uri); + ns = xmlNewNs (node, s_uri, s_prefix); + xmlSetNsProp (node, ns, s_localName, s_value); + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_getAttributeNodeNS (JNIEnv * env, + jobject self, + jstring uri, + jstring localName) +{ + xmlNodePtr node; + xmlAttrPtr attr; + const xmlChar *s_uri; + const xmlChar *s_localName; + + node = xmljGetNodeID (env, self); + attr = node->properties; + s_uri = xmljGetStringChars (env, uri); + s_localName = xmljGetStringChars (env, localName); + while (attr != NULL) + { + if (uri == NULL) + { + if (xmljMatch (s_localName, (xmlNodePtr) attr)) + break; + } + else + { + if (xmljMatchNS (s_uri, s_localName, (xmlNodePtr) attr)) + break; + } + attr = attr->next; + } + xmlFree ((xmlChar *) s_uri); + xmlFree ((xmlChar *) s_localName); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_setAttributeNodeNS (JNIEnv * env, + jobject self, + jobject newAttr) +{ + xmlNodePtr node; + xmlAttrPtr new_attr; + xmlAttrPtr old_attr; + const xmlChar *uri; + + node = xmljGetNodeID (env, self); + new_attr = (xmlAttrPtr) xmljGetNodeID (env, newAttr); + if (new_attr->parent != NULL) + { + xmljThrowDOMException (env, 10, NULL); /* INUSE_ATTRIBUTE_ERR */ + return NULL; + } + if (new_attr->doc != node->doc) + { + xmljThrowDOMException (env, 4, NULL); /* WRONG_DOCUMENT_ERR */ + return NULL; + } + uri = (new_attr->ns != NULL) ? new_attr->ns->href : NULL; + old_attr = xmlHasNsProp (node, new_attr->name, uri); + if (old_attr) + { + xmlUnlinkNode ((xmlNodePtr) old_attr); + } + xmljAddAttribute (node, new_attr); + return xmljGetNodeInstance (env, (xmlNodePtr) old_attr); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_hasAttribute (JNIEnv * env, + jobject self, + jstring name) +{ + xmlNodePtr node; + const xmlChar *s_name; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_name = xmljGetStringChars (env, name); + s_value = xmlGetProp (node, s_name); + xmlFree ((xmlChar *) s_name); + return (s_value != NULL); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeElement_hasAttributeNS (JNIEnv * env, + jobject self, + jstring uri, + jstring localName) +{ + xmlNodePtr node; + const xmlChar *s_uri; + const xmlChar *s_localName; + const xmlChar *s_value; + + node = xmljGetNodeID (env, self); + s_localName = xmljGetStringChars (env, localName); + if (uri == NULL) + { + s_value = xmlGetNoNsProp (node, s_localName); + } + else + { + s_uri = xmljGetStringChars (env, uri); + s_value = xmlGetNsProp (node, s_localName, s_uri); + xmlFree ((xmlChar *) s_uri); + } + xmlFree ((xmlChar *) s_localName); + return (s_value != NULL); +} + +/* -- GnomeEntity -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeEntity_getPublicId (JNIEnv * env, jobject self) +{ + xmlEntityPtr entity; + + entity = (xmlEntityPtr) xmljGetNodeID (env, self); + return xmljNewString (env, entity->ExternalID); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeEntity_getSystemId (JNIEnv * env, jobject self) +{ + xmlEntityPtr entity; + + entity = (xmlEntityPtr) xmljGetNodeID (env, self); + return xmljNewString (env, entity->SystemID); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeEntity_getNotationName (JNIEnv * env, + jobject self + __attribute__ ((__unused__))) +{ + /* TODO */ + xmljThrowDOMException (env, 9, NULL); /* NOT_SUPPORTED_ERR */ + return NULL; +} + +/* -- GnomeNamedNodeMap -- */ + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_getNamedItem (JNIEnv * env, + jobject self, + jstring name) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlAttrPtr attr; + + attr = xmljGetNamedItem (env, self, name); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); + } + else + { + xmlDtdPtr dtd; + xmlHashTablePtr hash; + const xmlChar *s_name; + xmlNodePtr ret; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + hash = (xmlHashTablePtr) ((type == 1) ? dtd->entities : dtd->notations); + if (hash == NULL) + { + return NULL; + } + s_name = xmljGetStringChars (env, name); + ret = (xmlNodePtr) xmlHashLookup (hash, s_name); + xmlFree ((xmlChar *) s_name); + return xmljGetNodeInstance (env, ret); + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_setNamedItem (JNIEnv * env, + jobject self, + jobject arg) +{ + jclass cls; + jfieldID field; + jint type; + xmlNodePtr node; + xmlNodePtr argNode; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + node = xmljGetNodeID (env, self); + argNode = xmljGetNodeID (env, arg); + + if (argNode->doc != node->doc) + { + xmljThrowDOMException (env, 4, NULL); /* WRONG_DOCUMENT_ERR */ + } + xmljValidateChildNode (env, node, argNode); + if ((*env)->ExceptionOccurred (env)) + { + return NULL; + } + if (type == 0) + { + if (argNode->parent != NULL) + { + xmljThrowDOMException (env, 10, NULL); /* INUSE_ATTRIBUTE_ERR */ + return NULL; + } + xmlAddChild (node, argNode); + } + else + { + xmlDtdPtr dtd; + xmlHashTablePtr hash; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + hash = (xmlHashTablePtr) ((type == 1) ? dtd->entities : dtd->notations); + if (hash == NULL) + { + hash = xmlHashCreate (10); + if (type == 1) + { + dtd->entities = hash; + } + else + { + dtd->notations = hash; + } + } + xmlHashAddEntry (hash, argNode->name, argNode); + } + return arg; +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_removeNamedItem (JNIEnv * env, + jobject self, + jstring name) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlAttrPtr attr; + + attr = xmljGetNamedItem (env, self, name); + if (attr == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + xmlUnlinkNode ((xmlNodePtr) attr); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); + } + else + { + xmlDtdPtr dtd; + xmlHashTablePtr hash; + const xmlChar *s_name; + xmlNodePtr ret; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + hash = (xmlHashTablePtr) ((type == 1) ? dtd->entities : dtd->notations); + if (hash == NULL) + { + return NULL; + } + s_name = xmljGetStringChars (env, name); + ret = (xmlNodePtr) xmlHashLookup (hash, s_name); + if (ret != NULL) + { + xmlHashRemoveEntry (hash, s_name, NULL); + } + xmlFree ((xmlChar *) s_name); + return xmljGetNodeInstance (env, ret); + } +} + +void +xmljHashScanner (void *payload, void *vdata, xmlChar *name) +{ + xmljHashScanData *data; + + data = (xmljHashScanData *) vdata; + if (data->count <= data->index) + { + data->node = (xmlNodePtr) payload; + } + data->count++; +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_item (JNIEnv * env, + jobject self, jint index) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlNodePtr node; + xmlAttrPtr attr; + jint count; + + node = xmljGetNodeID (env, self); + switch (node->type) + { + case XML_ELEMENT_NODE: + attr = node->properties; + for (count = 0; attr != NULL && count < index; count++) + { + attr = attr->next; + } + if (attr == NULL) + { + char msg[1024]; + sprintf (msg, "No attribute at index %d\n", (int) index); + xmljThrowException (env, "java/lang/NullPointerException", msg); + return NULL; + } + return xmljGetNodeInstance (env, (xmlNodePtr) attr); + default: + return NULL; + } + } + else + { + xmlDtdPtr dtd; + xmlHashTablePtr hash; + xmljHashScanData *data; + xmlNodePtr ret; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + hash = (xmlHashTablePtr) ((type == 1) ? dtd->entities : dtd->notations); + if (hash == NULL) + { + return NULL; + } + data = (xmljHashScanData *) malloc (sizeof (xmljHashScanData)); + if (data == NULL) + { + return NULL; + } + data->index = index; + data->count = 0; + data->node = NULL; + xmlHashScan (hash, xmljHashScanner, data); + ret = data->node; + free (data); + return xmljGetNodeInstance (env, ret); + } +} + +JNIEXPORT jint JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_getLength (JNIEnv * env, + jobject self) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlNodePtr node; + xmlAttrPtr attr; + jint count; + + node = xmljGetNodeID (env, self); + switch (node->type) + { + case XML_ELEMENT_NODE: + count = 0; + attr = node->properties; + while (attr != NULL) + { + count++; + attr = attr->next; + } + return count; + default: + return -1; + } + } + else + { + xmlDtdPtr dtd; + xmlHashTablePtr hash; + xmljHashScanData *data; + jint ret; + + dtd = (xmlDtdPtr) xmljGetNodeID (env, self); + hash = (xmlHashTablePtr) ((type == 1) ? dtd->entities : dtd->notations); + if (hash == NULL) + { + return 0; + } + data = (xmljHashScanData *) malloc (sizeof (xmljHashScanData)); + if (data == NULL) + { + return 0; + } + data->index = -1; + data->count = 0; + data->node = NULL; + xmlHashScan (hash, xmljHashScanner, data); + ret = data->count; + free (data); + return ret; + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_getNamedItemNS (JNIEnv * env, + jobject self, + jstring uri, + jstring localName) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlAttrPtr attr; + + attr = xmljGetNamedItemNS (env, self, uri, localName); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); + } + else + { + return NULL; + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_setNamedItemNS (JNIEnv * env, + jobject self, + jobject arg) +{ + return Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_setNamedItem (env, self, + arg); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNamedNodeMap_removeNamedItemNS (JNIEnv * env, + jobject self, + jstring uri, + jstring + localName) +{ + jclass cls; + jfieldID field; + jint type; + + cls = (*env)->GetObjectClass (env, self); + field = (*env)->GetFieldID (env, cls, "type", "I"); + type = (*env)->GetIntField (env, self, field); + + if (type == 0) + { + xmlAttrPtr attr; + + attr = xmljGetNamedItemNS (env, self, uri, localName); + if (attr == NULL) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + else + { + xmlUnlinkNode ((xmlNodePtr) attr); + return xmljGetNodeInstance (env, (xmlNodePtr) attr); + } + } + else + { + return NULL; + } +} + +/* -- GnomeNode -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getNodeName (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + if (node == NULL) + { + return NULL; + } + return xmljNewString (env, node->name); +} + +xmlChar * +xmljGetNodeValue (xmlNodePtr node) +{ + /* If not character data, return null */ + switch (node->type) + { + case XML_TEXT_NODE: + case XML_CDATA_SECTION_NODE: + case XML_COMMENT_NODE: + case XML_ATTRIBUTE_NODE: + return xmlNodeGetContent (node); + default: + return NULL; + } +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getNodeValue (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + xmlChar *text; + jstring ret; + + node = xmljGetNodeID (env, self); + text = xmljGetNodeValue (node); + ret = xmljNewString (env, (const xmlChar *) text); + if (text != NULL) + { + xmlFree (text); + } + return ret; +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_setNodeValue (JNIEnv * env, + jobject self, + jstring nodeValue) +{ + xmlNodePtr node; + const xmlChar *s_nodeValue; + + node = xmljGetNodeID (env, self); + + /* If not character data, return */ + if (node->type != XML_TEXT_NODE && + node->type != XML_CDATA_SECTION_NODE && node->type != XML_COMMENT_NODE) + return; + + s_nodeValue = xmljGetStringChars (env, nodeValue); + xmlNodeSetContent (node, s_nodeValue); +} + +JNIEXPORT jshort JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getNodeType (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + switch (node->type) + { + case XML_DTD_NODE: + return XML_DOCUMENT_TYPE_NODE; + case XML_ATTRIBUTE_DECL: + return XML_ATTRIBUTE_NODE; + case XML_ENTITY_DECL: + return XML_ENTITY_NODE; + default: + return node->type; + } +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getParentNode (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, node->parent); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getFirstChild (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, node->children); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getLastChild (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, node->last); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getPreviousSibling (JNIEnv * env, + jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, node->prev); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getNextSibling (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, node->next); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getOwnerDocument (JNIEnv * env, + jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return xmljGetNodeInstance (env, (xmlNodePtr) node->doc); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljInsertBefore (JNIEnv * env, + jobject self, + jobject newChild, + jobject refChild) +{ + xmlNodePtr node; + xmlNodePtr newChildNode; + xmlNodePtr refChildNode; + + node = xmljGetNodeID (env, self); + newChildNode = xmljGetNodeID (env, newChild); + refChildNode = xmljGetNodeID (env, refChild); + + /* Is refChildNode a child of this node? */ + if (refChildNode == NULL || + refChildNode->parent == NULL || + refChildNode->parent != node) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + /* Check new child */ + xmljValidateChildNode (env, node, newChildNode); + if ((*env)->ExceptionOccurred (env)) + { + return NULL; + } + + newChildNode = xmlAddPrevSibling (refChildNode, newChildNode); + return xmljGetNodeInstance (env, newChildNode); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljReplaceChild (JNIEnv * env, + jobject self, + jobject newChild, + jobject oldChild) +{ + xmlNodePtr node; + xmlNodePtr newChildNode; + xmlNodePtr oldChildNode; + + node = xmljGetNodeID (env, self); + newChildNode = xmljGetNodeID (env, newChild); + oldChildNode = xmljGetNodeID (env, oldChild); + + /* Is oldChildNode a child of this node? */ + if (oldChildNode == NULL || + oldChildNode->parent == NULL || + oldChildNode->parent != node) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + /* Check new child */ + xmljValidateChildNode (env, node, newChildNode); + if ((*env)->ExceptionOccurred (env)) + { + return NULL; + } + + newChildNode = xmlReplaceNode (oldChildNode, newChildNode); + return xmljGetNodeInstance (env, newChildNode); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljRemoveChild (JNIEnv * env, + jobject self, + jobject oldChild) +{ + xmlNodePtr node; + xmlNodePtr oldChildNode; + + node = xmljGetNodeID (env, self); + oldChildNode = xmljGetNodeID (env, oldChild); + + if (oldChildNode == NULL || + oldChildNode->parent == NULL || + oldChildNode->parent != node) + { + xmljThrowDOMException (env, 8, NULL); /* NOT_FOUND_ERR */ + return NULL; + } + xmlUnlinkNode (oldChildNode); + return oldChild; +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljAppendChild (JNIEnv * env, + jobject self, + jobject newChild) +{ + xmlNodePtr node; + xmlNodePtr newChildNode; + + node = xmljGetNodeID (env, self); + newChildNode = xmljGetNodeID (env, newChild); + + /* Check new child */ + xmljValidateChildNode (env, node, newChildNode); + if ((*env)->ExceptionOccurred (env)) + { + return NULL; + } + + newChildNode = xmlAddChild (node, newChildNode); + return xmljGetNodeInstance (env, newChildNode); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_hasChildNodes (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return (node->children != NULL); +} + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljCloneNode (JNIEnv * env, + jobject self, jboolean deep) +{ + xmlNodePtr node; + xmlNodePtr clone; + + node = xmljGetNodeID (env, self); + clone = xmlCopyNode (node, deep); + clone->parent = NULL; + clone->doc = node->doc; + return xmljGetNodeInstance (env, clone); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_normalize (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + xmljNormalizeNode (node); +} + +void +xmljNormalizeNode (xmlNodePtr node) +{ + xmlNodePtr cur; + xmlNodePtr last = NULL; + + cur = node->children; + while (cur != NULL) + { + switch (cur->type) + { + case XML_CDATA_SECTION_NODE: + case XML_TEXT_NODE: + if (xmlIsBlankNode (cur)) + { + xmlNodePtr next = cur->next; + xmlUnlinkNode (cur); + xmlFreeNode (cur); + cur = next; + continue; + } + if (last != NULL) + { + last = xmlTextMerge (last, cur); + xmlUnlinkNode (cur); + xmlFreeNode (cur); + cur = last; + } + else + { + last = cur; + } + break; + default: + last = NULL; + xmljNormalizeNode (cur); + } + cur = cur->next; + } +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getNamespaceURI (JNIEnv * env, + jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + if (node->type != XML_ELEMENT_NODE && + node->type != XML_ATTRIBUTE_NODE) + { + return NULL; + } + if (node->ns == NULL) + { + return NULL; + } + return xmljNewString (env, node->ns->href); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getPrefix (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + if (node->type != XML_ELEMENT_NODE && + node->type != XML_ATTRIBUTE_NODE) + { + return NULL; + } + if (node->ns == NULL) + { + return NULL; + } + return xmljNewString (env, node->ns->prefix); +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_setPrefix (JNIEnv * env, + jobject self, jstring prefix) +{ + xmlNodePtr node; + const xmlChar *s_prefix; + + s_prefix = xmljGetStringChars (env, prefix); + if (xmlValidateName (s_prefix, 0)) + { + xmljThrowDOMException (env, 5, NULL); /* INVALID_CHARACTER_ERR */ + } + node = xmljGetNodeID (env, self); + if (node->type != XML_ELEMENT_NODE && + node->type != XML_ATTRIBUTE_NODE) + { + xmljThrowDOMException (env, 3, NULL); /* HIERARCHY_REQUEST_ERR */ + return; + } + if (node->ns == NULL) + { + xmljThrowDOMException (env, 14, NULL); /* NAMESPACE_ERR */ + return; + } + node->ns->prefix = s_prefix; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getLocalName (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + int *len; + jstring ret; + + node = xmljGetNodeID (env, self); + if (node->name == NULL) + { + return NULL; + } + len = (int *) malloc (sizeof (int)); + if (xmlSplitQName3 (node->name, len) != NULL) + { + ret = xmljNewString (env, node->name + (*len)); + } + else + { + ret = xmljNewString (env, node->name); + } + free (len); + return ret; +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_hasAttributes (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + + node = xmljGetNodeID (env, self); + return (node->properties != NULL); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_getBaseURI (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + xmlChar *baseURI; + jstring ret; + + node = xmljGetNodeID (env, self); + baseURI = xmlNodeGetBase (node->doc, node); + ret = xmljNewString (env, (const xmlChar *) baseURI); + if (baseURI != NULL) + { + xmlFree (baseURI); + } + return ret; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_lookupPrefix (JNIEnv * env, jobject self, + jstring namespaceURI) +{ + xmlNodePtr node; + xmlNsPtr ns; + xmlDocPtr doc; + const xmlChar *s_uri; + + node = xmljGetNodeID (env, self); + doc = node->doc; + /* If this is a document node, search from the root element */ + if (node->type == XML_DOCUMENT_NODE) + { + doc = (xmlDocPtr) node; + node = xmlDocGetRootElement (doc); + } + s_uri = xmljGetStringChars (env, namespaceURI); + ns = xmlSearchNsByHref (doc, node, s_uri); + xmlFree ((xmlChar *) s_uri); + if (ns == NULL) + { + return NULL; + } + return xmljNewString (env, ns->prefix); +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_isDefaultNamespace (JNIEnv * env, + jobject self, + jstring namespaceURI) +{ + xmlNodePtr node; + xmlNsPtr ns; + const xmlChar *s_uri; + + node = xmljGetNodeID (env, self); + s_uri = xmljGetStringChars (env, namespaceURI); + ns = xmlSearchNsByHref (node->doc, node, s_uri); + xmlFree ((xmlChar *) s_uri); + if (ns == NULL) + { + return 0; + } + return (ns->prefix == NULL || xmlStrlen (ns->prefix) == 0); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_lookupNamespaceURI (JNIEnv * env, + jobject self, + jstring prefix) +{ + xmlNodePtr node; + xmlDocPtr doc; + xmlNsPtr ns; + const xmlChar *s_prefix; + + node = xmljGetNodeID (env, self); + doc = node->doc; + /* If this is a document node, search from the root element */ + if (node->type == XML_DOCUMENT_NODE) + { + doc = (xmlDocPtr) node; + node = xmlDocGetRootElement (doc); + } + s_prefix = xmljGetStringChars (env, prefix); + ns = xmlSearchNs (doc, node, s_prefix); + xmlFree ((xmlChar *) s_prefix); + if (ns == NULL) + { + return NULL; + } + return xmljNewString (env, ns->href); +} + +JNIEXPORT jint JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_xmljCompareTo (JNIEnv * env, + jobject self, + jobject other) +{ + xmlNodePtr n1, n2, x; + int d1, d2, delta, c; + + n1 = xmljGetNodeID (env, self); + n2 = xmljGetNodeID (env, other); + if (n1->doc != n2->doc) + { + return 0; + } + if (n1->type == XML_ATTRIBUTE_NODE || n2->type == XML_ATTRIBUTE_NODE) + { + return 0; + } + d1 = 0; + for (x = n1->parent; x && x->type != XML_DOCUMENT_NODE; x = x->parent) + { + d1++; + } + d2 = 0; + for (x = n2->parent; x && x->type != XML_DOCUMENT_NODE; x = x->parent) + { + d2++; + } + delta = d1 - d2; + while (d1 > d2) + { + n1 = n1->parent; + d1--; + } + while (d2 > d1) + { + n2 = n2->parent; + d2--; + } + c = xmljCompare (n1, n2); + return (c != 0) ? c : delta; +} + +/* Compare at same level */ +int +xmljCompare (xmlNodePtr n1, xmlNodePtr n2) +{ + int c, i1, i2; + + if (n1->parent == NULL || n1->type == XML_DOCUMENT_NODE || + n2->parent == NULL || n2->type == XML_DOCUMENT_NODE || + n1 == n2) + { + return 0; + } + c = xmljCompare (n1->parent, n2->parent); + if (c != 0) + { + return c; + } + i1 = 0; + for (n1 = n1->prev; n1; n1 = n1->prev) + { + i1++; + } + i2 = 0; + for (n2 = n2->prev; n2; n2 = n2->prev) + { + i2++; + } + return i1 - i2; +} + +int +xmljIsEqualNodeList (xmlNodePtr node1, xmlNodePtr node2) +{ + while (node1 != NULL) + { + if (!xmljIsEqualNode (node1, node2)) + { + return 0; + } + node1 = node1->next; + node2 = node2->next; + } + return 1; +} + +int +xmljIsEqualNode (xmlNodePtr node1, xmlNodePtr node2) +{ + const xmlChar *val1; + const xmlChar *val2; + + if (node1 == node2) + { + return 1; + } + if (node1 == NULL || node2 == NULL) + { + return 0; + } + /* Check node type */ + if (node1->type != node2->type) + { + return 0; + } + /* Check node name */ + if (!xmlStrEqual (node1->name, node2->name)) + { + return 0; + } + /* Check node namespace */ + if (node1->type == XML_ELEMENT_NODE || + node1->type == XML_ATTRIBUTE_NODE) + { + xmlNsPtr ns1, ns2; + + ns1 = node1->ns; + if (ns1 != NULL) + { + ns2 = node2->ns; + if (ns2 == NULL) + { + return 0; + } + val1 = ns1->href; + val2 = ns2->href; + if (!xmlStrEqual (val1, val2)) + { + return 0; + } + } + } + /* Check node value */ + val1 = xmljGetNodeValue (node1); + val2 = xmljGetNodeValue (node2); + if (!xmlStrEqual (val1, val2)) + { + return 0; + } + /* Check attributes */ + if (node1->type == XML_ELEMENT_NODE && + !xmljIsEqualNodeList ((xmlNodePtr) node1->properties, + (xmlNodePtr) node2->properties)) + { + return 0; + } + /* Check doctype */ + if (node1->type == XML_DOCUMENT_NODE) + { + xmlDocPtr doc1 = (xmlDocPtr) node1; + xmlDocPtr doc2 = (xmlDocPtr) node2; + + if (!xmljIsEqualNode ((xmlNodePtr) doc1->intSubset, + (xmlNodePtr) doc2->intSubset) || + !xmljIsEqualNode ((xmlNodePtr) doc1->extSubset, + (xmlNodePtr) doc2->extSubset)) + { + return 0; + } + } + /* Check child nodes */ + if (!xmljIsEqualNodeList (node1->children, node2->children)) + { + return 0; + } + return 1; +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNode_isEqualNode (JNIEnv * env, + jobject self, + jobject arg) +{ + xmlNodePtr node1; + xmlNodePtr node2; + + node1 = xmljGetNodeID (env, self); + node2 = xmljGetNodeID (env, arg); + return xmljIsEqualNode (node1, node2); +} + +/* -- GnomeNodeList -- */ + +JNIEXPORT jobject JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNodeList_item (JNIEnv * env, + jobject self, jint index) +{ + xmlNodePtr node; + jint count; + + node = xmljGetNodeID (env, self); + node = node->children; + count = 0; + for (count = 0; node != NULL && count < index; count++) + { + node = node->next; + } + return xmljGetNodeInstance (env, node); +} + +JNIEXPORT jint JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNodeList_getLength (JNIEnv * env, jobject self) +{ + xmlNodePtr node; + jint count; + + node = xmljGetNodeID (env, self); + count = 0; + node = node->children; + while (node != NULL) + { + count++; + node = node->next; + } + return count; +} + +/* -- GnomeNotation -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNotation_getPublicId (JNIEnv * env, + jobject self) +{ + xmlNotationPtr notation; + + notation = (xmlNotationPtr) xmljGetNodeID (env, self); + if (notation->PublicID == NULL) + { + return NULL; + } + return xmljNewString (env, notation->PublicID); +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeNotation_getSystemId (JNIEnv * env, + jobject self) +{ + xmlNotationPtr notation; + + notation = (xmlNotationPtr) xmljGetNodeID (env, self); + if (notation->SystemID == NULL) + { + return NULL; + } + return xmljNewString (env, notation->SystemID); +} + +/* -- GnomeProcessingInstruction -- */ + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeProcessingInstruction_getData (JNIEnv * env, + jobject self) +{ + xmlNodePtr node; + xmlChar *text; + jstring ret; + + node = xmljGetNodeID (env, self); + text = xmlNodeGetContent (node); + ret = xmljNewString (env, (const xmlChar *) text); + if (text != NULL) + { + xmlFree (text); + } + return ret; +} + +JNIEXPORT void JNICALL +Java_gnu_xml_libxmlj_dom_GnomeProcessingInstruction_setData (JNIEnv * env, + jobject self, + jstring data) +{ + xmlNodePtr node; + const xmlChar *s_data; + + node = xmljGetNodeID (env, self); + s_data = xmljGetStringChars (env, data); + xmlNodeSetContent (node, s_data); +} + +/* -- GnomeTypeInfo -- */ + +xmlDtdPtr xmljGetDtd (xmlDocPtr doc) +{ + xmlNodePtr ctx; + + for (ctx = doc->children; ctx; ctx = ctx->next) + { + if (ctx->type == XML_DOCUMENT_TYPE_NODE) + { + return (xmlDtdPtr) ctx; + } + } + return NULL; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeTypeInfo_getTypeName (JNIEnv *env, jobject self) +{ + xmlNodePtr node; + xmlDtdPtr dtd; + xmlAttributePtr attribute; + + node = xmljGetNodeID (env, self); + dtd = xmljGetDtd (node->doc); + if (dtd) + { + switch (node->type) + { + case XML_ATTRIBUTE_NODE: + attribute = xmlGetDtdAttrDesc (dtd, node->parent->name, node->name); + if (attribute) + { + switch (attribute->type) + { + case XML_ATTRIBUTE_CDATA: + return xmljNewString (env, BAD_CAST "CDATA"); + case XML_ATTRIBUTE_ID: + return xmljNewString (env, BAD_CAST "ID"); + case XML_ATTRIBUTE_IDREF: + return xmljNewString (env, BAD_CAST "IDREF"); + case XML_ATTRIBUTE_IDREFS: + return xmljNewString (env, BAD_CAST "IDREFS"); + case XML_ATTRIBUTE_ENTITY: + return xmljNewString (env, BAD_CAST "ENTITY"); + case XML_ATTRIBUTE_ENTITIES: + return xmljNewString (env, BAD_CAST "ENTITIES"); + case XML_ATTRIBUTE_NMTOKEN: + return xmljNewString (env, BAD_CAST "NMTOKEN"); + case XML_ATTRIBUTE_NMTOKENS: + return xmljNewString (env, BAD_CAST "NMTOKENS"); + default: + return NULL; + } + } + return NULL; + default: + return NULL; + } + } + /* TODO when XML Schema support is available */ + return NULL; +} + +JNIEXPORT jstring JNICALL +Java_gnu_xml_libxmlj_dom_GnomeTypeInfo_getTypeNamespace (JNIEnv *env, + jobject self) +{ + xmlNodePtr node; + xmlDtdPtr dtd; + xmlAttributePtr attribute; + + node = xmljGetNodeID (env, self); + dtd = xmljGetDtd (node->doc); + if (dtd) + { + switch (node->type) + { + case XML_ATTRIBUTE_NODE: + attribute = xmlGetDtdAttrDesc (dtd, node->parent->name, node->name); + if (attribute) + { + return xmljNewString (env, + BAD_CAST "http://www.w3.org/TR/REC-xml"); + } + return NULL; + default: + return NULL; + } + } + /* TODO when XML Schema support is available */ + return NULL; +} + +JNIEXPORT jboolean JNICALL +Java_gnu_xml_libxmlj_dom_GnomeTypeInfo_isDerivedFrom (JNIEnv *env + __attribute__ ((__unused__)), + jobject self + __attribute__ ((__unused__)), + jstring typeNS + __attribute__ ((__unused__)), + jstring typeName + __attribute__ ((__unused__)), + jint method + __attribute__ ((__unused__))) +{ + /* TODO when XML Schema support is available */ + return 0; +} + +/* -- Utility -- */ + +/* + * Create GnomeDocument object from the given xmlDocPtr + */ +jobject +xmljCreateDocument (JNIEnv * env, jobject self, xmlDocPtr doc) +{ + jclass cls; + jfieldID field; + jobject ret; + + if (!doc) + { + return NULL; + } + + /* Get document object */ + ret = xmljGetNodeInstance (env, (xmlNodePtr) doc); + + /* Set DOM implementation field */ + cls = (*env)->FindClass (env, "gnu/xml/libxmlj/dom/GnomeDocument"); + field = (*env)->GetFieldID (env, cls, "dom", + "Lorg/w3c/dom/DOMImplementation;"); + (*env)->SetObjectField (env, ret, field, self); + return ret; +} + +xmlAttrPtr +xmljGetNamedItem (JNIEnv * env, jobject self, jstring name) +{ + xmlNodePtr node; + xmlAttrPtr attr; + const xmlChar *s_name; + + s_name = xmljGetStringChars (env, name); + + node = xmljGetNodeID (env, self); + attr = node->properties; + while (attr != NULL) + { + if (xmljMatch (s_name, (xmlNodePtr) attr)) + break; + attr = attr->next; + } + xmlFree ((xmlChar *) s_name); + + return attr; +} + +xmlAttrPtr +xmljGetNamedItemNS (JNIEnv * env, jobject self, jstring uri, jstring localName) +{ + xmlNodePtr node; + xmlAttrPtr attr; + const xmlChar *s_uri; + const xmlChar *s_localName; + + s_uri = xmljGetStringChars (env, uri); + s_localName = xmljGetStringChars (env, localName); + + node = xmljGetNodeID (env, self); + attr = node->properties; + while (attr != NULL) + { + if (xmljMatchNS (s_uri, s_localName, (xmlNodePtr) attr)) + break; + attr = attr->next; + } + xmlFree ((xmlChar *) s_uri); + xmlFree ((xmlChar *) s_localName); + + return attr; +} |
