ruby_rnv 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11b77ce5fa44a0112a7741b4ab4aa8ed452c3a3acf71eafa7d32c892e619bfe9
-  data.tar.gz: ee3066b2c467a4b62539ac5b0bb1d83de10e5400a11ef18d7c93094bbc717881
+  metadata.gz: f72e473e7924c7c3e215b53e08311afcf6781bb17a3df2842300661e86b35601
+  data.tar.gz: e513f2403d0ae91f35fde8f4b81b264a3ff16bb0a6be5f1dc80b17f3aa00ddcc
 SHA512:
-  metadata.gz: 26a579f0daef0bc13bc70102e66c9bc361bbd5ab4d043bffbf48200068357d628c31702f2178dea63e420496e0fc2b0253a61d5f4124437d24f0daa01880d0e2
-  data.tar.gz: 9d01764589fecd74ba7c27114dc351dcb1eaddb1b69d86f9a4c0f2fa60e009917a29f5107b861d81065e6bd142d55c1758dc864199dcfaf9835a84a33d682e28
+  metadata.gz: b0ce856ca07f203e0a0a4307943a113ff703e5a32031946e463496d485b49bafbeeb42a9057b3d697a92a00294c5d79c29b6bc7be62565dc75a910f16b4c1dbf
+  data.tar.gz: 3a5028a2bf2d558a9a7501336fe190a994dc867dd9eef83fcf9ce38ff481f6c1743f77e9d5f604ee9f3d07e95840bf7d79870b163fabf9f866e7c122e40f570b

data/ext/rnv/extconf.rb

@@ -3,7 +3,7 @@ require 'mkmf'
 CONFIG['warnflags'].gsub!(/-W.* /, '')
 
 $srcs = %w{src/rn.c src/rnc.c src/rnd.c src/rnl.c src/rnv.c src/rnx.c src/drv.c src/ary.c src/xsd.c src/xsd_tm.c
-src/sc.c src/u.c src/ht.c src/er.c src/xmlc.c src/s.c src/m.c src/rx.c ruby_rnv.c}
+src/sc.c src/u.c src/ht.c src/er.c src/xmlc.c src/s.c src/m.c src/rx.c ruby_rnv_err.c ruby_rnv.c}
 
 $INCFLAGS << " -I$(srcdir)/src"
 

data/ext/rnv/ruby_rnv.c

@@ -1,423 +1,40 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <fcntl.h> /*open,close*/
-#include <sys/types.h>
-#include <unistd.h> /*open,read,close*/
-#include <string.h> /*strerror*/
-#include <errno.h>
-#include <assert.h>
-
-#include "src/m.h"
-#include "src/s.h"
-#include "src/erbit.h"
-#include "src/drv.h"
-#include "src/rnl.h"
-#include "src/rnv.h"
-#include "src/rnx.h"
-#include "src/ll.h"
-#include "src/er.h"
-#include "src/erbit.h"
-#include "src/rnc.h"
-#include "src/rnd.h"
-#include "src/rx.h"
-#include "src/xsd.h"
-
-#include <ruby.h>
-#include <ruby/io.h>
+#include "ruby_rnv.h"
 
 #define LEN_T XCL_LEN_T
 #define LIM_T XCL_LIM_T
 
