xmlj_dom.c

gcc的组建

      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 -- */