ruby_rnv 0.2.0

data/ext/rnv/src/rnd.h

@@ -0,0 +1,25 @@
+/* $Id: rnd.h,v 1.11 2004/01/02 20:27:23 dvd Exp $ */
+
+#include <stdarg.h>
+#include "type.h"
+
+#ifndef RND_H
+#define RND_H 1
+
+#define RND_ER_LOOPST 0
+#define RND_ER_LOOPEL 1
+#define RND_ER_CTYPE 2
+#define RND_ER_BADSTART 3
+#define RND_ER_BADMORE 4
+#define RND_ER_BADEXPT 5
+#define RND_ER_BADLIST 6
+#define RND_ER_BADATTR 7
+
+extern void rnd_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+
+extern void rnd_init(rnv_t *rnv, rnd_st_t *rnd_st, rn_st_t *rn_st);
+extern void rnd_clear(void);
+
+extern int rnd_fixup(rnv_t *rnv, rnd_st_t *rnd_st, rn_st_t *rn_st, int start);
+
+#endif

data/ext/rnv/src/rnl.c

@@ -0,0 +1,62 @@
+#include "type.h"
+
+/* $Id: rnl.c,v 1.2 2004/01/15 23:47:45 dvd Exp $ */
+
+#include <stdarg.h>
+#include "erbit.h"
+#include "rn.h"
+#include "rnc.h"
+#include "rnd.h"
+#include "rnl.h"
+
+void rnl_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+  if(erno&ERBIT_RNC) {
+    rnc_default_verror_handler(rnv, erno&~ERBIT_RNC,ap);
+  } else if(erno&ERBIT_RND) {
+    rnd_default_verror_handler(rnv, erno&~ERBIT_RND,ap);
+  }
+}
+
+static void verror_handler_rnc(rnv_t *rnv, int erno,va_list ap) {rnl_default_verror_handler(rnv, erno|ERBIT_RNC,ap);}
+static void verror_handler_rnd(rnv_t *rnv, int erno,va_list ap) {rnl_default_verror_handler(rnv, erno|ERBIT_RND,ap);}
+
+void rnl_init(rnv_t *rnv, rn_st_t *rn_st, rnc_st_t *rnc_st, rnd_st_t *rnd_st) {
+    rnv->rnl_verror_handler=&rnl_default_verror_handler;
+    rn_init(rnv, rn_st);
+    rnc_init(rnv, rnc_st, rn_st);
+    rnv->rnc_verror_handler=&verror_handler_rnc;
+    rnd_init(rnv, rnd_st, rn_st); 
+    rnv->rnd_verror_handler=&verror_handler_rnd;
+}
+
+void rnl_clear(void) {}
+
+static int load(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, struct rnc_source *sp) {
+  int start=-1;
+  if(!rnc_errors(sp)) start=rnc_parse(rnv, rnc_st, rn_st, sp); rnc_close(sp);
+  if(!rnc_errors(sp)&&(start=rnd_fixup(rnv, rnd_st, rn_st, start))) {
+    start=rn_compress_last(rnv, rn_st, start);
+  } else start=0;
+  return start;
+}
+
+int rnl_fn(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn) {
+  struct rnc_source src;
+  src.rnv = rnv;
+  rnc_open(&src,fn); 
+  return load(rnv, rnc_st, rn_st, rnd_st, &src);
+}
+
+int rnl_fd(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,int fd) {
+  struct rnc_source src;
+  src.rnv = rnv;
+  rnc_bind(&src,fn,fd); 
+  return load(rnv, rnc_st, rn_st, rnd_st, &src);
+}
+
+int rnl_s(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,char *s,int len) {
+  struct rnc_source src;
+  src.rnv = rnv;
+  rnc_stropen(&src,fn,s,len); 
+  return load(rnv, rnc_st, rn_st, rnd_st, &src);
+}

data/ext/rnv/src/rnl.h

