ruby_rnv 0.2.0

data/ext/rnv/src/s.h

@@ -0,0 +1,32 @@
+/* $Id: s.h,v 1.6 2005/01/05 09:46:25 dvd Exp $ */
+
+#ifndef S_H
+#define S_H 1
+
+/* compares two strings, s1 is null terminated, s2 is n characters long */
+extern int s_cmpn(char *s1,char *s2,int n2);
+
+/* compares two tokens, s1 is null terminated, s2 is n characters long */
+extern int s_tokcmpn(char *s1,char *s2,int n2);
+
+/* hash value for a zero-terminated string */
+extern int s_hval(char *s);
+
+/* strdup is a non-standard function */
+extern char *s_clone(char *s);
+
+/* compute the absolute path from a relative path and a base path;
+ the caller must ensure that there is enough space in r:
+ size(r) > strlen(r)+strlen(b)
+ returns a pointer to the string containing the relative path
+ */
+extern char *s_abspath(char *r,char *b);
+
+/* find a string in a sorted array, return the index,
+  or size on failure */
+extern int s_tab(char *s,char *tab[],int size);
+extern int s_ntab(char *s,int len,char *tab[],int size);
+
+extern void s_test(void);
+
+#endif

data/ext/rnv/src/sc.c

@@ -0,0 +1,62 @@
+/* $Id: sc.c,v 1.16 2004/03/13 13:28:02 dvd Exp $ */
+
+#include <assert.h> /*assert*/
+#include "m.h"
+#include "ll.h"
+#include "sc.h"
+
+#define BASE -1
+#define LOCK -2
+
+#define LEN SC_LEN
+
+static void windup(struct sc_stack *stp) {
+  stp->top=0;
+  sc_open(stp);
+}
+
+void sc_init(struct sc_stack *stp) {
+  stp->tab=(int(*)[SC_RECSIZE])m_alloc(stp->len=LEN,sizeof(int[SC_RECSIZE]));
+  windup(stp);
+}
+
+void sc_clear(struct sc_stack *stp) {
+  windup(stp);
+}
+
+void sc_open(struct sc_stack *stp) {
+  stp->tab[stp->base=stp->top++][1]=BASE;
+  if(stp->top==stp->len) stp->tab=(int(*)[SC_RECSIZE])m_stretch(
+    stp->tab,stp->len*=stp->top*2,stp->top,sizeof(int[SC_RECSIZE]));
+}
+
+int sc_void(struct sc_stack *stp) {
+  return stp->base==0;
+}
+
+void sc_lock(struct sc_stack *stp) {
+  stp->tab[stp->base][1]=LOCK;
+}
+
+int sc_locked(struct sc_stack *stp) {
+  return stp->tab[stp->base][1]==LOCK;
+}
+
+void sc_close(struct sc_stack *stp) {
+  stp->top=stp->base; while(stp->tab[--stp->base][1]>BASE);
+}
+
+int sc_find(struct sc_stack *stp,int key) {
+  int i=stp->top; stp->tab[stp->base][0]=key;
+  while(stp->tab[--i][0]!=key);
+  return i!=stp->base?i:0;
+}
+
+int sc_add(struct sc_stack *stp,int key,int val,int aux) {
+  int i=stp->top;
+  assert(!sc_locked(stp));
+  stp->tab[i][0]=key; stp->tab[i][1]=val; stp->tab[i][2]=aux;
+  if(++stp->top==stp->len) stp->tab=(int(*)[SC_RECSIZE])m_stretch(
+    stp->tab,stp->len=stp->top*2,stp->top,sizeof(int[SC_RECSIZE]));
+  return i;
+}

data/ext/rnv/src/sc.h

@@ -0,0 +1,26 @@
+/* $Id: sc.h,v 1.7 2004/01/15 23:47:45 dvd Exp $ */
+
+#ifndef SC_H
+#define SC_H 1
+
+#define SC_RECSIZE 3 /* 0 - key, 1 - value, 2 - auxiliary */
+
+struct sc_stack {
+  int (*tab)[SC_RECSIZE];
+  int len,base,top;
+};
+
+extern void sc_init(struct sc_stack *stp);
+extern void sc_clear(struct sc_stack *stp);
+
+extern void sc_open(struct sc_stack *stp);
+extern void sc_lock(struct sc_stack *stp);
+extern void sc_close(struct sc_stack *stp);
+
+extern int sc_void(struct sc_stack *sp);
+extern int sc_locked(struct sc_stack *stp);
+
+extern int sc_find(struct sc_stack *stp,int key); /* returns 0 if not found, index in tab otherwise */
+extern int sc_add(struct sc_stack *stp,int key,int val,int aux); /* returns index for the new record */
+
+#endif

