ruby_rnv 0.2.2 → 0.4.0

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;

data/ext/rnv/src/rx.h

@@ -19,16 +19,15 @@
 #define RX_ER_DNUOB 10
 #define RX_ER_NOTRC 11
 
-//extern void (*rx_verror_handler)(int erno,va_list ap);
-//extern int rx_compact;
-
-extern void rx_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+extern void rx_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
 
 extern void rx_init(rx_st_t *rx_st);
 extern void rx_clear(rx_st_t *rx_st);
 
+extern void rx_dispose(rx_st_t *rx_st);
+
 /* just compiles the expression to check the syntax */
-extern int rx_check(rnv_t *rnv, rx_st_t *rx_st, char *rx);
+extern int rx_check(rx_st_t *rx_st, char *rx);
 
 /*
  returns positive value if the s[0..n] ~= rx, 0 if not, -1 on regex error;
@@ -36,8 +35,8 @@ extern int rx_check(rnv_t *rnv, rx_st_t *rx_st, char *rx);
  rmatch replaces white space in s with 0x20,
  cmatch collapses white space.
  */
-extern int rx_match(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n);
-extern int rx_rmatch(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n);
-extern int rx_cmatch(rnv_t *rnv, rx_st_t *rx_st, char *rx,char *s,int n);
+extern int rx_match(rx_st_t *rx_st, char *rx,char *s,int n);
+extern int rx_rmatch(rx_st_t *rx_st, char *rx,char *s,int n);
+extern int rx_cmatch(rx_st_t *rx_st, char *rx,char *s,int n);
 
 #endif

data/ext/rnv/src/sc.c

@@ -1,5 +1,6 @@
 /* $Id: sc.c,v 1.16 2004/03/13 13:28:02 dvd Exp $ */
 
+#include <stdlib.h> /*NULL*/
 #include <assert.h> /*assert*/
 #include "m.h"
 #include "ll.h"
@@ -20,6 +21,10 @@ void sc_init(struct sc_stack *stp) {
   windup(stp);
 }
 
+void sc_dispose(struct sc_stack *stp) {
+  m_free(stp->tab); stp->tab = NULL;
+}
+
 void sc_clear(struct sc_stack *stp) {
   windup(stp);
 }

data/ext/rnv/src/sc.h

@@ -12,6 +12,7 @@ struct sc_stack {
 
 extern void sc_init(struct sc_stack *stp);
 extern void sc_clear(struct sc_stack *stp);
+extern void sc_dispose(struct sc_stack *stp);
 
 extern void sc_open(struct sc_stack *stp);
 extern void sc_lock(struct sc_stack *stp);

data/ext/rnv/src/type.h

@@ -20,14 +20,54 @@ typedef struct rn_st
   int len_nc;
   int len_s;
   int adding_ps;
+
 } rn_st_t;
 
+struct rnc_cym {
+  char *s; int slen;
+  int line,col;
+  int sym;
+};
+
+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];
+
+  int (*verror_handler)(void *data, int erno, char *format, va_list ap);
+  void *user_data;
+};
+
+typedef struct rnc_st
+{
+  int len_p;
+  char *path;
+  struct sc_stack nss;
+  struct sc_stack dts;
+  struct sc_stack defs;
+  struct sc_stack refs;
+  struct sc_stack prefs;
+
+  int (*verror_handler)(void *data, int erno, char *format, va_list ap);
+  void *user_data;
+
+} rnc_st_t;
+
 typedef struct rnd_st
 {
   int len_f;
   int n_f;
   int *flat;
   int errors;
+
+  int (*verror_handler)(void *data, int erno, char *format, va_list ap);
+  void *user_data;
+
 } rnd_st_t;
 
 typedef struct rnv rnv_t;
@@ -58,25 +98,12 @@ typedef struct rx_st
   int (*memo)[3];
   int (*r2p)[2];
 
