nokogiri 1.10.7 → 1.16.0

data/ext/nokogiri/xml_xpath_context.c

@@ -1,298 +1,483 @@
-#include <xml_xpath_context.h>
+#include <nokogiri.h>
 
-int vasprintf (char **strp, const char *fmt, va_list ap);
+VALUE cNokogiriXmlXpathContext;
+
+/*
+ * these constants have matching declarations in
+ * ext/java/nokogiri/internals/NokogiriNamespaceContext.java
+ */
+static const xmlChar *NOKOGIRI_PREFIX = (const xmlChar *)"nokogiri";
+static const xmlChar *NOKOGIRI_URI = (const xmlChar *)"http://www.nokogiri.org/default_ns/ruby/extensions_functions";
+static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-builtin";
+static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
-static void deallocate(xmlXPathContextPtr ctx)
+static void
+xml_xpath_context_deallocate(void *data)
 {
-  NOKOGIRI_DEBUG_START(ctx);
-  xmlXPathFreeContext(ctx);
-  NOKOGIRI_DEBUG_END(ctx);
+  xmlXPathContextPtr c_context = data;
+  xmlXPathFreeContext(c_context);
 }
 
+static const rb_data_type_t xml_xpath_context_type = {
+  .wrap_struct_name = "Nokogiri::XML::XPathContext",
+  .function = {
+    .dfree = xml_xpath_context_deallocate,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+/* find a CSS class in an HTML element's `class` attribute */
+static const xmlChar *
+builtin_css_class(const xmlChar *str, const xmlChar *val)
+{
+  int val_len;
+
+  if (str == NULL) { return (NULL); }
+  if (val == NULL) { return (NULL); }
+
+  val_len = xmlStrlen(val);
+  if (val_len == 0) { return (str); }
+
+  while (*str != 0) {
+    if ((*str == *val) && !xmlStrncmp(str, val, val_len)) {
+      const xmlChar *next_byte = str + val_len;
+
+      /* only match if the next byte is whitespace or end of string */
+      if ((*next_byte == 0) || (IS_BLANK_CH(*next_byte))) {
+        return ((const xmlChar *)str);
+      }
+    }
+
+    /* advance str to whitespace */
+    while ((*str != 0) && !IS_BLANK_CH(*str)) {
+      str++;
+    }
+
+    /* advance str to start of next word or end of string */
+    while ((*str != 0) && IS_BLANK_CH(*str)) {
+      str++;
+    }
+  }
+
+  return (NULL);
+}
+
+/* xmlXPathFunction to wrap builtin_css_class() */
+static void
+xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr hay, needle;
+
+  CHECK_ARITY(2);
+
+  CAST_TO_STRING;
+  needle = valuePop(ctxt);
+  if ((needle == NULL) || (needle->type != XPATH_STRING)) {
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  CAST_TO_STRING;
+  hay = valuePop(ctxt);
+  if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+    xmlXPathFreeObject(hay);
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  if (builtin_css_class(hay->stringval, needle->stringval)) {
+    valuePush(ctxt, xmlXPathNewBoolean(1));
+  } else {
+    valuePush(ctxt, xmlXPathNewBoolean(0));
+  }
+
+  xmlXPathFreeObject(hay);
+  xmlXPathFreeObject(needle);
+}
+
+
+/* xmlXPathFunction to select nodes whose local name matches, for HTML5 CSS queries that should
+ * ignore namespaces */
+static void
+xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr element_name;
+
+  assert(ctxt->context->node);
+
+  CHECK_ARITY(1);
+  CAST_TO_STRING;
+  CHECK_TYPE(XPATH_STRING);
+  element_name = valuePop(ctxt);
+
+  valuePush(
+    ctxt,
+    xmlXPathNewBoolean(xmlStrEqual(ctxt->context->node->name, element_name->stringval))
+  );
+
+  xmlXPathFreeObject(element_name);
+}
+
+
 /*
  * call-seq:
- *  register_ns(prefix, uri)
+ *   register_ns(prefix, uri) → Nokogiri::XML::XPathContext
  *
- * Register the namespace with +prefix+ and +uri+.
+ * Register the namespace with +prefix+ and +uri+ for use in future queries.
+ *
+ * [Returns] +self+
  */
-static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
+static VALUE
+rb_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
 {
-  xmlXPathContextPtr ctx;
-  Data_Get_Struct(self, xmlXPathContext, ctx);
+  xmlXPathContextPtr c_context;
 
-  xmlXPathRegisterNs( ctx,
-                      (const xmlChar *)StringValueCStr(prefix),
-                      (const xmlChar *)StringValueCStr(uri)
+  TypedData_Get_Struct(
+    rb_context,
+    xmlXPathContext,
+    &xml_xpath_context_type,
+    c_context
   );
-  return self;
+
+  xmlXPathRegisterNs(c_context,
+                     (const xmlChar *)StringValueCStr(prefix),
+                     (const xmlChar *)StringValueCStr(uri)
+                    );
+  return rb_context;
 }
 
 /*
  * call-seq:
- *  register_variable(name, value)
+ *   register_variable(name, value) → Nokogiri::XML::XPathContext
+ *
+ * Register the variable +name+ with +value+ for use in future queries.
  *
- * Register the variable +name+ with +value+.
+ * [Returns] +self+
  */
-static VALUE register_variable(VALUE self, VALUE name, VALUE value)
+static VALUE
+rb_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value)
 {
-   xmlXPathContextPtr ctx;
-   xmlXPathObjectPtr xmlValue;
-   Data_Get_Struct(self, xmlXPathContext, ctx);
+  xmlXPathContextPtr c_context;
+  xmlXPathObjectPtr xmlValue;
+
+  TypedData_Get_Struct(
+    rb_context,
+    xmlXPathContext,
+    &xml_xpath_context_type,
+    c_context
+  );
 
-   xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  xmlValue = xmlXPathNewCString(StringValueCStr(value));
 
-   xmlXPathRegisterVariable( ctx,
-      (const xmlChar *)StringValueCStr(name),
-      xmlValue
-   );
+  xmlXPathRegisterVariable(
+    c_context,
+    (const xmlChar *)StringValueCStr(name),
+    xmlValue
+  );
 
-   return self;
+  return rb_context;
 }
 
-void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name)
+
+/*
+ *  convert an XPath object into a Ruby object of the appropriate type.
+ *  returns Qundef if no conversion was possible.
+ */
+static VALUE
+xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr c_context)
 {
-  int i;
-  VALUE result, doc;
+  VALUE rb_retval;
+
+  assert(c_context->doc);
+  assert(DOC_RUBY_OBJECT_TEST(c_context->doc));
+
+  switch (c_xpath_object->type) {
+    case XPATH_STRING:
+      rb_retval = NOKOGIRI_STR_NEW2(c_xpath_object->stringval);
+      xmlFree(c_xpath_object->stringval);
+      return rb_retval;
+
+    case XPATH_NODESET:
+      return noko_xml_node_set_wrap(
+               c_xpath_object->nodesetval,
+               DOC_RUBY_OBJECT(c_context->doc)
+             );
+
+    case XPATH_NUMBER:
+      return rb_float_new(c_xpath_object->floatval);
+
+    case XPATH_BOOLEAN:
+      return (c_xpath_object->boolval == 1) ? Qtrue : Qfalse;
+
+    default:
+      return Qundef;
+  }
+}
+
+void
+Nokogiri_marshal_xpath_funcall_and_return_values(
+  xmlXPathParserContextPtr ctxt,
+  int argc,
+  VALUE rb_xpath_handler,
+  const char *method_name
+)
+{
+  VALUE rb_retval;
   VALUE *argv;
-  VALUE node_set = Qnil;
-  xmlNodeSetPtr xml_node_set = NULL;
-  xmlXPathObjectPtr obj;
+  VALUE rb_node_set = Qnil;
+  xmlNodeSetPtr c_node_set = NULL;
+  xmlXPathObjectPtr c_xpath_object;
 
-  assert(ctx->context->doc);
-  assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
+  assert(ctxt->context->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctxt->context->doc));
 
