ruby_rnv 0.2.2 → 0.4.0

data/ext/rnv/src/ary.c

@@ -1,6 +1,5 @@
-#include "type.h"
-
 /* $Id: ary.c,v 1.4 2004/02/25 00:00:32 dvd Exp $ */
+#include "type.h"
 
 #include "rn.h"
 #include "ary.h"

data/ext/rnv/src/drv.c

@@ -1,6 +1,5 @@
-#include "type.h"
-
 /* $Id: drv.c,v 1.41 2004/03/13 13:28:02 dvd Exp $ */
+#include "type.h"
 
 #include "xmlc.h" /*xmlc_white_space*/
 #include "m.h"
@@ -13,12 +12,6 @@
 #include "er.h"
 #include "drv.h"
 
-struct dtl {
-  int uri;
-  int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n);
-  int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n);
-};
-
 #define LEN_DTL DRV_LEN_DTL
 #define LEN_M DRV_LEN_M
 #define PRIME_M DRV_PRIME_M
@@ -34,10 +27,10 @@ struct dtl {
 #define M_SET(p) drv_st->memo[drv_st->i_m][M_SIZE-1]=p
 #define M_RET(m) drv_st->memo[m][M_SIZE-1]
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_DRV,msg"\n",ap);
-void drv_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+#define err(msg) (*handler)(data,erno|ERBIT_DRV,msg"\n",ap);
+void drv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   if(erno&ERBIT_XSD) {
-    xsd_default_verror_handler(rnv, erno&~ERBIT_XSD,ap);
+    xsd_default_verror_handler(data, erno&~ERBIT_XSD,handler, ap);
   } else {
     switch(erno) {
     case DRV_ER_NODTL: err("no datatype library for URI '%s'"); break;
@@ -46,14 +39,12 @@ void drv_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->drv_verror_handler)(rnv, erno,ap); va_end(ap);
+static void error_handler(drv_st_t *drv_st,int erno,...) {
+  va_list ap; va_start(ap,erno); drv_default_verror_handler(drv_st->user_data, erno, drv_st->verror_handler, ap); va_end(ap);
 }
 
-static void verror_handler_xsd(rnv_t *rnv, int erno,va_list ap) {drv_default_verror_handler(rnv,erno|ERBIT_XSD,ap);}
-
-static void new_memo(rnv_t *rnv, drv_st_t *drv_st, int typ) {
-  if(rnv->drv_compact) ht_deli(&drv_st->ht_m,drv_st->i_m);
+static void new_memo(drv_st_t *drv_st, int typ) {
+  if(drv_st->drv_compact) ht_deli(&drv_st->ht_m,drv_st->i_m);
   drv_st->memo[drv_st->i_m][0]=typ;
 }
 
@@ -68,54 +59,54 @@ static int hash_m(void *user, int m) {
   return ((me[0]&0x7)|((me[1]^me[2]^me[3])<<3))*PRIME_M;
 }
 
-static int newStartTagOpen(rnv_t *rnv, drv_st_t *drv_st, int p,int uri,int name) {
+static int newStartTagOpen(drv_st_t *drv_st, int p,int uri,int name) {
   int *me=drv_st->memo[drv_st->i_m];
-  new_memo(rnv, drv_st, M_STO);
+  new_memo(drv_st, M_STO);
   me[1]=p; me[2]=uri; me[3]=name;
   return ht_get(&drv_st->ht_m,drv_st->i_m);
 }
 
-static int newAttributeOpen(rnv_t *rnv, drv_st_t *drv_st, int p,int uri,int name) {
+static int newAttributeOpen(drv_st_t *drv_st, int p,int uri,int name) {
   int *me=drv_st->memo[drv_st->i_m];
-  new_memo(rnv, drv_st, M_ATT);
+  new_memo(drv_st, M_ATT);
   me[1]=p; me[2]=uri; me[3]=name;
   return ht_get(&drv_st->ht_m,drv_st->i_m);
 }
 
-static int newStartTagClose(rnv_t *rnv, drv_st_t *drv_st, int p) {
+static int newStartTagClose(drv_st_t *drv_st, int p) {
   int *me=drv_st->memo[drv_st->i_m];
-  new_memo(rnv, drv_st, M_STC);
+  new_memo(drv_st, M_STC);
   me[1]=p; me[2]=me[3]=0;
   return ht_get(&drv_st->ht_m,drv_st->i_m);
 }
 
-static int newMixedText(rnv_t *rnv, drv_st_t *drv_st, int p) {
+static int newMixedText(drv_st_t *drv_st, int p) {
   int *me=drv_st->memo[drv_st->i_m];
-  new_memo(rnv, drv_st, M_TXT);
+  new_memo(drv_st, M_TXT);
   me[1]=p; me[2]=me[3]=0;
   return ht_get(&drv_st->ht_m,drv_st->i_m);
 }
 
-static int newEndTag(rnv_t *rnv, drv_st_t *drv_st, int p) {
+static int newEndTag(drv_st_t *drv_st, int p) {
   int *me=drv_st->memo[drv_st->i_m];
-  new_memo(rnv, drv_st, M_END);
+  new_memo(drv_st, M_END);
   me[1]=p; me[2]=me[3]=0;
   return ht_get(&drv_st->ht_m,drv_st->i_m);
 }
 
-static void accept_m(rnv_t *rnv, drv_st_t *drv_st) {
+static void accept_m(drv_st_t *drv_st) {
   if(ht_get(&drv_st->ht_m,drv_st->i_m)!=-1) {
-    if(rnv->drv_compact) ht_del(&drv_st->ht_m,drv_st->i_m); else return;
+    if(drv_st->drv_compact) ht_del(&drv_st->ht_m,drv_st->i_m); else return;
   }
   ht_put(&drv_st->ht_m,drv_st->i_m++);
-  if(rnv->drv_compact&&drv_st->i_m==LIM_M) drv_st->i_m=0;
+  if(drv_st->drv_compact&&drv_st->i_m==LIM_M) drv_st->i_m=0;
   if(drv_st->i_m==drv_st->len_m) drv_st->memo=(int(*)[M_SIZE])m_stretch(drv_st->memo,drv_st->len_m=2*drv_st->i_m,drv_st->i_m,sizeof(int[M_SIZE]));
 }
 
-static int fallback_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {return 1;}
-static int fallback_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
+static int fallback_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {return 1;}
+static int fallback_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {return 1;}
 
-static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {
+static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {
   int dt=rn_newDatatype(rnv, rn_st, 0,typ-rnv->rn_string);
   if(dt==rnv->rn_dt_string) return s_cmpn(val,s,n)==0;
   else if(dt==rnv->rn_dt_token) return s_tokcmpn(val,s,n)==0;
@@ -123,44 +114,53 @@ static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,c
   return 0;
 }
 
-static int builtin_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
+static int builtin_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {return 1;}
 
-static void windup(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st);
+static int emb_xsd_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {
+  return xsd_allows(rx_st, typ,ps,s,n);
+}
+
+static int emb_xsd_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {
+  return xsd_equal(rx_st, typ,val,s,n);
+}
 
 void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st) {
-    rnv->drv_verror_handler=&drv_default_verror_handler;
-    rn_init(rnv, rn_st);
-    rx_st->rnv = rnv;
+    rx_st->verror_handler = &verror_default_handler;
+    drv_st->verror_handler = &verror_default_handler;
+    
     xsd_init(rx_st);
-    rnv->xsd_verror_handler=&verror_handler_xsd;
+    
+    if(rnv->verror_handler)
+      rx_st->verror_handler = rnv->verror_handler;
+    rx_st->user_data = rnv->user_data;
+
     drv_st->memo=(int (*)[M_SIZE])m_alloc(drv_st->len_m=LEN_M,sizeof(int[M_SIZE]));
     drv_st->dtl=(struct dtl*)m_alloc(drv_st->len_dtl=LEN_DTL,sizeof(struct dtl));
     drv_st->ht_m.user = drv_st;
     ht_init(&drv_st->ht_m,LEN_M,&hash_m,&equal_m);
-    windup(rnv, drv_st, rn_st);
-}
-
-static int emb_xsd_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {
-  return xsd_allows(rx_st, typ,ps,s,n);
-}
 
-static int emb_xsd_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {
-  return xsd_equal(rx_st, typ,val,s,n);
-}
+    drv_st->i_m=0; drv_st->n_dtl=0;
+    drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&fallback_equal,&fallback_allows); /* guard at 0 */
+    drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&builtin_equal,&builtin_allows);
+    drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+rnv->rn_xsd_uri,&emb_xsd_equal,&emb_xsd_allows);
 
-static void windup(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st) {
-  drv_st->i_m=0; drv_st->n_dtl=0;
-  drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&fallback_equal,&fallback_allows); /* guard at 0 */
-  drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&builtin_equal,&builtin_allows);
-  drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+rnv->rn_xsd_uri,&emb_xsd_equal,&emb_xsd_allows);
+    if(rnv->verror_handler)
+      drv_st->verror_handler = rnv->verror_handler;
+    drv_st->user_data = rnv->user_data;
 }
 
-void drv_clear(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st) {
-  ht_clear(&drv_st->ht_m);
-  windup(rnv, drv_st, rn_st);
+void drv_dispose(drv_st_t *drv_st) {
+  if (drv_st->memo)
+    m_free(drv_st->memo);
+  if (drv_st->dtl)
+    m_free(drv_st->dtl);
+  ht_dispose(&drv_st->ht_m);
+  m_free(drv_st);
 }
 
-void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n),int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n)) {
+void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
+    int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
+    int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n)) {
   if(drv_st->n_dtl==drv_st->len_dtl) drv_st->dtl=(struct dtl *)m_stretch(drv_st->dtl,drv_st->len_dtl=drv_st->n_dtl*2,drv_st->n_dtl,sizeof(struct dtl));
   drv_st->dtl[drv_st->n_dtl].uri=rn_newString(rnv, rn_st, suri);
   drv_st->dtl[drv_st->n_dtl].equal=equal;
@@ -172,7 +172,7 @@ static struct dtl *getdtl(rnv_t *rnv, drv_st_t *drv_st, int uri) {
   int i;
   drv_st->dtl[0].uri=uri; i=drv_st->n_dtl;
   while(drv_st->dtl[--i].uri!=uri);
-  if(i==0) error_handler(rnv, DRV_ER_NODTL,rnv->rn_string+uri);
+  if(i==0) error_handler(drv_st, DRV_ER_NODTL,rnv->rn_string+uri);
   return drv_st->dtl+i;
 }
 
@@ -207,7 +207,7 @@ static int apply_after(rnv_t *rnv, rn_st_t *rn_st, int (*f)(rnv_t *rnv, rn_st_t
 static int start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int uri,int name,int recover) {
   int nc,p1,p2,m,ret=0;
   if(!recover) {
-    m=newStartTagOpen(rnv, drv_st, p,uri,name);
+    m=newStartTagOpen(drv_st, p,uri,name);
     if(m!=-1) return M_RET(m);
   }
   switch(RN_P_TYP(p)) {
@@ -240,8 +240,8 @@ static int start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,in
   default: assert(0);
   }
   if(!recover) {
-    newStartTagOpen(rnv, drv_st, p,uri,name); M_SET(ret);
-    accept_m(rnv, drv_st);
+    newStartTagOpen(drv_st, p,uri,name); M_SET(ret);
+    accept_m(drv_st);
   }
   return ret;
 }
@@ -253,7 +253,7 @@ static int puorg_rn(rnv_t *rnv, rn_st_t *rn_st, int p2,int p1) {return rn_group(
 
 static int attribute_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int uri,int name) {
   int nc,p1,p2,m,ret=0;
-  m=newAttributeOpen(rnv, drv_st, p,uri,name);
+  m=newAttributeOpen(drv_st, p,uri,name);
   if(m!=-1) return M_RET(m);
   switch(RN_P_TYP(p)) {
   case RN_P_NOT_ALLOWED: case RN_P_EMPTY: case RN_P_TEXT:
@@ -285,8 +285,8 @@ static int attribute_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,in
     break;
   default: assert(0);
   }
-  newAttributeOpen(rnv, drv_st, p,uri,name); M_SET(ret);
-  accept_m(rnv, drv_st);
+  newAttributeOpen(drv_st, p,uri,name); M_SET(ret);
+  accept_m(drv_st);
   return ret;
 }
 
@@ -299,7 +299,7 @@ extern int drv_attribute_close_recover(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn
 static int start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recover) {
   int p1,p2,ret=0,m;
   if(!recover) {
-    m=newStartTagClose(rnv, drv_st, p);
+    m=newStartTagClose(drv_st, p);
     if(m!=-1) return M_RET(m);
   }
   switch(RN_P_TYP(p)) {
@@ -329,8 +329,8 @@ static int start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,i
   default: assert(0);
   }
   if(!recover) {
-    newStartTagClose(rnv, drv_st, p); M_SET(ret);
-    accept_m(rnv, drv_st);
+    newStartTagClose(drv_st, p); M_SET(ret);
+    accept_m(drv_st);
   }
   return ret;
 }
@@ -381,13 +381,13 @@ static int text(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, drv_st_t *drv_st, in
     ret=rn_nullable(list(rnv, rn_st, rx_st, drv_st, p1,s,n))?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_DATA: rn_Data(p,dt,ps); rn_Datatype(dt,lib,typ);
-    ret=getdtl(rnv, drv_st, lib)->allows(rnv,rn_st,rx_st,rnv->rn_string+typ,rnv->rn_string+ps,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
+    ret=getdtl(rnv, drv_st, lib)->allows(rnv,rn_st,rx_st, lib, rnv->rn_string+typ,rnv->rn_string+ps,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_DATA_EXCEPT: rn_DataExcept(p,p1,p2);
     ret=text(rnv, rn_st, rx_st, drv_st, p1,s,n)==rnv->rn_empty&&!rn_nullable(text(rnv, rn_st, rx_st, drv_st, p2,s,n))?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_VALUE: rn_Value(p,dt,val); rn_Datatype(dt,lib,typ);
-    ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
+    ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, lib, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   default: assert(0);
   }
@@ -405,7 +405,7 @@ int drv_text_recover(int p,char *s,int n) {return p;}
 
 static int mixed_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p) { /* matches text in mixed context */
   int p1,p2,ret=0,m;
-  m=newMixedText(rnv, drv_st, p);
+  m=newMixedText(drv_st, p);
   if(m!=-1) return M_RET(m);
   switch(RN_P_TYP(p)) {
   case RN_P_NOT_ALLOWED: case RN_P_EMPTY:
@@ -434,8 +434,8 @@ static int mixed_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p) { /*
     break;
   default: assert(0);
   }
-  newMixedText(rnv, drv_st, p); M_SET(ret);
-  accept_m(rnv, drv_st);
+  newMixedText(drv_st, p); M_SET(ret);
+  accept_m(drv_st);
   return ret;
 }
 int drv_mixed_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p) {return mixed_text(rnv, drv_st, rn_st, p);}
@@ -444,7 +444,7 @@ int drv_mixed_text_recover(int p) {return p;}
 static int end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recover) {
   int p1,p2,ret=0,m;
   if(!recover) {
-    m=newEndTag(rnv, drv_st, p);
+    m=newEndTag(drv_st, p);
     if(m!=-1) return M_RET(m);
   }
   switch(RN_P_TYP(p)) {
@@ -463,8 +463,8 @@ static int end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recov
   default: assert(0);
   }
   if(!recover) {
-    newEndTag(rnv, drv_st, p); M_SET(ret);
-    accept_m(rnv, drv_st);
+    newEndTag(drv_st, p); M_SET(ret);
+    accept_m(drv_st);
   }
   return ret;
 }

data/ext/rnv/src/drv.h

@@ -9,13 +9,22 @@
 
 #define DRV_ER_NODTL 0
 
-extern void drv_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+struct dtl {
+  int uri;
+  int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n);
+  int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n);
+};
+
+extern void drv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
 extern void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st);
-extern void drv_clear(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st);
+
+extern void drv_dispose(drv_st_t *drv_st);
 
 /* Expat passes character data unterminated.  Hence functions that can deal with cdata expect the length of the data */
-extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n),int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n));
+extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
+int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
+int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n));
 
 extern int drv_start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);
 extern int drv_start_tag_open_recover(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);

