ruby_rnv 0.2.3 → 0.4.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/ext/rnv/extconf.rb +1 -1
- data/ext/rnv/ruby_rnv.c +177 -457
- data/ext/rnv/ruby_rnv.h +62 -0
- data/ext/rnv/ruby_rnv_err.c +545 -0
- data/ext/rnv/src/ary.c +1 -2
- data/ext/rnv/src/drv.c +75 -75
- data/ext/rnv/src/drv.h +12 -3
- data/ext/rnv/src/er.c +1 -1
- data/ext/rnv/src/er.h +1 -1
- data/ext/rnv/src/erbit.h +3 -0
- data/ext/rnv/src/rn.c +24 -26
- data/ext/rnv/src/rn.h +1 -1
- data/ext/rnv/src/rnc.c +28 -16
- data/ext/rnv/src/rnc.h +3 -23
- data/ext/rnv/src/rnd.c +24 -20
- data/ext/rnv/src/rnd.h +3 -2
- data/ext/rnv/src/rnl.c +24 -20
- data/ext/rnv/src/rnl.h +2 -3
- data/ext/rnv/src/rnv.c +20 -18
- data/ext/rnv/src/rnv.h +2 -2
- data/ext/rnv/src/rnx.c +15 -17
- data/ext/rnv/src/rnx.h +2 -3
- data/ext/rnv/src/rx.c +44 -32
- data/ext/rnv/src/rx.h +7 -8
- data/ext/rnv/src/sc.c +5 -0
- data/ext/rnv/src/sc.h +1 -0
- data/ext/rnv/src/type.h +53 -29
- data/ext/rnv/src/xcl.c +24 -27
- data/ext/rnv/src/xsd.c +10 -23
- data/ext/rnv/src/xsd.h +1 -2
- data/lib/rnv.rb +3 -0
- data/lib/rnv/data_type_library.rb +21 -0
- data/lib/rnv/error.rb +102 -0
- data/lib/rnv/pre_processor.rb +25 -0
- data/lib/rnv/validator.rb +24 -11
- metadata +7 -2
data/ext/rnv/src/ary.c
CHANGED
data/ext/rnv/src/drv.c
CHANGED
@@ -1,6 +1,5 @@
|
|
1
|
-
#include "type.h"
|
2
|
-
|
3
1
|
/* $Id: drv.c,v 1.41 2004/03/13 13:28:02 dvd Exp $ */
|
2
|
+
#include "type.h"
|
4
3
|
|
5
4
|
#include "xmlc.h" /*xmlc_white_space*/
|
6
5
|
#include "m.h"
|
@@ -13,12 +12,6 @@
|
|
13
12
|
#include "er.h"
|
14
13
|
#include "drv.h"
|
15
14
|
|
16
|
-
struct dtl {
|
17
|
-
int uri;
|
18
|
-
int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n);
|
19
|
-
int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n);
|
20
|
-
};
|
21
|
-
|
22
15
|
#define LEN_DTL DRV_LEN_DTL
|
23
16
|
#define LEN_M DRV_LEN_M
|
24
17
|
#define PRIME_M DRV_PRIME_M
|
@@ -34,10 +27,10 @@ struct dtl {
|
|
34
27
|
#define M_SET(p) drv_st->memo[drv_st->i_m][M_SIZE-1]=p
|
35
28
|
#define M_RET(m) drv_st->memo[m][M_SIZE-1]
|
36
29
|
|
37
|
-
#define err(msg) (*
|
38
|
-
void drv_default_verror_handler(
|
30
|
+
#define err(msg) (*handler)(data,erno|ERBIT_DRV,msg"\n",ap);
|
31
|
+
void drv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap) {
|
39
32
|
if(erno&ERBIT_XSD) {
|
40
|
-
xsd_default_verror_handler(
|
33
|
+
xsd_default_verror_handler(data, erno&~ERBIT_XSD,handler, ap);
|
41
34
|
} else {
|
42
35
|
switch(erno) {
|
43
36
|
case DRV_ER_NODTL: err("no datatype library for URI '%s'"); break;
|
@@ -46,14 +39,12 @@ void drv_default_verror_handler(rnv_t *rnv, int erno,va_list ap) {
|
|
46
39
|
}
|
47
40
|
}
|
48
41
|
|
49
|
-
static void error_handler(
|
50
|
-
va_list ap; va_start(ap,erno); (
|
42
|
+
static void error_handler(drv_st_t *drv_st,int erno,...) {
|
43
|
+
va_list ap; va_start(ap,erno); drv_default_verror_handler(drv_st->user_data, erno, drv_st->verror_handler, ap); va_end(ap);
|
51
44
|
}
|
52
45
|
|
53
|
-
static void
|
54
|
-
|
55
|
-
static void new_memo(rnv_t *rnv, drv_st_t *drv_st, int typ) {
|
56
|
-
if(rnv->drv_compact) ht_deli(&drv_st->ht_m,drv_st->i_m);
|
46
|
+
static void new_memo(drv_st_t *drv_st, int typ) {
|
47
|
+
if(drv_st->drv_compact) ht_deli(&drv_st->ht_m,drv_st->i_m);
|
57
48
|
drv_st->memo[drv_st->i_m][0]=typ;
|
58
49
|
}
|
59
50
|
|
@@ -68,54 +59,54 @@ static int hash_m(void *user, int m) {
|
|
68
59
|
return ((me[0]&0x7)|((me[1]^me[2]^me[3])<<3))*PRIME_M;
|
69
60
|
}
|
70
61
|
|
71
|
-
static int newStartTagOpen(
|
62
|
+
static int newStartTagOpen(drv_st_t *drv_st, int p,int uri,int name) {
|
72
63
|
int *me=drv_st->memo[drv_st->i_m];
|
73
|
-
new_memo(
|
64
|
+
new_memo(drv_st, M_STO);
|
74
65
|
me[1]=p; me[2]=uri; me[3]=name;
|
75
66
|
return ht_get(&drv_st->ht_m,drv_st->i_m);
|
76
67
|
}
|
77
68
|
|
78
|
-
static int newAttributeOpen(
|
69
|
+
static int newAttributeOpen(drv_st_t *drv_st, int p,int uri,int name) {
|
79
70
|
int *me=drv_st->memo[drv_st->i_m];
|
80
|
-
new_memo(
|
71
|
+
new_memo(drv_st, M_ATT);
|
81
72
|
me[1]=p; me[2]=uri; me[3]=name;
|
82
73
|
return ht_get(&drv_st->ht_m,drv_st->i_m);
|
83
74
|
}
|
84
75
|
|
85
|
-
static int newStartTagClose(
|
76
|
+
static int newStartTagClose(drv_st_t *drv_st, int p) {
|
86
77
|
int *me=drv_st->memo[drv_st->i_m];
|
87
|
-
new_memo(
|
78
|
+
new_memo(drv_st, M_STC);
|
88
79
|
me[1]=p; me[2]=me[3]=0;
|
89
80
|
return ht_get(&drv_st->ht_m,drv_st->i_m);
|
90
81
|
}
|
91
82
|
|
92
|
-
static int newMixedText(
|
83
|
+
static int newMixedText(drv_st_t *drv_st, int p) {
|
93
84
|
int *me=drv_st->memo[drv_st->i_m];
|
94
|
-
new_memo(
|
85
|
+
new_memo(drv_st, M_TXT);
|
95
86
|
me[1]=p; me[2]=me[3]=0;
|
96
87
|
return ht_get(&drv_st->ht_m,drv_st->i_m);
|
97
88
|
}
|
98
89
|
|
99
|
-
static int newEndTag(
|
90
|
+
static int newEndTag(drv_st_t *drv_st, int p) {
|
100
91
|
int *me=drv_st->memo[drv_st->i_m];
|
101
|
-
new_memo(
|
92
|
+
new_memo(drv_st, M_END);
|
102
93
|
me[1]=p; me[2]=me[3]=0;
|
103
94
|
return ht_get(&drv_st->ht_m,drv_st->i_m);
|
104
95
|
}
|
105
96
|
|
106
|
-
static void accept_m(
|
97
|
+
static void accept_m(drv_st_t *drv_st) {
|
107
98
|
if(ht_get(&drv_st->ht_m,drv_st->i_m)!=-1) {
|
108
|
-
if(
|
99
|
+
if(drv_st->drv_compact) ht_del(&drv_st->ht_m,drv_st->i_m); else return;
|
109
100
|
}
|
110
101
|
ht_put(&drv_st->ht_m,drv_st->i_m++);
|
111
|
-
if(
|
102
|
+
if(drv_st->drv_compact&&drv_st->i_m==LIM_M) drv_st->i_m=0;
|
112
103
|
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]));
|
113
104
|
}
|
114
105
|
|
115
|
-
static int fallback_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {return 1;}
|
116
|
-
static int fallback_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
|
106
|
+
static int fallback_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 1;}
|
107
|
+
static int fallback_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;}
|
117
108
|
|
118
|
-
static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {
|
109
|
+
static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {
|
119
110
|
int dt=rn_newDatatype(rnv, rn_st, 0,typ-rnv->rn_string);
|
120
111
|
if(dt==rnv->rn_dt_string) return s_cmpn(val,s,n)==0;
|
121
112
|
else if(dt==rnv->rn_dt_token) return s_tokcmpn(val,s,n)==0;
|
@@ -123,44 +114,53 @@ static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,c
|
|
123
114
|
return 0;
|
124
115
|
}
|
125
116
|
|
126
|
-
static int builtin_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
|
117
|
+
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;}
|
127
118
|
|
128
|
-
static
|
119
|
+
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) {
|
120
|
+
return xsd_allows(rx_st, typ,ps,s,n);
|
121
|
+
}
|
122
|
+
|
123
|
+
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) {
|
124
|
+
return xsd_equal(rx_st, typ,val,s,n);
|
125
|
+
}
|
129
126
|
|
130
127
|
void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st) {
|
131
|
-
|
132
|
-
|
133
|
-
|
128
|
+
rx_st->verror_handler = &verror_default_handler;
|
129
|
+
drv_st->verror_handler = &verror_default_handler;
|
130
|
+
|
134
131
|
xsd_init(rx_st);
|
135
|
-
|
132
|
+
|
133
|
+
if(rnv->verror_handler)
|
134
|
+
rx_st->verror_handler = rnv->verror_handler;
|
135
|
+
rx_st->user_data = rnv->user_data;
|
136
|
+
|
136
137
|
drv_st->memo=(int (*)[M_SIZE])m_alloc(drv_st->len_m=LEN_M,sizeof(int[M_SIZE]));
|
137
138
|
drv_st->dtl=(struct dtl*)m_alloc(drv_st->len_dtl=LEN_DTL,sizeof(struct dtl));
|
138
139
|
drv_st->ht_m.user = drv_st;
|
139
140
|
ht_init(&drv_st->ht_m,LEN_M,&hash_m,&equal_m);
|
140
|
-
windup(rnv, drv_st, rn_st);
|
141
|
-
}
|
142
|
-
|
143
|
-
static int emb_xsd_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {
|
144
|
-
return xsd_allows(rx_st, typ,ps,s,n);
|
145
|
-
}
|
146
141
|
|
147
|
-
|
148
|
-
|
149
|
-
|
142
|
+
drv_st->i_m=0; drv_st->n_dtl=0;
|
143
|
+
drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&fallback_equal,&fallback_allows); /* guard at 0 */
|
144
|
+
drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&builtin_equal,&builtin_allows);
|
145
|
+
drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+rnv->rn_xsd_uri,&emb_xsd_equal,&emb_xsd_allows);
|
150
146
|
|
151
|
-
|
152
|
-
|
153
|
-
|
154
|
-
drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+0,&builtin_equal,&builtin_allows);
|
155
|
-
drv_add_dtl(rnv, drv_st, rn_st, rnv->rn_string+rnv->rn_xsd_uri,&emb_xsd_equal,&emb_xsd_allows);
|
147
|
+
if(rnv->verror_handler)
|
148
|
+
drv_st->verror_handler = rnv->verror_handler;
|
149
|
+
drv_st->user_data = rnv->user_data;
|
156
150
|
}
|
157
151
|
|
158
|
-
void
|
159
|
-
|
160
|
-
|
152
|
+
void drv_dispose(drv_st_t *drv_st) {
|
153
|
+
if (drv_st->memo)
|
154
|
+
m_free(drv_st->memo);
|
155
|
+
if (drv_st->dtl)
|
156
|
+
m_free(drv_st->dtl);
|
157
|
+
ht_dispose(&drv_st->ht_m);
|
158
|
+
m_free(drv_st);
|
161
159
|
}
|
162
160
|
|
163
|
-
void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
|
161
|
+
void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
|
162
|
+
int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
|
163
|
+
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)) {
|
164
164
|
if(drv_st->n_dtl==drv_st->len_dtl) drv_st->dtl=(struct dtl *)m_stretch(drv_st->dtl,drv_st->len_dtl=drv_st->n_dtl*2,drv_st->n_dtl,sizeof(struct dtl));
|
165
165
|
drv_st->dtl[drv_st->n_dtl].uri=rn_newString(rnv, rn_st, suri);
|
166
166
|
drv_st->dtl[drv_st->n_dtl].equal=equal;
|
@@ -172,7 +172,7 @@ static struct dtl *getdtl(rnv_t *rnv, drv_st_t *drv_st, int uri) {
|
|
172
172
|
int i;
|
173
173
|
drv_st->dtl[0].uri=uri; i=drv_st->n_dtl;
|
174
174
|
while(drv_st->dtl[--i].uri!=uri);
|
175
|
-
if(i==0) error_handler(
|
175
|
+
if(i==0) error_handler(drv_st, DRV_ER_NODTL,rnv->rn_string+uri);
|
176
176
|
return drv_st->dtl+i;
|
177
177
|
}
|
178
178
|
|
@@ -207,7 +207,7 @@ static int apply_after(rnv_t *rnv, rn_st_t *rn_st, int (*f)(rnv_t *rnv, rn_st_t
|
|
207
207
|
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) {
|
208
208
|
int nc,p1,p2,m,ret=0;
|
209
209
|
if(!recover) {
|
210
|
-
m=newStartTagOpen(
|
210
|
+
m=newStartTagOpen(drv_st, p,uri,name);
|
211
211
|
if(m!=-1) return M_RET(m);
|
212
212
|
}
|
213
213
|
switch(RN_P_TYP(p)) {
|
@@ -240,8 +240,8 @@ static int start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,in
|
|
240
240
|
default: assert(0);
|
241
241
|
}
|
242
242
|
if(!recover) {
|
243
|
-
newStartTagOpen(
|
244
|
-
accept_m(
|
243
|
+
newStartTagOpen(drv_st, p,uri,name); M_SET(ret);
|
244
|
+
accept_m(drv_st);
|
245
245
|
}
|
246
246
|
return ret;
|
247
247
|
}
|
@@ -253,7 +253,7 @@ static int puorg_rn(rnv_t *rnv, rn_st_t *rn_st, int p2,int p1) {return rn_group(
|
|
253
253
|
|
254
254
|
static int attribute_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int uri,int name) {
|
255
255
|
int nc,p1,p2,m,ret=0;
|
256
|
-
m=newAttributeOpen(
|
256
|
+
m=newAttributeOpen(drv_st, p,uri,name);
|
257
257
|
if(m!=-1) return M_RET(m);
|
258
258
|
switch(RN_P_TYP(p)) {
|
259
259
|
case RN_P_NOT_ALLOWED: case RN_P_EMPTY: case RN_P_TEXT:
|
@@ -285,8 +285,8 @@ static int attribute_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,in
|
|
285
285
|
break;
|
286
286
|
default: assert(0);
|
287
287
|
}
|
288
|
-
newAttributeOpen(
|
289
|
-
accept_m(
|
288
|
+
newAttributeOpen(drv_st, p,uri,name); M_SET(ret);
|
289
|
+
accept_m(drv_st);
|
290
290
|
return ret;
|
291
291
|
}
|
292
292
|
|
@@ -299,7 +299,7 @@ extern int drv_attribute_close_recover(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn
|
|
299
299
|
static int start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recover) {
|
300
300
|
int p1,p2,ret=0,m;
|
301
301
|
if(!recover) {
|
302
|
-
m=newStartTagClose(
|
302
|
+
m=newStartTagClose(drv_st, p);
|
303
303
|
if(m!=-1) return M_RET(m);
|
304
304
|
}
|
305
305
|
switch(RN_P_TYP(p)) {
|
@@ -329,8 +329,8 @@ static int start_tag_close(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,i
|
|
329
329
|
default: assert(0);
|
330
330
|
}
|
331
331
|
if(!recover) {
|
332
|
-
newStartTagClose(
|
333
|
-
accept_m(
|
332
|
+
newStartTagClose(drv_st, p); M_SET(ret);
|
333
|
+
accept_m(drv_st);
|
334
334
|
}
|
335
335
|
return ret;
|
336
336
|
}
|
@@ -381,13 +381,13 @@ static int text(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, drv_st_t *drv_st, in
|
|
381
381
|
ret=rn_nullable(list(rnv, rn_st, rx_st, drv_st, p1,s,n))?rnv->rn_empty:rnv->rn_notAllowed;
|
382
382
|
break;
|
383
383
|
case RN_P_DATA: rn_Data(p,dt,ps); rn_Datatype(dt,lib,typ);
|
384
|
-
ret=getdtl(rnv, drv_st, lib)->allows(rnv,rn_st,rx_st,rnv->rn_string+typ,rnv->rn_string+ps,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
|
384
|
+
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;
|
385
385
|
break;
|
386
386
|
case RN_P_DATA_EXCEPT: rn_DataExcept(p,p1,p2);
|
387
387
|
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;
|
388
388
|
break;
|
389
389
|
case RN_P_VALUE: rn_Value(p,dt,val); rn_Datatype(dt,lib,typ);
|
390
|
-
ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
|
390
|
+
ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, lib, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
|
391
391
|
break;
|
392
392
|
default: assert(0);
|
393
393
|
}
|
@@ -405,7 +405,7 @@ int drv_text_recover(int p,char *s,int n) {return p;}
|
|
405
405
|
|
406
406
|
static int mixed_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p) { /* matches text in mixed context */
|
407
407
|
int p1,p2,ret=0,m;
|
408
|
-
m=newMixedText(
|
408
|
+
m=newMixedText(drv_st, p);
|
409
409
|
if(m!=-1) return M_RET(m);
|
410
410
|
switch(RN_P_TYP(p)) {
|
411
411
|
case RN_P_NOT_ALLOWED: case RN_P_EMPTY:
|
@@ -434,8 +434,8 @@ static int mixed_text(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p) { /*
|
|
434
434
|
break;
|
435
435
|
default: assert(0);
|
436
436
|
}
|
437
|
-
newMixedText(
|
438
|
-
accept_m(
|
437
|
+
newMixedText(drv_st, p); M_SET(ret);
|
438
|
+
accept_m(drv_st);
|
439
439
|
return ret;
|
440
440
|
}
|
441
441
|
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);}
|
@@ -444,7 +444,7 @@ int drv_mixed_text_recover(int p) {return p;}
|
|
444
444
|
static int end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recover) {
|
445
445
|
int p1,p2,ret=0,m;
|
446
446
|
if(!recover) {
|
447
|
-
m=newEndTag(
|
447
|
+
m=newEndTag(drv_st, p);
|
448
448
|
if(m!=-1) return M_RET(m);
|
449
449
|
}
|
450
450
|
switch(RN_P_TYP(p)) {
|
@@ -463,8 +463,8 @@ static int end_tag(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,int recov
|
|
463
463
|
default: assert(0);
|
464
464
|
}
|
465
465
|
if(!recover) {
|
466
|
-
newEndTag(
|
467
|
-
accept_m(
|
466
|
+
newEndTag(drv_st, p); M_SET(ret);
|
467
|
+
accept_m(drv_st);
|
468
468
|
}
|
469
469
|
return ret;
|
470
470
|
}
|
data/ext/rnv/src/drv.h
CHANGED
@@ -9,13 +9,22 @@
|
|
9
9
|
|
10
10
|
#define DRV_ER_NODTL 0
|
11
11
|
|
12
|
-
|
12
|
+
struct dtl {
|
13
|
+
int uri;
|
14
|
+
int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n);
|
15
|
+
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);
|
16
|
+
};
|
17
|
+
|
18
|
+
extern void drv_default_verror_handler(void *data, int erno, int (*handler)(void *data, int erno,char *format, va_list ap), va_list ap);
|
13
19
|
|
14
20
|
extern void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st);
|
15
|
-
|
21
|
+
|
22
|
+
extern void drv_dispose(drv_st_t *drv_st);
|
16
23
|
|
17
24
|
/* Expat passes character data unterminated. Hence functions that can deal with cdata expect the length of the data */
|
18
|
-
extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
|
25
|
+
extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
|
26
|
+
int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
|
27
|
+
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));
|
19
28
|
|
20
29
|
extern int drv_start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);
|
21
30
|
extern int drv_start_tag_open_recover(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);
|
data/ext/rnv/src/er.c
CHANGED
@@ -12,4 +12,4 @@ int er_default_printf(char *format,...) {
|
|
12
12
|
return ret;
|
13
13
|
}
|
14
14
|
int er_default_vprintf(char *format,va_list ap) {return vfprintf(stderr,format,ap);}
|
15
|
-
int verror_default_handler(
|
15
|
+
int verror_default_handler(void *data, int erno, char *format,va_list ap) {return vfprintf(stderr,format,ap);}
|
data/ext/rnv/src/er.h
CHANGED
@@ -11,6 +11,6 @@ extern int (*er_vprintf)(char *format,va_list ap);
|
|
11
11
|
|
12
12
|
extern int er_default_printf(char *format,...);
|
13
13
|
extern int er_default_vprintf(char *format,va_list ap);
|
14
|
-
extern int verror_default_handler(
|
14
|
+
extern int verror_default_handler(void *data, int erno, char *format,va_list ap);
|
15
15
|
|
16
16
|
#endif
|
data/ext/rnv/src/erbit.h
CHANGED
data/ext/rnv/src/rn.c
CHANGED
@@ -1,8 +1,9 @@
|
|
1
|
-
#include "type.h"
|
2
|
-
|
3
1
|
/* $Id: rn.c,v 1.62 2004/03/13 14:12:11 dvd Exp $ */
|
4
2
|
|
5
3
|
#include <string.h> /* strcmp,strlen,strcpy*/
|
4
|
+
|
5
|
+
#include "type.h"
|
6
|
+
|
6
7
|
#include "m.h"
|
7
8
|
#include "s.h" /* s_hval */
|
8
9
|
#include "ht.h"
|
@@ -276,10 +277,7 @@ static int equal_p(void *user, int p1,int p2);
|
|
276
277
|
static int equal_nc(void *user, int nc1,int nc2);
|
277
278
|
static int equal_s(void *user, int s1,int s2);
|
278
279
|
|
279
|
-
static void windup(rnv_t *rnv, rn_st_t *rn_st);
|
280
|
-
|
281
280
|
void rn_init(rnv_t *rnv, rn_st_t *rn_st) {
|
282
|
-
memset(rn_st, 0, sizeof(rn_st_t));
|
283
281
|
rnv->rn_pattern=(int *)m_alloc(rn_st->len_p=P_AVG_SIZE*LEN_P,sizeof(int));
|
284
282
|
rnv->rn_nameclass=(int *)m_alloc(rn_st->len_nc=NC_AVG_SIZE*LEN_NC,sizeof(int));
|
285
283
|
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) {
|
|
289
287
|
ht_init(&rn_st->ht_p,LEN_P,&hash_p,&equal_p);
|
290
288
|
ht_init(&rn_st->ht_nc,LEN_NC,&hash_nc,&equal_nc);
|
291
289
|
ht_init(&rn_st->ht_s,LEN_S,&hash_s,&equal_s);
|
292
|
-
|
293
|
-
|
294
|
-
|
295
|
-
|
296
|
-
|
297
|
-
|
298
|
-
|
299
|
-
|
300
|
-
|
301
|
-
|
302
|
-
|
303
|
-
|
304
|
-
|
305
|
-
|
306
|
-
|
307
|
-
|
308
|
-
|
309
|
-
rn_st->
|
310
|
-
|
311
|
-
|
312
|
-
|
290
|
+
|
291
|
+
rn_st->i_p=rn_st->i_nc=rn_st->i_s=0;
|
292
|
+
rn_st->adding_ps=0;
|
293
|
+
rnv->rn_pattern[0]=RN_P_ERROR; accept_p(rnv, rn_st);
|
294
|
+
rnv->rn_nameclass[0]=RN_NC_ERROR; accept_nc(rnv, rn_st);
|
295
|
+
rn_newString(rnv, rn_st, "");
|
296
|
+
rnv->rn_notAllowed=rn_newNotAllowed(rnv, rn_st);
|
297
|
+
rnv->rn_empty=rn_newEmpty(rnv, rn_st);
|
298
|
+
rnv->rn_text=rn_newText(rnv, rn_st);
|
299
|
+
rn_st->BASE_P=rn_st->i_p;
|
300
|
+
rnv->rn_dt_string=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "string"));
|
301
|
+
rnv->rn_dt_token=rn_newDatatype(rnv, rn_st, 0,rn_newString(rnv, rn_st, "token"));
|
302
|
+
rnv->rn_xsd_uri=rn_newString(rnv, rn_st, "http://www.w3.org/2001/XMLSchema-datatypes");
|
303
|
+
}
|
304
|
+
|
305
|
+
void rn_dispose(rn_st_t *rn_st) {
|
306
|
+
ht_dispose(&rn_st->ht_p);
|
307
|
+
ht_dispose(&rn_st->ht_nc);
|
308
|
+
ht_dispose(&rn_st->ht_s);
|
309
|
+
|
310
|
+
m_free(rn_st);
|
313
311
|
}
|
314
312
|
|
315
313
|
static int hash_p(void *user, int p) {
|