libxml-ruby 4.1.2 → 6.0.0

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,116 +1,108 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-#include "ruby_xml_sax_parser.h"
-
-/*
- * Document-class: LibXML::XML::SaxParser
- *
- * XML::SaxParser provides a callback based API for parsing documents,
- * in contrast to XML::Parser's tree based API and XML::Reader's stream
- * based API.
- *
- * The XML::SaxParser API is fairly complex, not well standardized,
- * and does not directly support validation making entity, namespace and
- * base processing relatively hard.
- *
- * To use the XML::SaxParser, register a callback class via the
- * XML::SaxParser#callbacks=.  It is easiest to include the
- * XML::SaxParser::Callbacks module in your class and override
- * the methods as needed.
- *
- * Basic example:
- *
- *   class MyCallbacks
- *     include XML::SaxParser::Callbacks
- *     def on_start_element(element, attributes)
- *       puts #Element started: #{element}"
- *     end
- *   end
- *
- *   parser = XML::SaxParser.string(my_string)
- *   parser.callbacks = MyCallbacks.new
- *   parser.parse
- *
- * You can also parse strings (see XML::SaxParser.string) and
- * io objects (see XML::SaxParser.io).
- */
-
-VALUE cXMLSaxParser;
-static ID CALLBACKS_ATTR;
-static ID CONTEXT_ATTR;
-
-
-/* ======  Parser  =========== */
-
-/*
- * call-seq:
- *    parser.initialize(context) -> XML::Parser
- *
- * Creates a new XML::Parser from the specified 
- * XML::Parser::Context.
- */
-static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE context = Qnil;
-
-  rb_scan_args(argc, argv, "01", &context);
-
-  if (context == Qnil)
-  {
-    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::SaxParser.new");
-  }
-
-  rb_ivar_set(self, CONTEXT_ATTR, context);
-  return self;
-}
-
-/*
- * call-seq:
- *    parser.parse -> (true|false)
- *
- * Parse the input XML, generating callbacks to the object
- * registered via the +callbacks+ attributesibute.
- */
-static VALUE rxml_sax_parser_parse(VALUE self)
-{
-  int status;
-  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(context, xmlParserCtxt, ctxt);
-
-  ctxt->sax2 = 1;
-	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
-
-  if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
-    xmlFree(ctxt->sax);
-    
-  ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler));
-  if (ctxt->sax == NULL)
-    rb_fatal("Not enough memory.");
-  memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
-    
-  status = xmlParseDocument(ctxt);
-
-  /* Now check the parsing result*/
-  if (status == -1 || !ctxt->wellFormed)
-  {
-    rxml_raise(&ctxt->lastError);
-  }
-  return Qtrue;
-}
-
-void rxml_init_sax_parser(void)
-{
-  /* SaxParser */
-  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
-
-  /* Atributes */
-  CALLBACKS_ATTR = rb_intern("@callbacks");
-  CONTEXT_ATTR = rb_intern("@context");
-  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
-
-  /* Instance Methods */
-  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
-  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
-}
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+/*
+ * Document-class: LibXML::XML::SaxParser
+ *
+ * XML::SaxParser provides a callback based API for parsing documents,
+ * in contrast to XML::Parser's tree based API and XML::Reader's stream
+ * based API.
+ *
+ * The XML::SaxParser API is fairly complex, not well standardized,
+ * and does not directly support validation making entity, namespace and
+ * base processing relatively hard.
+ *
+ * To use the XML::SaxParser, register a callback class via the
+ * XML::SaxParser#callbacks=.  It is easiest to include the
+ * XML::SaxParser::Callbacks module in your class and override
+ * the methods as needed.
+ *
+ * Basic example:
+ *
+ *   class MyCallbacks
+ *     include XML::SaxParser::Callbacks
+ *     def on_start_element(element, attributes)
+ *       puts #Element started: #{element}"
+ *     end
+ *   end
+ *
+ *   parser = XML::SaxParser.string(my_string)
+ *   parser.callbacks = MyCallbacks.new
+ *   parser.parse
+ *
+ * You can also parse strings (see XML::SaxParser.string) and
+ * io objects (see XML::SaxParser.io).
+ */
+
+VALUE cXMLSaxParser;
+static ID CALLBACKS_ATTR;
+static ID CONTEXT_ATTR;
+
+
+/* ======  Parser  =========== */
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::SaxParser.new");
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> (true|false)
+ *
+ * Parse the input XML, generating callbacks to the object
+ * registered via the +callbacks+ attributesibute.
+ */
+static VALUE rxml_sax_parser_parse(VALUE self)
+{
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  xmlParserCtxtPtr ctxt;
+  TypedData_Get_Struct(context, xmlParserCtxt, &rxml_parser_context_type, ctxt);
+
+  ctxt->sax2 = 1;
+	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
+  memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
+    
+  int status = xmlParseDocument(ctxt);
+
+  /* Now check the parsing result*/
+  if (status == -1 || !ctxt->wellFormed)
+  {
+    rxml_raise(&ctxt->lastError);
+  }
+  return Qtrue;
+}
+
+void rxml_init_sax_parser(void)
+{
+  /* SaxParser */
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+
+  /* Atributes */
+  CALLBACKS_ATTR = rb_intern("@callbacks");
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
+
+  /* Instance Methods */
+  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
+  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
+}