data/ext/rnv/src/type.h

@@ -0,0 +1,121 @@
+#ifndef TYPE_H
+#define TYPE_H
+
+#include <stdarg.h>
+#include "ht.h"
+#include "sc.h"
+
+typedef struct rn_st
+{
+  struct hashtable ht_p;
+  struct hashtable ht_nc;
+  struct hashtable ht_s;
+  int i_p;
+  int i_nc;
+  int i_s;
+  int BASE_P;
+  int base_p;
+  int i_ref;
+  int len_p;
+  int len_nc;
+  int len_s;
+  int adding_ps;
+} rn_st_t;
+
+typedef struct rnd_st
+{
+  int len_f;
+  int n_f;
+  int *flat;
+  int errors;
+} rnd_st_t;
+
+typedef struct rnv rnv_t;
+typedef struct rx_st
+{
+  char *regex;
+  int *pattern;
+  struct hashtable ht_r;
+  struct hashtable ht_p;
+  struct hashtable ht_2;
+  int i_p;
+  int len_p;
+  int i_r;
+  int len_r;
+  int i_2;
+  int len_2;
+  int empty;
+  int notAllowed;
+  int any;
+  int i_m;
+  int len_m;
+  struct hashtable ht_m;
+  int r0;
+  int ri;
+  int sym;
+  int val;
+  int errors;
+  int (*memo)[3];
+  int (*r2p)[2];
+
+  // FIXME: for error handlers
+  rnv_t *rnv;
+} rx_st_t;
+
+typedef struct rnx_st
+{
+  int len_exp;
+} rnx_st_t;
+
+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;
+
+typedef struct drv_st
+{
+  struct dtl *dtl;
+  int len_dtl;
+  int n_dtl;
+  int i_m;
+  int len_m;
+  struct hashtable ht_m;
+  int (*memo)[5];
+} drv_st_t;
+
+typedef struct rnv
+{
+  int *rn_pattern;
+  int *rn_nameclass;
+  char *rn_string;
+  int rn_empty;
+  int rn_text;
+  int rn_notAllowed;
+  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);
+
+  void *user_data;
+
+} rnv_t;
+
+#endif // TYPE_H

data/ext/rnv/src/u.c