-typedef struct document
-{
-  char *fn;
-  int start;
-  int current;
-  int previous;
-  int lastline;
-  int lastcol;
-  int level;
-  int opened;
-  int ok;
-  char *text;
-  int len_txt;
-  int n_txt;
-  int mixed;
-  int nexp;
-
-  rnv_t *rnv;
-  rn_st_t *rn_st;
-  rnc_st_t *rnc_st;
-  rnx_st_t *rnx_st;
-  drv_st_t *drv_st;
-  rx_st_t *rx_st;
-  rnd_st_t *rnd_st;
-
-} document_t;
-
-VALUE RNV;
-
-// convert error code to symbol
-ID errno_to_id(int erno)
-{
-  ID id;
-  switch (erno)
-  {
-  case (ERBIT_RNC | RNC_ER_IO):
-    id = rb_intern("rnc_er_io");
-    break;
-  case (ERBIT_RNC | RNC_ER_UTF):
-    id = rb_intern("rnc_er_urf");
-    break;
-  case (ERBIT_RNC | RNC_ER_XESC):
-    id = rb_intern("rnc_er_xesc");
-    break;
-  case (ERBIT_RNC | RNC_ER_LEXP):
-    id = rb_intern("rnc_er_lexp");
-    break;
-  case (ERBIT_RNC | RNC_ER_LLIT):
-    id = rb_intern("rnc_er_llit");
-    break;
-  case (ERBIT_RNC | RNC_ER_LILL):
-    id = rb_intern("rnc_er_lill");
-    break;
-  case (ERBIT_RNC | RNC_ER_SEXP):
-    id = rb_intern("rnc_er_sexp");
-    break;
-  case (ERBIT_RNC | RNC_ER_SILL):
-    id = rb_intern("rnc_er_still");
-    break;
-  case (ERBIT_RNC | RNC_ER_NOTGR):
-    id = rb_intern("rnc_er_notgr");
-    break;
-  case (ERBIT_RNC | RNC_ER_EXT):
-    id = rb_intern("rnc_er_ext");
-    break;
-  case (ERBIT_RNC | RNC_ER_DUPNS):
-    id = rb_intern("rnc_er_dupns");
-    break;
-  case (ERBIT_RNC | RNC_ER_DUPDT):
-    id = rb_intern("rnc_er_dupdt");
-    break;
-  case (ERBIT_RNC | RNC_ER_DFLTNS):
-    id = rb_intern("rnc_er_dfltns");
-    break;
-  case (ERBIT_RNC | RNC_ER_DFLTDT):
-    id = rb_intern("rnc_er_dfltdt");
-    break;
-  case (ERBIT_RNC | RNC_ER_NONS):
-    id = rb_intern("rnc_er_nons");
-    break;
-  case (ERBIT_RNC | RNC_ER_NODT):
-    id = rb_intern("rnc_er_nodt");
-    break;
-  case (ERBIT_RNC | RNC_ER_NCEX):
-    id = rb_intern("rnc_er_ncex");
-    break;
-  case (ERBIT_RNC | RNC_ER_2HEADS):
-    id = rb_intern("rnc_er_2heads");
-    break;
-  case (ERBIT_RNC | RNC_ER_COMBINE):
-    id = rb_intern("rnc_er_combine");
-    break;
-  case (ERBIT_RNC | RNC_ER_OVRIDE):
-    id = rb_intern("rnc_er_ovride");
-    break;
-  case (ERBIT_RNC | RNC_ER_EXPT):
-    id = rb_intern("rnc_er_excpt");
-    break;
-  case (ERBIT_RNC | RNC_ER_INCONT):
-    id = rb_intern("rnc_er_incont");
-    break;
-  case (ERBIT_RNC | RNC_ER_NOSTART):
-    id = rb_intern("rnc_er_nostart");
-    break;
-  case (ERBIT_RNC | RNC_ER_UNDEF):
-    id = rb_intern("rnc_er_undef");
-    break;
-
-  case (ERBIT_RND | RND_ER_LOOPST):
-    id = rb_intern("rnd_er_loopst");
-    break;
-  case (ERBIT_RND | RND_ER_LOOPEL):
-    id = rb_intern("rnd_er_loopel");
-    break;
-  case (ERBIT_RND | RND_ER_CTYPE):
-    id = rb_intern("rnd_er_ctype");
-    break;
-  case (ERBIT_RND | RND_ER_BADSTART):
-    id = rb_intern("rnd_er_badstart");
-    break;
-  case (ERBIT_RND | RND_ER_BADMORE):
-    id = rb_intern("rnd_er_badmore");
-    break;
-  case (ERBIT_RND | RND_ER_BADEXPT):
-    id = rb_intern("rnd_er_badexpt");
-    break;
-  case (ERBIT_RND | RND_ER_BADLIST):
-    id = rb_intern("rnd_er_badlist");
-    break;
-  case (ERBIT_RND | RND_ER_BADATTR):
-    id = rb_intern("rnd_er_badattr");
-    break;
-
-  case (ERBIT_RX | RX_ER_BADCH):
-    id = rb_intern("rx_er_badch");
-    break;
-  case (ERBIT_RX | RX_ER_UNFIN):
-    id = rb_intern("rx_er_unfin");
-    break;
-  case (ERBIT_RX | RX_ER_NOLSQ):
-    id = rb_intern("rx_er_nolsq");
-    break;
-  case (ERBIT_RX | RX_ER_NORSQ):
-    id = rb_intern("rx_er_norsq");
-    break;
-  case (ERBIT_RX | RX_ER_NOLCU):
-    id = rb_intern("rx_er_nolcu");
-    break;
-  case (ERBIT_RX | RX_ER_NORCU):
-    id = rb_intern("rx_er_norcu");
-    break;
-  case (ERBIT_RX | RX_ER_NOLPA):
-    id = rb_intern("rx_er_nolpa");
-    break;
-  case (ERBIT_RX | RX_ER_NORPA):
-    id = rb_intern("rx_er_norpa");
-    break;
-  case (ERBIT_RX | RX_ER_BADCL):
-    id = rb_intern("rx_er_badcl");
-    break;
-  case (ERBIT_RX | RX_ER_NODGT):
-    id = rb_intern("rx_er_nodgt");
-    break;
-  case (ERBIT_RX | RX_ER_DNUOB):
-    id = rb_intern("rx_er_dnuob");
-    break;
-  case (ERBIT_RX | RX_ER_NOTRC):
-    id = rb_intern("rx_er_notrc");
-    break;
-
-  case (ERBIT_XSD | XSD_ER_TYP):
-    id = rb_intern("xsd_er_typ");
-    break;
-  case (ERBIT_XSD | XSD_ER_PAR):
-    id = rb_intern("xsd_er_par");
-    break;
-  case (ERBIT_XSD | XSD_ER_PARVAL):
-    id = rb_intern("xsd_er_parval");
-    break;
-  case (ERBIT_XSD | XSD_ER_VAL):
-    id = rb_intern("xsd_er_val");
-    break;
-  case (ERBIT_XSD | XSD_ER_NPAT):
-    id = rb_intern("xsd_er_npat");
-    break;
-  case (ERBIT_XSD | XSD_ER_WS):
-    id = rb_intern("xsd_er_ws");
-    break;
-  case (ERBIT_XSD | XSD_ER_ENUM):
-    id = rb_intern("xsd_er_enum");
-    break;
-
-  case (ERBIT_DRV | DRV_ER_NODTL):
-    id = rb_intern("drv_er_nodtl");
-    break;
-
-  case (ERBIT_RNV | RNV_ER_ELEM):
-    id = rb_intern("rnv_er_elem");
-    break;
-  case (ERBIT_RNV | RNV_ER_AKEY):
-    id = rb_intern("rnv_er_akey");
-    break;
-  case (ERBIT_RNV | RNV_ER_AVAL):
-    id = rb_intern("rnv_er_aval");
-    break;
-  case (ERBIT_RNV | RNV_ER_EMIS):
-    id = rb_intern("rnv_er_emis");
-    break;
-  case (ERBIT_RNV | RNV_ER_AMIS):
-    id = rb_intern("rnv_er_amis");
-    break;
-  case (ERBIT_RNV | RNV_ER_UFIN):
-    id = rb_intern("rnv_er_ufin");
-    break;
-  case (ERBIT_RNV | RNV_ER_TEXT):
-    id = rb_intern("rnv_er_text");
-    break;
-  case (ERBIT_RNV | RNV_ER_NOTX):
-    id = rb_intern("rnv_er_notx");
-    break;
-
-  default:
-    id = rb_intern("unknown");
-    break;
-  }
-  return id;
-}
+VALUE RNV, SchemaNotLoaded, Error, DataTypeLibrary, Document;
+
+extern int ruby_verror_handler(void *data, int erno, char *format, va_list ap);
 