-  argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_register_address(&argv[i]);
+  argv = (VALUE *)ruby_xcalloc((size_t)argc, sizeof(VALUE));
+  for (int j = 0 ; j < argc ; ++j) {
+    rb_gc_register_address(&argv[j]);
   }
 
-  doc = DOC_RUBY_OBJECT(ctx->context->doc);
-
-  if (nargs > 0) {
-    i = nargs - 1;
-    do {
-      obj = valuePop(ctx);
-      switch(obj->type) {
-        case XPATH_STRING:
-          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
-          break;
-        case XPATH_BOOLEAN:
-          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
-          break;
-        case XPATH_NUMBER:
-          argv[i] = rb_float_new(obj->floatval);
-          break;
-        case XPATH_NODESET:
-          argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc);
-          break;
-        default:
-          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
-      }
-      xmlXPathFreeNodeSetList(obj);
-    } while(i-- > 0);
+  for (int j = argc - 1 ; j >= 0 ; --j) {
+    c_xpath_object = valuePop(ctxt);
+    argv[j] = xpath2ruby(c_xpath_object, ctxt->context);
+    if (argv[j] == Qundef) {
+      argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(c_xpath_object));
+    }
+    xmlXPathFreeNodeSetList(c_xpath_object);
   }
 
-  result = rb_funcall2(handler, rb_intern((const char*)function_name), nargs, argv);
+  rb_retval = rb_funcall2(
+                rb_xpath_handler,
+                rb_intern((const char *)method_name),
+                argc,
+                argv
+              );
 
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_unregister_address(&argv[i]);
+  for (int j = 0 ; j < argc ; ++j) {
+    rb_gc_unregister_address(&argv[j]);
   }