@@ -0,0 +1,88 @@
+/* $Id: u.c,v 1.24 2004/01/25 09:44:04 dvd Exp $ */
+
+#include "u.h"
+
+#define ux(u,c) (((u)<<6)|(c&0x3F))
+#define u1(t) t[0]
+#define u2(t) ux(t[0]&0x1F,t[1])
+#define u3(t) ux(ux(t[0]&0xF,t[1]),t[2])
+#define u4(t) ux(ux(ux(t[0]&0x7,t[1]),t[2]),t[3])
+#define u5(t) ux(ux(ux(ux(t[0]&0x3,t[1]),t[2]),t[3]),t[4])
+#define u6(t) ux(ux(ux(ux(ux(t[0]&0x1,t[1]),t[2]),t[3]),t[4]),t[5])
+
+#define vx(c,u) c=0x80|((u)&0x3F)
+#define v1(t,u) t[0]=u
+#define v2(t,u) t[0]=0xC0|(u>>6);vx(t[1],u)
+#define v3(t,u) t[0]=0xE0|(u>>12);vx(t[1],u>>6);vx(t[2],u)
+#define v4(t,u) t[0]=0xF0|(u>>18);vx(t[1],u>>12);vx(t[2],u>>6);vx(t[3],u)
+#define v5(t,u) t[0]=0xF8|(u>>24);vx(t[1],u>>18);vx(t[2],u>>12);vx(t[3],u>>6);vx(t[4],u)
+#define v6(t,u) t[0]=0xFC|(u>>30);vx(t[1],u>>24);vx(t[2],u>>18);vx(t[3],u>>12);vx(t[4],u>>6);vx(t[5],u)
+
+#define B1 0xFFFFFF80
+#define B2 0xFFFFF800
+#define B3 0xFFFF0000
+#define B4 0xFFE00000
+#define B5 0xFC000000
+#define B6 0x80000000
+
+#define BOM "\xEF\xBB\xBF"
+#define BOMLEN 3
+
+int u_bom(char *s,int n) {
+  char *bom=(char*)(BOM+BOMLEN);
+  if(n>=BOMLEN) {
+    n=BOMLEN; s+=n;
+    while(n--!=0) if(*(--s)!=*(--bom)) return 0;
+    return BOMLEN;
+  }
+  return 0;
+}
+
+int u_get(int *up,char *s) {
+  unsigned char *t=(unsigned char*)s;
+  if(*t<0x80) {*up=u1(t); return 1;}
+  if(*t<0xC0) return 0;
+  if(*t<0xE0) {*up=u2(t); return (*up&B1)?2:0;}
+  if(*t<0xF0) {*up=u3(t); return (*up&B2)?3:0;}
+  if(*t<0xF8) {*up=u4(t); return (*up&B3)?4:0;}
+  if(*t<0xFC) {*up=u5(t); return (*up&B4)?5:0;}
+  if(*t<0xFE) {*up=u6(t); return (*up&B5)?6:0;}
+  return 0;
+}
+
+int u_put(char *s,int u) {
+  unsigned char *t=(unsigned char*)s;
+  if(!(u&B1)) {v1(t,u); return 1;}
+  if(!(u&B2)) {v2(t,u); return 2;}
+  if(!(u&B3)) {v3(t,u); return 3;}
+  if(!(u&B4)) {v4(t,u); return 4;}
+  if(!(u&B5)) {v5(t,u); return 5;}
+  if(!(u&B6)) {v6(t,u); return 6;}
+  return 0;
+}
+
+int u_strlen(char *s) {int n=0; while(*(s+n)) ++n; return u_strnlen(s,n);}
+int u_strnlen(char *s,int n) {
+  int i,len=0,u;
+  char *end=s+n;
+  for(;;) {
+    if(s==end) break;
+    i=u_get(&u,s);
+    if(i==0) {len=-1; break;}
+    s+=i;
+    if(s>end) {len=-1; break;}
+    ++len;
+  }
+  return len;
+}
+
+int u_in_ranges(int u,int r[][2],int len) {
+  int n=0,m=len-1,i;
+  for(;;) {
+    if(n>m) return 0;
+    i=(n+m)/2;
+    if(u<r[i][0]) m=i-1;
+    else if(u>r[i][1]) n=i+1;
+    else return 1;
+  }
+}

data/ext/rnv/src/u.h

@@ -0,0 +1,26 @@
+/* $Id: u.h,v 1.15 2004/01/15 23:47:45 dvd Exp $ */
+
+#ifndef U_H
+#define U_H 1
+
+#define U_MAXLEN 6
+
+/* returns BOM length if the string starts with BOM */
+extern int u_bom(char *s,int n);
+
+/* computes a unicode character u off the head of s;
+ returns number of bytes read. 0 means error.
+ */
+extern int u_get(int *up,char *s);
+
+/* encodes u in utf-8, returns number of octets taken */
+extern int u_put(char *s,int u);
+
+/* number of unicode characters in the string; -1 means error */
+extern int u_strlen(char *s);
+extern int u_strnlen(char *s,int n);
+
+/* checks whether a character falls within one of sorted ranges */
+extern int u_in_ranges(int u,int r[][2],int len);
+
+#endif

data/ext/rnv/src/xcl.c