-int ruby_verror_handler(rnv_t *rnv, int erno, char *format, va_list ap)
+VALUE rb_datatype_push_error(VALUE self, VALUE r_msg)
 {
-  VALUE self = (VALUE)rnv->user_data;
   document_t *document;
+  VALUE r_doc = rb_iv_get(self, "@document");
+  Data_Get_Struct(r_doc, document_t, document);
 
-  Data_Get_Struct(self, document_t, document);
-
-  rnx_st_t *rnx_st = document->rnx_st;
-
-  VALUE errors = rb_iv_get(self, "@errors");
-
-  VALUE error_array = rb_ary_new2(2);
-  VALUE error_str = rb_vsprintf(format, ap);
-  VALUE error_erno = ID2SYM(errno_to_id(erno));
+  Check_Type(r_msg, T_STRING);
 
-  // lazyly strip with ruby
-  rb_funcall(error_str, rb_intern("strip!"), 0);
+  if(document->rnv->verror_handler)
+    document->rnv->verror_handler((void *)r_doc, ERBIT_DTL, RSTRING_PTR(r_msg), NULL);
 
-  VALUE err_class = rb_const_get(RNV, rb_intern("Error"));
-  VALUE err_obj = rb_class_new_instance(0, NULL, err_class);
-  rb_iv_set(err_obj, "@document", self);
-  rb_iv_set(err_obj, "@code", error_erno);
-  rb_iv_set(err_obj, "@message", error_str);
-  rb_iv_set(err_obj, "@line", rb_iv_get(self, "@last_line"));
-  rb_iv_set(err_obj, "@col", rb_iv_get(self, "@last_col"));
-
-  VALUE expected = rb_str_new2("");
-  if (erno & ERBIT_RNV)
-  {
-    if (document->nexp)
-    {
-      int req = 2, i = 0;
-      char *s;
-      while (req--)
-      {
-        rnx_expected(rnv, rnx_st, document->previous, req);
-        if (i == rnv->rnx_n_exp)
-          continue;
-        if (rnv->rnx_n_exp > document->nexp)
-          break;
-
-        expected = rb_str_cat2(expected, (char *)(req ? "required:\n" : "allowed:\n"));
-
-        for (; i != rnv->rnx_n_exp; ++i)
-        {
-          s = rnx_p2str(rnv, rnv->rnx_exp[i]);
-          expected = rb_str_cat2(expected, "\t");
-          expected = rb_str_cat2(expected, s);
-          expected = rb_str_cat2(expected, "\n");
-          m_free(s);
-        }
-      }
-    }
-  }
-
-  rb_iv_set(err_obj, "@expected", expected);
-
-  rb_ary_push(errors, err_obj);
-}
-
-/*
- * @return [String]
- */
-VALUE rb_error_inspect(VALUE self)
-{
-  VALUE code = rb_iv_get(self, "@code");
-  VALUE message = rb_iv_get(self, "@message");
-  VALUE expected = rb_iv_get(self, "@expected");
-  VALUE line = rb_iv_get(self, "@line");
-  VALUE col = rb_iv_get(self, "@col");
-
-  VALUE ret = rb_str_new2("#<RNV::Error ");
-  ret = rb_str_cat2(ret, "code: :");
-  ret = rb_str_append(ret, rb_obj_as_string(code));
-  ret = rb_str_cat2(ret, ", ");
-  ret = rb_str_cat2(ret, "message: '");
-  ret = rb_str_append(ret, message);
-  ret = rb_str_cat2(ret, "', ");
-  ret = rb_str_cat2(ret, "expected: '");
-  ret = rb_str_append(ret, expected);
-  ret = rb_str_cat2(ret, "', ");
-  ret = rb_str_cat2(ret, "line: ");
-  ret = rb_str_append(ret, rb_obj_as_string(line));
-  ret = rb_str_cat2(ret, ", ");
-  ret = rb_str_cat2(ret, "col: ");
-  ret = rb_str_append(ret, rb_obj_as_string(col));
-  ret = rb_str_cat2(ret, ">");
-  return ret;
+  return Qnil;
 }
 