@@ -0,0 +1,18 @@
+/* $Id: rnl.h,v 1.1 2004/01/10 14:25:05 dvd Exp $ */
+
+#ifndef RNL_H
+#define RNL_H 1
+
+#include <stdarg.h>
+#include "type.h"
+
+extern void rnl_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+
+extern void rnl_init(rnv_t *rnv, rn_st_t *rn_st, rnc_st_t *rnc_st, rnd_st_t *rnd_st);
+extern void rnl_clear(void);
+
+extern int rnl_fn(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn);
+extern int rnl_fd(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,int fd);
+extern int rnl_s(rnv_t *rnv, rnc_st_t *rnc_st, rn_st_t *rn_st, rnd_st_t *rnd_st, char *fn,char *s,int len);
+
+#endif

data/ext/rnv/src/rnv.c

@@ -0,0 +1,158 @@
+#include "type.h"
+
+/* $Id: rnv.c,v 1.69 2004/01/28 23:21:24 dvd Exp $ */
+
+#include <string.h> /*strncpy,strrchr*/
+#include <assert.h>
+#include "m.h"
+#include "xmlc.h" /*xmlc_white_space*/
+#include "erbit.h"
+#include "drv.h"
+#include "er.h"
+#include "rnv.h"
+
+#define err(msg) (*rnv->verror_handler)(rnv,erno|ERBIT_RNV,msg"\n",ap);
+void rnv_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
+  if(erno&ERBIT_DRV) {
+    drv_default_verror_handler(rnv, erno&~ERBIT_DRV,ap);
+  } else {
+    switch(erno) {
+    case RNV_ER_ELEM: err("element %s^%s not allowed"); break;
+    case RNV_ER_AKEY: err("attribute %s^%s not allowed"); break;
+    case RNV_ER_AVAL: err("attribute %s^%s with invalid value \"%s\""); break;
+    case RNV_ER_EMIS: err("incomplete content"); break;
+    case RNV_ER_AMIS: err("missing attributes of %s^%s"); break;
+    case RNV_ER_UFIN: err("unfinished content of element %s^%s"); break;
+    case RNV_ER_TEXT: err("invalid data or text not allowed"); break;
+    case RNV_ER_NOTX: err("text not allowed"); break;
+    default: assert(0);
+    }
+  }
+}
+
+static void error_handler(rnv_t *rnv, int erno,...) {
+  va_list ap; va_start(ap,erno); (*rnv->rnv_verror_handler)(rnv,erno,ap); va_end(ap);
+}
+
+static void verror_handler_drv(rnv_t *rnv, int erno,va_list ap) {rnv_default_verror_handler(rnv,erno|ERBIT_DRV,ap);}
+
+static void windup(void);
+void rnv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st) {
+    rnv->rnv_verror_handler=&rnv_default_verror_handler;
+    drv_init(rnv, drv_st, rn_st, rx_st);
+    rnv->drv_verror_handler=&verror_handler_drv;
+    windup();
+}
+
+void rnv_clear(void) {
+  windup();
+}
+
+static void windup(void) {
+}
+
+static char *qname_open(char **surip,char **snamep,char *name) {
+  char *sep;
+  if((sep=strrchr(name,':'))) {
+    *snamep=sep+1; *surip=name; *sep='\0';
+  } else {
+    *snamep=name; while(*name) ++name; *surip=name;
+  }
+  return sep; /* NULL if no namespace */
+}
+
+static void qname_close(char *sep) {if(sep) *sep=':';}
+
+static int whitespace(char *text,int n_txt) {
+  char *s=text,*end=text+n_txt;
+  for(;;) {
+    if(s==end) return 1;
+    if(!xmlc_white_space(*(s++))) return 0;
+  }
+}
+
+int rnv_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *text,int n_txt,int mixed) {
+  int ok=1;
+  if(mixed) {
+    if(!whitespace(text,n_txt)) {
+      *curp=drv_mixed_text(rnv, drv_st, rn_st, *prevp=*curp);
+      if(*curp==rnv->rn_notAllowed) { ok=0;
+	*curp=drv_mixed_text_recover(*prevp);
+	error_handler(rnv, RNV_ER_NOTX);
+      }
+    }
+  } else {
+    *curp=drv_text(rnv, rn_st, rx_st, drv_st, *prevp=*curp,text,n_txt);
+    if(*curp==rnv->rn_notAllowed) { ok=0;
+      *curp=drv_text_recover(*prevp,text,n_txt);
+      error_handler(rnv, RNV_ER_TEXT);
+    }
+  }
+  return ok;
+}
+
+int rnv_start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name) {
+  int ok=1; char *suri,*sname,*sep;
+  sep=qname_open(&suri,&sname,name);
+  *curp=drv_start_tag_open(rnv, drv_st, rn_st, *prevp=*curp,suri,sname);
+  if(*curp==rnv->rn_notAllowed) { ok=0;
+    *curp=drv_start_tag_open_recover(rnv, drv_st, rn_st, *prevp,suri,sname);
+    error_handler(rnv, *curp==rnv->rn_notAllowed?RNV_ER_ELEM:RNV_ER_EMIS,suri,sname);
+  }
+  qname_close(sep);
+  return ok;
+}
+
+int rnv_attribute(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *name,char *val) {
+  int ok=1; char *suri,*sname,*sep;
+  sep=qname_open(&suri,&sname,name);
+  *curp=drv_attribute_open(rnv, drv_st, rn_st, *prevp=*curp,suri,sname);
+  if(*curp==rnv->rn_notAllowed) { ok=0;
+    *curp=drv_attribute_open_recover(*prevp,suri,sname);
+    error_handler(rnv, RNV_ER_AKEY,suri,sname);
+  } else {
+    *curp=drv_text(rnv, rn_st, rx_st, drv_st, *prevp=*curp,(char*)val,strlen(val));
+    if(*curp==rnv->rn_notAllowed || (*curp=drv_attribute_close(rnv, drv_st, rn_st, *prevp=*curp))==rnv->rn_notAllowed) { ok=0;
+      *curp=drv_attribute_close_recover(rnv, drv_st, rn_st, *prevp);
+      error_handler(rnv, RNV_ER_AVAL,suri,sname,val);
+    }
+  }
+  qname_close(sep);
+  return ok;
+}
+
+int rnv_start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name) {
+  int ok=1; char *suri,*sname,*sep;
+  *curp=drv_start_tag_close(rnv, drv_st, rn_st, *prevp=*curp);
+  if(*curp==rnv->rn_notAllowed) { ok=0;
+    *curp=drv_start_tag_close_recover(rnv, drv_st, rn_st, *prevp);
+    sep=qname_open(&suri,&sname,name);
+    error_handler(rnv, RNV_ER_AMIS,suri,sname);
+    qname_close(sep);
+  }
+  return ok;
+}
+
+int rnv_start_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st,  rx_st_t *rx_st, int *curp,int *prevp,char *name,char **attrs) {
+  int ok=1;
+  ok=rnv_start_tag_open(rnv, drv_st, rn_st, curp,prevp,name)&&ok;
+  while(*curp!=rnv->rn_notAllowed) {
+    if(!(*attrs)) break;
+    ok = rnv_attribute(rnv, drv_st, rn_st, rx_st, curp,prevp,*attrs,*(attrs+1))&&ok;
+    attrs+=2;
+  }
+  if(*curp!=rnv->rn_notAllowed) ok=rnv_start_tag_close(rnv, drv_st, rn_st, curp,prevp,name)&&ok;
+  return ok;
+}
+
+int rnv_end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name) {
+  int ok=1; char *suri,*sname,*sep;
+  *curp=drv_end_tag(rnv, drv_st, rn_st, *prevp=*curp);
+  if(*curp==rnv->rn_notAllowed) { ok=0;
+    sep=qname_open(&suri,&sname,name);
+    error_handler(rnv, RNV_ER_UFIN,suri,sname);
+    qname_close(sep);
+    *curp=drv_end_tag_recover(rnv, drv_st, rn_st, *prevp);
+  }
+  return ok;
+}