-  free(argv);
+  ruby_xfree(argv);
 
-  switch(TYPE(result)) {
+  switch (TYPE(rb_retval)) {
     case T_FLOAT:
     case T_BIGNUM:
     case T_FIXNUM:
-      xmlXPathReturnNumber(ctx, NUM2DBL(result));
+      xmlXPathReturnNumber(ctxt, NUM2DBL(rb_retval));
       break;
     case T_STRING:
-      xmlXPathReturnString(
-          ctx,
-          xmlCharStrdup(StringValueCStr(result))
-      );
+      xmlXPathReturnString(ctxt, xmlCharStrdup(StringValueCStr(rb_retval)));
       break;
     case T_TRUE:
-      xmlXPathReturnTrue(ctx);
+      xmlXPathReturnTrue(ctxt);
       break;
     case T_FALSE:
-      xmlXPathReturnFalse(ctx);
+      xmlXPathReturnFalse(ctxt);
       break;
     case T_NIL:
       break;
-    case T_ARRAY:
-      {
-        VALUE args[2];
-        args[0] = doc;
-        args[1] = result;
-        node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
-        Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
-        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
-      }
+    case T_ARRAY: {
+      VALUE construct_args[2] = { DOC_RUBY_OBJECT(ctxt->context->doc), rb_retval };
+      rb_node_set = rb_class_new_instance(2, construct_args, cNokogiriXmlNodeSet);
+      c_node_set = noko_xml_node_set_unwrap(rb_node_set);
+      xmlXPathReturnNodeSet(ctxt, xmlXPathNodeSetMerge(NULL, c_node_set));
+    }
     break;
     case T_DATA:
-      if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
-        Data_Get_Struct(result, xmlNodeSet, xml_node_set);
+      if (rb_obj_is_kind_of(rb_retval, cNokogiriXmlNodeSet)) {
+        c_node_set = noko_xml_node_set_unwrap(rb_retval);
         /* Copy the node set, otherwise it will get GC'd. */
-        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+        xmlXPathReturnNodeSet(ctxt, xmlXPathNodeSetMerge(NULL, c_node_set));
         break;
       }
     default:
       rb_raise(rb_eRuntimeError, "Invalid return type");
-    }
+  }
 }
 
-static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
+static void
+method_caller(xmlXPathParserContextPtr ctxt, int argc)
 {
-  VALUE handler = Qnil;
-  const char *function = NULL ;
-
-  assert(ctx);
-  assert(ctx->context);
-  assert(ctx->context->userData);
-  assert(ctx->context->function);
-
-  handler = (VALUE)(ctx->context->userData);
-  function = (const char*)(ctx->context->function);
-
-  Nokogiri_marshal_xpath_funcall_and_return_values(ctx, nargs, handler, function);
+  VALUE rb_xpath_handler = Qnil;
+  const char *method_name = NULL ;
+
+  assert(ctxt);
+  assert(ctxt->context);
+  assert(ctxt->context->userData);
+  assert(ctxt->context->function);
+
+  rb_xpath_handler = (VALUE)(ctxt->context->userData);
+  method_name = (const char *)(ctxt->context->function);
+
+  Nokogiri_marshal_xpath_funcall_and_return_values(
+    ctxt,
+    argc,
+    rb_xpath_handler,
+    method_name
+  );
 }
 