data/ext/libxml/ruby_xml_sax_parser.h

@@ -1,10 +1,10 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_SAX_PARSER__
-#define __RXML_SAX_PARSER__
-
-extern VALUE cXMLSaxParser;
-
-void rxml_init_sax_parser(void);
-
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX_PARSER__
+#define __RXML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+
+void rxml_init_sax_parser(void);
+
+#endif

data/ext/libxml/ruby_xml_schema.c

@@ -109,11 +109,18 @@ struct _xmlSchemaImport {
 
 VALUE cXMLSchema;
 
-static void rxml_schema_free(xmlSchemaPtr xschema)
+static void rxml_schema_free(void *data)
 {
+  xmlSchemaPtr xschema = (xmlSchemaPtr)data;
   xmlSchemaFree(xschema);
 }
 
+const rb_data_type_t rxml_schema_type = {
+  "XML::Schema",
+  {NULL, rxml_schema_free, NULL},
+  NULL, NULL, 0
+};
+
 VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
 {
   VALUE result;
@@ -121,7 +128,7 @@ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
   if (!xschema)
     rb_raise(rb_eArgError, "XML::Schema is required!");
 
-  result = Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+  result = TypedData_Wrap_Struct(cXMLSchema, &rxml_schema_type, xschema);
 
   /*
    * Create these as instance variables to provide the output of inspect/to_str some
@@ -130,7 +137,7 @@ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
   rb_iv_set(result, "@target_namespace", QNIL_OR_STRING(xschema->targetNamespace));
   rb_iv_set(result, "@name", QNIL_OR_STRING(xschema->name));
   rb_iv_set(result, "@id", QNIL_OR_STRING(xschema->id));
-  rb_iv_set(result, "@version", QNIL_OR_STRING(xschema->name));
+  rb_iv_set(result, "@version", QNIL_OR_STRING(xschema->version));
 
   return result;
 }
@@ -143,7 +150,7 @@ static VALUE rxml_schema_init(VALUE class, xmlSchemaParserCtxtPtr xparser)
   xmlSchemaFreeParserCtxt(xparser);
 
   if (!xschema)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_wrap_schema(xschema);
 }
@@ -163,7 +170,7 @@ static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
   xmlResetLastError();
   xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }
@@ -179,12 +186,12 @@ static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
   xmlDocPtr xdoc;
   xmlSchemaParserCtxtPtr xparser;
 
-  Data_Get_Struct(document, xmlDoc, xdoc);
+  TypedData_Get_Struct(document, xmlDoc, &rxml_document_data_type, xdoc);
 
   xmlResetLastError();
   xparser = xmlSchemaNewDocParserCtxt(xdoc);
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }
@@ -204,7 +211,7 @@ static VALUE rxml_schema_init_from_string(VALUE class, VALUE schema_str)
   xmlResetLastError();
   xparser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), (int)strlen(StringValuePtr(schema_str)));
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }
@@ -219,7 +226,7 @@ static VALUE rxml_schema_document(VALUE self)
 {
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
 }
@@ -254,7 +261,7 @@ static VALUE rxml_schema_namespaces(VALUE self)
   VALUE result;
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   result = rb_ary_new();
   xmlHashScan(xschema->schemasImports, (xmlHashScanner)scan_namespaces, (void *)result);
@@ -273,7 +280,7 @@ static VALUE rxml_schema_elements(VALUE self)
   VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
   xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_schema_element, (void *)result);
 
   return result;
@@ -300,7 +307,7 @@ static VALUE rxml_schema_imported_ns_elements(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {
@@ -321,7 +328,7 @@ static VALUE rxml_schema_types(VALUE self)
   VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema != NULL && xschema->typeDecl != NULL)
   {
@@ -350,7 +357,7 @@ static VALUE rxml_schema_imported_types(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {
@@ -381,7 +388,7 @@ static VALUE rxml_schema_imported_ns_types(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {

data/ext/libxml/ruby_xml_schema.h

@@ -1,25 +1,26 @@
-#ifndef __RXML_SCHEMA__
-#define __RXML_SCHEMA__
-
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemastypes.h>
-
-typedef struct _xmlSchemaItemList xmlSchemaItemList;
-typedef xmlSchemaItemList *xmlSchemaItemListPtr;
-struct _xmlSchemaItemList {
-    void **items;
-    /* used for dynamic addition of schemata */
-    int nbItems;
-    /* used for dynamic addition of schemata */
-    int sizeItems; /* used for dynamic addition of schemata */
-};
-
-#define QNIL_OR_STRING(slot) \
-    (slot == NULL) ? Qnil : rb_str_new2((const char *)slot)
-
-extern VALUE cXMLSchema;
-
-void rxml_init_schema(void);
-
-#endif
-
+#ifndef __RXML_SCHEMA__
+#define __RXML_SCHEMA__
+
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemastypes.h>
+
+typedef struct _xmlSchemaItemList xmlSchemaItemList;
+typedef xmlSchemaItemList *xmlSchemaItemListPtr;
+struct _xmlSchemaItemList {
+    void **items;
+    /* used for dynamic addition of schemata */
+    int nbItems;
+    /* used for dynamic addition of schemata */
+    int sizeItems; /* used for dynamic addition of schemata */
+};
+
+#define QNIL_OR_STRING(slot) \
+    (slot == NULL) ? Qnil : rb_str_new2((const char *)slot)
+
+extern VALUE cXMLSchema;
+extern const rb_data_type_t rxml_schema_type;
+
+void rxml_init_schema(void);
+
+#endif
+

data/ext/libxml/ruby_xml_schema_attribute.c

@@ -50,11 +50,11 @@ struct _xmlSchemaAttributeUseProhib {
 
 VALUE cXMLSchemaAttribute;
 
-static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
-{
-  attr = NULL;
-  xmlFree(attr);
-}
+static const rb_data_type_t rxml_schema_attribute_type = {
+  "XML::Schema::Attribute",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
 {
@@ -64,7 +64,7 @@ VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
   if (!attr)
     rb_raise(rb_eArgError, "XML::Schema::Attribute required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaAttribute, NULL, rxml_schema_attribute_free, attr);
+  result = TypedData_Wrap_Struct(cXMLSchemaAttribute, &rxml_schema_attribute_type, attr);
 
   if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
     tns_str = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
@@ -89,7 +89,7 @@ static VALUE rxml_schema_attribute_node(VALUE self)
 {
   xmlSchemaAttributeUsePtr attr;
 
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
+  TypedData_Get_Struct(self, xmlSchemaAttributeUse, &rxml_schema_attribute_type, attr);
 
   return rxml_node_wrap(attr->node);
 }

data/ext/libxml/ruby_xml_schema_attribute.h

@@ -1,37 +1,37 @@
-#ifndef __RXML_SCHEMA_ATTRIBUTE__
-#define __RXML_SCHEMA_ATTRIBUTE__
-
-#include "ruby_xml_schema.h"
-
-extern VALUE cXMLSchemaAttribute;
-
-/**
- * xmlSchemaAttributeUsePtr:
- *
- * The abstract base type for tree-like structured schema components.
- * (Extends xmlSchemaTreeItem)
- */
-typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
-typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
-struct _xmlSchemaAttributeUse {
-    xmlSchemaTypeType type;
-    xmlSchemaAnnotPtr annot;
-    xmlSchemaAttributeUsePtr next; /* The next attr. use. */
-    /*
-    * The attr. decl. OR a QName-ref. to an attr. decl. OR
-    * a QName-ref. to an attribute group definition.
-    */
-    xmlSchemaAttributePtr attrDecl;
-
-    int flags;
-    xmlNodePtr node;
-    int occurs;
-    /* required, optional */
-    const xmlChar *defValue;
-    xmlSchemaValPtr defVal;
-};
-
-void rxml_init_schema_attribute(void);
-VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr);
-
-#endif
+#ifndef __RXML_SCHEMA_ATTRIBUTE__
+#define __RXML_SCHEMA_ATTRIBUTE__
+
+#include "ruby_xml_schema.h"
+
+extern VALUE cXMLSchemaAttribute;
+
+/**
+ * xmlSchemaAttributeUsePtr:
+ *
+ * The abstract base type for tree-like structured schema components.
+ * (Extends xmlSchemaTreeItem)
+ */
+typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
+typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
+struct _xmlSchemaAttributeUse {
+    xmlSchemaTypeType type;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaAttributeUsePtr next; /* The next attr. use. */
+    /*
+    * The attr. decl. OR a QName-ref. to an attr. decl. OR
+    * a QName-ref. to an attribute group definition.
+    */
+    xmlSchemaAttributePtr attrDecl;
+
+    int flags;
+    xmlNodePtr node;
+    int occurs;
+    /* required, optional */
+    const xmlChar *defValue;
+    xmlSchemaValPtr defVal;
+};
+
+void rxml_init_schema_attribute(void);
+VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr);
+
+#endif

data/ext/libxml/ruby_xml_schema_element.c

@@ -4,11 +4,11 @@
 
 VALUE cXMLSchemaElement;
 
-static void rxml_schema_element_free(xmlSchemaElementPtr xschema_element)
-{
-  xschema_element = NULL;
-  xmlFree(xschema_element);
-}
+static const rb_data_type_t rxml_schema_element_type = {
+  "XML::Schema::Element",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelem)
 {
@@ -17,7 +17,7 @@ VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelem)
   if (!xelem)
     rb_raise(rb_eArgError, "XML::Schema::Element is required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelem);
+  result = TypedData_Wrap_Struct(cXMLSchemaElement, &rxml_schema_element_type, xelem);
 
   rb_iv_set(result, "@name", QNIL_OR_STRING(xelem->name));
   rb_iv_set(result, "@value", QNIL_OR_STRING(xelem->value));
@@ -31,7 +31,7 @@ static VALUE rxml_schema_element_node(VALUE self)
 {
   xmlSchemaElementPtr xelem;
 
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
+  TypedData_Get_Struct(self, xmlSchemaElement, &rxml_schema_element_type, xelem);
 
   return rxml_node_wrap(xelem->node);
 }
@@ -41,7 +41,7 @@ static VALUE rxml_schema_element_annot(VALUE self)
   xmlSchemaElementPtr xelem;
   VALUE annotation = Qnil;
 
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
+  TypedData_Get_Struct(self, xmlSchemaElement, &rxml_schema_element_type, xelem);
 
   if ((xelem->annot != NULL) && (xelem->annot->content != NULL))
   {

data/ext/libxml/ruby_xml_schema_element.h

@@ -1,11 +1,11 @@
-#ifndef __RXML_SCHEMA_ELEMENT__
-#define __RXML_SCHEMA_ELEMENT__
-
-#include "ruby_xml_schema.h"
-
-extern VALUE cXMLSchemaElement;
-
-VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement);
-void rxml_init_schema_element(void);
-
-#endif
+#ifndef __RXML_SCHEMA_ELEMENT__
+#define __RXML_SCHEMA_ELEMENT__
+
+#include "ruby_xml_schema.h"
+
+extern VALUE cXMLSchemaElement;
+
+VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement);
+void rxml_init_schema_element(void);
+
+#endif