ruby_rnv 0.3.0 → 0.5.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"
@@ -28,10 +27,10 @@
 #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;
@@ -40,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;
 }
 
@@ -62,47 +59,47 @@ 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]));
 }
 
@@ -119,39 +116,46 @@ static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, ch
 
 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, int uri, char *typ,char *ps,char *s,int n) {
-  return xsd_allows(rx_st, typ,ps,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 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);
-}
-
-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,
@@ -168,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;
 }
 
@@ -203,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)) {
@@ -236,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;
 }
@@ -249,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:
@@ -281,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;
 }
 
@@ -295,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)) {
@@ -325,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;
 }
@@ -377,7 +381,18 @@ 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);
+    int i;
+    // avoid dtl called multiple times for same data
+    for(i = 0;i<drv_st->n_dtl_cb;i++) {
+      if(drv_st->dtl_cb[i].p == p)
+        ret = drv_st->dtl_cb[i].ret;
+    }
+    if(!ret) {
     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;
+    drv_st->dtl_cb[drv_st->n_dtl_cb].p = p;
+    drv_st->dtl_cb[drv_st->n_dtl_cb].ret = ret;
+    drv_st->n_dtl_cb++;
+    }
     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;
@@ -391,6 +406,7 @@ static int text(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, drv_st_t *drv_st, in
 }
 
 static int textws(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, drv_st_t *drv_st, int p,char *s,int n) {
+  drv_st->n_dtl_cb = 0;
   int p1=text(rnv, rn_st, rx_st, drv_st, p,s,n),ws=1;
   char *end=s+n;
   while(s!=end) {if(!xmlc_white_space(*s)) {ws=0; break;} ++s;}
@@ -401,7 +417,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:
@@ -430,8 +446,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);}
@@ -440,7 +456,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)) {
@@ -459,8 +475,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

@@ -15,10 +15,11 @@ struct dtl {
   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(rnv_t *rnv, int erno,va_list ap);
+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,

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) {

data/ext/rnv/src/rn.h

@@ -142,7 +142,7 @@ extern void rn_add_psval(rnv_t *rnv, rn_st_t *rn_st, char *s);
 extern void rn_end_ps(rnv_t *rnv, rn_st_t *rn_st);
 
 extern void rn_init(rnv_t *rnv, rn_st_t *rn_st);
-extern void rn_clear(rnv_t *rnv, rn_st_t *rn_st);
+extern void rn_dispose(rn_st_t *rn_st);
 
 extern void rn_compress(rnv_t *rnv, rn_st_t *rn_st, int *starts,int n);
 extern int rn_compress_last(rnv_t *rnv, rn_st_t *rn_st, int start);

data/ext/rnv/src/rnc.c

@@ -1,7 +1,4 @@
-#include "type.h"
-
 /* $Id: rnc.c,v 1.74 2004/08/18 19:10:51 dvd Exp $ */
-
 #include <fcntl.h> /* open, close */
 #include <sys/types.h>
 #include <unistd.h> /* open,read,close */
@@ -9,6 +6,8 @@
 #include <errno.h> /*errno*/
 #include <assert.h> /*assert*/
 
+#include "type.h"
+
 #include "u.h"
 #include "xmlc.h"
 #include "m.h"
@@ -75,9 +74,9 @@ static char *kwdtab[NKWD]={
 #define SYM_DOCUMENTATION 41 /* ## */
 #define SYM_LITERAL 42
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RNC,"%s:%i:%i: error: "msg"\n",ap)
-#define warn(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RNC,"%s:%i:%i: warning: "msg"\n",ap)
-void rnc_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+#define err(msg) (*handler)(data,erno|ERBIT_RNC,"%s:%i:%i: error: "msg"\n",ap)
+#define warn(msg) (*handler)(data,erno|ERBIT_RNC,"%s:%i:%i: warning: "msg"\n",ap)
+void rnc_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   switch(erno) {
   case RNC_ER_IO: err("I/O error: %s\n"); break;
   case RNC_ER_UTF: err("invalid UTF-8 sequence"); break;
@@ -171,6 +170,9 @@ static void rnc_source_init(struct rnc_source *sp,char *fn) {
   sp->cur=0;
   for(i=0;i!=2;++i)  sp->sym[i].s=(char*)m_alloc(
     sp->sym[i].slen=BUFSIZE,sizeof(char));
+
+  if(!sp->verror_handler)
+    sp->verror_handler= &verror_default_handler;
 }
 
 static int rnc_read(struct rnc_source *sp) {
@@ -201,20 +203,29 @@ int rnc_errors(struct rnc_source *sp) {
 #define DE_CHOICE 8
 #define DE_ILEAVE 16
 
-void rnc_init(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st) {
-    memset(rnc_st, 0, sizeof(rnc_st_t));
-    rnv->rnc_verror_handler=&rnc_default_verror_handler;
-    rn_init(rnv, rn_st);
+void rnc_init(rnc_st_t *rnc_st) {
+    rnc_st->verror_handler = &verror_default_handler;
     rnc_st->len_p=LEN_P; rnc_st->path=(char*)m_alloc(rnc_st->len_p,sizeof(char));
     /* initialize scopes */
     sc_init(&rnc_st->nss); sc_init(&rnc_st->dts); sc_init(&rnc_st->defs); sc_init(&rnc_st->refs); sc_init(&rnc_st->prefs);
 }
 
-void rnc_clear(void) {}
+void rnc_dispose(rnc_st_t *rnc_st) {
+  if (rnc_st->path)
+    m_free(rnc_st->path);
+
+  sc_dispose(&rnc_st->nss);
+  sc_dispose(&rnc_st->dts);
+  sc_dispose(&rnc_st->defs);
+  sc_dispose(&rnc_st->refs);
+  sc_dispose(&rnc_st->prefs);
+
+  m_free(rnc_st);
+}
 
 static void error(int force,struct rnc_source *sp,int erno,...) {
   if(force || sp->line != sp->prevline) {
-    va_list ap; va_start(ap,erno); sp->rnv->rnc_verror_handler(sp->rnv, erno,ap); va_end(ap);
+    va_list ap; va_start(ap,erno); rnc_default_verror_handler(sp->user_data, erno, sp->verror_handler, ap); va_end(ap);
     sp->prevline=sp->line;
   }
   sp->flags|=SRC_ERRORS;
@@ -222,7 +233,7 @@ static void error(int force,struct rnc_source *sp,int erno,...) {
 
 static void warning(int force,struct rnc_source *sp,int erno,...) {
   if(force || sp->line != sp->prevline) {
-    va_list ap; va_start(ap,erno); sp->rnv->rnc_verror_handler(sp->rnv, erno,ap); va_end(ap);
+    va_list ap; va_start(ap,erno); rnc_default_verror_handler(sp->user_data, erno,sp->verror_handler, ap); va_end(ap);
   }
 }
 
@@ -902,7 +913,8 @@ static void add_well_known_nss(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, int
 static int file(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, struct rnc_source *sp,int nsuri) {
   int ret=0;
   struct rnc_source src;
-  src.rnv = rnv;
+  src.verror_handler = rnv->verror_handler;
+  src.user_data = rnv->user_data;
   add_well_known_nss(rnv, rnc_st, rn_st, nsuri);
   if(rnc_open(&src,rnc_st->path)!=-1) {
     ret=topLevel(rnv, rnc_st, rn_st, &src);
@@ -1107,6 +1119,7 @@ static void include(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, struct rnc_sou
     nsuri=inherit(rnv, rnc_st, rn_st, sp);
     sc_open(&rnc_st->nss); open_scope(rnc_st, sp);
     if(file(rnv, rnc_st, rn_st, sp,nsuri)!=-1) error(1,sp,RNC_ER_NOTGR,sp->fn,CUR(sp).line,CUR(sp).col);
+    sc_close(&rnc_st->nss);
     sc_lock(&rnc_st->defs);
     if(CUR(sp).sym==SYM_LCUR) {
       getsym(sp);
@@ -1114,7 +1127,6 @@ static void include(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, struct rnc_sou
       chk_skip_get(sp,SYM_RCUR);
     }
     fold_scope(rnv, rnc_st, rn_st, sp);
-    sc_close(&rnc_st->nss);
   }
 }
 
@@ -1154,7 +1166,7 @@ static int topLevel(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, struct rnc_sou
   getsym(sp); getsym(sp);
   while(decl(rnv, rn_st, rnc_st, sp));
   if((is_grammar=(CUR(sp).sym==SYM_GRAMMAR))) {
-    chk_get(sp,SYM_LCUR);
+    getsym(sp);chk_get(sp,SYM_LCUR);
   }
   if(grammarContent(rnv, rn_st, rnc_st, sp)) {
     while(grammarContent(rnv, rn_st, rnc_st, sp));