@@ -0,0 +1,472 @@
+/* rnv command line tool keeped for reference, actually not used */
+/* $Id: xcl.c,v 1.44 2006/01/29 18:29:57 dvd Exp $ */
+#include "type.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 <expat.h>
+#include "m.h"
+#include "s.h"
+#include "erbit.h"
+#include "drv.h"
+#include "rnl.h"
+#include "rnv.h"
+#include "rnx.h"
+#include "ll.h"
+#include "er.h"
+
+#define RNV_VERSION "1.7.8"
+
+extern int rn_notAllowed, rx_compact, drv_compact;
+
+  typedef struct xcl_st {
+   int peipe;
+   int verbose;
+   int nexp;
+   int rnck;
+   char * xml;
+   int start;
+   int current;
+   int previous;
+   int lastline;
+   int lastcol;
+   int level;
+   int ok;
+   char * text;
+   int len_txt;
+   int n_txt;
+
+   rnv_t *rnv;
+   drv_st_t *drv_st; 
+   rn_st_t *rn_st;
+   rx_st_t *rx_st;
+  } xcl_st_t;
+
+#define LEN_T XCL_LEN_T
+#define LIM_T XCL_LIM_T
+
+#define BUFSIZE 1024
+
+/* maximum number of candidates to display */
+#define NEXP 16
+
+#define XCL_ER_IO 0
+#define XCL_ER_XML 1
+#define XCL_ER_XENT 2
+
+#define PIXGFILE "davidashen-net-xg-file"
+#define PIXGPOS "davidashen-net-xg-pos"
+
+static XML_Parser expat = NULL;
+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)
+{
+  if (erno & ERBIT_RNL)
+  {
+    rnl_default_verror_handler(rnv, erno & ~ERBIT_RNL, ap);
+  }
+  else
+  {
+    int line = XML_GetCurrentLineNumber(expat), col = XML_GetCurrentColumnNumber(expat);
+    if (line != xcl_st->lastline || col != xcl_st->lastcol)
+    {
+      xcl_st->lastline = line;
+      xcl_st->lastcol = col;
+      if (xgfile)
+        (*er_printf)("%s:%s: error: ", xgfile, xgpos);
+      else
+        (*er_printf)("%s:%i:%i: error: ", xcl_st->xml, line, col);
+      if (erno & ERBIT_RNV)
+      {
+        rnv_default_verror_handler(rnv, erno & ~ERBIT_RNV, ap);
+        if (xcl_st->nexp)
+        {
+          int req = 2, i = 0;
+          char *s;
+          while (req--)
+          {
+            rnx_expected(rnv, rnx_st, xcl_st->previous, req);
+            if (i == rnv->rnx_n_exp)
+              continue;
+            if (rnv->rnx_n_exp > xcl_st->nexp)
+              break;
+            (*er_printf)((char *)(req ? "required:\n" : "allowed:\n"));
+            for (; i != rnv->rnx_n_exp; ++i)
+            {
+              (*er_printf)("\t%s\n", s = rnx_p2str(rnv, rnv->rnx_exp[i]));
+              m_free(s);
+            }
+          }
+        }
+      }
+      else
+      {
+        switch (erno)
+        {
+        case XCL_ER_IO:
+          err("%s");
+          break;
+        case XCL_ER_XML:
+          err("%s");
+          break;
+        case XCL_ER_XENT:
+          err("pipe through xx to expand external entities");
+          break;
+        default:
+          assert(0);
+        }
+      }
+    }
+  }
+}
+
+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 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)
+{
+    rnv->verror_handler=&verror_default_handler;
+    rnl_init(rnv, rn_st, rnd_st, rnc_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);
+    xcl_st->text = (char *)m_alloc(xcl_st->len_txt = LEN_T, sizeof(char));
+    windup(xcl_st);
+}
+
+static void clear(xcl_st_t *xcl_st)
+{
+  if (xcl_st->len_txt > LIM_T)
+  {
+    m_free(xcl_st->text);
+    xcl_st->text = (char *)m_alloc(xcl_st->len_txt = LEN_T, sizeof(char));
+  }
+  windup(xcl_st);
+}
+
+static void windup(xcl_st_t *xcl_st)
+{
+  xcl_st->text[xcl_st->n_txt = 0] = '\0';
+  xcl_st->level = 0;
+  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, ...)
+{
+  va_list ap;
+  va_start(ap, erno);
+  verror_handler(rnv, xcl_st, rnx_st, erno, ap);
+  va_end(ap);
+}
+
+static void flush_text(rnv_t *rnv, xcl_st_t *xcl_st, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st)
+{
+  xcl_st->ok = rnv_text(rnv, drv_st, rn_st, rx_st, &xcl_st->current, &xcl_st->previous, xcl_st->text, xcl_st->n_txt, mixed) && xcl_st->ok;
+  xcl_st->text[xcl_st->n_txt = 0] = '\0';
+}
+
+static void start_element(void *userData, const char *name, const char **attrs)
+{
+  xcl_st_t *xcl_st = (xcl_st_t *)userData;
+  rnv_t *rnv = xcl_st->rnv;
+  drv_st_t *drv_st = xcl_st->drv_st;
+  rn_st_t *rn_st = xcl_st->rn_st;
+  rx_st_t *rx_st = xcl_st->rx_st;
+
+  if (xcl_st->current != rnv->rn_notAllowed)
+  {
+    mixed = 1;
+    flush_text(rnv, xcl_st, drv_st, rn_st, rx_st);
+    xcl_st->ok = rnv_start_tag(rnv, drv_st, rn_st, rx_st, &xcl_st->current, &xcl_st->previous, (char *)name, (char **)attrs) && xcl_st->ok;
+    mixed = 0;
+  }
+  else
+  {
+    ++xcl_st->level;
+  }
+}
+
+static void end_element(void *userData, const char *name)
+{
+  xcl_st_t *xcl_st = (xcl_st_t *)userData;
+  rnv_t *rnv = xcl_st->rnv;
+  drv_st_t *drv_st = xcl_st->drv_st;
+  rn_st_t *rn_st = xcl_st->rn_st;
+  rx_st_t *rx_st = xcl_st->rx_st;
+
+  if (xcl_st->current != rnv->rn_notAllowed)
+  {
+    flush_text(rnv, xcl_st, drv_st, rn_st, rx_st);
+    xcl_st->ok = rnv_end_tag(rnv, drv_st, rn_st, &xcl_st->current, &xcl_st->previous, (char *)name) && xcl_st->ok;
+    mixed = 1;
+  }
+  else
+  {
+    if (xcl_st->level == 0)
+      xcl_st->current = xcl_st->previous;
+    else
+      --xcl_st->level;
+  }
+}
+
+static void characters(void *userData, const char *s, int len)
+{
+  xcl_st_t *xcl_st = (xcl_st_t *)userData;
+  rnv_t *rnv = xcl_st->rnv;
+
+  if (xcl_st->current != rnv->rn_notAllowed)
+  {
+    int newlen_txt = xcl_st->n_txt + len + 1;
+    if (newlen_txt <= LIM_T && LIM_T < xcl_st->len_txt)
+      newlen_txt = LIM_T;
+    else if (newlen_txt < xcl_st->len_txt)
+      newlen_txt = xcl_st->len_txt;
+    if (xcl_st->len_txt != newlen_txt)
+      xcl_st->text = (char *)m_stretch(xcl_st->text, xcl_st->len_txt = newlen_txt, xcl_st->n_txt, sizeof(char));
+    memcpy(xcl_st->text + xcl_st->n_txt, s, len);
+    xcl_st->n_txt += len;
+    xcl_st->text[xcl_st->n_txt] = '\0'; /* '\0' guarantees that the text is bounded, and strto[ld] work for data */
+  }
+}
+
+static void processingInstruction(void *userData,
+                                  const char *target, const char *data)
+{
+  if (strcmp(PIXGFILE, target) == 0)
+  {
+    if (xgfile)
+      m_free(xgfile);
+    xgfile = s_clone((char *)data);
+  }
+  else if (strcmp(PIXGPOS, target) == 0)
+  {
+    if (xgpos)
+      m_free(xgpos);
+    xgpos = s_clone((char *)data);
+    *strchr(xgpos, ' ') = ':';
+  }
+}
+
+static int pipeout(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_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));
+      return 0;
+    }
+    ofs += iw;
+    lenw -= iw;
+    if (lenw == 0)
+      return 1;
+  }
+}
+
+static int process(rnv_t *rnv, xcl_st_t *xcl_st, rnx_st_t *rnx_st, int fd)
+{
+  void *buf;
+  int len;
+  for (;;)
+  {
+    buf = XML_GetBuffer(expat, BUFSIZE);
+    len = read(fd, buf, BUFSIZE);
+    if (len < 0)
+    {
+      error_handler(rnv, xcl_st, rnx_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);
+    if (!XML_ParseBuffer(expat, len, len == 0))
+      goto PARSE_ERROR;
+    if (len == 0)
+      break;
+  }
+  return xcl_st->ok;
+
+PARSE_ERROR:
+  error_handler(rnv, xcl_st, rnx_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);
+ERROR:
+  return 0;
+}
+
+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);
+  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)
+{
+  xcl_st->previous = xcl_st->current = xcl_st->start;
+  expat = XML_ParserCreateNS(NULL, ':');
+  XML_SetParamEntityParsing(expat, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetElementHandler(expat, &start_element, &end_element);
+  XML_SetCharacterDataHandler(expat, &characters);
+  XML_SetExternalEntityRefHandler(expat, &externalEntityRef);
+  XML_SetProcessingInstructionHandler(expat, &processingInstruction);
+  XML_SetUserData(expat, xcl_st);
+  xcl_st->ok = process(rnv, xcl_st, rnx_st, fd);
+  XML_ParserFree(expat);
+}
+
+static void version(void) { (*er_printf)("rnv version %s\n", RNV_VERSION); }
+static void usage(void) { (*er_printf)("usage: rnv {-[qnspcvh?]} schema.rnc {document.xml}\n"); }
+
+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;
+  xcl_st_t *xcl_st;
+
+  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));
+  xcl_st = malloc(sizeof(xcl_st_t));
+
+  xcl_st->rnv = rnv;
+  xcl_st->drv_st = drv_st;
+  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);
+
+  xcl_st->peipe = 0;
+  xcl_st->verbose = 1;
+  xcl_st->nexp = NEXP;
+  xcl_st->rnck = 0;
+  while (*(++argv) && **argv == '-')
+  {
+    int i = 1;
+    for (;;)
+    {
+      switch (*(*argv + i))
+      {
+      case '\0':
+        goto END_OF_OPTIONS;
+      case 'q':
+        xcl_st->verbose = 0;
+        xcl_st->nexp = 0;
+        break;
+      case 'n':
+        if (*(argv + 1))
+          xcl_st->nexp = atoi(*(++argv));
+        goto END_OF_OPTIONS;
+      case 's':
+        rnv->drv_compact = 1;
+        rnv->rx_compact = 1;
+        break;
+      case 'p':
+        xcl_st->peipe = 1;
+        break;
+      case 'c':
+        xcl_st->rnck = 1;
+        break;
+#if DXL_EXC
+      case 'd':
+        dxl_cmd = *(argv + 1);
+        if (*(argv + 1))
+          ++argv;
+        goto END_OF_OPTIONS;
+#endif
+#if DSL_SCM
+      case 'e':
+        dsl_ld(*(argv + 1));
+        if (*(argv + 1))
+          ++argv;
+        goto END_OF_OPTIONS;
+#endif
+      case 'v':
+        version();
+        break;
+      case 'h':
+      case '?':
+        usage();
+        return 1;
+      default:
+        (*er_printf)("unknown option '-%c'\n", *(*argv + i));
+        break;
+      }
+      ++i;
+    }
+  END_OF_OPTIONS:;
+  }
+
+  if (!*(argv))
+  {
+    usage();
+    return 1;
+  }
+
+  if ((xcl_st->ok = xcl_st->start = rnl_fn(rnv, rnc_st, rn_st, rnd_st, *(argv++))))
+  {
+    if (*argv)
+    {
+      do
+      {
+        int fd;
+        xcl_st->xml = *argv;
+        if ((fd = open(xcl_st->xml, O_RDONLY)) == -1)
+        {
+          (*er_printf)("I/O error (%s): %s\n", xcl_st->xml, strerror(errno));
+          xcl_st->ok = 0;
+          continue;
+        }
+        if (xcl_st->verbose)
+          (*er_printf)("%s\n", xcl_st->xml);
+        validate(rnv, xcl_st, drv_st, rn_st, rnx_st, fd);
+        close(fd);
+        clear(xcl_st);
+      } while (*(++argv));
+      if (!xcl_st->ok && xcl_st->verbose)
+        (*er_printf)("error: some documents are invalid\n");
+    }
+    else
+    {
+      if (!xcl_st->rnck)
+      {
+        xcl_st->xml = "stdin";
+        validate(rnv, xcl_st, drv_st, rn_st, rnx_st, 0);
+        clear(xcl_st);
+        if (!xcl_st->ok && xcl_st->verbose)
+          (*er_printf)("error: invalid input\n");
+      }
+    }
+  }
+
+  free(rnv);
+  free(rn_st);
+  free(rnc_st);
+  free(rnx_st);
+  free(drv_st);
+  free(rx_st);
+  free(rnd_st);
+  free(xcl_st);
+
+  return xcl_st->ok ? EXIT_SUCCESS : EXIT_FAILURE;
+}