nokolexbor 0.2.5 → 0.3.1

data/ext/nokolexbor/nl_node_set.c

@@ -6,7 +6,7 @@ VALUE cNokolexborNodeSet;
 extern rb_data_type_t nl_document_type;
 
 lxb_status_t nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx);
-void sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_array_t *array);
+void nl_sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_array_t *array);
 lxb_status_t nl_node_at_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx);
 lxb_status_t nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx);
 
@@ -55,8 +55,7 @@ nl_node_set_allocate(VALUE klass)
 VALUE
 nl_rb_node_set_create_with_data(lexbor_array_t *array, VALUE rb_document)
 {
-  if (array == NULL)
-  {
+  if (array == NULL) {
     array = lexbor_array_create();
   }
   VALUE ret = TypedData_Wrap_Struct(cNokolexborNodeSet, &nl_node_set_type, array);
@@ -77,8 +76,7 @@ nl_node_set_push(VALUE self, VALUE rb_node)
   lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
 
   lxb_status_t status = lexbor_array_push_unique(array, node);
-  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED)
-  {
+  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED) {
     nl_raise_lexbor_error(status);
   }
 
@@ -93,13 +91,11 @@ nl_node_set_delete(VALUE self, VALUE rb_node)
 
   size_t i;
   for (i = 0; i < array->length; i++)
-    if (array->list[i] == node)
-    {
+    if (array->list[i] == node) {
       break;
     }
 
-  if (i >= array->length)
-  {
+  if (i >= array->length) {
     // not found
     return Qnil;
   }
@@ -114,8 +110,7 @@ nl_node_set_is_include(VALUE self, VALUE rb_node)
   lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
 
   for (size_t i = 0; i < array->length; i++)
-    if (array->list[i] == node)
-    {
+    if (array->list[i] == node) {
       return Qtrue;
     }
 
@@ -126,13 +121,11 @@ static VALUE
 nl_node_set_index_at(VALUE self, long offset)
 {
   lexbor_array_t *array = nl_rb_node_set_unwrap(self);
-  if (offset >= (long)array->length || abs((int)offset) > (long)array->length)
-  {
+  if (offset >= (long)array->length || abs((int)offset) > (long)array->length) {
     return Qnil;
   }
 
-  if (offset < 0)
-  {
+  if (offset < 0) {
     offset += array->length;
   }
 
@@ -145,35 +138,28 @@ nl_node_set_subseq(VALUE self, long beg, long len)
 {
   lexbor_array_t *old_array = nl_rb_node_set_unwrap(self);
 
-  if (beg > (long)old_array->length)
-  {
+  if (beg > (long)old_array->length) {
     return Qnil;
   }
-  if (beg < 0 || len < 0)
-  {
+  if (beg < 0 || len < 0) {
     return Qnil;
   }
 
-  if ((beg + len) > (long)old_array->length)
-  {
+  if ((beg + len) > (long)old_array->length) {
     len = old_array->length - beg;
   }
 
   lexbor_array_t *new_array = lexbor_array_create();
-  if (len > 0)
-  {
+  if (len > 0) {
     lxb_status_t status = lexbor_array_init(new_array, len);
-    if (status != LXB_STATUS_OK)
-    {
+    if (status != LXB_STATUS_OK) {
       nl_raise_lexbor_error(status);
     }
   }
 
-  for (long j = beg; j < beg + len; ++j)
-  {
+  for (long j = beg; j < beg + len; ++j) {
     lxb_status_t status = lexbor_array_push(new_array, old_array->list[j]);
-    if (status != LXB_STATUS_OK)
-    {
+    if (status != LXB_STATUS_OK) {
       nl_raise_lexbor_error(status);
     }
   }
@@ -188,31 +174,26 @@ nl_node_set_slice(int argc, VALUE *argv, VALUE self)
 
   lexbor_array_t *array = nl_rb_node_set_unwrap(self);
 
-  if (argc == 2)
-  {
+  if (argc == 2) {
     beg = NUM2LONG(argv[0]);
     len = NUM2LONG(argv[1]);
-    if (beg < 0)
-    {
+    if (beg < 0) {
       beg += array->length;
     }
     return nl_node_set_subseq(self, beg, len);
   }
 
-  if (argc != 1)
-  {
+  if (argc != 1) {
     rb_scan_args(argc, argv, "11", NULL, NULL);
   }
   arg = argv[0];
 
-  if (FIXNUM_P(arg))
-  {
+  if (FIXNUM_P(arg)) {
     return nl_node_set_index_at(self, FIX2LONG(arg));
   }
 
   /* if arg is Range */
-  switch (rb_range_beg_len(arg, &beg, &len, array->length, 0))
-  {
+  switch (rb_range_beg_len(arg, &beg, &len, array->length, 0)) {
   case Qfalse:
     break;
   case Qnil:
@@ -231,8 +212,7 @@ nl_node_set_to_array(VALUE self)
 
   VALUE list = rb_ary_new2(array->length);
   VALUE doc = nl_rb_document_get(self);
-  for (size_t i = 0; i < array->length; i++)
-  {
+  for (size_t i = 0; i < array->length; i++) {
     lxb_dom_node_t *node = (lxb_dom_node_t *)array->list[i];
     VALUE rb_node = nl_rb_node_create(node, doc);
     rb_ary_push(list, rb_node);
@@ -244,31 +224,27 @@ nl_node_set_to_array(VALUE self)
 static VALUE
 nl_node_set_union(VALUE self, VALUE other)
 {
-  if (!rb_obj_is_kind_of(other, cNokolexborNodeSet))
-  {
+  if (!rb_obj_is_kind_of(other, cNokolexborNodeSet)) {
     rb_raise(rb_eArgError, "Parameter must be a Nokolexbor::NodeSet");
   }
 
   lexbor_array_t *self_array = nl_rb_node_set_unwrap(self);
   lexbor_array_t *other_array = nl_rb_node_set_unwrap(other);
 
-  if (self_array->length + other_array->length == 0)
-  {
+  if (self_array->length + other_array->length == 0) {
     return nl_rb_node_set_create_with_data(NULL, nl_rb_document_get(self));
   }
 
   lexbor_array_t *new_array = lexbor_array_create();
   lxb_status_t status = lexbor_array_init(new_array, self_array->length + other_array->length);
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     nl_raise_lexbor_error(status);
   }
 
   memcpy(new_array->list, self_array->list, sizeof(lxb_dom_node_t *) * self_array->length);
   new_array->length = self_array->length;
 
-  for (size_t i = 0; i < other_array->length; i++)
-  {
+  for (size_t i = 0; i < other_array->length; i++) {
     lexbor_array_push_unique(new_array, other_array->list[i]);
   }
 
@@ -279,40 +255,33 @@ static lxb_status_t
 nl_node_set_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 {
   lxb_dom_document_t *doc = nl_rb_document_unwrap(nl_rb_document_get(self));
-  if (doc == NULL)
-  {
+  if (doc == NULL) {
     rb_raise(rb_eRuntimeError, "Error getting document");
   }
   // Wrap direct children with a temporary fragment so that they can be searched
   lxb_dom_document_fragment_t *frag = lxb_dom_document_fragment_interface_create(doc);
-  if (frag == NULL)
-  {
+  if (frag == NULL) {
     rb_raise(rb_eRuntimeError, "Error creating document fragment");
   }
   lexbor_array_t *array = nl_rb_node_set_unwrap(self);
 
   lexbor_array_t *backup_array = lexbor_array_create();
-  if (array->length > 0)
-  {
+  if (array->length > 0) {
     lxb_status_t status = lexbor_array_init(backup_array, array->length);
-    if (status != LXB_STATUS_OK)
-    {
+    if (status != LXB_STATUS_OK) {
       nl_raise_lexbor_error(status);
     }
   }
   // Backup original node data and re-group them into a fragment
-  for (size_t i = 0; i < array->length; i++)
-  {
+  for (size_t i = 0; i < array->length; i++) {
     lxb_dom_node_t *node = (lxb_dom_node_t *)array->list[i];
     lxb_dom_node_t *backup_node = malloc(sizeof(lxb_dom_node_t));
-    if (backup_node == NULL)
-    {
+    if (backup_node == NULL) {
       nl_raise_lexbor_error(LXB_STATUS_ERROR_MEMORY_ALLOCATION);
     }
     memcpy(backup_node, node, sizeof(lxb_dom_node_t));
     lxb_status_t status = lexbor_array_push(backup_array, backup_node);
-    if (status != LXB_STATUS_OK)
-    {
+    if (status != LXB_STATUS_OK) {
       nl_raise_lexbor_error(LXB_STATUS_ERROR_MEMORY_ALLOCATION);
     }
     lxb_dom_node_insert_child(&frag->node, node);
@@ -323,8 +292,7 @@ nl_node_set_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 
   lxb_dom_document_fragment_interface_destroy(frag);
   // Restore original node data
-  for (size_t i = 0; i < array->length; i++)
-  {
+  for (size_t i = 0; i < array->length; i++) {
     memcpy(array->list[i], backup_array->list[i], sizeof(lxb_dom_node_t));
     free(backup_array->list[i]);
   }
@@ -341,19 +309,17 @@ nl_node_set_at_css(VALUE self, VALUE selector)
 
   lxb_status_t status = nl_node_set_find(self, selector, nl_node_at_css_callback, array);
 
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     lexbor_array_destroy(array, true);
     nl_raise_lexbor_error(status);
   }
 
-  if (array->length == 0)
-  {
+  if (array->length == 0) {
     lexbor_array_destroy(array, true);
     return Qnil;
   }
 
-  sort_nodes_if_necessary(selector, doc, array);
+  nl_sort_nodes_if_necessary(selector, doc, array);
 
   VALUE ret = nl_rb_node_create(array->list[0], nl_rb_document_get(self));
 
@@ -369,13 +335,12 @@ nl_node_set_css(VALUE self, VALUE selector)
   lxb_dom_document_t *doc = nl_rb_document_unwrap(nl_rb_document_get(self));
 
   lxb_status_t status = nl_node_set_find(self, selector, nl_node_css_callback, array);
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     lexbor_array_destroy(array, true);
     nl_raise_lexbor_error(status);
   }
 
-  sort_nodes_if_necessary(selector, doc, array);
+  nl_sort_nodes_if_necessary(selector, doc, array);
 
   return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
 }

data/ext/nokolexbor/nl_text.c

@@ -0,0 +1,44 @@
+#include "nokolexbor.h"
+
+VALUE cNokolexborText;
+extern VALUE cNokolexborCharacterData;
+extern VALUE mNokolexbor;
+
+static VALUE
+nl_text_new(int argc, VALUE *argv, VALUE klass)
+{
+  lxb_dom_document_t *document;
+  VALUE rb_text;
+  VALUE rb_document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &rb_text, &rb_document, &rest);
+
+  if (!rb_obj_is_kind_of(rb_document, cNokolexborDocument)) {
+    rb_raise(rb_eArgError, "Document must be a Nokolexbor::Document");
+  }
+
+  document = nl_rb_document_unwrap(rb_document);
+
+  const char* c_text = StringValuePtr(rb_text);
+  size_t text_len = RSTRING_LEN(rb_text);
+  lxb_dom_text_t *element = lxb_dom_document_create_text_node(document, (const lxb_char_t *)c_text, text_len);
+  if (element == NULL) {
+    rb_raise(rb_eRuntimeError, "Error creating text node");
+  }
+
+  VALUE rb_node = nl_rb_node_create(&element->char_data.node, rb_document);
+
+  if (rb_block_given_p()) {
+    rb_yield(rb_node);
+  }
+
+  return rb_node;
+}
+
+void Init_nl_text(void)
+{
+  cNokolexborText = rb_define_class_under(mNokolexbor, "Text", cNokolexborCharacterData);
+
+  rb_define_singleton_method(cNokolexborText, "new", nl_text_new, -1);
+}

data/ext/nokolexbor/nl_xpath_context.c

@@ -1,11 +1,11 @@
-#include <ruby.h>
-#include <ruby/util.h>
-#include "nokolexbor.h"
 #include "libxml.h"
 #include "libxml/globals.h"
+#include "libxml/parserInternals.h"
 #include "libxml/xpath.h"
 #include "libxml/xpathInternals.h"
-#include "libxml/parserInternals.h"
+#include "nokolexbor.h"
+#include <ruby.h>
+#include <ruby/util.h>
 
 #define RBSTR_OR_QNIL(_str) (_str ? rb_utf8_str_new_cstr(_str) : Qnil)
 
@@ -18,7 +18,7 @@ VALUE cNokolexborXpathSyntaxError;
 static void
 free_xml_xpath_context(xmlXPathContextPtr ctx)
 {
-  xmlXPathFreeContext(ctx);
+  nl_xmlXPathFreeContext(ctx);
 }
 
 /*
@@ -33,9 +33,9 @@ nl_xpath_context_register_ns(VALUE self, VALUE prefix, VALUE uri)
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
-  xmlXPathRegisterNs(ctx,
-                     (const xmlChar *)StringValueCStr(prefix),
-                     (const xmlChar *)StringValueCStr(uri));
+  nl_xmlXPathRegisterNs(ctx,
+                        (const xmlChar *)StringValueCStr(prefix),
+                        (const xmlChar *)StringValueCStr(uri));
   return self;
 }
 
@@ -52,11 +52,11 @@ nl_xpath_context_register_variable(VALUE self, VALUE name, VALUE value)
   xmlXPathObjectPtr xmlValue;
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
-  xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  xmlValue = nl_xmlXPathNewCString(StringValueCStr(value));
 
-  xmlXPathRegisterVariable(ctx,
-                           (const xmlChar *)StringValueCStr(name),
-                           xmlValue);
+  nl_xmlXPathRegisterVariable(ctx,
+                              (const xmlChar *)StringValueCStr(name),
+                              xmlValue);
 
   return self;
 }
@@ -70,28 +70,23 @@ xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr ctx, VALUE rb_do
 {
   VALUE rb_retval;
 
-  switch (c_xpath_object->type)
-  {
+  switch (c_xpath_object->type) {
   case XPATH_STRING:
     rb_retval = rb_utf8_str_new_cstr((const char *)c_xpath_object->stringval);
-    xmlFree(c_xpath_object->stringval);
+    nl_xmlFree(c_xpath_object->stringval);
     return rb_retval;
 
-  case XPATH_NODESET:
-  {
-    if (c_xpath_object->nodesetval == NULL)
-    {
+  case XPATH_NODESET: {
+    if (c_xpath_object->nodesetval == NULL) {
       return nl_rb_node_set_create_with_data(NULL, rb_document);
     }
-    if (c_xpath_object->nodesetval->nodeNr == 0)
-    {
+    if (c_xpath_object->nodesetval->nodeNr == 0) {
       return nl_rb_node_set_create_with_data(NULL, rb_document);
     }
 
     lexbor_array_t *array = lexbor_array_create();
     lxb_status_t status = lexbor_array_init(array, c_xpath_object->nodesetval->nodeNr);
-    if (status != LXB_STATUS_OK)
-    {
+    if (status != LXB_STATUS_OK) {
       nl_raise_lexbor_error(status);
     }
     memcpy(array->list, c_xpath_object->nodesetval->nodeTab, sizeof(lxb_dom_node_t *) * c_xpath_object->nodesetval->nodeNr);
@@ -122,8 +117,7 @@ nl_xpath_wrap_syntax_error(xmlErrorPtr error)
       &msg,
       cNokolexborXpathSyntaxError);
 
-  if (error)
-  {
+  if (error) {
     rb_iv_set(e, "@domain", INT2NUM(error->domain));
     rb_iv_set(e, "@code", INT2NUM(error->code));
     rb_iv_set(e, "@level", INT2NUM((short)error->level));
@@ -182,8 +176,7 @@ nl_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
-  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;
   }
 
@@ -192,30 +185,28 @@ nl_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
   // if (Qnil != xpath_handler) {
   //   /* FIXME: not sure if this is the correct place to shove private data. */
   //   ctx->userData = (void *)xpath_handler;
-  //   xmlXPathRegisterFuncLookup(ctx, handler_lookup, (void *)xpath_handler);
+  //   nl_xmlXPathRegisterFuncLookup(ctx, handler_lookup, (void *)xpath_handler);
   // }
 
-  xmlSetStructuredErrorFunc((void *)errors, nl_xpath_error_array_pusher);
-  xmlSetGenericErrorFunc((void *)errors, nl_xpath_generic_exception_pusher);
+  nl_xmlSetStructuredErrorFunc((void *)errors, nl_xpath_error_array_pusher);
+  nl_xmlSetGenericErrorFunc((void *)errors, nl_xpath_generic_exception_pusher);
 
-  xpath = xmlXPathEvalExpression(query, ctx);
+  xpath = nl_xmlXPathEvalExpression(query, ctx);
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlSetGenericErrorFunc(NULL, NULL);
+  nl_xmlSetStructuredErrorFunc(NULL, NULL);
+  nl_xmlSetGenericErrorFunc(NULL, NULL);
 
-  if (xpath == NULL)
-  {
-    xmlXPathFreeObject(xpath);
+  if (xpath == NULL) {
+    nl_xmlXPathFreeObject(xpath);
     rb_exc_raise(rb_ary_entry(errors, 0));
   }
 
   retval = xpath2ruby(xpath, ctx, nl_rb_document_get(self));
-  if (retval == Qundef)
-  {
+  if (retval == Qundef) {
     retval = rb_funcall(cNokolexborNodeSet, rb_intern("new"), 1, rb_ary_new());
   }
 
-  xmlXPathFreeObject(xpath);
+  nl_xmlXPathFreeObject(xpath);
 
   return retval;
 }
@@ -234,7 +225,7 @@ nl_xpath_context_new(VALUE klass, VALUE rb_node)
 
   lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
 
-  ctx = xmlXPathNewContext(node->owner_document);
+  ctx = nl_xmlXPathNewContext(node->owner_document);
   ctx->node = node;
 
   self = Data_Wrap_Struct(klass, 0, free_xml_xpath_context, ctx);
@@ -246,9 +237,9 @@ nl_xpath_context_new(VALUE klass, VALUE rb_node)
 void Init_nl_xpath_context(void)
 {
 #ifndef NOKOLEXBOR_ASAN
-  xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+  nl_xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
 #else
-  xmlMemSetup((xmlFreeFunc)free, (xmlMallocFunc)malloc, (xmlReallocFunc)realloc, strdup);
+  nl_xmlMemSetup((xmlFreeFunc)free, (xmlMallocFunc)malloc, (xmlReallocFunc)realloc, strdup);
 #endif
 
   cNokolexborXpathContext = rb_define_class_under(mNokolexbor, "XPathContext", rb_cObject);

data/ext/nokolexbor/nokolexbor.c

@@ -2,11 +2,11 @@
 
 VALUE mNokolexbor;
 VALUE eLexborError;
+VALUE eLexborSyntaxError;
 
 void nl_raise_lexbor_error(lxb_status_t error)
 {
-  switch (error)
-  {
+  switch (error) {
   case LXB_STATUS_ERROR:
     rb_raise(eLexborError, "LXB_STATUS_ERROR");
   case LXB_STATUS_ERROR_MEMORY_ALLOCATION:
@@ -30,7 +30,7 @@ void nl_raise_lexbor_error(lxb_status_t error)
   case LXB_STATUS_ERROR_UNEXPECTED_RESULT:
     rb_raise(eLexborError, "LXB_STATUS_ERROR_UNEXPECTED_RESULT");
   case LXB_STATUS_ERROR_UNEXPECTED_DATA:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_UNEXPECTED_DATA");
+    rb_raise(eLexborSyntaxError, "LXB_STATUS_ERROR_UNEXPECTED_DATA");
   case LXB_STATUS_ERROR_OVERFLOW:
     rb_raise(eLexborError, "LXB_STATUS_ERROR_OVERFLOW");
   case LXB_STATUS_CONTINUE:
@@ -56,8 +56,12 @@ void Init_nokolexbor(void)
 {
   mNokolexbor = rb_define_module("Nokolexbor");
   eLexborError = rb_define_class_under(mNokolexbor, "LexborError", rb_eStandardError);
+  eLexborSyntaxError = rb_define_class_under(mNokolexbor, "LexborSyntaxError", eLexborError);
   Init_nl_node();
   Init_nl_document();
+  Init_nl_text();
+  Init_nl_comment();
+  Init_nl_cdata();
   Init_nl_node_set();
   Init_nl_xpath_context();
 }

data/ext/nokolexbor/nokolexbor.h

@@ -3,8 +3,8 @@
 
 #include <ruby.h>
 
-#include <lexbor/html/html.h>
 #include <lexbor/css/css.h>
+#include <lexbor/html/html.h>
 #include <lexbor/selectors/selectors.h>
 
 extern VALUE cNokolexborDocument;
@@ -12,6 +12,9 @@ extern VALUE cNokolexborDocument;
 void Init_nl_document(void);
 void Init_nl_node(void);
 void Init_nl_node_set(void);
+void Init_nl_text(void);
+void Init_nl_comment(void);
+void Init_nl_cdata(void);
 void Init_nl_xpath_context(void);
 
 void nl_raise_lexbor_error(lxb_status_t error);
@@ -21,14 +24,13 @@ VALUE nl_rb_node_set_create_with_data(lexbor_array_t *array, VALUE rb_document);
 
 lxb_inline VALUE nl_rb_document_get(VALUE rb_node_or_doc)
 {
-    if (rb_obj_class(rb_node_or_doc) == cNokolexborDocument)
-    {
-        return rb_node_or_doc;
-    }
-    return rb_iv_get(rb_node_or_doc, "@document");
+  if (rb_obj_is_kind_of(rb_node_or_doc, cNokolexborDocument)) {
+    return rb_node_or_doc;
+  }
+  return rb_iv_get(rb_node_or_doc, "@document");
 }
 
-lxb_dom_document_t * nl_rb_document_unwrap(VALUE rb_doc);
+lxb_dom_document_t *nl_rb_document_unwrap(VALUE rb_doc);
 
 const lxb_char_t *
 lxb_dom_node_name_qualified(lxb_dom_node_t *node, size_t *len);

data/ext/nokolexbor/private/buf.h

@@ -43,7 +43,7 @@ xmlBufIsEmpty(const xmlBufPtr buf);
 XML_HIDDEN int
 xmlBufAddLen(xmlBufPtr buf, size_t len);
 
-/* const xmlChar * xmlBufContent(const xmlBuf *buf); */
+/* const xmlChar * nl_xmlBufContent(const xmlBuf *buf); */
 /* const xmlChar * xmlBufEnd(xmlBufPtr buf); */
 
 XML_HIDDEN xmlChar *

data/ext/nokolexbor/private/error.h

@@ -5,17 +5,17 @@
 #include "libxml/xmlversion.h"
 
 XML_HIDDEN void
-__xmlRaiseError(xmlStructuredErrorFunc schannel,
+__nl_xmlRaiseError(xmlStructuredErrorFunc schannel,
                 xmlGenericErrorFunc channel, void *data, void *ctx,
                 void *nod, int domain, int code, xmlErrorLevel level,
                 const char *file, int line, const char *str1,
                 const char *str2, const char *str3, int int1, int col,
 	        const char *msg, ...) LIBXML_ATTR_FORMAT(16,17);
 XML_HIDDEN void
-__xmlSimpleError(int domain, int code, lxb_dom_node_t_ptr node,
+__nl_xmlSimpleError(int domain, int code, lxb_dom_node_t_ptr node,
                  const char *msg, const char *extra) LIBXML_ATTR_FORMAT(4,0);
 XML_HIDDEN void
-xmlGenericErrorDefaultFunc(void *ctx, const char *msg,
+nl_xmlGenericErrorDefaultFunc(void *ctx, const char *msg,
                            ...) LIBXML_ATTR_FORMAT(2,3);
 
 #endif /* XML_ERROR_H_PRIVATE__ */

data/ext/nokolexbor/xml_SAX2.c

@@ -16,7 +16,7 @@
 #include "libxml/globals.h"
 
 /**
- * xmlSAX2GetPublicId:
+ * nl_xmlSAX2GetPublicId:
  * @ctx: the user data (XML parser context)
  *
  * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
@@ -24,14 +24,14 @@
  * Returns a xmlChar *
  */
 const xmlChar *
-xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
+nl_xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
 {
     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
     return(NULL);
 }
 
 /**
- * xmlSAX2GetSystemId:
+ * nl_xmlSAX2GetSystemId:
  * @ctx: the user data (XML parser context)
  *
  * Provides the system ID, basically URL or filename e.g.
@@ -40,7 +40,7 @@ xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
  * Returns a xmlChar *
  */
 const xmlChar *
-xmlSAX2GetSystemId(void *ctx)
+nl_xmlSAX2GetSystemId(void *ctx)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
@@ -48,7 +48,7 @@ xmlSAX2GetSystemId(void *ctx)
 }
 
 /**
- * xmlSAX2GetLineNumber:
+ * nl_xmlSAX2GetLineNumber:
  * @ctx: the user data (XML parser context)
  *
  * Provide the line number of the current parsing point.
@@ -56,7 +56,7 @@ xmlSAX2GetSystemId(void *ctx)
  * Returns an int
  */
 int
-xmlSAX2GetLineNumber(void *ctx)
+nl_xmlSAX2GetLineNumber(void *ctx)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
@@ -64,7 +64,7 @@ xmlSAX2GetLineNumber(void *ctx)
 }
 
 /**
- * xmlSAX2GetColumnNumber:
+ * nl_xmlSAX2GetColumnNumber:
  * @ctx: the user data (XML parser context)
  *
  * Provide the column number of the current parsing point.
@@ -72,7 +72,7 @@ xmlSAX2GetLineNumber(void *ctx)
  * Returns an int
  */
 int
-xmlSAX2GetColumnNumber(void *ctx)
+nl_xmlSAX2GetColumnNumber(void *ctx)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     if ((ctx == NULL) || (ctxt->input == NULL)) return(0);