fly/flightgear
1
0
Fork 0
Code Activity
flightgear/utils/xmlgrep/xml.c
ehofman fc0b771cdf * Implement a node cache that can be enabled at compile time. 
the node cache prevents recursively walking the xml tree over and over
    again to find the specified nodes.
2009-06-03 00:18:55 +02:00

1998 lines
46 KiB
C
Raw Blame History

/* Copyright (c) 2007-2009 by Adalin B.V.
* Copyright (c) 2007-2009 by Erik Hofman
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of (any of) the copyrightholder(s) nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef WIN32
# include <io.h>
#else /* !WIN32 */
# include <sys/mman.h>
# include <unistd.h>
#endif
#ifndef NDEBUG
# include <stdio.h>
#endif
#include <stdlib.h> /* free, malloc */
#include <malloc.h>
#include <string.h> /* memcmp */
#ifndef _MSC_VER
#include <strings.h> /* strncasecmp */
#else
# define strncasecmp strnicmp
#endif
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <assert.h>
#include <ctype.h>
#include "xml.h"
#ifndef XML_NONVALIDATING
static const char *__xml_error_str[XML_MAX_ERROR];
static void __xmlErrorSet(const void *, const char *, unsigned int);
# define xmlErrorSet(a, b, c) __xmlErrorSet(a, b, c)
# ifndef NDEBUG
# define PRINT_INFO(a) \
assert((a) < XML_MAX_ERROR); \
printf("at line %i: %s\n", __LINE__, __xml_error_str[(a)])
# else
# define PRINT_INFO(a)
# endif
# define SET_ERROR_AND_RETURN(a, b) \
{ *rlen = 0; *name = (a); *len = (b); PRINT_INFO(b); return 0; }
#else /* !XML_NONVALIDATING */
# define xmlErrorSet(a, b, c)
# define SET_ERROR_AND_RETURN(a, b) return 0;
#endif
static char *__xmlNodeGetPath(void **, const char *, size_t *, char **, size_t *);
static char *__xmlNodeGet(void *, const char *, size_t *, char **, size_t *, size_t *);
static char *__xmlProcessCDATA(char **, size_t *);
static char *__xmlCommentSkip(const char *, size_t);
static char *__xmlInfoProcess(const char *, size_t);
static void *__xml_memncasecmp(const char *, size_t *, char **, size_t *);
static void __xmlPrepareData(char **, size_t *);
#ifdef WIN32
/*
* map 'filename' and return a pointer to it.
*/
static void *simple_mmap(int, size_t, SIMPLE_UNMMAP *);
static void simple_unmmap(SIMPLE_UNMMAP *);
# define mmap(a,b,c,d,e,f) simple_mmap((e), (b), &rid->un)
# define munmap(a,b) simple_unmmap(&rid->un)
#endif
#ifndef NDEBUG
# define PRINT(a, b, c) { \
size_t l1 = (b), l2 = (c); \
char *s = (a); \
if (s) { \
size_t q, len = l2; \
if (l1 < l2) len = l1; \
if (len < 50000) { \
printf("(%i) '", len); \
for (q=0; q<len; q++) printf("%c", s[q]); \
printf("'\n"); \
} else printf("Length (%u) seems too large at line %i\n",len, __LINE__); \
} else printf("NULL pointer at line %i\n", __LINE__); \
}
#endif
void *
xmlOpen(const char *filename)
{
struct _root_id *rid = 0;
if (filename)
{
int fd = open(filename, O_RDONLY);
if (fd >= 0)
{
struct stat statbuf;
void *mm;
fstat(fd, &statbuf);
mm = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0L);
if (mm != (void *)-1)
{
rid = calloc(1, sizeof(struct _root_id));
if (rid)
{
size_t blen = statbuf.st_size;
#ifdef XML_USE_NODECACHE
size_t num = 0, nlen = 1;
char *n = "*";
rid->node = cacheInit();
__xmlNodeGet(rid->node, mm, &blen, &n, &nlen, &num);
#endif
rid->fd = fd;
rid->start = mm;
rid->len = blen;
}
}
}
}
return (void *)rid;
}
void *
xmlInitBuffer(const char *buffer, size_t size)
{
struct _root_id *rid = 0;
if (buffer && (size > 0))
{
rid = calloc(1, sizeof(struct _root_id));
if (rid)
{
#ifdef XML_USE_NODECACHE
size_t num = 0, nlen = 1;
size_t blen = size;
char *n = "*";
rid->node = cacheInit();
__xmlNodeGet(rid->node, buffer, &blen, &n, &nlen, &num);
#endif
rid->fd = -1;
rid->start = (char *)buffer;
rid->len = size;
}
}
return (void *)rid;
}
void
xmlClose(void *id)
{
struct _root_id *rid = (struct _root_id *)id;
assert(rid != 0);
assert(rid->name == 0);
if (rid->fd != -1)
{
munmap(rid->start, rid->len);
close(rid->fd);
}
#ifdef XML_USE_NODECACHE
if (rid->node) cacheFree(rid->node);
#endif
#ifndef XML_NONVALIDATING
if (rid->info) free(rid->info);
#endif
free(rid);
id = 0;
}
void *
xmlNodeGet(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _xml_id *xsid = 0;
size_t len, slen;
char *ptr, *node;
void *nc, *nnc;
assert(id != 0);
assert(path != 0);
node = (char *)path;
len = xid->len;
slen = strlen(path);
nnc = nc = cacheNodeGet(xid);
ptr = __xmlNodeGetPath(&nnc, xid->start, &len, &node, &slen);
if (ptr)
{
xsid = malloc(sizeof(struct _xml_id));
if (xsid)
{
xsid->name = node;
xsid->name_len = slen;
xsid->start = ptr;
xsid->len = len;
#ifdef XML_USE_NODECACHE
xsid->node = nnc;
#endif
#ifndef XML_NONVALIDATING
if (xid->name)
xsid->root = xid->root;
else
xsid->root = (struct _root_id *)xid;
#endif
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
return (void *)xsid;
}
void *
xmlNodeCopy(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _xml_id *xsid = 0;
char *ptr, *node, *p;
size_t slen, len;
void *nc, *nnc;
node = (char *)path;
len = xid->len;
slen = strlen(path);
nnc = nc = cacheNodeGet(xid);
ptr = __xmlNodeGetPath(&nnc, xid->start, &len, &node, &slen);
if (ptr)
{
xsid = malloc(sizeof(struct _xml_id) + len);
if (xsid)
{
p = (char *)xsid + sizeof(struct _xml_id);
xsid->len = len;
xsid->start = p;
xsid->name_len = slen;
xsid->name = node;
#ifdef XML_USE_NODECACHE
xsid->node = nc;
#endif
#ifndef XML_NONVALIDATING
if (xid->name)
xsid->root = xid->root;
else
xsid->root = (struct _root_id *)xid;
#endif
memcpy(xsid->start, ptr, len);
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
return (void *)xsid;
}
char *
xmlNodeGetName(const void *id)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t len;
char *ret;
assert(xid != 0);
len = xid->name_len;
ret = malloc(len+1);
if (ret)
{
memcpy(ret, xid->name, len);
*(ret + len) = 0;
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
return ret;
}
size_t
xmlNodeCopyName(const void *id, char *buf, size_t buflen)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t slen = 0;
assert(buf != 0);
assert(buflen > 0);
slen = xid->name_len;
if (slen >= buflen)
{
slen = buflen-1;
xmlErrorSet(xid, 0, XML_TRUNCATE_RESULT);
}
memcpy(buf, xid->name, slen);
*(buf + slen) = 0;
return slen;
}
unsigned int
xmlNodeGetNum(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t num = 0;
assert(xid != 0);
assert(path != 0);
if (xid->len)
{
char *nodename, *pathname;
size_t len, slen;
void *nc;
char *p;
nodename = (char *)path;
if (*path == '/') nodename++;
slen = strlen(nodename);
nc = cacheNodeGet(xid);
pathname = strchr(nodename, '/');
if (pathname)
{
char *node;
len = xid->len;
pathname++;
slen -= pathname-nodename;
node = pathname;
p = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (p == 0 && slen == 0)
{
xmlErrorSet(xid, node, len);
}
}
else
{
p = xid->start;
len = xid->len;
}
if (p)
{
char *ret, *node = nodename;
#ifndef XML_USE_NODECACHE
ret = __xmlNodeGet(nc, p, &len, &node, &slen, &num);
#else
ret = __xmlNodeGetFromCache(&nc, p, &len, &node, &slen, &num);
#endif
if (ret == 0 && slen == 0)
{
xmlErrorSet(xid, node, len);
num = 0;
}
}
}
return num;
}
void *
xmlNodeGetPos(const void *pid, void *id, const char *element, size_t num)
{
struct _xml_id *xpid = (struct _xml_id *)pid;
struct _xml_id *xid = (struct _xml_id *)id;
size_t len, slen;
char *ptr, *node;
void *ret = 0;
void *nc;
assert(xpid != 0);
assert(xid != 0);
assert(element != 0);
len = xpid->len;
slen = strlen(element);
node = (char *)element;
nc = cacheNodeGet(xpid);
#ifndef XML_USE_NODECACHE
ptr = __xmlNodeGet(nc, xpid->start, &len, &node, &slen, &num);
#else
ptr = __xmlNodeGetFromCache(&nc, xpid->start, &len, &node, &slen, &num);
#endif
if (ptr)
{
xid->len = len;
xid->start = ptr;
xid->name = node;
xid->name_len = slen;
#ifdef XML_USE_NODECACHE
/* unused for the cache but tested at the start of this function */
if (len == 0) xid->len = 1;
xid->node = nc;
#endif
ret = xid;
}
else if (slen == 0)
{
xmlErrorSet(xpid, node, len);
}
return ret;
}
char *
xmlGetString(const void *id)
{
struct _xml_id *xid = (struct _xml_id *)id;
char *str = 0;
assert(xid != 0);
if (xid->len)
{
size_t len;
char *ps;
ps = xid->start;
len = xid->len;
__xmlPrepareData(&ps, &len);
if (len)
{
str = malloc(len+1);
if (str)
{
memcpy(str, ps, len);
*(str+len) = 0;
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
}
}
return str;
}
size_t
xmlCopyString(const void *id, char *buffer, size_t buflen)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t ret = 0;
assert(xid != 0);
assert(buffer != 0);
assert(buflen > 0);
*buffer = '\0';
if (xid->len)
{
size_t len;
char *ps;
ps = xid->start;
len = xid->len;
__xmlPrepareData(&ps, &len);
if (len)
{
if (len >= buflen)
{
len = buflen-1;
xmlErrorSet(xid, 0, XML_TRUNCATE_RESULT);
}
memcpy(buffer, ps, len);
*(buffer+len) = 0;
}
ret = len;
}
return ret;
}
int
xmlCompareString(const void *id, const char *s)
{
struct _xml_id *xid = (struct _xml_id *)id;
int ret = -1;
assert(xid != 0);
assert(s != 0);
if (xid->len && (strlen(s) > 0))
{
size_t len;
char *ps;
ps = xid->start;
len = xid->len;
__xmlPrepareData(&ps, &len);
ret = strncasecmp(ps, s, len);
}
return ret;
}
char *
xmlNodeGetString(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
char *str = 0;
assert(xid != 0);
assert(path != 0);
if (xid->len)
{
char *ptr, *node = (char *)path;
size_t slen = strlen(node);
size_t len = xid->len;
void *nc;
nc = cacheNodeGet(xid);
ptr = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (ptr && len)
{
__xmlPrepareData(&ptr, &len);
str = malloc(len+1);
if (str)
{
memcpy(str, ptr, len);
*(str+len) = '\0';
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
}
else
{
xmlErrorSet(xid, node, len);
}
}
return str;
}
size_t
xmlNodeCopyString(const void *id, const char *path, char *buffer, size_t buflen)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t ret = 0;
assert(xid != 0);
assert(path != 0);
assert(buffer != 0);
assert(buflen > 0);
*buffer = '\0';
if (xid->len)
{
char *p, *node = (char *)path;
size_t slen = strlen(node);
size_t len = xid->len;
void *nc;
nc = cacheNodeGet(xid);
p = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (p)
{
__xmlPrepareData(&p, &len);
if (len)
{
if (len >= buflen)
{
len = buflen-1;
xmlErrorSet(xid, 0, XML_TRUNCATE_RESULT);
}
memcpy(buffer, p, len);
*(buffer+len) = '\0';
}
ret = 0;
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
}
return ret;
}
int
xmlNodeCompareString(const void *id, const char *path, const char *s)
{
struct _xml_id *xid = (struct _xml_id *)id;
int ret = -1;
assert(xid != 0);
assert(path != 0);
assert(s != 0);
if (xid->len && (strlen(s) > 0))
{
char *node, *str, *ps, *pe;
size_t len, slen;
void *nc;
len = xid->len;
slen = strlen(path);
node = (char *)path;
nc = cacheNodeGet(xid);
str = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (str)
{
ps = str;
__xmlPrepareData(&ps, &len);
ret = strncasecmp(ps, s, len);
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
}
return ret;
}
long int
xmlGetInt(const void *id)
{
struct _xml_id *xid = (struct _xml_id *)id;
long int li = 0;
assert(xid != 0);
if (xid->len)
{
char *end = xid->start + xid->len;
li = strtol(xid->start, &end, 10);
}
return li;
}
long int
xmlNodeGetInt(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
long int li = 0;
assert(xid != 0);
assert(path != 0);
if (xid->len)
{
size_t len, slen;
char *str, *node;
void *nc;
len = xid->len;
slen = strlen(path);
node = (char *)path;
nc = cacheNodeGet(xid);
str = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (str)
{
char *end = str+len;
li = strtol(str, &end, 10);
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
}
return li;
}
double
xmlGetDouble(const void *id)
{
struct _xml_id *xid = (struct _xml_id *)id;
double d = 0.0;
assert(xid != 0);
if (xid->len)
{
char *end = xid->start + xid->len;
d = strtod(xid->start, &end);
}
return d;
}
double
xmlNodeGetDouble(const void *id, const char *path)
{
struct _xml_id *xid = (struct _xml_id *)id;
double d = 0.0;
assert(xid != 0);
assert(path != 0);
if (xid->len)
{
size_t len, slen;
char *str, *node;
void *nc;
len = xid->len;
slen = strlen(path);
node = (char *)path;
nc = cacheNodeGet(xid);
str = __xmlNodeGetPath(&nc, xid->start, &len, &node, &slen);
if (str)
{
char *end = str+len;
d = strtod(str, &end);
}
else if (slen == 0)
{
xmlErrorSet(xid, node, len);
}
}
return d;
}
void *
xmlMarkId(const void *id)
{
struct _xml_id *xmid = 0;
assert(id != 0);
xmid = malloc(sizeof(struct _xml_id));
if (xmid)
{
struct _root_id *xrid = (struct _root_id *)id;
if (xrid->name == 0)
{
xmid->name = "";
xmid->name_len = 0;
xmid->start = xrid->start;
xmid->len = xrid->len;
#ifdef XML_USE_NODECACHE
xmid->node = xrid->node;
#endif
#ifndef XML_NONVALIDATING
xmid->root = xrid;
#endif
}
else
{
memcpy(xmid, id, sizeof(struct _xml_id));
}
}
else
{
xmlErrorSet(id, 0, XML_OUT_OF_MEMORY);
}
return (void *)xmid;
}
double
xmlAttributeGetDouble(const void *id, const char *name)
{
struct _xml_id *xid = (struct _xml_id *)id;
double ret = 0.0;
assert(xid != 0);
assert(name != 0);
if (xid->name_len)
{
size_t slen = strlen(name);
char *ps, *pe;
assert(xid->start > xid->name);
ps = xid->name + xid->name_len + 1;
pe = xid->start - 1;
while (ps<pe)
{
while ((ps<pe) && isspace(*ps)) ps++;
if (((size_t)(pe-ps) > slen) && (strncasecmp(ps, name, slen) == 0))
{
ps += slen;
if ((ps<pe) && (*ps == '='))
{
char *start;
ps++;
if (*ps == '"' || *ps == '\'') ps++;
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_OPENING_QUOTE);
return 0;
}
start = ps;
while ((ps<pe) && (*ps != '"') && (*ps != '\'')) ps++;
if (ps<pe)
{
ret = strtod(start, &ps);
}
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_CLOSING_QUOTE);
return 0;
}
}
else
{
while ((ps<pe) && !isspace(*ps)) ps++;
continue;
}
break;
}
while ((ps<pe) && !isspace(*ps)) ps++;
}
}
return ret;
}
long int
xmlAttributeGetInt(const void *id, const char *name)
{
struct _xml_id *xid = (struct _xml_id *)id;
long int ret = 0;
assert(xid != 0);
assert(name != 0);
if (xid->name_len)
{
size_t slen = strlen(name);
char *ps, *pe;
assert(xid->start > xid->name);
ps = xid->name + xid->name_len + 1;
pe = xid->start - 1;
while (ps<pe)
{
while ((ps<pe) && isspace(*ps)) ps++;
if (((size_t)(pe-ps) > slen) && (strncasecmp(ps, name, slen) == 0))
{
ps += slen;
if ((ps<pe) && (*ps == '='))
{
char *start;
ps++;
if (*ps == '"' || *ps == '\'') ps++;
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_OPENING_QUOTE);
return 0;
}
start = ps;
while ((ps<pe) && (*ps != '"') && (*ps != '\'')) ps++;
if (ps<pe)
{
ret = strtol(start, &ps, 10);
}
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_CLOSING_QUOTE);
return 0;
}
}
else
{
while ((ps<pe) && isspace(*ps)) ps++;
continue;
}
break;
}
while ((ps<pe) && !isspace(*ps)) ps++;
}
}
return ret;
}
char *
xmlAttributeGetString(const void *id, const char *name)
{
struct _xml_id *xid = (struct _xml_id *)id;
char *ret = 0;
assert(xid != 0);
assert(name != 0);
if (xid->name_len)
{
size_t slen = strlen(name);
char *ps, *pe;
assert(xid->start > xid->name);
ps = xid->name + xid->name_len + 1;
pe = xid->start - 1;
while (ps<pe)
{
while ((ps<pe) && isspace(*ps)) ps++;
if (((size_t)(pe-ps) > slen) && (strncasecmp(ps, name, slen) == 0))
{
ps += slen;
if ((ps<pe) && (*ps == '='))
{
char *start;
ps++;
if (*ps == '"' || *ps == '\'') ps++;
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_OPENING_QUOTE);
return 0;
}
start = ps;
while ((ps<pe) && (*ps != '"') && (*ps != '\'')) ps++;
if (ps<pe)
{
ret = malloc(ps-start);
if (ret)
{
memcpy(ret, start, (ps-start));
*(ret+(ps-start)) = '\0';
}
else
{
xmlErrorSet(xid, 0, XML_OUT_OF_MEMORY);
}
}
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_CLOSING_QUOTE);
return 0;
}
}
else
{
while ((ps<pe) && !isspace(*ps)) ps++;
continue;
}
break;
}
while ((ps<pe) && !isspace(*ps)) ps++;
}
}
return ret;
}
size_t
xmlAttributeCopyString(const void *id, const char *name,
char *buffer, size_t buflen)
{
struct _xml_id *xid = (struct _xml_id *)id;
size_t ret = 0;
assert(xid != 0);
assert(name != 0);
assert(buffer != 0);
assert(buflen > 0);
if (xid->name_len)
{
size_t slen = strlen(name);
char *ps, *pe;
assert(xid->start > xid->name);
*buffer = '\0';
ps = xid->name + xid->name_len + 1;
pe = xid->start - 1;
while (ps<pe)
{
while ((ps<pe) && isspace(*ps)) ps++;
if (((size_t)(pe-ps) > slen) && (strncasecmp(ps, name, slen) == 0))
{
ps += slen;
if ((ps<pe) && (*ps == '='))
{
char *start;
ps++;
if (*ps == '"' || *ps == '\'') ps++;
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_OPENING_QUOTE);
return 0;
}
start = ps;
while ((ps<pe) && (*ps != '"') && (*ps != '\'')) ps++;
if (ps<pe)
{
size_t restlen = ps-start;
if (restlen >= buflen)
{
restlen = buflen-1;
xmlErrorSet(xid, ps, XML_TRUNCATE_RESULT);
}
memcpy(buffer, start, restlen);
*(buffer+restlen) = 0;
ret = restlen;
}
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_CLOSING_QUOTE);
return 0;
}
}
else
{
while ((ps<pe) && isspace(*ps)) ps++;
continue;
}
break;
}
while ((ps<pe) && !isspace(*ps)) ps++;
}
}
return ret;
}
int
xmlAttributeCompareString(const void *id, const char *name, const char *s)
{
struct _xml_id *xid = (struct _xml_id *)id;
int ret = -1;
assert(xid != 0);
assert(name != 0);
assert(s != 0);
if (xid->name_len && strlen(s))
{
size_t slen = strlen(name);
char *ps, *pe;
assert(xid->start > xid->name);
ps = xid->name + xid->name_len + 1;
pe = xid->start - 1;
while (ps<pe)
{
while ((ps<pe) && isspace(*ps)) ps++;
if (((size_t)(pe-ps) > slen) && (strncasecmp(ps, name, slen) == 0))
{
ps += slen;
if ((ps<pe) && (*ps == '='))
{
char *start;
ps++;
if (*ps == '"' || *ps == '\'') ps++;
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_OPENING_QUOTE);
return 0;
}
start = ps;
while ((ps<pe) && (*ps != '"') && (*ps != '\'')) ps++;
if (ps<pe)
{
ret = strncasecmp(start, s, ps-start);
}
else
{
xmlErrorSet(xid, ps, XML_ATTRIB_NO_CLOSING_QUOTE);
return 0;
}
}
else
{
while ((ps<pe) && !isspace(*ps)) ps++;
continue;
}
break;
}
while ((ps<pe) && !isspace(*ps)) ps++;
}
}
return ret;
}
#ifndef XML_NONVALIDATING
int
xmlErrorGetNo(const void *id, int clear)
{
int ret = 0;
if (id)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _root_id *rid;
if (xid->name) rid = xid->root;
else rid = (struct _root_id *)xid;
assert(rid != 0);
if (rid->info)
{
struct _xml_error *err = rid->info;
ret = err->err_no;
if (clear) err->err_no = 0;
}
}
return ret;
}
size_t
xmlErrorGetLineNo(const void *id, int clear)
{
size_t ret = 0;
if (id)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _root_id *rid;
if (xid->name) rid = xid->root;
else rid = (struct _root_id *)xid;
assert(rid != 0);
if (rid->info)
{
struct _xml_error *err = rid->info;
char *ps = rid->start;
char *pe = err->pos;
char *new;
ret++;
while (ps<pe)
{
new = memchr(ps, '\n', pe-ps);
if (new) ret++;
else break;
ps = new+1;
}
if (clear) err->err_no = 0;
}
}
return ret;
}
size_t
xmlErrorGetColumnNo(const void *id, int clear)
{
size_t ret = 0;
if (id)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _root_id *rid;
if (xid->name) rid = xid->root;
else rid = (struct _root_id *)xid;
assert(rid != 0);
if (rid->info)
{
struct _xml_error *err = rid->info;
char *ps = rid->start;
char *pe = err->pos;
char *new;
while (ps<pe)
{
new = memchr(ps, '\n', pe-ps);
new = memchr(ps, '\n', pe-ps);
if (new) ret++;
else break;
ps = new+1;
}
ret = pe-ps;
if (clear) err->err_no = 0;
}
}
return ret;
}
const char *
xmlErrorGetString(const void *id, int clear)
{
char *ret = 0;
if (id)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _root_id *rid;
if (xid->name) rid = xid->root;
else rid = (struct _root_id *)xid;
assert(rid != 0);
if (rid->info)
{
struct _xml_error *err = rid->info;
if (XML_NO_ERROR <= err->err_no && err->err_no < XML_MAX_ERROR)
{
ret = (char *)__xml_error_str[err->err_no];
}
else
{
ret = "incorrect error number.";
}
if (clear) err->err_no = 0;
}
}
return ret;
}
#else
int
xmlErrorGetNo(const void *id, int clear)
{
return XML_NO_ERROR;
}
size_t
xmlErrorGetLineNo(const void *id, int clear)
{
return 0;
}
size_t
xmlErrorGetColumnNo(const void *id, int clear)
{
return 0;
}
const char *
xmlErrorGetString(const void *id, int clear)
{
return "error detection was not enabled at compile time: no error.";
}
#endif
/* -------------------------------------------------------------------------- */
#ifndef XML_NONVALIDATING
static const char *__xml_error_str[XML_MAX_ERROR] =
{
"no error.",
"unable to allocate enough memory.",
"unable to open file for reading.",
"requested node name is invalid.",
"unexpected end of section.",
"buffer too small to hold all data, truncating.",
"incorrect comment section.",
"bad information block.",
"incompatible opening tag for element.",
"missing or invalid closing tag for element.",
"missing or invalid opening quote for attribute.",
"missing or invalid closing quote for attribute."
};
#endif
char *
__xmlNodeGetPath(void **nc, const char *start, size_t *len, char **name, size_t *nlen)
{
char *path;
char *ret = 0;
assert(start != 0);
assert(len != 0);
assert(*len != 0);
assert(name != 0);
assert(*name != 0);
assert(nlen != 0);
assert(*nlen != 0);
if (*nlen > *len) return 0;
path = *name;
if (*path == '/') path++;
if (*path != '\0')
{
size_t num, blocklen, pathlen, nodelen;
char *node;
node = path;
pathlen = strlen(path);
path = strchr(node, '/');
if (!path) nodelen = pathlen;
else nodelen = path++ - node;
num = 0;
blocklen = *len;
#ifndef XML_USE_NODECACHE
ret = __xmlNodeGet(nc, start, &blocklen, &node, &nodelen, &num);
#else
ret = __xmlNodeGetFromCache(nc, start, &blocklen, &node, &nodelen, &num);
#endif
if (ret)
{
if (path)
{
ret = __xmlNodeGetPath(nc, ret, &blocklen, &path, &pathlen);
*name = path;
*len = blocklen;
*nlen = pathlen;
}
else
{
*name = node;
*nlen = nodelen;
*len = blocklen;
}
}
else
{
*len = 0;
*nlen = 0;
}
}
return ret;
}
char *
__xmlNodeGet(void *nc, const char *start, size_t *len, char **name, size_t *rlen, size_t *nodenum)
{
char *cdata, *open_element = *name;
char *element, *start_tag=0;
char *new, *cur, *ne, *ret = 0;
size_t restlen, elementlen;
size_t open_len = *rlen;
size_t return_len = 0;
int found, num;
void *nnc = 0;
assert(start != 0);
assert(len != 0);
assert(name != 0);
assert(rlen != 0);
assert(nodenum != 0);
if (open_len == 0 || *name == 0)
SET_ERROR_AND_RETURN((char *)start, XML_INVALID_NODE_NAME);
cdata = (char *)start;
if (*rlen > *len)
SET_ERROR_AND_RETURN((char *)start, XML_UNEXPECTED_EOF);
found = 0;
num = *nodenum;
restlen = *len;
cur = (char *)start;
ne = cur + restlen;
#ifdef XML_USE_NODECACHE
cacheInitLevel(nc);
#endif
/* search for an opening tag */
while ((new = memchr(cur, '<', restlen)) != 0)
{
size_t len_remaining;
char *rptr;
if (*(new+1) == '/') /* end of section */
{
*len -= restlen;
break;
}
new++;
restlen -= new-cur;
cur = new;
if (*cur == '!') /* comment */
{
char *start = cur;
size_t blocklen = restlen;
new = __xmlProcessCDATA(&start, &blocklen);
if (!new && start && open_len) /* CDATA */
SET_ERROR_AND_RETURN(cur, XML_INVALID_COMMENT);
restlen -= new-cur;
cur = new;
continue;
}
else if (*cur == '?') /* info block */
{
new = __xmlInfoProcess(cur, restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_INVALID_INFO_BLOCK);
restlen -= new-cur;
cur = new;
continue;
}
/*
* get element name and a pointer to after the opening tag
*/
element = *name;
elementlen = *rlen;
len_remaining = restlen;
rptr = __xml_memncasecmp(cur, &restlen, &element, &elementlen);
if (rptr) /* requested element was found */
{
new = rptr;
return_len = elementlen;
if (found == num)
{
ret = new;
open_len = elementlen;
start_tag = element;
}
else start_tag = 0;
}
else /* different element name was foud */
{
new = cur + (len_remaining - restlen);
if (new >= ne)
SET_ERROR_AND_RETURN(cur, XML_UNEXPECTED_EOF);
element = *name;
}
#ifdef XML_USE_NODECACHE
nnc = cacheNodeNew(nc);
#endif
if (*(new-2) == '/') /* e.g. <test/> */
{
cur = new;
if (rptr)
{
#ifdef XML_USE_NODECACHE
cacheDataSet(nnc, element, elementlen, rptr, 0);
#endif
if (found == num)
{
open_element = start_tag;
*len = 0;
}
found++;
}
continue;
}
/*
* get the next xml tag
*/
/* restlen -= new-cur; not necessary because of __xml_memncasecmp */
cur = new;
new = memchr(cur, '<', restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
new++;
restlen -= new-cur;
cur = new;
if (*cur == '!') /* comment, CDATA */
{
char *start = cur;
size_t blocklen = restlen;
new = __xmlProcessCDATA(&start, &blocklen);
if (new && start && open_len) /* CDATA */
{
cdata = ret;
}
else if (!new)
SET_ERROR_AND_RETURN(cur, XML_INVALID_COMMENT);
restlen -= new-cur;
cur = new;
/*
* look for the closing tag of the cascading block
*/
new = memchr(cur, '<', restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
new++;
restlen -= new-cur;
cur = new;
}
if (*cur == '/') /* closing tag of leaf node found */
{
if (!strncasecmp(new+1, element, elementlen))
{
#ifdef XML_USE_NODECACHE
cacheDataSet(nnc, element, elementlen, rptr, new-rptr-1);
#endif
if (*(new+elementlen+1) != '>')
SET_ERROR_AND_RETURN(new+1, XML_ELEMENT_NO_CLOSING_TAG);
if (found == num)
{
if (start_tag)
{
*len = new-ret-1;
open_element = start_tag;
cdata = (char *)start;
start_tag = 0;
}
else /* report error */
SET_ERROR_AND_RETURN(new, XML_ELEMENT_NO_OPENING_TAG);
}
found++;
}
new = memchr(cur, '>', restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
restlen -= new-cur;
cur = new;
continue;
}
/* no leaf node, continue */
if (*cur != '/') /* cascading tag found */
{
char *node = "*";
size_t slen = restlen+1; /* due to cur-1 below*/
size_t nlen = 1;
size_t pos = -1;
/*
* recursively walk the xml tree from here
*/
new = __xmlNodeGet(nnc, cur-1, &slen, &node, &nlen, &pos);
if (!new)
{
if (nlen == 0) /* error upstream */
{
*rlen = nlen;
*name = node;
*len = slen;
return 0;
}
if (slen == restlen)
SET_ERROR_AND_RETURN(cur, XML_UNEXPECTED_EOF);
slen--;
new = cur + slen;
restlen -= slen;
}
else restlen -= slen;
/*
* look for the closing tag of the cascading block
*/
cur = new;
new = memchr(cur, '<', restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
new++;
restlen -= new-cur;
cur = new;
}
if (*cur == '/') /* closing tag found */
{
if (!strncasecmp(new+1, element, elementlen))
{
if (*(new+elementlen+1) != '>')
SET_ERROR_AND_RETURN(new+1, XML_ELEMENT_NO_CLOSING_TAG);
#ifdef XML_USE_NODECACHE
cacheDataSet(nnc, element, elementlen, rptr, new-rptr-1);
#endif
if (found == num)
{
if (start_tag)
{
*len = new-ret-1;
open_element = start_tag;
cdata = (char *)start;
start_tag = 0;
}
else /* report error */
SET_ERROR_AND_RETURN(new, XML_ELEMENT_NO_OPENING_TAG);
}
found++;
}
new = memchr(cur, '>', restlen);
if (!new)
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
restlen -= new-cur;
cur = new;
}
else
SET_ERROR_AND_RETURN(cur, XML_ELEMENT_NO_CLOSING_TAG);
} /* while */
if (found == 0)
{
ret = 0;
*rlen = 0;
*name = start_tag;
*len = XML_NO_ERROR; /* element not found, no real error */
}
else
{
*rlen = open_len;
*name = open_element;
*nodenum = found;
}
return ret;
}
char *
__xmlProcessCDATA(char **start, size_t *len)
{
char *cur, *new;
size_t restlen = *len;
cur = *start;
if ((restlen > 6) && (*(cur+1) == '-')) /* comment */
{
new = __xmlCommentSkip(cur, restlen);
if (new)
{
*start = new;
*len = 0;
}
return new;
}
if (restlen < 12) return 0; /* ![CDATA[ ]]> */
cur = *start;
new = 0;
if (memcmp(cur, "![CDATA[", 8) == 0)
{
*start = cur+8;
cur += 8;
restlen -= 8;
do
{
new = memchr(cur, ']', restlen);
if (new)
{
if ((restlen > 3) && (memcmp(new, "]]>", 3) == 0))
{
*len = new-1 - *start;
restlen -= 3;
new += 3;
break;
}
cur = new+1;
}
else
{
*len = 0;
break;
}
}
while (new && (restlen > 2));
}
return new;
}
char *
__xmlCommentSkip(const char *start, size_t len)
{
char *cur, *new;
if (len < 7) return 0; /* !-- --> */
cur = (char *)start;
new = 0;
if (memcmp(cur, "!--", 3) == 0)
{
cur += 3;
len -= 3;
do
{
new = memchr(cur, '-', len);
if (new)
{
len -= new-cur;
if ((len >= 3) && (memcmp(new, "-->", 3) == 0))
{
new += 3;
/* len -= 3; */
break;
}
cur = new+1;
len -= cur-new;
}
else break;
}
while (new && (len > 2));
}
return new;
}
char *
__xmlInfoProcess(const char *start, size_t len)
{
char *cur, *new;
cur = (char *)start;
new = 0;
if (*cur == '?')
{
if (len < 3) return 0; /* <? ?> */
cur++;
len--;
new = memchr(cur, '?', len);
if (!new || *(new+1) != '>') return 0;
new += 2;
}
return new;
}
static void
__xmlPrepareData(char **start, size_t *blocklen)
{
size_t len = *blocklen;
char *pe, *ps = *start;
if (len > 1)
{
pe = ps + len-1;
while ((ps<pe) && isspace(*ps)) ps++;
while ((pe>ps) && isspace(*pe)) pe--;
len = (pe-ps)+1;
}
else if (isspace(*(ps+1))) len--;
/* CDATA or comment */
if ((len >= 2) && !strncmp(ps, "<!", 2))
{
char *start = ps+1;
size_t blocklen = len-1;
if (blocklen >= 6) /* !-- --> */
{
char *new = __xmlProcessCDATA(&start, &len);
if (new)
{
ps = start;
pe = ps + len;
while ((ps<pe) && isspace(*ps)) ps++;
while ((pe>ps) && isspace(*pe)) pe--;
len = (pe-ps);
}
}
}
*start = ps;
*blocklen = len;
}
#define NOCASECMP(a,b) ( ((a)^(b)) & 0xdf )
void *
__xml_memncasecmp(const char *haystack, size_t *haystacklen,
char **needle, size_t *needlelen)
{
char *rptr = 0;
if (haystack && needle && needlelen && (*needlelen > 0)
&& (*haystacklen >= *needlelen))
{
char *hs = (char *)haystack;
char *ns;
size_t i;
ns = *needle;
/* search for everything */
if ((*ns == '*') && (*needlelen == 1))
{
char *he = hs + *haystacklen;
while ((hs < he) && !isspace(*hs) && (*hs != '>')) hs++;
if (*(hs-1) == '/') hs--;
*needle = (char *)haystack;
*needlelen = hs - haystack;
ns = memchr(hs, '>', he-hs);
if (ns) hs = ns+1;
else hs = he;
rptr = hs;
}
else
{
size_t nlen = *needlelen;
char *he = hs + *haystacklen;
for (i=0; i<nlen; i++)
{
if (NOCASECMP(*hs,*ns) && (*ns != '?')) break;
if (isspace(*hs) || (*hs == '/') || (*hs == '>')) break;
hs++;
ns++;
}
if (i == nlen)
{
*needle = (char *)haystack;
*needlelen = hs - haystack;
ns = memchr(hs, '>', he-hs);
if (ns) hs = ns+1;
else hs = he;
rptr = hs;
}
else /* not found */
{
while((hs < he) && !isspace(*hs) && (*hs != '>')) hs++;
if (*(hs-1) == '/') hs--;
*needle = (char *)haystack;
*needlelen = hs - haystack;
ns = memchr(hs, '>', he-hs);
if (ns) hs = ns+1;
else hs = he;
}
}
*haystacklen -= hs - haystack;
}
return rptr;
}
#ifndef XML_NONVALIDATING
void
__xmlErrorSet(const void *id, const char *pos, unsigned int err_no)
{
struct _xml_id *xid = (struct _xml_id *)id;
struct _root_id *rid;
assert(xid != 0);
if (xid->name) rid = xid->root;
else rid = (struct _root_id *)xid;
assert(rid != 0);
if (rid->info == 0)
{
rid->info = malloc(sizeof(struct _xml_error));
}
if (rid->info)
{
struct _xml_error *err = rid->info;
err->pos = (char *)pos;
err->err_no = err_no;
}
}
#endif
#ifdef WIN32
/* Source:
* https://mollyrocket.com/forums/viewtopic.php?p=2529
*/
void *
simple_mmap(int fd, size_t length, SIMPLE_UNMMAP *un)
{
HANDLE f;
HANDLE m;
void *p;
f = (HANDLE)_get_osfhandle(fd);
if (!f) return (void *)-1;
m = CreateFileMapping(f, NULL, PAGE_READONLY, 0, 0, NULL);
if (!m) return (void *)-1;
p = MapViewOfFile(m, FILE_MAP_READ, 0,0,0);
if (!p)
{
CloseHandle(m);
return (void *)-1;
}
if (un)
{
un->m = m;
un->p = p;
}
return p;
}
void
simple_unmmap(SIMPLE_UNMMAP *un)
{
UnmapViewOfFile(un->p);
CloseHandle(un->m);
}
#endif
View git blame Copy permalink