nokolexbor 0.2.0

data/ext/nokolexbor/nl_node_set.c

@@ -0,0 +1,368 @@
+#include "nokolexbor.h"
+
+extern VALUE mNokolexbor;
+extern VALUE cNokolexborNode;
+VALUE cNokolexborNodeSet;
+extern rb_data_type_t nl_document_type;
+
+VALUE nl_node_at_css(VALUE self, VALUE selector);
+VALUE nl_node_css(VALUE self, VALUE selector);
+
+typedef VALUE (*nl_node_find_f)(VALUE self, VALUE selector);
+
+lxb_status_t
+lexbor_array_push_unique(lexbor_array_t *array, void *value)
+{
+  for (int i = 0; i < array->length; i++)
+    if (array->list[i] == value)
+      return LXB_STATUS_STOPPED;
+
+  return lexbor_array_push(array, value);
+}
+
+static void
+free_nl_node_set(lexbor_array_t *array)
+{
+  lexbor_array_destroy(array, true);
+}
+
+const rb_data_type_t nl_node_set_type = {
+    "Nokolexbor::NodeSet",
+    {
+        0,
+        free_nl_node_set,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+lexbor_array_t *
+nl_rb_node_set_unwrap(VALUE rb_node_set)
+{
+  lexbor_array_t *array;
+  TypedData_Get_Struct(rb_node_set, lexbor_array_t, &nl_node_set_type, array);
+  return array;
+}
+
+static VALUE
+nl_node_set_allocate(VALUE klass)
+{
+  lexbor_array_t *array = lexbor_array_create();
+  return TypedData_Wrap_Struct(cNokolexborNodeSet, &nl_node_set_type, array);
+}
+
+VALUE
+nl_rb_node_set_create_with_data(lexbor_array_t *array, VALUE rb_document)
+{
+  if (array == NULL)
+  {
+    array = lexbor_array_create();
+  }
+  VALUE ret = TypedData_Wrap_Struct(cNokolexborNodeSet, &nl_node_set_type, array);
+  rb_iv_set(ret, "@document", rb_document);
+  return ret;
+}
+
+static VALUE
+nl_node_set_length(VALUE self)
+{
+  return INT2NUM(nl_rb_node_set_unwrap(self)->length);
+}
+
+static VALUE
+nl_node_set_push(VALUE self, VALUE rb_node)
+{
+  lexbor_array_t *array = nl_rb_node_set_unwrap(self);
+  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)
+  {
+    nl_raise_lexbor_error(status);
+  }
+
+  return self;
+}
+
+static VALUE
+nl_node_set_delete(VALUE self, VALUE rb_node)
+{
+  lexbor_array_t *array = nl_rb_node_set_unwrap(self);
+  lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
+
+  int i;
+  for (i = 0; i < array->length; i++)
+    if (array->list[i] == node)
+    {
+      break;
+    }
+
+  if (i >= array->length)
+  {
+    // not found
+    return Qnil;
+  }
+  lexbor_array_delete(array, i, 1);
+  return rb_node;
+}
+
+static VALUE
+nl_node_set_is_include(VALUE self, VALUE rb_node)
+{
+  lexbor_array_t *array = nl_rb_node_set_unwrap(self);
+  lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
+
+  for (int i = 0; i < array->length; i++)
+    if (array->list[i] == node)
+    {
+      return Qtrue;
+    }
+
+  return Qfalse;
+}
+
+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)
+  {
+    return Qnil;
+  }
+
+  if (offset < 0)
+  {
+    offset += array->length;
+  }
+
+  lxb_dom_node_t *node = lexbor_array_get(array, offset);
+  return nl_rb_node_create(node, nl_rb_document_get(self));
+}
+
+static VALUE
+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)
+  {
+    return Qnil;
+  }
+  if (beg < 0 || len < 0)
+  {
+    return Qnil;
+  }
+
+  if ((beg + len) > (long)old_array->length)
+  {
+    len = old_array->length - beg;
+  }
+
+  lexbor_array_t *new_array = lexbor_array_create();
+  if (len > 0)
+  {
+    lxb_status_t status = lexbor_array_init(new_array, len);
+    if (status != LXB_STATUS_OK)
+    {
+      nl_raise_lexbor_error(status);
+    }
+  }
+
+  for (int j = beg; j < beg + len; ++j)
+  {
+    lxb_status_t status = lexbor_array_push(new_array, old_array->list[j]);
+    if (status != LXB_STATUS_OK)
+    {
+      nl_raise_lexbor_error(status);
+    }
+  }
+  return TypedData_Wrap_Struct(cNokolexborNodeSet, &nl_node_set_type, new_array);
+}
+
+static VALUE
+nl_node_set_slice(int argc, VALUE *argv, VALUE self)
+{
+  VALUE arg;
+  long beg, len;
+
+  lexbor_array_t *array = nl_rb_node_set_unwrap(self);
+
+  if (argc == 2)
+  {
+    beg = NUM2LONG(argv[0]);
+    len = NUM2LONG(argv[1]);
+    if (beg < 0)
+    {
+      beg += array->length;
+    }
+    return nl_node_set_subseq(self, beg, len);
+  }
+
+  if (argc != 1)
+  {
+    rb_scan_args(argc, argv, "11", NULL, NULL);
+  }
+  arg = argv[0];
+
+  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))
+  {
+  case Qfalse:
+    break;
+  case Qnil:
+    return Qnil;
+  default:
+    return nl_node_set_subseq(self, beg, len);
+  }
+
+  return nl_node_set_index_at(self, NUM2LONG(arg));
+}
+
+static VALUE
+nl_node_set_to_array(VALUE self)
+{
+  lexbor_array_t *array = nl_rb_node_set_unwrap(self);
+
+  VALUE list = rb_ary_new2(array->length);
+  VALUE doc = nl_rb_document_get(self);
+  for (int 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);
+  }
+
+  return list;
+}
+
+static VALUE
+nl_node_set_union(VALUE self, VALUE other)
+{
+  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)
+  {
+    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)
+  {
+    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 (int i = 0; i < other_array->length; i++)
+  {
+    lexbor_array_push_unique(new_array, other_array->list[i]);
+  }
+
+  return nl_rb_node_set_create_with_data(new_array, nl_rb_document_get(self));
+}
+
+static VALUE
+nl_node_set_find(VALUE self, VALUE selector, nl_node_find_f finder)
+{
+  VALUE rb_doc = nl_rb_document_get(self);
+  lxb_dom_document_t *doc;
+  TypedData_Get_Struct(rb_doc, lxb_dom_document_t, &nl_document_type, doc);
+  if (doc == NULL)
+  {
+    rb_raise(rb_eRuntimeError, "Error getting document");
+  }
+  lxb_dom_document_fragment_t *frag = lxb_dom_document_fragment_interface_create(doc);
+  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)
+  {
+    lxb_status_t status = lexbor_array_init(backup_array, array->length);
+    if (status != LXB_STATUS_OK)
+    {
+      nl_raise_lexbor_error(status);
+    }
+  }
+  // Backup original node data and re-group them into a fragment
+  for (int 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)
+    {
+      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)
+    {
+      nl_raise_lexbor_error(LXB_STATUS_ERROR_MEMORY_ALLOCATION);
+    }
+    lxb_dom_node_insert_child(&frag->node, node);
+  }
+  VALUE rb_frag = nl_rb_node_create(&frag->node, nl_rb_document_get(self));
+
+  VALUE ret = finder(rb_frag, selector);
+
+  lxb_dom_document_fragment_interface_destroy(frag);
+  // Restore original node data
+  for (int i = 0; i < array->length; i++)
+  {
+    memcpy(array->list[i], backup_array->list[i], sizeof(lxb_dom_node_t));
+    free(backup_array->list[i]);
+  }
+  lexbor_array_destroy(backup_array, true);
+  return ret;
+}
+
+static VALUE
+nl_node_set_at_css(VALUE self, VALUE selector)
+{
+  return nl_node_set_find(self, selector, nl_node_at_css);
+}
+
+static VALUE
+nl_node_set_css(VALUE self, VALUE selector)
+{
+  return nl_node_set_find(self, selector, nl_node_css);
+}
+
+void Init_nl_node_set(void)
+{
+  cNokolexborNodeSet = rb_define_class_under(mNokolexbor, "NodeSet", cNokolexborNode);
+
+  rb_define_alloc_func(cNokolexborNodeSet, nl_node_set_allocate);
+
+  rb_define_method(cNokolexborNodeSet, "length", nl_node_set_length, 0);
+  rb_define_method(cNokolexborNodeSet, "[]", nl_node_set_slice, -1);
+  rb_define_method(cNokolexborNodeSet, "slice", nl_node_set_slice, -1);
+  rb_define_method(cNokolexborNodeSet, "push", nl_node_set_push, 1);
+  rb_define_method(cNokolexborNodeSet, "|", nl_node_set_union, 1);
+  rb_define_method(cNokolexborNodeSet, "to_a", nl_node_set_to_array, 0);
+  rb_define_method(cNokolexborNodeSet, "delete", nl_node_set_delete, 1);
+  rb_define_method(cNokolexborNodeSet, "include?", nl_node_set_is_include, 1);
+  rb_define_method(cNokolexborNodeSet, "at_css", nl_node_set_at_css, 1);
+  rb_define_method(cNokolexborNodeSet, "css", nl_node_set_css, 1);
+
+  rb_define_alias(cNokolexborNodeSet, "<<", "push");
+  rb_define_alias(cNokolexborNodeSet, "size", "length");
+  rb_define_alias(cNokolexborNodeSet, "+", "|");
+}

