xmlj_sax.c

gcc的组建

}

void
xmljSAXReference (void *vctx,
                  const xmlChar * name)
{
  xmlSAX2Reference (vctx, name);
}

void
xmljSAXCharacters (void *vctx,
                   const xmlChar * ch,
                   int len)
{
  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  JNIEnv *env;
  jobject target;
  jstring j_ch;
  xmlChar *dup;

  xmlSAX2Characters (vctx, ch, len);

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  env = sax->env;
  target = sax->obj;

  xmljCheckWellFormed (ctx);
  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }

  if (sax->characters == NULL)
    {
      sax->characters = xmljGetMethodID (env,
                                         target,
                                         "characters",
                                         "(Ljava/lang/String;)V");
      if (sax->characters == NULL)
        {
          return;
        }
    }

  dup = xmlStrndup (ch, len);
  j_ch = xmljNewString (env, dup);

  (*env)->CallVoidMethod (env,
                          target,
                          sax->characters,
                          j_ch);
  xmlFree (dup);
}

void
xmljSAXIgnorableWhitespace (void *vctx,
                            const xmlChar * ch,
                            int len)
{
  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  JNIEnv *env;
  jobject target;
  jstring j_ch;
  xmlChar *dup;

  xmlSAX2IgnorableWhitespace (vctx, ch, len);

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  env = sax->env;
  target = sax->obj;

  xmljCheckWellFormed (ctx);
  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }

  if (sax->ignorableWhitespace == NULL)
    {
      sax->ignorableWhitespace = xmljGetMethodID (env,
                                                  target,
                                                  "ignorableWhitespace",
                                                  "(Ljava/lang/String;)V");
      if (sax->ignorableWhitespace == NULL)
        {
          return;
        }
    }

  dup = xmlStrndup (ch, len);
  j_ch = xmljNewString (env, dup);

  (*env)->CallVoidMethod (env,
                          target,
                          sax->ignorableWhitespace,
                          j_ch);
  xmlFree (dup);
}

void
xmljSAXProcessingInstruction (void *vctx,
                              const xmlChar * targ,
                              const xmlChar * data)
{
  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  JNIEnv *env;
  jobject target;
  jstring j_targ;
  jstring j_data;

  xmlSAX2ProcessingInstruction (vctx, targ, data);

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  env = sax->env;
  target = sax->obj;

  xmljCheckWellFormed (ctx);
  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }

  if (sax->processingInstruction == NULL)
    {
      sax->processingInstruction =
        xmljGetMethodID (env,
                         target,
                         "processingInstruction",
                         "(Ljava/lang/String;Ljava/lang/String;)V");
      if (sax->processingInstruction == NULL)
        {
          return;
        }
    }

  j_targ = xmljNewString (env, targ);
  j_data = xmljNewString (env, data);

  (*env)->CallVoidMethod (env,
                          target,
                          sax->processingInstruction,
                          j_targ,
                          j_data);
}

void
xmljSAXComment (void *vctx,
                const xmlChar * value)
{
  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  JNIEnv *env;
  jobject target;
  jstring j_text;

  xmlSAX2Comment (vctx, value);

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  env = sax->env;
  target = sax->obj;

  xmljCheckWellFormed (ctx);
  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }

  if (sax->comment == NULL)
    {
      sax->comment =
        xmljGetMethodID (env,
                         target,
                         "comment",
                         "(Ljava/lang/String;)V");
      if (sax->comment == NULL)
        {
          return;
        }
    }

  j_text = xmljNewString (env, value);

  (*env)->CallVoidMethod (env,
                          target,
                          sax->comment,
                          j_text);
}

void
xmljSAXCDataBlock (void *vctx,
                   const xmlChar * ch,
                   int len)
{
  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  JNIEnv *env;
  jobject target;
  jstring j_ch;
  xmlChar *dup;

  xmlSAX2CDataBlock (vctx, ch, len);

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  env = sax->env;
  target = sax->obj;

  xmljCheckWellFormed (ctx);
  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }

  if (sax->cdataBlock == NULL)
    {
      sax->cdataBlock =
        xmljGetMethodID (env,
                         target,
                         "cdataBlock",
                         "(Ljava/lang/String;)V");
      if (sax->cdataBlock == NULL)
        {
          return;
        }
    }

  dup = xmlStrndup (ch, len);
  j_ch = xmljNewString (env, dup);

  (*env)->CallVoidMethod (env,
                          target,
                          sax->cdataBlock,
                          j_ch);
  xmlFree (dup);
}