data/ext/rnv/src/er.c

@@ -12,4 +12,4 @@ int er_default_printf(char *format,...) {
   return ret;
 }
 int er_default_vprintf(char *format,va_list ap) {return vfprintf(stderr,format,ap);}
-int verror_default_handler(rnv_t *rnv, int erno, char *format,va_list ap) {return vfprintf(stderr,format,ap);}
+int verror_default_handler(void *data, int erno, char *format,va_list ap) {return vfprintf(stderr,format,ap);}

data/ext/rnv/src/er.h

@@ -11,6 +11,6 @@ extern int (*er_vprintf)(char *format,va_list ap);
 
 extern int er_default_printf(char *format,...);
 extern int er_default_vprintf(char *format,va_list ap);
-extern int verror_default_handler(rnv_t *rnv, int erno, char *format,va_list ap);
+extern int verror_default_handler(void *data, int erno, char *format,va_list ap);
 
 #endif

data/ext/rnv/src/erbit.h

@@ -6,9 +6,12 @@
 #define ERBIT_RNC 0x01000
 #define ERBIT_RND 0x02000
 #define ERBIT_RNL 0x04000
+
 #define ERBIT_RX  0x08000
 #define ERBIT_XSD 0x10000
 #define ERBIT_DRV 0x20000
 #define ERBIT_RNV 0x40000
 