data/ext/nokolexbor/nl_xpath_context.c

@@ -0,0 +1,200 @@
+#include <ruby.h>
+#include <ruby/util.h>
+#include "nokolexbor.h"
+#include "libxml.h"
+#include "libxml/globals.h"
+#include "libxml/xpath.h"
+#include "libxml/xpathInternals.h"
+#include "libxml/parserInternals.h"
+
+extern VALUE mNokolexbor;
+extern VALUE cNokolexborNodeSet;
+VALUE cNokoLexborXpathContext;
+
+static void
+free_xml_xpath_context(xmlXPathContextPtr ctx)
+{
+  xmlXPathFreeContext(ctx);
+}
+
+/*
+ * call-seq:
+ *  register_ns(prefix, uri)
+ *
+ * Register the namespace with +prefix+ and +uri+.
+ */
+static VALUE
+rb_xml_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));
+  return self;
+}
+
+/*
+ * call-seq:
+ *  register_variable(name, value)
+ *
+ * Register the variable +name+ with +value+.
+ */
+static VALUE
+rb_xml_xpath_context_register_variable(VALUE self, VALUE name, VALUE value)
+{
+  xmlXPathContextPtr ctx;
+  xmlXPathObjectPtr xmlValue;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  xmlValue = xmlXPathNewCString(StringValueCStr(value));
+
+  xmlXPathRegisterVariable(ctx,
+                           (const xmlChar *)StringValueCStr(name),
+                           xmlValue);
+
+  return self;
+}
+
+/*
+ *  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 ctx, VALUE rb_document)
+{
+  VALUE rb_retval;
+
+  switch (c_xpath_object->type)
+  {
+  case XPATH_STRING:
+    rb_retval = rb_utf8_str_new_cstr(c_xpath_object->stringval);
+    xmlFree(c_xpath_object->stringval);
+    return rb_retval;
+
+  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)
+    {
+      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)
+    {
+      nl_raise_lexbor_error(status);
+    }
+    memcpy(array->list, c_xpath_object->nodesetval->nodeTab, sizeof(lxb_dom_node_t *) * c_xpath_object->nodesetval->nodeNr);
+    array->length = c_xpath_object->nodesetval->nodeNr;
+    return nl_rb_node_set_create_with_data(array, rb_document);
+  }
+
+  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;
+  }
+}
+
+/*
+ * call-seq:
+ *  evaluate(search_path, handler = nil)
+ *
+ * Evaluate the +search_path+ returning an XML::XPath object.
+ */
+static VALUE
+rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
+{
+  VALUE search_path, xpath_handler;
+  VALUE retval = Qnil;
+  xmlXPathContextPtr ctx;
+  xmlXPathObjectPtr xpath;
+  xmlChar *query;
+  VALUE errors = rb_ary_new();
+
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  if (rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+  {
+    xpath_handler = Qnil;
+  }
+
+  query = (xmlChar *)StringValueCStr(search_path);
+
+  // 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);
+  // }
+
+  // xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  // xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
+
+  xpath = xmlXPathEvalExpression(query, ctx);
+
+  // xmlSetStructuredErrorFunc(NULL, NULL);
+  // xmlSetGenericErrorFunc(NULL, NULL);
+
+  if (xpath == NULL)
+  {
+    rb_exc_raise(rb_ary_entry(errors, 0));
+  }
+
+  retval = xpath2ruby(xpath, ctx, nl_rb_document_get(self));
+  if (retval == Qundef)
+  {
+    retval = rb_funcall(cNokolexborNodeSet, rb_intern("new"), 1, rb_ary_new());
+  }
+
+  // xmlXPathFreeNodeSetList(xpath);
+
+  return retval;
+}
+
+/*
+ * call-seq:
+ *  new(node)
+ *
+ * Create a new XPathContext with +node+ as the reference point.
+ */
+static VALUE
+rb_xml_xpath_context_new(VALUE klass, VALUE rb_node)
+{
+  xmlXPathContextPtr ctx;
+  VALUE self;
+
+  lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
+
+  ctx = xmlXPathNewContext(node->owner_document);
+  ctx->node = node;
+
+  self = Data_Wrap_Struct(klass, 0, free_xml_xpath_context, ctx);
+  rb_iv_set(self, "@document", rb_iv_get(rb_node, "@document"));
+
+  return self;
+}
+
+void Init_nl_xpath_context(void)
+{
+  xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+
+  cNokoLexborXpathContext = rb_define_class_under(mNokolexbor, "XPathContext", rb_cObject);
+
+  rb_undef_alloc_func(cNokoLexborXpathContext);
+
+  rb_define_singleton_method(cNokoLexborXpathContext, "new", rb_xml_xpath_context_new, 1);
+
+  rb_define_method(cNokoLexborXpathContext, "evaluate", rb_xml_xpath_context_evaluate, -1);
+  rb_define_method(cNokoLexborXpathContext, "register_variable", rb_xml_xpath_context_register_variable, 2);
+  rb_define_method(cNokoLexborXpathContext, "register_ns", rb_xml_xpath_context_register_ns, 2);
+}

data/ext/nokolexbor/nokolexbor.c

@@ -0,0 +1,63 @@
+#include "nokolexbor.h"
+
+VALUE mNokolexbor;
+VALUE eLexborError;
+
+void nl_raise_lexbor_error(lxb_status_t error)
+{
+  switch (error)
+  {
+  case LXB_STATUS_ERROR:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR");
+  case LXB_STATUS_ERROR_MEMORY_ALLOCATION:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_MEMORY_ALLOCATION");
+  case LXB_STATUS_ERROR_OBJECT_IS_NULL:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_OBJECT_IS_NULL");
+  case LXB_STATUS_ERROR_SMALL_BUFFER:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_SMALL_BUFFER");
+  case LXB_STATUS_ERROR_INCOMPLETE_OBJECT:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_INCOMPLETE_OBJECT");
+  case LXB_STATUS_ERROR_NO_FREE_SLOT:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_NO_FREE_SLOT");
+  case LXB_STATUS_ERROR_TOO_SMALL_SIZE:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_TOO_SMALL_SIZE");
+  case LXB_STATUS_ERROR_NOT_EXISTS:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_NOT_EXISTS");
+  case LXB_STATUS_ERROR_WRONG_ARGS:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_WRONG_ARGS");
+  case LXB_STATUS_ERROR_WRONG_STAGE:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_WRONG_STAGE");
+  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");
+  case LXB_STATUS_ERROR_OVERFLOW:
+    rb_raise(eLexborError, "LXB_STATUS_ERROR_OVERFLOW");
+  case LXB_STATUS_CONTINUE:
+    rb_raise(eLexborError, "LXB_STATUS_CONTINUE");
+  case LXB_STATUS_SMALL_BUFFER:
+    rb_raise(eLexborError, "LXB_STATUS_SMALL_BUFFER");
+  case LXB_STATUS_ABORTED:
+    rb_raise(eLexborError, "LXB_STATUS_ABORTED");
+  case LXB_STATUS_STOPPED:
+    rb_raise(eLexborError, "LXB_STATUS_STOPPED");
+  case LXB_STATUS_NEXT:
+    rb_raise(eLexborError, "LXB_STATUS_NEXT");
+  case LXB_STATUS_STOP:
+    rb_raise(eLexborError, "LXB_STATUS_STOP");
+  case LXB_STATUS_OK:
+    return;
+  default:
+    rb_raise(eLexborError, "LXB_ERROR_UKNOWN(%d)", error);
+  }
+}
+
+void Init_nokolexbor(void)
+{
+  mNokolexbor = rb_define_module("Nokolexbor");
+  eLexborError = rb_define_class_under(mNokolexbor, "LexborError", rb_eStandardError);
+  Init_nl_node();
+  Init_nl_document();
+  Init_nl_node_set();
+  Init_nl_xpath_context();
+}

data/ext/nokolexbor/nokolexbor.h

@@ -0,0 +1,37 @@
+#ifndef __NOKOLEXBOR_RUBY_H__
+#define __NOKOLEXBOR_RUBY_H__
+
+#include <ruby.h>
+
+#include <lexbor/html/html.h>
+#include <lexbor/css/css.h>
+#include <lexbor/selectors/selectors.h>
+
+extern VALUE cNokolexborDocument;
+
+void Init_nl_document(void);
+void Init_nl_node(void);
+void Init_nl_node_set(void);
+void Init_nl_xpath_context(void);
+
+void nl_raise_lexbor_error(lxb_status_t error);
+lxb_dom_node_t *nl_rb_node_unwrap(VALUE rb_node);
+VALUE nl_rb_node_create(lxb_dom_node_t *node, VALUE rb_document);
+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");
+}
+
+const lxb_char_t *
+lxb_dom_node_name_qualified(lxb_dom_node_t *node, size_t *len);
+
+lxb_status_t
+lexbor_array_push_unique(lexbor_array_t *array, void *value);
+
+#endif