-  // FIXME: for error handlers
-  rnv_t *rnv;
-} rx_st_t;
+  int rx_compact;
 
-typedef struct rnx_st
-{
-  int len_exp;
-} rnx_st_t;
+  int (*verror_handler)(void *data, int erno, char *format, va_list ap);
+  void *user_data;
 
-typedef struct rnc_st
-{
-  int len_p;
-  char *path;
-  struct sc_stack nss;
-  struct sc_stack dts;
-  struct sc_stack defs;
-  struct sc_stack refs;
-  struct sc_stack prefs;
-} rnc_st_t;
+} rx_st_t;
 
 typedef struct drv_st
 {
@@ -87,6 +114,12 @@ typedef struct drv_st
   int len_m;
   struct hashtable ht_m;
   int (*memo)[5];
+
+  int drv_compact;
+
+  int (*verror_handler)(void *data, int erno, char *format, va_list ap);
+  void *user_data;
+
 } drv_st_t;
 
 typedef struct rnv
@@ -100,22 +133,13 @@ typedef struct rnv
   int rn_dt_string;
   int rn_dt_token;
   int rn_xsd_uri;
-  int rx_compact;
+
   int rnx_n_exp;
   int *rnx_exp;
-  int drv_compact;
-
-  int (*verror_handler)(rnv_t *rnv, int erno, char *format,va_list ap);
-  void (*drv_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*rnc_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*rnd_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*rnl_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*rnv_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*rx_verror_handler)(rnv_t *rnv, int erno, va_list ap);
-  void (*xsd_verror_handler)(rnv_t *rnv, int erno, va_list ap);
+  int rnx_len_exp;
 
+  int (*verror_handler)(void *data, int erno, char *format,va_list ap);
   void *user_data;
-
 } rnv_t;
 
 #endif // TYPE_H

data/ext/rnv/src/xcl.c

@@ -68,7 +68,7 @@ static int mixed = 0;
 static char *xgfile = NULL, *xgpos = NULL;
 
 #define err(msg) (*rnv->verror_handler)(rnv,erno,msg "\n", ap);
