ruby_rnv 0.3.1 → 0.5.1

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,18 @@ 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
+} rx_st_t;
+
+typedef struct dtl_cb 
 {
-  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;
+  int p;
+  int ret;
+} dtl_cb_t;
 
 typedef struct drv_st
 {
@@ -87,6 +120,15 @@ typedef struct drv_st
   int len_m;
   struct hashtable ht_m;
   int (*memo)[5];
+
+  dtl_cb_t dtl_cb[256];
+  int n_dtl_cb;
+
+  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 +142,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);

data/ext/rnv/src/xsd.c

@@ -1,5 +1,3 @@
-#include "type.h"
-
 /* $Id: xsd.c,v 1.47 2005/01/06 21:04:06 dvd Exp $ */
 
 #include <limits.h> /*INT_MAX*/
@@ -7,6 +5,9 @@
 #include <string.h> /*strlen*/
 #include <math.h> /*HUGE_VAL*/
 #include <assert.h>
+
+#include "type.h"
+
 #include "u.h"
 #include "xmlc.h"
 #include "s.h"
@@ -16,11 +17,10 @@
 #include "er.h"
 #include "xsd.h"
 
-#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_XSD,msg"\n",ap)
-void xsd_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
-  (*er_printf)("XML Schema datatypes: ");
+#define err(msg) (*handler)(data,erno|ERBIT_XSD,"XML Schema datatypes: "msg"\n",ap)
+void xsd_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
   if(erno&ERBIT_RX) {
-    rx_default_verror_handler(rnv, erno&~ERBIT_RX,ap);
+    rx_default_verror_handler(data, erno&~ERBIT_RX,handler,ap);
   } else {
     switch(erno) {
     case XSD_ER_TYP: err("unknown type %s"); break;
@@ -36,24 +36,11 @@ void xsd_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
 }
 
 static void error_handler(rx_st_t *rx_st, int erno,...) {
-  va_list ap; va_start(ap,erno); (*rx_st->rnv->xsd_verror_handler)(rx_st->rnv,erno,ap); va_end(ap);
+  va_list ap; va_start(ap,erno); xsd_default_verror_handler(rx_st->user_data,erno,rx_st->verror_handler,ap); va_end(ap);
 }
 
-static void verror_handler_rx(rnv_t *rnv, int erno,va_list ap) {xsd_default_verror_handler(rnv,erno|ERBIT_RX,ap);}
-
-static void windup(void);
 void xsd_init(rx_st_t *rx_st) {
-    rx_st->rnv->xsd_verror_handler = &xsd_default_verror_handler;
     rx_init(rx_st);
-    rx_st->rnv->rx_verror_handler=&verror_handler_rx;
-    windup();
-}
-
-void xsd_clear(void) {
-  windup();
-}
-
-static void windup(void) {
 }
 
 #define FCT_ENUMERATION 0
@@ -81,7 +68,7 @@ static char *fcttab[NFCT]={
 #define WS_REPLACE 1
 #define WS_COLLAPSE 2
 
-static int (*match[])(rnv_t *rnv, rx_st_t *rx_st, char *r,char *s,int n)={&rx_match, &rx_rmatch,&rx_cmatch};
+static int (*match[])(rx_st_t *rx_st, char *r,char *s,int n)={&rx_match, &rx_rmatch,&rx_cmatch};
 
 #define TYP_ENTITIES 0
 #define TYP_ENTITY 1
@@ -327,7 +314,7 @@ struct facets {
 #define PAT_MONTH0 "(0[1-9]|1[0-2])"
 #define PAT_DAY0 "([0-2][0-9]|3[01])"
 #define PAT_YEAR "-?"PAT_YEAR0 PAT_ZONE"?"
-#define PAT_MONTH "--"PAT_MONTH0"--"PAT_ZONE"?"
+#define PAT_MONTH "--"PAT_MONTH0 PAT_ZONE"?"
 #define PAT_DAY "---"PAT_DAY0 PAT_ZONE"?"
 #define PAT_YEAR_MONTH "-?"PAT_YEAR0"-"PAT_MONTH0 PAT_ZONE"?"
 #define PAT_MONTH_DAY "--"PAT_MONTH0"-"PAT_DAY0 PAT_ZONE"?"
@@ -661,7 +648,7 @@ int xsd_allows(rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {
   default: assert(0);
   }
 
-  while(fct.npat--) ok=ok&&match[fct.whiteSpace](rx_st->rnv, rx_st, fct.pattern[fct.npat],s,n);
+  while(fct.npat--) ok=ok&&match[fct.whiteSpace](rx_st, fct.pattern[fct.npat],s,n);
 
   if(fct.set&(1<<FCT_LENGTH)) ok=ok&&length==fct.length;
   if(fct.set&(1<<FCT_MAX_LENGTH)) ok=ok&&length<=fct.maxLength;