-static xmlXPathFunction lookup( void *ctx,
-                                const xmlChar * name,
-                                const xmlChar* ns_uri )
+static xmlXPathFunction
+handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
 {
-  VALUE xpath_handler = (VALUE)ctx;
-  if(rb_respond_to(xpath_handler, rb_intern((const char *)name)))
-    return ruby_funcall;
+  VALUE rb_handler = (VALUE)data;
+  if (rb_respond_to(rb_handler, rb_intern((const char *)c_name))) {
+    if (c_ns_uri == NULL) {
+      NOKO_WARN_DEPRECATION("A custom XPath or CSS handler function named '%s' is being invoked without a namespace. Please update your query to reference this function as 'nokogiri:%s'. Invoking custom handler functions without a namespace is deprecated and will become an error in Nokogiri v1.17.0.",
+                            c_name, c_name); // deprecated in v1.15.0, remove in v1.17.0
+    }
+    return method_caller;
+  }
 
   return NULL;
 }
 
-NORETURN(static void xpath_generic_exception_handler(void * ctx, const char *msg, ...));
-static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
+PRINTFLIKE_DECL(2, 3)
+static void
+generic_exception_pusher(void *data, const char *msg, ...)
 {
-  char * message;
+  VALUE rb_errors = (VALUE)data;
+  VALUE rb_message;
+  VALUE rb_exception;
+
+  Check_Type(rb_errors, T_ARRAY);
 
+#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("generic_exception_pusher: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  rb_raise(rb_eRuntimeError, "%s", message);
+  rb_exception = rb_exc_new_str(cNokogiriXmlXpathSyntaxError, rb_message);
+  rb_ary_push(rb_errors, rb_exception);
 }
 
 /*
  * call-seq:
- *  evaluate(search_path, handler = nil)
+ *   evaluate(search_path, handler = nil) → Object
  *
- * Evaluate the +search_path+ returning an XML::XPath object.
+ * Evaluate the +search_path+ query.
+ *
+ * [Returns] an object of the appropriate type for the query, which could be +NodeSet+, a +String+,
+ * a +Float+, or a boolean.
  */
-static VALUE evaluate(int argc, VALUE *argv, VALUE self)
+static VALUE
+rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
 {
   VALUE search_path, xpath_handler;
-  VALUE thing = Qnil;
-  xmlXPathContextPtr ctx;
+  VALUE retval = Qnil;
+  xmlXPathContextPtr c_context;
   xmlXPathObjectPtr xpath;
   xmlChar *query;
+  VALUE errors = rb_ary_new();
 
-  Data_Get_Struct(self, xmlXPathContext, ctx);
+  TypedData_Get_Struct(
+    rb_context,
+    xmlXPathContext,
+    &xml_xpath_context_type,
+    c_context
+  );
 
-  if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+  if (rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) {
     xpath_handler = Qnil;
+  }
 
   query = (xmlChar *)StringValueCStr(search_path);
 
-  if(Qnil != xpath_handler) {
+  if (Qnil != xpath_handler) {
     /* FIXME: not sure if this is the correct place to shove private data. */
-    ctx->userData = (void *)xpath_handler;
-    xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
+    c_context->userData = (void *)xpath_handler;
+    xmlXPathRegisterFuncLookup(
+      c_context,
+      handler_lookup,
+      (void *)xpath_handler
+    );
   }
 
-  xmlResetLastError();
-  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_raise);
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
 
-  /* For some reason, xmlXPathEvalExpression will blow up with a generic error */
-  /* when there is a non existent function. */
-  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+  xpath = xmlXPathEvalExpression(query, c_context);
 
-  xpath = xmlXPathEvalExpression(query, ctx);
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
-  if(xpath == NULL) {
-    xmlErrorPtr error = xmlGetLastError();
-    rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
+  if (xpath == NULL) {
+    rb_exc_raise(rb_ary_entry(errors, 0));
   }
 
-  assert(ctx->doc);
-  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
-
-  switch(xpath->type) {
-    case XPATH_STRING:
-      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
-      xmlFree(xpath->stringval);
-      break;
-    case XPATH_NODESET:
-      thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval,
-                                         DOC_RUBY_OBJECT(ctx->doc));
-      break;
-    case XPATH_NUMBER:
-      thing = rb_float_new(xpath->floatval);
-      break;
-    case XPATH_BOOLEAN:
-      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
-      break;
-    default:
-      thing = Nokogiri_wrap_xml_node_set(NULL, DOC_RUBY_OBJECT(ctx->doc));
+  retval = xpath2ruby(xpath, c_context);
+  if (retval == Qundef) {
+    retval = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(c_context->doc));
   }
 
   xmlXPathFreeNodeSetList(xpath);
 
-  return thing;
+  return retval;
 }
 
 /*
  * call-seq:
- *  new(node)
+ *   new(node)
  *
- * Create a new XPathContext with +node+ as the reference point.
+ * Create a new XPathContext with +node+ as the context node.
  */
