nokogiri 1.9.1 → 1.15.3

data/ext/nokogiri/xml_relax_ng.c

@@ -1,33 +1,44 @@
-#include <xml_relax_ng.h>
+#include <nokogiri.h>
 
-static void dealloc(xmlRelaxNGPtr schema)
+VALUE cNokogiriXmlRelaxNG;
+
+static void
+xml_relax_ng_deallocate(void *data)
 {
-  NOKOGIRI_DEBUG_START(schema);
+  xmlRelaxNGPtr schema = data;
   xmlRelaxNGFree(schema);
-  NOKOGIRI_DEBUG_END(schema);
 }
 
+static const rb_data_type_t xml_relax_ng_type = {
+  .wrap_struct_name = "Nokogiri::XML::RelaxNG",
+  .function = {
+    .dfree = xml_relax_ng_deallocate,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 /*
  * call-seq:
  *  validate_document(document)
  *
  * Validate a Nokogiri::XML::Document against this RelaxNG schema.
  */
-static VALUE validate_document(VALUE self, VALUE document)
+static VALUE
+validate_document(VALUE self, VALUE document)
 {
   xmlDocPtr doc;
   xmlRelaxNGPtr schema;
   VALUE errors;
   xmlRelaxNGValidCtxtPtr valid_ctxt;
 
-  Data_Get_Struct(self, xmlRelaxNG, schema);
-  Data_Get_Struct(document, xmlDoc, doc);
+  TypedData_Get_Struct(self, xmlRelaxNG, &xml_relax_ng_type, schema);
+  doc = noko_xml_document_unwrap(document);
 
   errors = rb_ary_new();
 
   valid_ctxt = xmlRelaxNGNewValidCtxt(schema);
 
-  if(NULL == valid_ctxt) {
+  if (NULL == valid_ctxt) {
     /* we have a problem */
     rb_raise(rb_eRuntimeError, "Could not create a validation context");
   }
@@ -47,115 +58,113 @@ static VALUE validate_document(VALUE self, VALUE document)
   return errors;
 }
 
-/*
- * call-seq:
- *  read_memory(string)
- *
- * Create a new RelaxNG from the contents of +string+
- */
-static VALUE read_memory(VALUE klass, VALUE content)
+static VALUE
+xml_relax_ng_parse_schema(
+  VALUE klass,
+  xmlRelaxNGParserCtxtPtr c_parser_context,
+  VALUE rb_parse_options
+)
 {
-  xmlRelaxNGParserCtxtPtr ctx = xmlRelaxNGNewMemParserCtxt(
-      (const char *)StringValuePtr(content),
-      (int)RSTRING_LEN(content)
-  );
-  xmlRelaxNGPtr schema;
-  VALUE errors = rb_ary_new();
+  VALUE rb_errors;
   VALUE rb_schema;
+  xmlRelaxNGPtr c_schema;
+
+  if (NIL_P(rb_parse_options)) {
+    rb_parse_options = rb_const_get_at(
+                         rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")),
+                         rb_intern("DEFAULT_SCHEMA")
+                       );
+  }
 
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  rb_errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)rb_errors, Nokogiri_error_array_pusher);
 
 #ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
   xmlRelaxNGSetParserStructuredErrors(
-    ctx,
+    c_parser_context,
     Nokogiri_error_array_pusher,
-    (void *)errors
+    (void *)rb_errors
   );
 #endif
 
-  schema = xmlRelaxNGParse(ctx);
+  c_schema = xmlRelaxNGParse(c_parser_context);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlRelaxNGFreeParserCtxt(ctx);
+  xmlRelaxNGFreeParserCtxt(c_parser_context);
 
-  if(NULL == schema) {
+  if (NULL == c_schema) {
     xmlErrorPtr error = xmlGetLastError();
-    if(error)
+    if (error) {
       Nokogiri_error_raise(NULL, error);
-    else
+    } else {
       rb_raise(rb_eRuntimeError, "Could not parse document");
+    }
 
     return Qnil;
   }
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
+  rb_schema = TypedData_Wrap_Struct(klass, &xml_relax_ng_type, c_schema);
+  rb_iv_set(rb_schema, "@errors", rb_errors);
+  rb_iv_set(rb_schema, "@parse_options", rb_parse_options);
 
   return rb_schema;
 }
 
 /*
  * call-seq:
- *  from_document(doc)
+ *  read_memory(string)
  *
- * Create a new RelaxNG schema from the Nokogiri::XML::Document +doc+
+ * Create a new RelaxNG from the contents of +string+
  */
-static VALUE from_document(VALUE klass, VALUE document)
+static VALUE
+read_memory(int argc, VALUE *argv, VALUE klass)
 {
-  xmlDocPtr doc;
-  xmlRelaxNGParserCtxtPtr ctx;
-  xmlRelaxNGPtr schema;
-  VALUE errors;
-  VALUE rb_schema;
-
-  Data_Get_Struct(document, xmlDoc, doc);
-
-  /* In case someone passes us a node. ugh. */
-  doc = doc->doc;
+  VALUE rb_content;
+  VALUE rb_parse_options;
+  xmlRelaxNGParserCtxtPtr c_parser_context;
 
-  ctx = xmlRelaxNGNewDocParserCtxt(doc);
+  rb_scan_args(argc, argv, "11", &rb_content, &rb_parse_options);
 
-  errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
-
-#ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
-  xmlRelaxNGSetParserStructuredErrors(
-    ctx,
-    Nokogiri_error_array_pusher,
-    (void *)errors
-  );
-#endif
+  c_parser_context = xmlRelaxNGNewMemParserCtxt(
+                       (const char *)StringValuePtr(rb_content),
+                       (int)RSTRING_LEN(rb_content)
+                     );
 
-  schema = xmlRelaxNGParse(ctx);
+  return xml_relax_ng_parse_schema(klass, c_parser_context, rb_parse_options);
+}
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new RelaxNG schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE
+from_document(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rb_document;
+  VALUE rb_parse_options;
+  xmlDocPtr c_document;
+  xmlRelaxNGParserCtxtPtr c_parser_context;
 
-  if(NULL == schema) {
-    xmlErrorPtr error = xmlGetLastError();
-    if(error)
-      Nokogiri_error_raise(NULL, error);
-    else
-      rb_raise(rb_eRuntimeError, "Could not parse document");
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_parse_options);
 
-    return Qnil;
-  }
+  c_document = noko_xml_document_unwrap(rb_document);
+  c_document = c_document->doc; /* In case someone passes us a node. ugh. */
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
+  c_parser_context = xmlRelaxNGNewDocParserCtxt(c_document);
 
-  return rb_schema;
+  return xml_relax_ng_parse_schema(klass, c_parser_context, rb_parse_options);
 }
 
-VALUE cNokogiriXmlRelaxNG;
-void init_xml_relax_ng()
+void
+noko_init_xml_relax_ng(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE klass = rb_define_class_under(xml, "RelaxNG", cNokogiriXmlSchema);
+  assert(cNokogiriXmlSchema);
+  cNokogiriXmlRelaxNG = rb_define_class_under(mNokogiriXml, "RelaxNG", cNokogiriXmlSchema);
 
-  cNokogiriXmlRelaxNG = klass;
+  rb_define_singleton_method(cNokogiriXmlRelaxNG, "read_memory", read_memory, -1);
+  rb_define_singleton_method(cNokogiriXmlRelaxNG, "from_document", from_document, -1);
 
-  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
-  rb_define_singleton_method(klass, "from_document", from_document, 1);
-  rb_define_private_method(klass, "validate_document", validate_document, 1);
+  rb_define_private_method(cNokogiriXmlRelaxNG, "validate_document", validate_document, 1);
 }

data/ext/nokogiri/xml_sax_parser.c

@@ -1,23 +1,23 @@
-#include <xml_sax_parser.h>
+#include <nokogiri.h>
 
-int vasprintf (char **strp, const char *fmt, va_list ap);
-void vasprintf_free (void *p);
+VALUE cNokogiriXmlSaxParser ;
 
 static ID id_start_document, id_end_document, id_start_element, id_end_element;
 static ID id_start_element_namespace, id_end_element_namespace;
 static ID id_comment, id_characters, id_xmldecl, id_error, id_warning;
-static ID id_cdata_block, id_cAttribute;
+static ID id_cdata_block;
 static ID id_processing_instruction;
 
-static void start_document(void * ctx)
+static void
+start_document(void *ctx)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
 
   xmlParserCtxtPtr ctxt = NOKOGIRI_SAX_CTXT(ctx);
 
-  if(NULL != ctxt && ctxt->html != 1) {
-    if(ctxt->standalone != -1) {  /* -1 means there was no declaration */
+  if (NULL != ctxt && ctxt->html != 1) {
+    if (ctxt->standalone != -1) { /* -1 means there was no declaration */
       VALUE encoding = Qnil ;
       VALUE standalone = Qnil;
       VALUE version;
@@ -29,8 +29,7 @@ static void start_document(void * ctx)
 
       version = ctxt->version ? NOKOGIRI_STR_NEW2(ctxt->version) : Qnil;
 
-      switch(ctxt->standalone)
-      {
+      switch (ctxt->standalone) {
         case 0:
           standalone = NOKOGIRI_STR_NEW2("no");
           break;
@@ -46,138 +45,140 @@ static void start_document(void * ctx)
   rb_funcall(doc, id_start_document, 0);
 }
 
-static void end_document(void * ctx)
+static void
+end_document(void *ctx)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
   rb_funcall(doc, id_end_document, 0);
 }
 
-static void start_element(void * ctx, const xmlChar *name, const xmlChar **atts)
+static void
+start_element(void *ctx, const xmlChar *name, const xmlChar **atts)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
   VALUE attributes = rb_ary_new();
-  const xmlChar * attr;
+  const xmlChar *attr;
   int i = 0;
-  if(atts) {
-    while((attr = atts[i]) != NULL) {
-      const xmlChar * val = atts[i+1];
+  if (atts) {
+    while ((attr = atts[i]) != NULL) {
+      const xmlChar *val = atts[i + 1];
       VALUE value = val != NULL ? NOKOGIRI_STR_NEW2(val) : Qnil;
       rb_ary_push(attributes, rb_ary_new3(2, NOKOGIRI_STR_NEW2(attr), value));
-      i+=2;
+      i += 2;
     }
   }
 
-  rb_funcall( doc,
-              id_start_element,
-              2,
-              NOKOGIRI_STR_NEW2(name),
-              attributes
-  );
+  rb_funcall(doc,
+             id_start_element,
+             2,
+             NOKOGIRI_STR_NEW2(name),
+             attributes
+            );
 }
 
-static void end_element(void * ctx, const xmlChar *name)
+static void
+end_element(void *ctx, const xmlChar *name)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
   rb_funcall(doc, id_end_element, 1, NOKOGIRI_STR_NEW2(name));
 }
 
-static VALUE attributes_as_list(
-  VALUE self,
-  int nb_attributes,
-  const xmlChar ** attributes)
+static VALUE
+attributes_as_array(int attributes_len, const xmlChar **c_attributes)
 {
-  VALUE list = rb_ary_new2((long)nb_attributes);
+  VALUE rb_array = rb_ary_new2((long)attributes_len);
+  VALUE cNokogiriXmlSaxParserAttribute;
 
-  VALUE attr_klass = rb_const_get(cNokogiriXmlSaxParser, id_cAttribute);
-  if (attributes) {
+  cNokogiriXmlSaxParserAttribute = rb_const_get_at(cNokogiriXmlSaxParser, rb_intern("Attribute"));
+  if (c_attributes) {
     /* Each attribute is an array of [localname, prefix, URI, value, end] */
     int i;
-    for (i = 0; i < nb_attributes * 5; i += 5) {
-      VALUE argv[4], attribute;
+    for (i = 0; i < attributes_len * 5; i += 5) {
+      VALUE rb_constructor_args[4], rb_attribute;
 
-      argv[0] = RBSTR_OR_QNIL(attributes[i + 0]); /* localname */
-      argv[1] = RBSTR_OR_QNIL(attributes[i + 1]); /* prefix */
-      argv[2] = RBSTR_OR_QNIL(attributes[i + 2]); /* URI */
+      rb_constructor_args[0] = RBSTR_OR_QNIL(c_attributes[i + 0]); /* localname */
+      rb_constructor_args[1] = RBSTR_OR_QNIL(c_attributes[i + 1]); /* prefix */
+      rb_constructor_args[2] = RBSTR_OR_QNIL(c_attributes[i + 2]); /* URI */
 
       /* value */
-      argv[3] = NOKOGIRI_STR_NEW((const char*)attributes[i+3],
-          (attributes[i+4] - attributes[i+3]));
+      rb_constructor_args[3] = NOKOGIRI_STR_NEW((const char *)c_attributes[i + 3],
+                               (c_attributes[i + 4] - c_attributes[i + 3]));
 
-      attribute = rb_class_new_instance(4, argv, attr_klass);
-      rb_ary_push(list, attribute);
+      rb_attribute = rb_class_new_instance(4, rb_constructor_args, cNokogiriXmlSaxParserAttribute);
+      rb_ary_push(rb_array, rb_attribute);
     }
   }
 
-  return list;
+  return rb_array;
 }
 
 static void
-start_element_ns (
-  void * ctx,
-  const xmlChar * localname,
-  const xmlChar * prefix,
-  const xmlChar * uri,
+start_element_ns(
+  void *ctx,
+  const xmlChar *localname,
+  const xmlChar *prefix,
+  const xmlChar *uri,
   int nb_namespaces,
-  const xmlChar ** namespaces,
+  const xmlChar **namespaces,
   int nb_attributes,
   int nb_defaulted,
-  const xmlChar ** attributes)
+  const xmlChar **attributes)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
 
-  VALUE attribute_list = attributes_as_list(self, nb_attributes, attributes);
+  VALUE attribute_ary = attributes_as_array(nb_attributes, attributes);
 
   VALUE ns_list = rb_ary_new2((long)nb_namespaces);
 
   if (namespaces) {
     int i;
-    for (i = 0; i < nb_namespaces * 2; i += 2)
-    {
+    for (i = 0; i < nb_namespaces * 2; i += 2) {
       rb_ary_push(ns_list,
-        rb_ary_new3((long)2,
-          RBSTR_OR_QNIL(namespaces[i + 0]),
-          RBSTR_OR_QNIL(namespaces[i + 1])
-        )
-      );
+                  rb_ary_new3((long)2,
+                              RBSTR_OR_QNIL(namespaces[i + 0]),
+                              RBSTR_OR_QNIL(namespaces[i + 1])
+                             )
+                 );
     }
   }
 
-  rb_funcall( doc,
-              id_start_element_namespace,
-              5,
-              NOKOGIRI_STR_NEW2(localname),
-              attribute_list,
-              RBSTR_OR_QNIL(prefix),
-              RBSTR_OR_QNIL(uri),
-              ns_list
-  );
+  rb_funcall(doc,
+             id_start_element_namespace,
+             5,
+             NOKOGIRI_STR_NEW2(localname),
+             attribute_ary,
+             RBSTR_OR_QNIL(prefix),
+             RBSTR_OR_QNIL(uri),
+             ns_list
+            );
 }
 
 /**
  * end_element_ns was borrowed heavily from libxml-ruby.
  */
 static void
-end_element_ns (
-  void * ctx,
-  const xmlChar * localname,
-  const xmlChar * prefix,
-  const xmlChar * uri)
+end_element_ns(
+  void *ctx,
+  const xmlChar *localname,
+  const xmlChar *prefix,
+  const xmlChar *uri)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
 
   rb_funcall(doc, id_end_element_namespace, 3,
-    NOKOGIRI_STR_NEW2(localname),
-    RBSTR_OR_QNIL(prefix),
-    RBSTR_OR_QNIL(uri)
-  );
+             NOKOGIRI_STR_NEW2(localname),
+             RBSTR_OR_QNIL(prefix),
+             RBSTR_OR_QNIL(uri)
+            );
 }
 
-static void characters_func(void * ctx, const xmlChar * ch, int len)
+static void
+characters_func(void *ctx, const xmlChar *ch, int len)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
@@ -185,7 +186,8 @@ static void characters_func(void * ctx, const xmlChar * ch, int len)
   rb_funcall(doc, id_characters, 1, str);
 }
 
-static void comment_func(void * ctx, const xmlChar * value)
+static void
+comment_func(void *ctx, const xmlChar *value)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
@@ -193,41 +195,52 @@ static void comment_func(void * ctx, const xmlChar * value)
   rb_funcall(doc, id_comment, 1, str);
 }
 
-static void warning_func(void * ctx, const char *msg, ...)
+PRINTFLIKE_DECL(2, 3)
+static void
+warning_func(void *ctx, const char *msg, ...)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
-  char * message;
-  VALUE ruby_message;
+  VALUE rb_message;
 
+#ifdef TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+  /* It is not currently possible to pass var args from native
+     functions to sulong, so we work around the issue here. */
+  rb_message = rb_sprintf("warning_func: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  ruby_message = NOKOGIRI_STR_NEW2(message);
-  vasprintf_free(message);
-  rb_funcall(doc, id_warning, 1, ruby_message);
+  rb_funcall(doc, id_warning, 1, rb_message);
 }
 
-static void error_func(void * ctx, const char *msg, ...)
+PRINTFLIKE_DECL(2, 3)
+static void
+error_func(void *ctx, const char *msg, ...)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
-  char * message;
-  VALUE ruby_message;
+  VALUE rb_message;
 
+#ifdef TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+  /* It is not currently possible to pass var args from native
+     functions to sulong, so we work around the issue here. */
+  rb_message = rb_sprintf("error_func: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  ruby_message = NOKOGIRI_STR_NEW2(message);
-  vasprintf_free(message);
-  rb_funcall(doc, id_error, 1, ruby_message);
+  rb_funcall(doc, id_error, 1, rb_message);
 }
 
-static void cdata_block(void * ctx, const xmlChar * value, int len)
+static void
+cdata_block(void *ctx, const xmlChar *value, int len)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
@@ -235,7 +248,8 @@ static void cdata_block(void * ctx, const xmlChar * value, int len)
   rb_funcall(doc, id_cdata_block, 1, string);
 }
 
-static void processing_instruction(void * ctx, const xmlChar * name, const xmlChar * content)
+static void
+processing_instruction(void *ctx, const xmlChar *name, const xmlChar *content)
 {
   VALUE rb_content;
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
@@ -243,26 +257,35 @@ static void processing_instruction(void * ctx, const xmlChar * name, const xmlCh
 
   rb_content = content ? NOKOGIRI_STR_NEW2(content) : Qnil;
 
-  rb_funcall( doc,
-              id_processing_instruction,
-              2,
-              NOKOGIRI_STR_NEW2(name),
-              rb_content
-  );
+  rb_funcall(doc,
+             id_processing_instruction,
+             2,
+             NOKOGIRI_STR_NEW2(name),
+             rb_content
+            );
 }
 
-static void deallocate(xmlSAXHandlerPtr handler)
+static size_t
+memsize(const void *data)
 {
-  NOKOGIRI_DEBUG_START(handler);
-  free(handler);
-  NOKOGIRI_DEBUG_END(handler);
+  return sizeof(xmlSAXHandler);
 }
 
-static VALUE allocate(VALUE klass)
+/* Used by Nokogiri::XML::SAX::Parser and Nokogiri::HTML::SAX::Parser */
+static const rb_data_type_t noko_sax_handler_type = {
+  .wrap_struct_name = "Nokogiri::SAXHandler",
+  .function = {
+    .dfree = RUBY_TYPED_DEFAULT_FREE,
+    .dsize = memsize
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE
+allocate(VALUE klass)
 {
-  xmlSAXHandlerPtr handler = calloc((size_t)1, sizeof(xmlSAXHandler));
-
-  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSAXHandlerPtr handler;
+  VALUE self = TypedData_Make_Struct(klass, xmlSAXHandler, &noko_sax_handler_type, handler);
 
   handler->startDocument = start_document;
   handler->endDocument = end_document;
@@ -278,32 +301,34 @@ static VALUE allocate(VALUE klass)
   handler->processingInstruction = processing_instruction;
   handler->initialized = XML_SAX2_MAGIC;
 
-  return Data_Wrap_Struct(klass, NULL, deallocate, handler);
+  return self;
 }
 
-VALUE cNokogiriXmlSaxParser ;
-void init_xml_sax_parser()
+xmlSAXHandlerPtr
+noko_sax_handler_unwrap(VALUE rb_sax_handler)
 {
-  VALUE nokogiri  = rb_define_module("Nokogiri");
-  VALUE xml       = rb_define_module_under(nokogiri, "XML");
-  VALUE sax       = rb_define_module_under(xml, "SAX");
-  VALUE klass     = rb_define_class_under(sax, "Parser", rb_cObject);
+  xmlSAXHandlerPtr c_sax_handler;
+  TypedData_Get_Struct(rb_sax_handler, xmlSAXHandler, &noko_sax_handler_type, c_sax_handler);
+  return c_sax_handler;
+}
 
-  cNokogiriXmlSaxParser = klass;
+void
+noko_init_xml_sax_parser(void)
+{
+  cNokogiriXmlSaxParser = rb_define_class_under(mNokogiriXmlSax, "Parser", rb_cObject);
 
-  rb_define_alloc_func(klass, allocate);
+  rb_define_alloc_func(cNokogiriXmlSaxParser, allocate);
 
   id_start_document = rb_intern("start_document");
-  id_end_document   = rb_intern("end_document");
-  id_start_element  = rb_intern("start_element");
-  id_end_element    = rb_intern("end_element");
-  id_comment        = rb_intern("comment");
-  id_characters     = rb_intern("characters");
-  id_xmldecl        = rb_intern("xmldecl");
-  id_error          = rb_intern("error");
-  id_warning        = rb_intern("warning");
-  id_cdata_block    = rb_intern("cdata_block");
-  id_cAttribute     = rb_intern("Attribute");
+  id_end_document = rb_intern("end_document");
+  id_start_element = rb_intern("start_element");
+  id_end_element = rb_intern("end_element");
+  id_comment = rb_intern("comment");
+  id_characters = rb_intern("characters");
+  id_xmldecl = rb_intern("xmldecl");
+  id_error = rb_intern("error");
+  id_warning = rb_intern("warning");
+  id_cdata_block = rb_intern("cdata_block");
   id_start_element_namespace = rb_intern("start_element_namespace");
   id_end_element_namespace = rb_intern("end_element_namespace");
   id_processing_instruction = rb_intern("processing_instruction");