-/*
- * @return [String]
- */
-VALUE rb_error_to_s(VALUE self)
+void document_free(document_t *document)
 {
-  VALUE message = rb_iv_get(self, "@message");
-  VALUE expected = rb_iv_get(self, "@expected");
-  VALUE line = rb_iv_get(self, "@line");
-  VALUE col = rb_iv_get(self, "@col");
+  rnd_dispose(document->rnd_st);
+  rx_dispose(document->rx_st);
+  drv_dispose(document->drv_st);
 
-  VALUE ret = rb_str_new2("");
+  rnc_dispose(document->rnc_st);
 
-  ret = rb_str_append(ret, rb_obj_as_string(line));
-  ret = rb_str_cat2(ret, ":");
-  ret = rb_str_append(ret, rb_obj_as_string(col));
+  rn_dispose(document->rn_st);
 
-  ret = rb_str_cat2(ret, ": error: ");
+  rnv_dispose(document->rnv);
 
-  ret = rb_str_append(ret, message);
-  ret = rb_str_cat2(ret, "\n");
-  ret = rb_str_append(ret, expected);
-
-  return ret;
-}
-
-void document_free(document_t *document)
-{
-  // FIXME : introduce *_delete functions
-  if (document->rnd_st->flat)
-    free(document->rnd_st->flat);
-  free(document->rnd_st);
-
-  ht_dispose(&document->rx_st->ht_r);
-  ht_dispose(&document->rx_st->ht_p);
-  ht_dispose(&document->rx_st->ht_2);
-  ht_dispose(&document->rx_st->ht_m);
-  if (document->rx_st->regex)
-    free(document->rx_st->regex);
-  if (document->rx_st->pattern)
-    free(document->rx_st->pattern);
-  free(document->rx_st);
-
-  if (document->drv_st->dtl)
-    free(document->drv_st->dtl);
-  ht_dispose(&document->drv_st->ht_m);
-  free(document->drv_st);
-
-  free(document->rnx_st);
-
-  if (document->rnc_st->path)
-    free(document->rnc_st->path);
-  free(document->rnc_st);
-
-  ht_dispose(&document->rn_st->ht_p);
-  ht_dispose(&document->rn_st->ht_nc);
-  ht_dispose(&document->rn_st->ht_s);
-
-  free(document->rn_st);
-
-  if (document->rnv->rn_pattern)
-    free(document->rnv->rn_pattern);
-  if (document->rnv->rn_nameclass)
-    free(document->rnv->rn_nameclass);
-  if (document->rnv->rn_string)
-    free(document->rnv->rn_string);
-  if (document->rnv->rnx_exp)
-    free(document->rnv->rnx_exp);
-
-  free(document->rnv);
-
-  free(document->text);
+  if (document->text)
+    free(document->text);
 
   ruby_xfree(document);
 }