-static void verror_handler(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int erno, va_list ap)
+static void verror_handler(rnv_t *rnv, xcl_st_t *xcl_st, int erno, va_list ap)
 {
   if (erno & ERBIT_RNL)
   {
@@ -94,7 +94,7 @@ static void verror_handler(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int e
           char *s;
           while (req--)
           {
-            rnx_expected(rnv, rnx_st, xcl_st->previous, req);
+            rnx_expected(rnv,  xcl_st->previous, req);
             if (i == rnv->rnx_n_exp)
               continue;
             if (rnv->rnx_n_exp > xcl_st->nexp)
@@ -129,18 +129,18 @@ static void verror_handler(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int e
   }
 }
 
-static void verror_handler_rnl(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int erno, va_list ap) { verror_handler(rnv, xcl_st, rnx_st, erno | ERBIT_RNL, ap); }
-static void verror_handler_rnv(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int erno, va_list ap) { verror_handler(rnv, xcl_st, rnx_st, erno | ERBIT_RNV, ap); }
+static void verror_handler_rnl(rnv_t *rnv, xcl_st_t *xcl_st, int erno, va_list ap) { verror_handler(rnv, xcl_st,  erno | ERBIT_RNL, ap); }
+static void verror_handler_rnv(rnv_t *rnv, xcl_st_t *xcl_st, int erno, va_list ap) { verror_handler(rnv, xcl_st,  erno | ERBIT_RNV, ap); }
 
 static void windup(xcl_st_t *xcl_st);
-static void init(rnv_t *rnv, xcl_st_t *xcl_st, rn_st_t *rn_st, rnd_st_t *rnd_st, rnc_st_t *rnc_st, rnx_st_t *rnx_st, drv_st_t *drv_st, rx_st_t *rx_st)
+static void init(rnv_t *rnv, xcl_st_t *xcl_st, rn_st_t *rn_st, rnc_st_t *rnc_st, rnd_st_t *rnd_st, drv_st_t *drv_st, rx_st_t *rx_st)
 {
     rnv->verror_handler=&verror_default_handler;
-    rnl_init(rnv, rn_st, rnd_st, rnc_st);
+    rnl_init(rnv, rnc_st, rn_st, rnd_st);
     //rnl_verror_handler = &verror_handler_rnl;
     rnv_init(rnv, drv_st, rn_st, rx_st);
     //rnv_verror_handler = &verror_handler_rnv;
-    rnx_init(rnv, rnx_st);
+    rnx_init(rnv);
     xcl_st->text = (char *)m_alloc(xcl_st->len_txt = LEN_T, sizeof(char));
     windup(xcl_st);
 }
@@ -162,11 +162,11 @@ static void windup(xcl_st_t *xcl_st)
   xcl_st->lastline = xcl_st->lastcol = -1;
 }
 
-static void error_handler(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int erno, ...)
+static void error_handler(rnv_t *rnv, xcl_st_t *xcl_st, int erno, ...)
 {
   va_list ap;
   va_start(ap, erno);
-  verror_handler(rnv, xcl_st, rnx_st, erno, ap);
+  verror_handler(rnv, xcl_st,  erno, ap);
   va_end(ap);
 }
 
@@ -258,14 +258,14 @@ static void processingInstruction(void *userData,
   }
 }
 
-static int pipeout(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, void *buf, int len)
+static int pipeout(rnv_t *rnv, xcl_st_t *xcl_st, void *buf, int len)
 {
   int ofs = 0, iw, lenw = len;
   for (;;)
   {
     if ((iw = write(1, (char *)buf + ofs, lenw)) == -1)
     {
-      error_handler(rnv, xcl_st, rnx_st, XCL_ER_IO, strerror(errno));
+      error_handler(rnv, xcl_st,  XCL_ER_IO, strerror(errno));
       return 0;
     }
     ofs += iw;
@@ -275,7 +275,7 @@ static int pipeout(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, void *buf, in
   }
 }
 
-static int process(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int fd)
+static int process(rnv_t *rnv, xcl_st_t *xcl_st, int fd)
 {
   void *buf;
   int len;
@@ -285,11 +285,11 @@ static int process(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int fd)
     len = read(fd, buf, BUFSIZE);
     if (len < 0)
     {
-      error_handler(rnv, xcl_st, rnx_st, XCL_ER_IO, xcl_st->xml, strerror(errno));
+      error_handler(rnv, xcl_st,  XCL_ER_IO, xcl_st->xml, strerror(errno));
       goto ERROR;
     }
     if (xcl_st->peipe)
-      xcl_st->peipe = xcl_st->peipe && pipeout(rnv, xcl_st, rnx_st, buf, len);
+      xcl_st->peipe = xcl_st->peipe && pipeout(rnv, xcl_st,  buf, len);
     if (!XML_ParseBuffer(expat, len, len == 0))
       goto PARSE_ERROR;
     if (len == 0)
@@ -298,9 +298,9 @@ static int process(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int fd)
   return xcl_st->ok;
 
 PARSE_ERROR:
-  error_handler(rnv, xcl_st, rnx_st, XCL_ER_XML, XML_ErrorString(XML_GetErrorCode(expat)));
+  error_handler(rnv, xcl_st,  XCL_ER_XML, XML_ErrorString(XML_GetErrorCode(expat)));
   while (xcl_st->peipe && (len = read(fd, buf, BUFSIZE)) != 0)
-    xcl_st->peipe = xcl_st->peipe && pipeout(rnv, xcl_st, rnx_st, buf, len);
+    xcl_st->peipe = xcl_st->peipe && pipeout(rnv, xcl_st,  buf, len);
 ERROR:
   return 0;
 }
@@ -308,11 +308,11 @@ ERROR:
 static int externalEntityRef(XML_Parser p, const char *context,
                              const char *base, const char *systemId, const char *publicId)
 {
-  //error_handler(rnv, xcl_st, rnx_st, XCL_ER_XENT);
+  //error_handler(rnv, xcl_st,  XCL_ER_XENT);
   return 1;
 }
 
-static void validate(rnv_t *rnv, xcl_st_t *xcl_st, drv_st_t *drv_st, rn_st_t *rn_st, rnx_st_t *rnx_st, int fd)
+static void validate(rnv_t *rnv, xcl_st_t *xcl_st, drv_st_t *drv_st, rn_st_t *rn_st, int fd)
 {
   xcl_st->previous = xcl_st->current = xcl_st->start;
   expat = XML_ParserCreateNS(NULL, ':');
@@ -322,7 +322,7 @@ static void validate(rnv_t *rnv, xcl_st_t *xcl_st, drv_st_t *drv_st, rn_st_t *rn
   XML_SetExternalEntityRefHandler(expat, &externalEntityRef);
   XML_SetProcessingInstructionHandler(expat, &processingInstruction);
   XML_SetUserData(expat, xcl_st);
-  xcl_st->ok = process(rnv, xcl_st, rnx_st, fd);
+  xcl_st->ok = process(rnv, xcl_st,  fd);
   XML_ParserFree(expat);
 }
 
@@ -334,7 +334,6 @@ int main(int argc, char **argv)
   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;
@@ -343,7 +342,6 @@ int main(int argc, char **argv)
   rnv = malloc(sizeof(rnv_t));
   rn_st = malloc(sizeof(rn_st_t));
   rnc_st = malloc(sizeof(rnc_st_t));
-  rnx_st = malloc(sizeof(rnx_st_t));
   drv_st = malloc(sizeof(drv_st_t));
   rx_st = malloc(sizeof(rx_st_t));
   rnd_st = malloc(sizeof(rnd_st_t));
@@ -354,7 +352,7 @@ int main(int argc, char **argv)
   xcl_st->rn_st = rn_st;
   xcl_st->rx_st = rx_st;
 
-  init(rnv, xcl_st, rn_st, rnc_st, rnd_st, rnx_st, drv_st, rx_st);
+  init(rnv, xcl_st, rn_st, rnc_st, rnd_st,  drv_st, rx_st);
 
   xcl_st->peipe = 0;
   xcl_st->verbose = 1;
@@ -378,8 +376,8 @@ int main(int argc, char **argv)
           xcl_st->nexp = atoi(*(++argv));
         goto END_OF_OPTIONS;
       case 's':
-        rnv->drv_compact = 1;
-        rnv->rx_compact = 1;
+        drv_st->drv_compact = 1;
+        rx_st->rx_compact = 1;
         break;
       case 'p':
         xcl_st->peipe = 1;
@@ -439,7 +437,7 @@ int main(int argc, char **argv)
         }
         if (xcl_st->verbose)
           (*er_printf)("%s\n", xcl_st->xml);
-        validate(rnv, xcl_st, drv_st, rn_st, rnx_st, fd);
+        validate(rnv, xcl_st, drv_st, rn_st,  fd);
         close(fd);
         clear(xcl_st);
       } while (*(++argv));
@@ -451,7 +449,7 @@ int main(int argc, char **argv)
       if (!xcl_st->rnck)
       {
         xcl_st->xml = "stdin";
-        validate(rnv, xcl_st, drv_st, rn_st, rnx_st, 0);
+        validate(rnv, xcl_st, drv_st, rn_st,  0);
         clear(xcl_st);
         if (!xcl_st->ok && xcl_st->verbose)
           (*er_printf)("error: invalid input\n");
@@ -462,7 +460,6 @@ int main(int argc, char **argv)
   free(rnv);
   free(rn_st);
   free(rnc_st);
-  free(rnx_st);
   free(drv_st);
   free(rx_st);
   free(rnd_st);