ruby_rnv 0.3.1 → 0.5.1

data/ext/rnv/src/rnc.h

@@ -31,30 +31,10 @@
 #define RNC_ER_NOSTART 70
 #define RNC_ER_UNDEF 71
 
-struct rnc_cym {
-  char *s; int slen;
-  int line,col;
-  int sym;
-};
+extern void rnc_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
-struct rnc_source {
-  int flags;
-  char *fn; int fd;
-  char *buf; int i,n;
-  int complete;
-  int line,col,prevline/*when error reported*/;
-  int u,v,w; int nx;
-  int cur;
-  struct rnc_cym sym[2];
-
-  // FIXME: for error handlers
-  rnv_t *rnv;
-};
-
-extern void rnc_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
-
-extern void rnc_init(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st);
-extern void rnc_clear(void);
+extern void rnc_init(rnc_st_t *rnc_st);
+extern void rnc_dispose(rnc_st_t *rnc_st);
 
 extern int rnc_open(struct rnc_source *sp,char *fn);
 extern int rnc_stropen(struct rnc_source *sp,char *fn,char *s,int len);

data/ext/rnv/src/rnd.c

@@ -1,10 +1,10 @@
-#include "type.h"
-
 /* $Id: rnd.c,v 1.33 2004/02/25 00:00:32 dvd Exp $ */
-
 #include <stdlib.h>
 #include <assert.h>
 #include <string.h>
+
+#include "type.h"
+
 #include "m.h"
 #include "rn.h"
 #include "rnx.h"
@@ -15,8 +15,8 @@
 
 #define LEN_F RND_LEN_F
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RND,"error: "msg"\n",ap)
-void rnd_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+#define err(msg) (*handler)(data,erno|ERBIT_RND,"error: "msg"\n",ap)
+void rnd_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   switch(erno) {
   case RND_ER_LOOPST: err("loop in start pattern"); break;
   case RND_ER_LOOPEL: err("loop in pattern for element '%s'"); break;
@@ -30,17 +30,21 @@ void rnd_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
   }
 }
 