-static VALUE new(VALUE klass, VALUE nodeobj)
+static VALUE
+rb_xml_xpath_context_new(VALUE klass, VALUE rb_node)
 {
   xmlNodePtr node;
-  xmlXPathContextPtr ctx;
-  VALUE self;
+  xmlXPathContextPtr c_context;
+  VALUE rb_context;
 
-  xmlXPathInit();
+  Noko_Node_Get_Struct(rb_node, xmlNode, node);
 
-  Data_Get_Struct(nodeobj, xmlNode, node);
+#if LIBXML_VERSION < 21000
+  /* deprecated in 40483d0 */
+  xmlXPathInit();
+#endif
+
+  c_context = xmlXPathNewContext(node->doc);
+  c_context->node = node;
+
+  xmlXPathRegisterNs(c_context, NOKOGIRI_PREFIX, NOKOGIRI_URI);
+  xmlXPathRegisterNs(c_context, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
+  xmlXPathRegisterFuncNS(
+    c_context,
+    (const xmlChar *)"css-class",
+    NOKOGIRI_BUILTIN_URI,
+    xpath_builtin_css_class
+  );
+  xmlXPathRegisterFuncNS(
+    c_context,
+    (const xmlChar *)"local-name-is",
+    NOKOGIRI_BUILTIN_URI,
+    xpath_builtin_local_name_is
+  );
 
-  ctx = xmlXPathNewContext(node->doc);
-  ctx->node = node;
-  self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
-  /*rb_iv_set(self, "@xpath_handler", Qnil); */
-  return self;
+  rb_context = TypedData_Wrap_Struct(
+                 klass,
+                 &xml_xpath_context_type,
+                 c_context
+               );
+  return rb_context;
 }
 
-VALUE cNokogiriXmlXpathContext;
-void init_xml_xpath_context(void)
+void
+noko_init_xml_xpath_context(void)
 {
-  VALUE module = rb_define_module("Nokogiri");
-
   /*
-   * Nokogiri::XML
+   * XPathContext is the entry point for searching a +Document+ by using XPath.
    */
-  VALUE xml = rb_define_module_under(module, "XML");
+  cNokogiriXmlXpathContext = rb_define_class_under(mNokogiriXml, "XPathContext", rb_cObject);
 
-  /*
-   * XPathContext is the entry point for searching a Document by using XPath.
-   */
-  VALUE klass = rb_define_class_under(xml, "XPathContext", rb_cObject);
+  rb_undef_alloc_func(cNokogiriXmlXpathContext);
 
-  cNokogiriXmlXpathContext = klass;
+  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", rb_xml_xpath_context_new, 1);
 
-  rb_define_singleton_method(klass, "new", new, 1);
-  rb_define_method(klass, "evaluate", evaluate, -1);
-  rb_define_method(klass, "register_variable", register_variable, 2);
-  rb_define_method(klass, "register_ns", register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "evaluate", rb_xml_xpath_context_evaluate, -1);
+  rb_define_method(cNokogiriXmlXpathContext, "register_variable", rb_xml_xpath_context_register_variable, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "register_ns", rb_xml_xpath_context_register_ns, 2);
 }