@@ -426,13 +43,12 @@ VALUE rb_document_alloc(VALUE klass)
 {
   document_t *document = ruby_xmalloc(sizeof(document_t));
 
-  document->rnv = malloc(sizeof(rnv_t));
-  document->rn_st = malloc(sizeof(rn_st_t));
-  document->rnc_st = malloc(sizeof(rnc_st_t));
-  document->rnx_st = malloc(sizeof(rnx_st_t));
-  document->drv_st = malloc(sizeof(drv_st_t));
-  document->rx_st = malloc(sizeof(rx_st_t));
-  document->rnd_st = malloc(sizeof(rnd_st_t));
+  document->rnv = calloc(1, sizeof(rnv_t));
+  document->rn_st = calloc(1, sizeof(rn_st_t));
+  document->rnc_st = calloc(1, sizeof(rnc_st_t));
+  document->drv_st = calloc(1, sizeof(drv_st_t));
+  document->rx_st = calloc(1, sizeof(rx_st_t));
+  document->rnd_st = calloc(1, sizeof(rnd_st_t));
 
   return Data_Wrap_Struct(klass, NULL, document_free, document);
 }
@@ -442,17 +58,31 @@ VALUE rb_document_init(VALUE self)
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  rnl_init(document->rnv, document->rn_st, document->rnc_st, document->rnd_st);
+  document->rnv->verror_handler = &ruby_verror_handler;
+  document->rnv->user_data = (void *)self;
+
+  rnl_init(document->rnv, document->rnc_st, document->rn_st, document->rnd_st);
   rnv_init(document->rnv, document->drv_st, document->rn_st, document->rx_st);