+#define ERBIT_DTL 0x80000
+
 #endif

data/ext/rnv/src/rn.c

@@ -1,8 +1,9 @@
-#include "type.h"
-
 /* $Id: rn.c,v 1.62 2004/03/13 14:12:11 dvd Exp $ */
 
 #include <string.h> /* strcmp,strlen,strcpy*/
+
+#include "type.h"
+
 #include "m.h"
 #include "s.h" /* s_hval */
 #include "ht.h"
@@ -276,10 +277,7 @@ static int equal_p(void *user, int p1,int p2);
 static int equal_nc(void *user, int nc1,int nc2);
 static int equal_s(void *user, int s1,int s2);
 
-static void windup(rnv_t *rnv, rn_st_t *rn_st);
-
 void rn_init(rnv_t *rnv, rn_st_t *rn_st) {
-    memset(rn_st, 0, sizeof(rn_st_t));
     rnv->rn_pattern=(int *)m_alloc(rn_st->len_p=P_AVG_SIZE*LEN_P,sizeof(int));
     rnv->rn_nameclass=(int *)m_alloc(rn_st->len_nc=NC_AVG_SIZE*LEN_NC,sizeof(int));
     rnv->rn_string=(char*)m_alloc(rn_st->len_s=S_AVG_SIZE*LEN_S,sizeof(char));
@@ -289,27 +287,27 @@ void rn_init(rnv_t *rnv, rn_st_t *rn_st) {
     ht_init(&rn_st->ht_p,LEN_P,&hash_p,&equal_p);
     ht_init(&rn_st->ht_nc,LEN_NC,&hash_nc,&equal_nc);
     ht_init(&rn_st->ht_s,LEN_S,&hash_s,&equal_s);
-    windup(rnv, rn_st);
-}
-
-void rn_clear(rnv_t *rnv, rn_st_t *rn_st) {
-  ht_clear(&rn_st->ht_p); ht_clear(&rn_st->ht_nc); ht_clear(&rn_st->ht_s);
-  windup(rnv, rn_st);
-}
-
-static void windup(rnv_t *rnv, rn_st_t *rn_st) {
-  rn_st->i_p=rn_st->i_nc=rn_st->i_s=0;
-  rn_st->adding_ps=0;
-  rnv->rn_pattern[0]=RN_P_ERROR;  accept_p(rnv, rn_st);
-  rnv->rn_nameclass[0]=RN_NC_ERROR; accept_nc(rnv, rn_st);
-  rn_newString(rnv, rn_st, "");
-  rnv->rn_notAllowed=rn_newNotAllowed(rnv, rn_st); 
-  rnv->rn_empty=rn_newEmpty(rnv, rn_st); 
-  rnv->rn_text=rn_newText(rnv, rn_st); 
-  rn_st->BASE_P=rn_st->i_p;
-  rnv->rn_dt_string=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "string")); 
-  rnv->rn_dt_token=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "token"));
-  rnv->rn_xsd_uri=rn_newString(rnv, rn_st, "http://www.w3.org/2001/XMLSchema-datatypes");
+
+    rn_st->i_p=rn_st->i_nc=rn_st->i_s=0;
+    rn_st->adding_ps=0;
+    rnv->rn_pattern[0]=RN_P_ERROR;  accept_p(rnv, rn_st);
+    rnv->rn_nameclass[0]=RN_NC_ERROR; accept_nc(rnv, rn_st);
+    rn_newString(rnv, rn_st, "");
+    rnv->rn_notAllowed=rn_newNotAllowed(rnv, rn_st); 
+    rnv->rn_empty=rn_newEmpty(rnv, rn_st); 
+    rnv->rn_text=rn_newText(rnv, rn_st); 
+    rn_st->BASE_P=rn_st->i_p;
+    rnv->rn_dt_string=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "string")); 
+    rnv->rn_dt_token=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "token"));
+    rnv->rn_xsd_uri=rn_newString(rnv, rn_st, "http://www.w3.org/2001/XMLSchema-datatypes");
+}
+
+void rn_dispose(rn_st_t *rn_st) {
+  ht_dispose(&rn_st->ht_p);
+  ht_dispose(&rn_st->ht_nc);
+  ht_dispose(&rn_st->ht_s);
+
+  m_free(rn_st);
 }
 
 static int hash_p(void *user, int p) {