data/ext/rnv/src/rnv.h

@@ -0,0 +1,30 @@
+/* $Id: rnv.h,v 1.7 2004/01/09 10:19:39 dvd Exp $ */
+
+#include <stdarg.h>
+#include "type.h"
+
+#ifndef RNV_H
+#define RNV_H 1
+
+#define RNV_ER_ELEM 0
+#define RNV_ER_AKEY 1
+#define RNV_ER_AVAL 2
+#define RNV_ER_EMIS 3
+#define RNV_ER_AMIS 4
+#define RNV_ER_UFIN 5
+#define RNV_ER_TEXT 6
+#define RNV_ER_NOTX 7
+
+extern void rnv_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
+
+extern void rnv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st);
+extern void rnv_clear(void);
+
+extern int rnv_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *text,int n_t,int mixed);
+extern int rnv_start_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *name,char **attrs);
+extern int rnv_start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name);
+extern int rnv_attribute(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st, int *curp,int *prevp,char *name,char *val);
+extern int rnv_start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name);
+extern int rnv_end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int *curp,int *prevp,char *name);
+
+#endif

data/ext/rnv/src/rnx.c

@@ -0,0 +1,153 @@
+#include "type.h"
+
+/* $Id: rnx.c,v 1.24 2004/02/25 00:00:32 dvd Exp $ */
+
+#include <stdlib.h> /*NULL*/
+#include <string.h> /*strcat*/
+#include "m.h"
+#include "s.h"
+#include "rn.h"
+#include "ll.h"
+#include "rnx.h"
+
+#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_clear(void) {}
+
+static void expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int first,int req) {
+  int p1,p2,px=0,i;
+  if(req && rn_nullable(p)) return;
+  switch(RN_P_TYP(p)) {
+  case RN_P_ERROR: break;
+  case RN_P_NOT_ALLOWED: break;
+  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;
+  case RN_P_INTERLEAVE: rn_Interleave(p,p1,p2);
+    expected(rnv, rnx_st, p1,first,req); expected(rnv, rnx_st, 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;
+  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;
+  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;
+  case RN_P_REF: break;
+  default: assert(0);
+  }
+  if(px&&(first||RN_P_IS(px,RN_P_ATTRIBUTE))) {
+    for(i=0;i!=rnv->rnx_n_exp;++i) {
+      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));
+      rnv->rnx_exp[rnv->rnx_n_exp++]=px;
+    }
+  }
+}
+void rnx_expected(rnv_t *rnv, rnx_st_t *rnx_st, int p,int req) {
+  if(req) {
+    if(rnx_st->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_n_exp=0;
+  }
+  expected(rnv, rnx_st, p,1,req);
+}
+
+char *rnx_p2str(rnv_t *rnv, int p) {
+  char *s=NULL,*s1;
+  int dt,ps,val,nc,p1;
+  switch(RN_P_TYP(p)) {
+  case RN_P_ERROR: s=s_clone("error"); break;
+  case RN_P_NOT_ALLOWED: s=s_clone("notAllowed"); break;
+  case RN_P_EMPTY: s=s_clone("empty"); break;
+  case RN_P_TEXT: s=s_clone("text"); break;
+  case RN_P_CHOICE: s=s_clone("choice (|)"); break;
+  case RN_P_INTERLEAVE: s=s_clone("interleave (&)"); break;
+  case RN_P_GROUP: s=s_clone("group (,)"); break;
+  case RN_P_ONE_OR_MORE: s=s_clone("one or more (+)"); break;
+  case RN_P_LIST: s=s_clone("list"); break;
+  case RN_P_DATA: rn_Data(p,dt,ps);
+    s1=rnx_nc2str(rnv, dt);
+    s=(char*)m_alloc(strlen("data ")+1+strlen(s1),sizeof(char));
+    strcpy(s,"data "); strcat(s,s1);
+    m_free(s1);
+    break;
+  case RN_P_DATA_EXCEPT: s=s_clone("dataExcept (-)");  break;
+  case RN_P_VALUE: rn_Value(p,dt,val);
+    s1=rnx_nc2str(rnv, dt);
+    s=(char*)m_alloc(strlen("value \"\" ")+1+strlen(s1)+strlen(rnv->rn_string+val),sizeof(char));
+    strcpy(s,"value "); strcat(s,s1); strcat(s," \""); strcat(s,rnv->rn_string+val); strcat(s,"\"");
+    m_free(s1);
+    break;
+  case RN_P_ATTRIBUTE: rn_Attribute(p,nc,p1);
+    s1=rnx_nc2str(rnv, nc);
+    s=(char*)m_alloc(strlen("attribute ")+1+strlen(s1),sizeof(char));
+    strcpy(s,"attribute "); strcat(s,s1);
+    m_free(s1);
+    break;
+  case RN_P_ELEMENT: rn_Element(p,nc,p1);
+    s1=rnx_nc2str(rnv, nc);
+    s=(char*)m_alloc(strlen("element ")+1+strlen(s1),sizeof(char));
+    strcpy(s,"element "); strcat(s,s1);
+    m_free(s1);
+    break;
+  case RN_P_REF: s=s_clone("ref"); break;
+  case RN_P_AFTER: s=s_clone("after"); break;
+  default: assert(0);
+  }
+  return s;
+}
+
+char *rnx_nc2str(rnv_t *rnv, int nc) {
+  char *s=NULL,*s1,*s2;
+  int nc1,nc2,uri,name;
+  switch(RN_NC_TYP(nc)) {
+  case RN_NC_ERROR: s=s_clone("?"); break;
+  case RN_NC_NSNAME:
+    rn_NsName(nc,uri);
+    s=(char*)m_alloc(strlen(rnv->rn_string+uri)+3,sizeof(char));
+    strcpy(s,rnv->rn_string+uri); strcat(s,":*");
+    break;
+  case RN_NC_QNAME:
+    rn_QName(nc,uri,name);
+    s=(char*)m_alloc(strlen(rnv->rn_string+uri)+strlen(rnv->rn_string+name)+2,sizeof(char));
+    strcpy(s,rnv->rn_string+uri); strcat(s,"^"); strcat(s,rnv->rn_string+name);
+    break;
+  case RN_NC_ANY_NAME: s=s_clone("*"); break;
+  case RN_NC_EXCEPT:
+    rn_NameClassExcept(nc,nc1,nc2);
+    s1=rnx_nc2str(rnv, nc1); s2=rnx_nc2str(rnv, nc2);
+    s=(char*)m_alloc(strlen(s1)+strlen(s2)+2,sizeof(char));
+    strcpy(s,s1); strcat(s,"-"); strcat(s,s2);
+    m_free(s1); m_free(s2);
+    break;
+  case RN_NC_CHOICE:
+    rn_NameClassChoice(nc,nc1,nc2);
+    s1=rnx_nc2str(rnv, nc1); s2=rnx_nc2str(rnv, nc2);
+    s=(char*)m_alloc(strlen(s1)+strlen(s2)+2,sizeof(char));
+    strcpy(s,s1); strcat(s,"|"); strcat(s,s2);
+    m_free(s1); m_free(s2);
+    break;
+  case RN_NC_DATATYPE:
+    rn_Datatype(nc,uri,name);
+    s=(char*)m_alloc(strlen(rnv->rn_string+uri)+strlen(rnv->rn_string+name)+2,sizeof(char));
+    strcpy(s,rnv->rn_string+uri); strcat(s,"^"); strcat(s,rnv->rn_string+name);
+    break;
+  default: assert(0);
+  }
+  return s;
+}