-void rnd_init(rnv_t *rnv, rnd_st_t *rnd_st, rn_st_t *rn_st) {
-    memset(rnd_st, 0, sizeof(rnd_st_t));
-    rnv->rnd_verror_handler=&rnd_default_verror_handler;
-    rn_init(rnv, rn_st);
+void rnd_init(rnd_st_t *rnd_st) {
+    rnd_st->verror_handler = &verror_default_handler;
+}
+
+void rnd_dispose(rnd_st_t *rnd_st) {
+  if (rnd_st->flat)
+    m_free(rnd_st->flat);
+  m_free(rnd_st);
 }
 
 void rnd_clear(void) {}
 
-static void error_handler(rnv_t *rnv, rnd_st_t *rnd_st, int er_no,...) {
-  va_list ap; va_start(ap,er_no); 
-  rnv->rnd_verror_handler(rnv, er_no,ap); 
+static void error_handler(rnd_st_t *rnd_st, int erno,...) {
+  va_list ap; va_start(ap,erno); 
+  rnd_default_verror_handler(rnd_st->user_data, erno, rnd_st->verror_handler, ap); 
   va_end(ap);
   ++rnd_st->errors;
 }
@@ -141,9 +145,9 @@ static void loops(rnv_t *rnv, rnd_st_t *rnd_st) {
   int i=0,p=rnd_st->flat[i],nc=-1,p1;
   for(;;) {
     if(loop(rnv, p)) {
-      if(i==0) error_handler(rnv, rnd_st, RND_ER_LOOPST); else {
+      if(i==0) error_handler(rnd_st, RND_ER_LOOPST); else {
 	char *s=rnx_nc2str(rnv, nc);
-	error_handler(rnv, rnd_st,RND_ER_LOOPEL, s);
+	error_handler(rnd_st,RND_ER_LOOPEL, s);
 	m_free(s);
       }
     }
@@ -195,7 +199,7 @@ static void ctypes(rnv_t *rnv, rnd_st_t *rnd_st) {
       ctype(rnv, p1);
       if(!rn_contentType(rnv, p1)) {
 	char *s=rnx_nc2str(rnv, nc);
-	error_handler(rnv,rnd_st,RND_ER_CTYPE, s);
+	error_handler(rnd_st,RND_ER_CTYPE, s);
 	m_free(s);
       }
     }
@@ -328,18 +332,18 @@ static void path(rnv_t *rnv, rnd_st_t *rnd_st, int p,int nc) {
   case RN_P_INTERLEAVE: rn_Interleave(p,p1,p2); goto BINARY;
   case RN_P_GROUP: rn_Group(p,p1,p2); goto BINARY;
   case RN_P_DATA_EXCEPT: rn_DataExcept(p,p1,p2);
-    if(bad_data_except(rnv, p2)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnv,rnd_st,RND_ER_BADEXPT, s); m_free(s);}
+    if(bad_data_except(rnv, p2)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnd_st,RND_ER_BADEXPT, s); m_free(s);}
     goto BINARY;
   BINARY: path(rnv, rnd_st, p1,nc); path(rnv, rnd_st, p2,nc); break;
 
   case RN_P_ONE_OR_MORE: rn_OneOrMore(p,p1);
-    if(bad_one_or_more(rnv, p1,0)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnv,rnd_st,RND_ER_BADMORE, s); m_free(s);}
+    if(bad_one_or_more(rnv, p1,0)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnd_st,RND_ER_BADMORE, s); m_free(s);}
     goto UNARY;
   case RN_P_LIST: rn_List(p,p1);
-    if(bad_list(rnv, p1)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnv,rnd_st,RND_ER_BADLIST, s); m_free(s);}
+    if(bad_list(rnv, p1)) {char *s=rnx_nc2str(rnv, nc); error_handler(rnd_st,RND_ER_BADLIST, s); m_free(s);}
     goto UNARY;
   case RN_P_ATTRIBUTE: rn_Attribute(p,nc1,p1);
-    if(bad_attribute(rnv, p1)) {char *s=rnx_nc2str(rnv, nc),*s1=rnx_nc2str(rnv, nc1); error_handler(rnv,rnd_st,RND_ER_BADATTR, s1,s); m_free(s1); m_free(s);}
+    if(bad_attribute(rnv, p1)) {char *s=rnx_nc2str(rnv, nc),*s1=rnx_nc2str(rnv, nc1); error_handler(rnd_st,RND_ER_BADATTR, s1,s); m_free(s1); m_free(s);}
     goto UNARY;
   UNARY: path(rnv, rnd_st, p1,nc); break;
 
@@ -349,7 +353,7 @@ static void path(rnv_t *rnv, rnd_st_t *rnd_st, int p,int nc) {
 
 static void paths(rnv_t *rnv, rnd_st_t *rnd_st) {
   int i,p,p1,nc;
-  if(bad_start(rnv, rnd_st->flat[0])) error_handler(rnv,rnd_st, RND_ER_BADSTART);
+  if(bad_start(rnv, rnd_st->flat[0])) error_handler(rnd_st, RND_ER_BADSTART);
   for(i=0;i!=rnd_st->n_f;++i) {
     p=rnd_st->flat[i];
     if(RN_P_IS(p,RN_P_ELEMENT)) {

data/ext/rnv/src/rnd.h

@@ -15,10 +15,11 @@
 #define RND_ER_BADLIST 6
 #define RND_ER_BADATTR 7
 
-extern void rnd_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+extern void rnd_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
-extern void rnd_init(rnv_t *rnv, rnd_st_t *rnd_st, rn_st_t *rn_st);
+extern void rnd_init(rnd_st_t *rnd_st);
 extern void rnd_clear(void);
+extern void rnd_dispose(rnd_st_t *rnd_st);
 
 extern int rnd_fixup(rnv_t *rnv, rnd_st_t *rnd_st, rn_st_t *rn_st, int start);
 

data/ext/rnv/src/rnl.c

@@ -1,35 +1,36 @@
-#include "type.h"
-
 /* $Id: rnl.c,v 1.2 2004/01/15 23:47:45 dvd Exp $ */
-
 #include <stdarg.h>
+
+#include "type.h"
+
 #include "erbit.h"
 #include "rn.h"
 #include "rnc.h"
 #include "rnd.h"
 #include "rnl.h"
 
-void rnl_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+void rnl_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   if(erno&ERBIT_RNC) {
-    rnc_default_verror_handler(rnv, erno&~ERBIT_RNC,ap);
+    rnc_default_verror_handler(data, erno&~ERBIT_RNC,handler, ap);
   } else if(erno&ERBIT_RND) {
-    rnd_default_verror_handler(rnv, erno&~ERBIT_RND,ap);
+    rnd_default_verror_handler(data, erno&~ERBIT_RND,handler, ap);
   }
 }
 
-static void verror_handler_rnc(rnv_t *rnv, int erno,va_list ap) {rnl_default_verror_handler(rnv, erno|ERBIT_RNC,ap);}
-static void verror_handler_rnd(rnv_t *rnv, int erno,va_list ap) {rnl_default_verror_handler(rnv, erno|ERBIT_RND,ap);}
-
-void rnl_init(rnv_t *rnv, rn_st_t *rn_st, rnc_st_t *rnc_st, rnd_st_t *rnd_st) {
-    rnv->rnl_verror_handler=&rnl_default_verror_handler;
+void rnl_init(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st) {
     rn_init(rnv, rn_st);
-    rnc_init(rnv, rnc_st, rn_st);
-    rnv->rnc_verror_handler=&verror_handler_rnc;
-    rnd_init(rnv, rnd_st, rn_st); 
-    rnv->rnd_verror_handler=&verror_handler_rnd;
-}
+    rnc_init(rnc_st);
+
+    if(rnv->verror_handler)
+      rnc_st->verror_handler = rnv->verror_handler;
+    rnc_st->user_data = rnv->user_data;
 
-void rnl_clear(void) {}
+    rnd_init(rnd_st); 
+
+    if(rnv->verror_handler)
+      rnd_st->verror_handler = rnv->verror_handler;
+    rnd_st->user_data = rnv->user_data;
+}
 
 static int load(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, struct rnc_source *sp) {
   int start=-1;
@@ -42,21 +43,24 @@ static int load(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st,
 
 int rnl_fn(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn) {
   struct rnc_source src;
-  src.rnv = rnv;
+  src.verror_handler = rnv->verror_handler;
+  src.user_data = rnv->user_data;
   rnc_open(&src,fn); 
   return load(rnv, rnc_st, rn_st, rnd_st, &src);
 }
 
 int rnl_fd(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,int fd) {
   struct rnc_source src;
-  src.rnv = rnv;
+  src.verror_handler = rnv->verror_handler;
+  src.user_data = rnv->user_data;
   rnc_bind(&src,fn,fd); 
   return load(rnv, rnc_st, rn_st, rnd_st, &src);
 }
 
 int rnl_s(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,char *s,int len) {
   struct rnc_source src;
-  src.rnv = rnv;
+  src.verror_handler = rnv->verror_handler;
+  src.user_data = rnv->user_data;
   rnc_stropen(&src,fn,s,len); 
   return load(rnv, rnc_st, rn_st, rnd_st, &src);
 }

data/ext/rnv/src/rnl.h

@@ -6,10 +6,9 @@
 #include <stdarg.h>
 #include "type.h"
 
-extern void rnl_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+extern void rnl_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
-extern void rnl_init(rnv_t *rnv, rn_st_t *rn_st, rnc_st_t *rnc_st, rnd_st_t *rnd_st);
-extern void rnl_clear(void);
+extern void rnl_init(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st);
 
 extern int rnl_fn(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn);
 extern int rnl_fd(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,int fd);

data/ext/rnv/src/rnv.c

@@ -1,9 +1,9 @@
-#include "type.h"
-
 /* $Id: rnv.c,v 1.69 2004/01/28 23:21:24 dvd Exp $ */
-
 #include <string.h> /*strncpy,strrchr*/
 #include <assert.h>
+
+#include "type.h"
+
 #include "m.h"
 #include "xmlc.h" /*xmlc_white_space*/
 #include "erbit.h"
@@ -11,10 +11,10 @@
 #include "er.h"
 #include "rnv.h"
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RNV,msg"\n",ap);
-void rnv_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+#define err(msg) (*handler)(data,erno|ERBIT_RNV,msg"\n",ap);
+void rnv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   if(erno&ERBIT_DRV) {
-    drv_default_verror_handler(rnv, erno&~ERBIT_DRV,ap);
+    drv_default_verror_handler(data, erno&~ERBIT_DRV, handler, ap);
   } else {
     switch(erno) {
     case RNV_ER_ELEM: err("element %s^%s not allowed"); break;
@@ -31,24 +31,26 @@ void rnv_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
 }
 
 static void error_handler(rnv_t *rnv, int erno,...) {
-  va_list ap; va_start(ap,erno); (*rnv->rnv_verror_handler)(rnv,erno,ap); va_end(ap);
+  va_list ap; va_start(ap,erno); rnv_default_verror_handler(rnv->user_data,erno,rnv->verror_handler,ap); va_end(ap);
 }
 
-static void verror_handler_drv(rnv_t *rnv, int erno,va_list ap) {rnv_default_verror_handler(rnv,erno|ERBIT_DRV,ap);}
-
-static void windup(void);
 void rnv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st) {
-    rnv->rnv_verror_handler=&rnv_default_verror_handler;
+    if(!rnv->verror_handler)
+      rnv->verror_handler = &verror_default_handler;
     drv_init(rnv, drv_st, rn_st, rx_st);
-    rnv->drv_verror_handler=&verror_handler_drv;
-    windup();
-}
-
-void rnv_clear(void) {
-  windup();
 }
 
-static void windup(void) {
+void rnv_dispose(rnv_t *rnv) {
+  if (rnv->rn_pattern)
+    m_free(rnv->rn_pattern);
+  if (rnv->rn_nameclass)
+    m_free(rnv->rn_nameclass);
+  if (rnv->rn_string)
+    m_free(rnv->rn_string);
+  if (rnv->rnx_exp)
+    m_free(rnv->rnx_exp);
+
+  m_free(rnv);
 }
 
 static char *qname_open(char **surip,char **snamep,char *name) {

data/ext/rnv/src/rnv.h

@@ -15,10 +15,10 @@
 #define RNV_ER_TEXT 6
 #define RNV_ER_NOTX 7
 
-extern void rnv_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+extern void rnv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
 extern void rnv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st);
-extern void rnv_clear(void);
+extern void rnv_dispose(rnv_t *rnv);
 
 extern int rnv_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *text,int n_t,int mixed);
 extern int rnv_start_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *name,char **attrs);

data/ext/rnv/src/rnx.c

@@ -13,13 +13,11 @@
 #define LEN_EXP RNX_LEN_EXP
 #define LIM_EXP RNX_LIM_EXP
 
-void rnx_init(rnv_t *rnv, rnx_st_t *rnx_st) {
-    rnv->rnx_exp=(int*)m_alloc(rnx_st->len_exp=LEN_EXP,sizeof(int));
+void rnx_init(rnv_t *rnv) {
+    rnv->rnx_exp=(int*)m_alloc(rnv->rnx_len_exp=LEN_EXP,sizeof(int));
 }
 
-void rnx_clear(void) {}
-
-static void expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int first,int req) {
+static void expected(rnv_t *rnv, int p,int first,int req) {
   int p1,p2,px=0,i;
   if(req && rn_nullable(p)) return;
   switch(RN_P_TYP(p)) {
@@ -28,21 +26,21 @@ static void expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int first,int req) {
   case RN_P_EMPTY: break;
   case RN_P_TEXT: px=p; break;
   case RN_P_CHOICE: rn_Choice(p,p1,p2);
-    expected(rnv, rnx_st, p1,first,req); expected(rnv, rnx_st, p2,first,req); break;
+    expected(rnv, p1,first,req); expected(rnv, p2,first,req); break;
   case RN_P_INTERLEAVE: rn_Interleave(p,p1,p2);
-    expected(rnv, rnx_st, p1,first,req); expected(rnv, rnx_st, p2,first,req); break;
+    expected(rnv, p1,first,req); expected(rnv, p2,first,req); break;
   case RN_P_GROUP: rn_Group(p,p1,p2);
-    expected(rnv, rnx_st, p1,first,req); expected(rnv, rnx_st, p2,first&&rn_nullable(p1),req); break;
-  case RN_P_ONE_OR_MORE: rn_OneOrMore(p,p1); expected(rnv, rnx_st, p1,first,req); break;
-  case RN_P_LIST: rn_List(p,p1); expected(rnv, rnx_st, p1,first,req); break;
+    expected(rnv, p1,first,req); expected(rnv, p2,first&&rn_nullable(p1),req); break;
+  case RN_P_ONE_OR_MORE: rn_OneOrMore(p,p1); expected(rnv, p1,first,req); break;
+  case RN_P_LIST: rn_List(p,p1); expected(rnv, p1,first,req); break;
   case RN_P_DATA: px=p; break;
   case RN_P_DATA_EXCEPT: rn_DataExcept(p,p1,p2);
-    expected(rnv, rnx_st, p1,first,req); break;
+    expected(rnv, p1,first,req); break;
   case RN_P_VALUE: px=p; break;
   case RN_P_ATTRIBUTE: px=p; break;
   case RN_P_ELEMENT: px=p; break;
   case RN_P_AFTER: rn_After(p,p1,p2);
-    expected(rnv, rnx_st, p1,first,req); if(rn_nullable(p1)) px=p; break;
+    expected(rnv, p1,first,req); if(rn_nullable(p1)) px=p; break;
   case RN_P_REF: break;
   default: assert(0);
   }
@@ -51,20 +49,20 @@ static void expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int first,int req) {
       if(rnv->rnx_exp[i]==px) {px=0; break;}
     }
     if(px) {
-      if(rnv->rnx_n_exp==rnx_st->len_exp) rnv->rnx_exp=(int*)m_stretch(rnv->rnx_exp,rnx_st->len_exp=2*rnv->rnx_n_exp,rnv->rnx_n_exp,sizeof(int));
+      if(rnv->rnx_n_exp==rnv->rnx_len_exp) rnv->rnx_exp=(int*)m_stretch(rnv->rnx_exp,rnv->rnx_len_exp=2*rnv->rnx_n_exp,rnv->rnx_n_exp,sizeof(int));
       rnv->rnx_exp[rnv->rnx_n_exp++]=px;
     }
   }
 }
-void rnx_expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int req) {
+void rnx_expected(rnv_t *rnv, int p,int req) {
   if(req) {
-    if(rnx_st->len_exp>LIM_EXP) {
+    if(rnv->rnx_len_exp>LIM_EXP) {
       m_free(rnv->rnx_exp);
-      rnv->rnx_exp=(int*)m_alloc(rnx_st->len_exp=LIM_EXP,sizeof(int));
+      rnv->rnx_exp=(int*)m_alloc(rnv->rnx_len_exp=LIM_EXP,sizeof(int));
     }
     rnv->rnx_n_exp=0;
   }
-  expected(rnv, rnx_st, p,1,req);
+  expected(rnv, p,1,req);
 }
 
 char *rnx_p2str(rnv_t *rnv, int p) {

data/ext/rnv/src/rnx.h

@@ -5,10 +5,9 @@
 #ifndef RNX_H
 #define RNX_H 1
 
-extern void rnx_init(rnv_t *rnv, rnx_st_t *rnx_st);
-extern void rnx_clear(void);
+extern void rnx_init(rnv_t *rnv);
 
-extern void rnx_expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int req);
+extern void rnx_expected(rnv_t *rnv, int p,int req);
 
 extern char *rnx_p2str(rnv_t *rnv, int p);
 extern char *rnx_nc2str(rnv_t *rnv, int nc);

data/ext/rnv/src/rx.c

@@ -1,9 +1,10 @@
-#include "type.h"
-
 /* $Id: rx.c,v 1.33 2004/02/25 00:00:32 dvd Exp $ */
 
 #include <string.h> /*strlen,strcpy,strcmp*/
 #include <assert.h>
+
+#include "type.h"
+
 #include "u.h" /*u_get,u_strlen*/
 #include "xmlc.h"
 #include "m.h"
@@ -186,9 +187,8 @@ static int add_r(rx_st_t *rx_st, char *rx) {
 
 #define ERRPOS
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RX,msg" in \"%s\" at offset %i\n",ap)
-void rx_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
-  (*er_printf)("regular expressions: ");
+#define err(msg) (*handler)(data, erno|ERBIT_RX,"regular expressions: "msg" in \"%s\" at offset %i\n",ap)
+void rx_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno, char *format, va_list ap), va_list ap) {
   switch(erno) {
   case RX_ER_BADCH: err("bad character"); break;
   case RX_ER_UNFIN: err("unfinished expression"); break;
@@ -206,10 +206,8 @@ void rx_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
   }
 }
 
-//void (*rx_verror_handler)(int erno,va_list ap)=&rx_default_verror_handler;
-
 static void error_handler(rx_st_t *rx_st,int erno,...) {
-  va_list ap; va_start(ap,erno); (*rx_st->rnv->rx_verror_handler)(rx_st->rnv, erno,ap); va_end(ap);
+  va_list ap; va_start(ap,erno); rx_default_verror_handler(rx_st->user_data, erno, rx_st->verror_handler, ap); va_end(ap);
 }
 
 #define LEN_M RX_LEN_M
@@ -248,26 +246,40 @@ static void accept_m(rx_st_t *rx_st) {
 
 static void windup(rx_st_t *rx_st);
 void rx_init(rx_st_t *rx_st) {
-    // memset(rx_st, 0, sizeof(rx_st_t));
+  rx_st->verror_handler=&verror_default_handler;
 
-    rx_st->rnv->rx_verror_handler=&rx_default_verror_handler;
+  rx_st->pattern=(int *)m_alloc(rx_st->len_p=P_AVG_SIZE*LEN_P,sizeof(int));
+  rx_st->r2p=(int (*)[2])m_alloc(rx_st->len_2=LEN_2,sizeof(int[2]));
+  rx_st->regex=(char*)m_alloc(rx_st->len_r=R_AVG_SIZE*LEN_R,sizeof(char));
+  rx_st->memo=(int (*)[M_SIZE])m_alloc(rx_st->len_m=LEN_M,sizeof(int[M_SIZE]));
 
-    rx_st->pattern=(int *)m_alloc(rx_st->len_p=P_AVG_SIZE*LEN_P,sizeof(int));
-    rx_st->r2p=(int (*)[2])m_alloc(rx_st->len_2=LEN_2,sizeof(int[2]));
-    rx_st->regex=(char*)m_alloc(rx_st->len_r=R_AVG_SIZE*LEN_R,sizeof(char));
-    rx_st->memo=(int (*)[M_SIZE])m_alloc(rx_st->len_m=LEN_M,sizeof(int[M_SIZE]));
+  rx_st->ht_p.user = rx_st;
+  rx_st->ht_2.user = rx_st;
+  rx_st->ht_r.user = rx_st;
+  rx_st->ht_m.user = rx_st;
 
-    rx_st->ht_p.user = rx_st;
-    rx_st->ht_2.user = rx_st;
-    rx_st->ht_r.user = rx_st;
-    rx_st->ht_m.user = rx_st;
+  ht_init(&rx_st->ht_p,LEN_P,&hash_p,&equal_p);
+  ht_init(&rx_st->ht_2,LEN_2,&hash_2,&equal_2);
+  ht_init(&rx_st->ht_r,LEN_R,&hash_r,&equal_r);
+  ht_init(&rx_st->ht_m,LEN_M,&hash_m,&equal_m);
 
-    ht_init(&rx_st->ht_p,LEN_P,&hash_p,&equal_p);
-    ht_init(&rx_st->ht_2,LEN_2,&hash_2,&equal_2);
-    ht_init(&rx_st->ht_r,LEN_R,&hash_r,&equal_r);
-    ht_init(&rx_st->ht_m,LEN_M,&hash_m,&equal_m);
+  windup(rx_st);
+}
 
-    windup(rx_st);
+void rx_dispose(rx_st_t *rx_st) {
+  ht_dispose(&rx_st->ht_r);
+  ht_dispose(&rx_st->ht_p);
+  ht_dispose(&rx_st->ht_2);
+  ht_dispose(&rx_st->ht_m);
+  if (rx_st->regex)
+    m_free(rx_st->regex);
+  if (rx_st->pattern)
+    m_free(rx_st->pattern);
+  if (rx_st->memo)
+    m_free(rx_st->memo);
+  if (rx_st->r2p)
+    m_free(rx_st->r2p);
+  m_free(rx_st);
 }
 
 void rx_clear(rx_st_t *rx_st) {
@@ -503,11 +515,11 @@ static void bind(rx_st_t *rx_st, int r) {
   getsym(rx_st);
 }
 
-static int compile(rnv_t *rnv, rx_st_t *rx_st, char *rx) {
+static int compile(rx_st_t *rx_st, char *rx) {
   int r=0,p=0,d_r;
   d_r=add_r(rx_st, rx);
   if((r=ht_get(&rx_st->ht_r,rx_st->i_r))==-1) {
-    if(rnv->rx_compact&&rx_st->i_p>=P_AVG_SIZE*LIM_P) {rx_clear(rx_st); d_r=add_r(rx_st, rx);}
+    if(rx_st->rx_compact&&rx_st->i_p>=P_AVG_SIZE*LIM_P) {rx_clear(rx_st); d_r=add_r(rx_st, rx);}
     ht_put(&rx_st->ht_r,r=rx_st->i_r);
     rx_st->i_r+=d_r;
     bind(rx_st, r); p=expression(rx_st); if(rx_st->sym!=SYM_END) error(rx_st, RX_ER_BADCH);
@@ -687,10 +699,10 @@ static int drv(rx_st_t *rx_st, int p,int c) {
   return ret;
 }
 
-int rx_check(rnv_t *rnv, rx_st_t *rx_st, char *rx) {(void)compile(rnv, rx_st, rx); return !rx_st->errors;}
+int rx_check(rx_st_t *rx_st, char *rx) {(void)compile(rx_st, rx); return !rx_st->errors;}
 
-int rx_match(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n) {
-  int p=compile(rnv, rx_st, rx);
+int rx_match(rx_st_t *rx_st, char *rx,char *s,int n) {
+  int p=compile(rx_st, rx);
   if(!rx_st->errors) {
     char *end=s+n;
     int u;
@@ -703,8 +715,8 @@ int rx_match(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n) {
   } else return 0;
 }
 
-int rx_rmatch(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n) {
-  int p=compile(rnv, rx_st, rx);
+int rx_rmatch(rx_st_t *rx_st, char *rx,char *s,int n) {
+  int p=compile(rx_st, rx);
   if(!rx_st->errors) {
     char *end=s+n;
     int u;
@@ -718,8 +730,8 @@ int rx_rmatch(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n) {
   } else return 0;
 }
 
-int rx_cmatch(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n) {
-  int p=compile(rnv, rx_st, rx);
+int rx_cmatch(rx_st_t *rx_st, char *rx,char *s,int n) {
+  int p=compile(rx_st, rx);
   if(!rx_st->errors) {
     char *end=s+n;
     int u;