-  rnx_init(document->rnv, document->rnx_st);
+  rnx_init(document->rnv);
 
   document->opened = document->ok = 0;
-  document->rnv->user_data = (void *)self;
-  document->rnv->verror_handler = &ruby_verror_handler;
+
   document->nexp = 16; /* maximum number of candidates to display */
+  document->text = NULL;
 
   rb_iv_set(self, "@errors", rb_ary_new2(0));
 
+  rb_iv_set(self, "@libraries", rb_hash_new());
+
+  document->last_line = -1;
+  document->last_col = -1;
+
+  rb_iv_set(self, "@last_line", INT2NUM(-1));
+  rb_iv_set(self, "@last_col", INT2NUM(-1));
+
+  //document->rx_st->rx_compact = 1;
+  //document->drv_st->drv_compact = 1;
+
   return self;
 }
 
@@ -470,7 +100,7 @@ static void document_load(document_t *document)
 /*
  * load schema from a buffer
  * @param [String] r_str buffer
- * @return [String]
+ * @return [Boolean]
  */
 VALUE rb_document_load_string(VALUE self, VALUE r_str)
 {
@@ -489,40 +119,42 @@ VALUE rb_document_load_string(VALUE self, VALUE r_str)
                            document->fn,
                            RSTRING_PTR(r_str), RSTRING_LEN(r_str));
 
-  document_load(document);
-  return INT2NUM(document->ok);
+  if (document->opened)
+  {
+    document_load(document);
+    return Qtrue;
+  }
+  else
+    return Qfalse;
 }
 
 /*
  * load schema from a file
  * @param [String] r_fn filename
- * @return [String]
+ * @return [Boolean]
  */
 VALUE rb_document_load_file(VALUE self, VALUE r_fn)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  switch (TYPE(r_fn))
+  Check_Type(r_fn, T_STRING);
+
+  document->fn = RSTRING_PTR(r_fn);
+
+  document->opened = rnl_fn(document->rnv,
+                            document->rnc_st,
+                            document->rn_st,
+                            document->rnd_st,
+                            document->fn);
+
+  if (document->opened)
   {
-  case T_STRING:
-    document->fn = RSTRING_PTR(r_fn);
-
-    document->opened = rnl_fn(document->rnv,
-                              document->rnc_st,
-                              document->rn_st,
-                              document->rnd_st,
-                              document->fn);
-
-    break;
-  case T_FILE: // TODO
-  default:
-    rb_raise(rb_eTypeError, "invalid argument");
-    break;
+    document_load(document);
+    return Qtrue;
   }