void
xmljDispatchError (xmlParserCtxtPtr ctx,
                   xmlSAXLocatorPtr loc,
                   JNIEnv *env,
                   jobject target,
                   jmethodID method,
                   const char *msg,
                   va_list args)
{
  jint lineNumber;
  jint columnNumber;
  jstring publicId;
  jstring systemId;
  char buffer[2048] = "";

  if (msg != NULL)
    {
      vsnprintf (buffer, sizeof buffer, msg, args);
    }
  lineNumber = loc->getLineNumber (ctx);
  columnNumber = loc->getColumnNumber (ctx);
  publicId = xmljNewString (env, loc->getPublicId (ctx));
  systemId = xmljNewString (env, loc->getSystemId (ctx));
  (*env)->CallVoidMethod (env,
                          target,
                          method,
                          (*env)->NewStringUTF (env, buffer),
                          lineNumber,
                          columnNumber,
                          publicId,
                          systemId);
}

void
xmljSAXWarning (void *vctx,
                const char *msg,
                ...)
{
  va_list args;

  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  xmlSAXLocatorPtr loc;
  JNIEnv *env;
  jobject target;

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  loc = (xmlSAXLocatorPtr) sax->loc;
  env = sax->env;
  target = sax->obj;

  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }
  if (sax->warning == NULL)
    {
      sax->warning =
        xmljGetMethodID (env,
                         target,
                         "warning",
                         "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V");
      if (sax->warning == NULL)
        {
          return;
        }
    }

  va_start (args, msg);
  /* xmlParserWarning (vctx, msg, args); */
  xmljDispatchError (ctx, loc, env, target, sax->warning, msg, args);
  va_end (args);
}

void
xmljSAXError (void *vctx,
              const char *msg,
              ...)
{
  va_list args;

  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  xmlSAXLocatorPtr loc;
  JNIEnv *env;
  jobject target;

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  loc = (xmlSAXLocatorPtr) sax->loc;
  env = sax->env;
  target = sax->obj;

  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }
  if (sax->error == NULL)
    {
      sax->error =
        xmljGetMethodID (env,
                         target,
                         "error",
                         "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V");
      if (sax->error == NULL)
        {
          return;
        }
    }

  va_start (args, msg);
  /* xmlParserError (vctx, msg, args); */
  xmljDispatchError (ctx, loc, env, target, sax->error, msg, args);
  va_end (args);
}

void
xmljSAXFatalError (void *vctx,
                   const char *msg,
                   ...)
{
  va_list args;

  xmlParserCtxtPtr ctx;
  SAXParseContext *sax;
  xmlSAXLocatorPtr loc;
  JNIEnv *env;
  jobject target;

  ctx = (xmlParserCtxtPtr) vctx;
  sax = (SAXParseContext *) ctx->_private;
  loc = (xmlSAXLocatorPtr) sax->loc;
  env = sax->env;
  target = sax->obj;

  if ((*env)->ExceptionOccurred (env))
    {
      return;
    }
  if (sax->fatalError == NULL)
    {
      sax->fatalError =
        xmljGetMethodID (env,
                         target,
                         "fatalError",
                         "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;)V");
      if (sax->fatalError == NULL)
        {
          return;
        }
    }
  
  va_start (args, msg);
  /* xmlParserError (vctx, msg, args); */
  xmljDispatchError (ctx, loc, env, target, sax->fatalError, msg, args);
  va_end (args);
}

void
xmljCheckWellFormed (xmlParserCtxtPtr ctx)
{
  if (!ctx->wellFormed)
    {
      xmljSAXFatalError (ctx, "document is not well-formed");
    }
  if (ctx->validate && !ctx->valid)
    {
      xmljSAXFatalError (ctx, "document is not valid");
    }
}

/*
 * Convert a libxml2 attribute type to a string.
 */
jstring
xmljAttributeTypeName (JNIEnv * env, int type)
{
  const char *text;

  switch (type)
    {
    case XML_ATTRIBUTE_CDATA:
      text = "CDATA";
      break;
    case XML_ATTRIBUTE_ID:
      text = "ID";
      break;
    case XML_ATTRIBUTE_IDREF:
      text = "IDREF";
      break;
    case XML_ATTRIBUTE_IDREFS:
      text = "IDREFS";
      break;
    case XML_ATTRIBUTE_NMTOKEN:
      text = "NMTOKEN";
      break;
    case XML_ATTRIBUTE_NMTOKENS:
      text = "NMTOKENS";
      break;
    case XML_ATTRIBUTE_ENTITY:
      text = "ID";
      break;
    case XML_ATTRIBUTE_ENTITIES:
      text = "ID";
      break;
    default:
      return NULL;
    }

  return (*env)->NewStringUTF (env, text);
}

/*
 * Convert a libxml2 attribute default value type to a string.
 */
jstring
xmljAttributeModeName (JNIEnv * env, int type)
{
  const char *text;

  switch (type)
    {
    case XML_ATTRIBUTE_IMPLIED:
      text = "#IMPLIED";
      break;
    case XML_ATTRIBUTE_REQUIRED:
      text = "#REQUIRED";
      break;
    case XML_ATTRIBUTE_FIXED:
      text = "#FIXED";
      break;
    default:
      return NULL;
    }

  return (*env)->NewStringUTF (env, text);
}