41 static xht _nad_alloc_tracked = NULL;
42 static xht _nad_free_tracked = NULL;
46 snprintf(loc,
sizeof(loc),
"%x", (
int) nad);
48 if(
xhash_get(_nad_alloc_tracked, loc) == NULL) {
49 fprintf(stderr,
">>> NAD OP %s: 0x%x not allocated!\n", func, (
int) nad);
53 if(
xhash_get(_nad_free_tracked, loc) != NULL) {
54 fprintf(stderr,
">>> NAD OP %s: 0x%x previously freed!\n", func, (
int) nad);
58 fprintf(stderr,
">>> NAD OP %s: 0x%x\n", func, (
int) nad);
61 #define _nad_ptr_check(func,nad)
84 *oblocks = realloc(*oblocks, nlen);
89 #define NAD_SAFE(blocks, size, len) if((size) > len) len = _nad_realloc((void**)&(blocks),(size));
96 memcpy(nad->
cdata + nad->
ccur, cdata, len);
98 return nad->
ccur - len;
102 static int _nad_attr(
nad_t nad,
int elem,
int ns,
const char *name,
const char *val,
int vallen)
129 nad = calloc(1,
sizeof(
struct nad_st));
136 snprintf(loc,
sizeof(loc),
"%x", (
int) nad);
151 if(nad == NULL)
return NULL;
180 if(nad == NULL)
return;
186 snprintf(loc,
sizeof(loc),
"%x", (
int) nad);
212 if(elem >= nad->
ecur)
return -1;
216 if(name != NULL) lname = strlen(name);
219 for(elem++;elem < nad->
ecur;elem++)
243 if(elem >= nad->
ecur || name == NULL)
return -1;
246 lname = strlen(name);
247 if(val != NULL) lval = strlen(val);
253 (lval <= 0 || (lval == nad->
attrs[attr].
lval && strncmp(val,nad->
cdata + nad->
attrs[attr].
ival, lval) == 0)) &&
269 if(elem >= nad->
ecur || uri == NULL)
return -1;
279 if(strlen(uri) ==
NAD_NURI_L(nad, ns) && strncmp(uri,
NAD_NURI(nad, ns),
NAD_NURI_L(nad, ns)) == 0 && (prefix == NULL || (nad->
nss[ns].
iprefix >= 0 && strlen(prefix) ==
NAD_NPREFIX_L(nad, ns) && strncmp(prefix,
NAD_NPREFIX(nad, ns),
NAD_NPREFIX_L(nad, ns)) == 0)))
299 for(ns = 0; ns < nad->
ncur; ns++)
319 char *str, *slash, *qmark, *equals;
324 if(elem >= nad->
ecur || name == NULL)
return -1;
327 if(strstr(name,
"/") == NULL && strstr(name,
"?") == NULL)
331 slash = strstr(str,
"/");
332 qmark = strstr(str,
"?");
333 equals = strstr(str,
"=");
336 if(qmark != NULL && (slash == NULL || qmark < slash))
349 if(strcmp(qmark,
"xmlns") == 0) {
386 _nad_attr(nad, elem, ns, name, val, vallen);
409 if (parent >= nad->
ecur) {
411 parent = nad->
ecur -1;
423 if(nad->
ecur != elem)
457 if(elem >= nad->
ecur)
return;
466 nad->
ecur -= next - elem;
469 for(cur = elem; cur < nad->
ecur; cur++)
481 if(elem >= nad->
ecur)
return;
490 for(cur = elem + 1; cur < nad->
ecur; cur++)
513 int nelem, first, i, j, ns, nattr, attr;
514 char buri[256], *uri = buri, bprefix[256], *prefix = bprefix;
520 if(src->
ecur <= selem || dest->
ecur <= delem)
525 while(selem + nelem < src->ecur && src->
elems[selem + nelem].
depth > src->
elems[selem].
depth) nelem++;
531 memmove(&dest->
elems[delem + nelem + 1], &dest->
elems[delem + 1], (dest->
ecur - delem - 1) *
sizeof(
struct nad_elem_st));
535 for(i = delem + nelem; i < dest->
ecur; i++)
542 for(i = 0; i < nelem; i++) {
565 for(j = 0; j < dest->
ncur; j++)
572 if(j == dest->
ncur) {
576 uri = (
char *) malloc(
sizeof(
char) * (
NAD_NURI_L(src, ns) + 1));
578 prefix = (
char *) malloc(
sizeof(
char) * (
NAD_NURI_L(src, ns) + 1));
588 if(uri != buri) free(uri);
589 if(prefix != bprefix) free(prefix);
594 for(ns = src->
elems[selem + i].
ns; ns >= 0; ns = src->
nss[ns].
next) {
595 for(j = 0; j < dest->
ncur; j++)
600 if(j == dest->
ncur) {
604 uri = (
char *) malloc(
sizeof(
char) * (
NAD_NURI_L(src, ns) + 1));
606 prefix = (
char *) malloc(
sizeof(
char) * (
NAD_NURI_L(src, ns) + 1));
616 if(uri != buri) free(uri);
617 if(prefix != bprefix) free(prefix);
628 for(attr = src->
elems[selem + i].
attr; attr >= 0; attr = src->
attrs[attr].
next) nattr++;
648 for(j = 0; j < dest->
ncur; j++)
689 nad->
depths[depth] = elem;
711 int elem = nad->
ecur - 1;
726 elem = nad->
depths[depth];
753 nad->
nss[ns].
luri = strlen(uri);
785 nad->
nss[ns].
luri = strlen(uri);
806 while(flag >= 4 && (c = memchr(nad->
cdata + data,
'"',len)) != NULL)
816 memcpy(nad->
cdata + nad->
ccur,
""", 6);
820 len -= (ic+1) - data;
825 while(flag >= 3 && (c = memchr(nad->
cdata + data,
'\'',len)) != NULL)
832 memcpy(nad->
cdata + nad->
ccur,
"'", 6);
836 len -= (ic+1) - data;
841 while(flag >= 2 && (c = memchr(nad->
cdata + data,
'<',len)) != NULL)
848 memcpy(nad->
cdata + nad->
ccur,
"<", 4);
852 len -= (ic+1) - data;
857 while(flag >= 1 && (c = memchr(nad->
cdata + data,
'>', len)) != NULL)
864 memcpy(nad->
cdata + nad->
ccur,
">", 4);
868 len -= (ic+1) - data;
873 while((c = memchr(nad->
cdata + data,
'&',len)) != NULL)
882 nad->
ccur += (ic - data);
885 memcpy(nad->
cdata + nad->
ccur,
"&", 5);
889 len -= (ic+1) - data;
911 while(elem != nad->
ecur)
954 memcpy(nad->
cdata + nad->
ccur,
" xmlns", 6);
1013 if(elem+1 == nad->
ecur)
1019 if(ndepth <= nad->elems[elem].depth)
1025 memcpy(nad->
cdata + nad->
ccur,
"/>", 2);
1043 memcpy(nad->
cdata + nad->
ccur,
"</", 2);
1063 if(ndepth < nad->elems[elem].depth)
1088 memcpy(nad->
cdata + nad->
ccur,
"</", 2);
1117 int ixml = nad->
ccur;
1122 *len = nad->
ccur - ixml;
1123 *xml = nad->
cdata + ixml;
1148 *len =
sizeof(int) * 5 +
1152 sizeof(char) * nad->
ccur;
1154 *buf = (
char *) malloc(*len);
1157 * (
int *) pos = *len; pos +=
sizeof(int);
1158 * (
int *) pos = nad->
ecur; pos +=
sizeof(
int);
1159 * (
int *) pos = nad->
acur; pos +=
sizeof(
int);
1160 * (
int *) pos = nad->
ncur; pos +=
sizeof(
int);
1161 * (
int *) pos = nad->
ccur; pos +=
sizeof(
int);
1166 memcpy(pos, nad->
cdata,
sizeof(
char) * nad->
ccur);
1171 const char *pos = buf +
sizeof(int);
1175 nad->
ecur = * (
int *) pos; pos +=
sizeof(int);
1176 nad->
acur = * (
int *) pos; pos +=
sizeof(int);
1177 nad->
ncur = * (
int *) pos; pos +=
sizeof(int);
1178 nad->
ccur = * (
int *) pos; pos +=
sizeof(int);
1207 nad->
cdata = (
char *) malloc(
sizeof(
char) * nad->
ccur);
1208 memcpy(nad->
cdata, pos,
sizeof(
char) * nad->
ccur);
1226 char *uri, *elem, *prefix;
1231 strncpy(buf, name, 1024);
1242 elem = strchr(uri,
'|');
1246 prefix = strchr(elem,
'|');
1247 if(prefix != NULL) {
1265 while(attr[0] != NULL) {
1268 strncpy(buf, attr[0], 1024);
1273 elem = strchr(uri,
'|');
1277 prefix = strchr(elem,
'|');
1278 if(prefix != NULL) {
1323 #ifdef HAVE_XML_STOPPARSER
1325 static void _nad_parse_entity_declaration(
void *arg,
const char *entityName,
1326 int is_parameter_entity,
const char *value,
1327 int value_length,
const char *base,
1328 const char *systemId,
const char *publicId,
1329 const char *notationName)
1333 XML_StopParser(bd->
p, XML_FALSE);
1344 p = XML_ParserCreateNS(NULL,
'|');
1349 XML_SetReturnNSTriplet(p, 1);
1355 #ifdef HAVE_XML_STOPPARSER
1356 XML_SetEntityDeclHandler(p, (
void *) _nad_parse_entity_declaration);
1358 XML_SetDefaultHandler(p, NULL);
1364 XML_SetUserData(p, (
void *) &bd);
1369 if(!XML_Parse(p, buf, len, 1)) {