-
-  document_load(document);
-  return INT2NUM(document->ok);
+  else
+    return Qfalse;
 }
 
 /*
@@ -540,6 +172,63 @@ VALUE rb_document_valid(VALUE self)
     return Qfalse;
 }
 
+static int rb_dtl_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ, char *val, char *s, int n)
+{
+  VALUE self = (VALUE)rnv->user_data;
+  VALUE libraries = rb_iv_get(self, "@libraries");
+  VALUE lib = rb_hash_aref(libraries, INT2FIX(uri));
+
+  // do we need n here, do s always null terminated ?
+  VALUE ret = rb_funcall(lib, rb_intern("equal"), 3,
+                         rb_str_new2(typ), rb_str_new2(val), rb_str_new2(s));
+
+  return RTEST(ret);
+}
+
+static int rb_dtl_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ, char *ps, char *s, int n)
+{
+  VALUE self = (VALUE)rnv->user_data;
+  VALUE libraries = rb_iv_get(self, "@libraries");
+  VALUE lib = rb_hash_aref(libraries, INT2FIX(uri));
+
+  // do we need n here, do s always null terminated ?
+  VALUE ret = rb_funcall(lib, rb_intern("allows"), 3,
+                         rb_str_new2(typ), rb_str_new2(ps), rb_str_new2(s));
+
+  return RTEST(ret);
+}
+
+/*
+ * add a new datatype library
+ * @see https://www.oasis-open.org/committees/relax-ng/spec-20010811.html#IDA1I1R
+ * @param [String] r_ns unique ns URL for this datatype
+ * @param [RNV::DataTypeLibrary] r_cb_obj
+ * @return [nil]
+ */
+VALUE rb_document_add_dtl(VALUE self, VALUE r_ns, VALUE r_cb_obj)
+{
+  document_t *document;
+  Data_Get_Struct(self, document_t, document);
+
+  if (document->opened)
+  {
+    Check_Type(r_ns, T_STRING);
+
+    char *suri = RSTRING_PTR(r_ns);
+
+    drv_add_dtl(document->rnv, document->drv_st, document->rn_st, suri, &rb_dtl_equal, &rb_dtl_allows);
+
+    int uri = document->drv_st->dtl[document->drv_st->n_dtl - 1].uri;
+
+    VALUE libraries = rb_iv_get(self, "@libraries");
+
+    rb_iv_set(r_cb_obj, "@document", self);
+
+    rb_hash_aset(libraries, INT2FIX(uri), r_cb_obj);
+  }
+  return Qnil;
+}
+
 static void flush_text(document_t *document)
 {
   document->ok = rnv_text(document->rnv, document->drv_st, document->rn_st, document->rx_st,
@@ -549,7 +238,7 @@ static void flush_text(document_t *document)
 }
 
 /*
- * begin a new document
+ * begin parsing a new document
  * @return [nil]
  */
 VALUE rb_document_begin(VALUE self)
@@ -557,11 +246,22 @@ VALUE rb_document_begin(VALUE self)
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  // reset errors
+  rb_iv_set(self, "@errors", rb_ary_new2(0));
+
   m_free(document->text);
   document->text = (char *)m_alloc(document->len_txt = LEN_T, sizeof(char));
 
   document->ok = document->current = document->previous = document->start;
 
+  document->last_line = 0;
+  document->last_col = 0;
+
+  document->level = 0;
+
   document->text[0] = '\0';
   document->n_txt = 0;
   document->mixed = 0;
@@ -572,14 +272,17 @@ VALUE rb_document_begin(VALUE self)
 /*
  * to be called by SAX characters handler
  * @param [String] r_str characters
- * @return [Integer]
+ * @return [Boolean]
  */
 VALUE rb_document_characters(VALUE self, VALUE r_str)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
     Check_Type(r_str, T_STRING);
     char *s = RSTRING_PTR(r_str);
@@ -600,21 +303,24 @@ VALUE rb_document_characters(VALUE self, VALUE r_str)
     document->text[document->n_txt] = '\0'; /* '\0' guarantees that the text is bounded, and strto[ld] work for data */
   }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 /*
  * to be called by SAX start tag handler
  * @param [String] r_name tag name, must be in the form 'NS_URI:TAG_NAME'
- * @param [Array<String>] r_attrs flattened array of tag attributes in the form ['NS_URI:ATTR_NAME','ATTR_VALUE']
- * @return [Integer]
+ * @param [Array<Array<String>>] r_attrs flattened array of tag attributes in the form [['NS_URI:ATTR_NAME','ATTR_VALUE']]
+ * @return [Boolean]
  */
 VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
     int i;
     char *name;
@@ -624,20 +330,22 @@ VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
     name = RSTRING_PTR(r_name);
 
     Check_Type(r_attrs, T_ARRAY);
-    unsigned int attrs_len = RARRAY_LEN(r_attrs);
+
+    // lazyly flatten with ruby
+    VALUE r_flat_attrs = rb_funcall(r_attrs, rb_intern("flatten"), 0);
+    unsigned int attrs_len = RARRAY_LEN(r_flat_attrs);
 
     attrs = malloc(sizeof(char *) * (attrs_len + 1));
 
     for (i = 0; i < attrs_len; i++)
     {
-      attrs[i] = RSTRING_PTR(rb_ary_entry(r_attrs, i));
+      attrs[i] = RSTRING_PTR(rb_ary_entry(r_flat_attrs, i));
     }
     attrs[attrs_len] = 0; // zero terminated
 
     document->mixed = 1;
 
     flush_text(document);
-    //printf("RNV START %d/%d %s %d\n", current, previous, name, attrs_len);
     document->ok = rnv_start_tag(document->rnv, document->drv_st, document->rn_st, document->rx_st,
                                  &document->current, &document->previous, (char *)name, (char **)attrs) &&
                    document->ok;
@@ -645,21 +353,28 @@ VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
     document->mixed = 0;
     free(attrs);
   }
+  else
+  {
+    ++document->level;
+  }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 /*
  * to be called by SAX end tag handler
  * @param [String] r_name tag name, must be in the form 'NS_URI:TAG_NAME'
- * @return [Integer]
+ * @return [Boolean]
  */
 VALUE rb_document_end_tag(VALUE self, VALUE r_name)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
     char *name;
 
@@ -668,15 +383,21 @@ VALUE rb_document_end_tag(VALUE self, VALUE r_name)
 
     flush_text(document);
 
-    //printf("RNV END %d/%d %s\n", current, previous, name);
     document->ok = rnv_end_tag(document->rnv, document->drv_st, document->rn_st,
                                &document->current, &document->previous, (char *)name) &&
                    document->ok;
 
     document->mixed = 1;
   }
+  else
+  {
+    if (document->level == 0)
+      document->current = document->previous;
+    else
+      --document->level;
+  }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 // The initialization method for this module
@@ -684,21 +405,15 @@ void Init_rnv()
 {
   RNV = rb_define_module("RNV");
 
-  VALUE Error = rb_define_class_under(RNV, "Error", rb_cObject);
+  SchemaNotLoaded = rb_define_class_under(RNV, "SchemaNotLoaded", rb_eStandardError);
 
-  rb_define_method(Error, "inspect", rb_error_inspect, 0);
-  rb_define_method(Error, "to_s", rb_error_to_s, 0);
+  Error = rb_define_class_under(RNV, "Error", rb_cObject);
 
   /*
    * error symbol code
    * @return [Symbol]
    */
   rb_define_attr(Error, "code", 1, 0);
-  /*
-   * error message
-   * @return [String]
-   */
-  rb_define_attr(Error, "message", 1, 0);
   /*
    * error line
    * @return [Integer]
@@ -710,7 +425,17 @@ void Init_rnv()
    */
   rb_define_attr(Error, "col", 1, 0);
 
-  VALUE Document = rb_define_class_under(RNV, "Document", rb_cObject);
+  DataTypeLibrary = rb_define_class_under(RNV, "DataTypeLibrary", rb_cObject);
+
+  /*
+   * document in which library is registered
+   * @return [RNV::Document]
+   */
+  rb_define_attr(DataTypeLibrary, "document", 1, 0);
+
+  rb_define_method(DataTypeLibrary, "push_error", rb_datatype_push_error, 1);
+
+  Document = rb_define_class_under(RNV, "Document", rb_cObject);
 
   rb_define_alloc_func(Document, rb_document_alloc);
   rb_define_method(Document, "initialize", rb_document_init, 0);
@@ -719,6 +444,8 @@ void Init_rnv()
   rb_define_method(Document, "load_string", rb_document_load_string, 1);
   rb_define_method(Document, "valid?", rb_document_valid, 0);
 
+  rb_define_method(Document, "add_datatype_library", rb_document_add_dtl, 2);
+
   rb_define_method(Document, "start_document", rb_document_begin, 0);
   rb_define_method(Document, "start_tag", rb_document_start_tag, 2);
   rb_define_method(Document, "characters", rb_document_characters, 1);