|
|
#if 0
|
|
|
liblilxml
|
|
|
Copyright (C) 2003 Elwood C. Downey
|
|
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
License as published by the Free Software Foundation; either
|
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
License along with this library; if not, write to the Free Software
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
|
#endif
|
|
|
|
|
|
/* little DOM-style XML parser.
|
|
|
* only handles elements, attributes and pcdata content.
|
|
|
* <! ... > and <? ... > are silently ignored.
|
|
|
* pcdata is collected into one string, sans leading whitespace first line.
|
|
|
*
|
|
|
* #define MAIN_TST to create standalone test program
|
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <string.h>
|
|
|
#include <ctype.h>
|
|
|
|
|
|
#include "lilxml.h"
|
|
|
#include "indicom.h"
|
|
|
|
|
|
static int oneXMLchar (LilXML *lp, int c, char errmsg[]);
|
|
|
static void initParser(LilXML *lp);
|
|
|
static void pushXMLEle(LilXML *lp);
|
|
|
static void popXMLEle(LilXML *lp);
|
|
|
static void resetEndTag(LilXML *lp);
|
|
|
static void addAttr(LilXML *lp);
|
|
|
static void delAttr (XMLAtt *a);
|
|
|
static int isTokenChar (int start, int c);
|
|
|
static void growString (char **sp, int c);
|
|
|
static void growPCData (XMLEle *ep, int c);
|
|
|
static char *newString (void);
|
|
|
static void *moremem (void *old, int n);
|
|
|
static void freemem (void *m);
|
|
|
|
|
|
typedef enum {
|
|
|
LOOK4START = 0, /* looking for first element start */
|
|
|
LOOK4TAG, /* looking for element tag */
|
|
|
INTAG, /* reading tag */
|
|
|
LOOK4ATTRN, /* looking for attr name, > or / */
|
|
|
INATTRN, /* reading attr name */
|
|
|
LOOK4ATTRV, /* looking for attr value */
|
|
|
SAWSLASH, /* saw / in element opening */
|
|
|
INATTRV, /* in attr value */
|
|
|
LOOK4CON, /* skipping leading content whitespc */
|
|
|
INCON, /* reading content */
|
|
|
LTINCON, /* saw < in content */
|
|
|
LOOK4CLOSETAG, /* looking for closing tag after < */
|
|
|
INCLOSETAG /* reading closing tag */
|
|
|
} State; /* parsing states */
|
|
|
|
|
|
/* maintain state while parsing */
|
|
|
struct _LilXML {
|
|
|
State cs; /* current state */
|
|
|
int ln; /* line number for diags */
|
|
|
XMLEle *ce; /* current element being built */
|
|
|
char *endtag; /* to check for match with opening tag*/
|
|
|
int delim; /* attribute value delimiter */
|
|
|
int lastc; /* last char (just used wiht skipping)*/
|
|
|
int skipping; /* in comment or declaration */
|
|
|
};
|
|
|
|
|
|
/* internal representation of a (possibly nested) XML element */
|
|
|
struct _xml_ele {
|
|
|
char *tag; /* element tag */
|
|
|
struct _xml_ele *pe; /* parent element, or NULL if root */
|
|
|
XMLAtt **at; /* list of attributes */
|
|
|
int nat; /* number of attributes */
|
|
|
int ait; /* used to iterate over at[] */
|
|
|
struct _xml_ele **el; /* list of child elements */
|
|
|
int nel; /* number of child elements */
|
|
|
int eit; /* used to iterate over el[] */
|
|
|
char *pcdata; /* character data in this element */
|
|
|
int pcdatal; /* handy length sans \0 (tends to be big) */
|
|
|
};
|
|
|
|
|
|
/* internal representation of an attribute */
|
|
|
struct _xml_att {
|
|
|
char *name; /* name */
|
|
|
char *valu; /* value */
|
|
|
struct _xml_ele *ce; /* containing element */
|
|
|
};
|
|
|
|
|
|
/* default memory managers, override with indi_xmlMalloc() */
|
|
|
static void *(*mymalloc)(size_t size) = malloc;
|
|
|
static void *(*myrealloc)(void *ptr, size_t size) = realloc;
|
|
|
static void (*myfree)(void *ptr) = free;
|
|
|
|
|
|
/* install new version of malloc/realloc/free.
|
|
|
* N.B. don't call after first use of any other lilxml function
|
|
|
*/
|
|
|
void
|
|
|
indi_xmlMalloc (void *(*newmalloc)(size_t size),
|
|
|
void *(*newrealloc)(void *ptr, size_t size),
|
|
|
void (*newfree)(void *ptr))
|
|
|
{
|
|
|
mymalloc = newmalloc;
|
|
|
myrealloc = newrealloc;
|
|
|
myfree = newfree;
|
|
|
}
|
|
|
|
|
|
/* pass back a fresh handle for use with our other functions */
|
|
|
LilXML *
|
|
|
newLilXML ()
|
|
|
{
|
|
|
LilXML *lp = (LilXML *) moremem (NULL, sizeof(LilXML));
|
|
|
initParser(lp);
|
|
|
return (lp);
|
|
|
}
|
|
|
|
|
|
/* discard */
|
|
|
void
|
|
|
delLilXML (LilXML *lp)
|
|
|
{
|
|
|
freemem (lp);
|
|
|
}
|
|
|
|
|
|
/* delete ep and all its children */
|
|
|
void
|
|
|
delXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
/* benign if NULL */
|
|
|
if (!ep)
|
|
|
return;
|
|
|
|
|
|
/* delete all parts of ep */
|
|
|
freemem (ep->tag);
|
|
|
freemem (ep->pcdata);
|
|
|
if (ep->at) {
|
|
|
for (i = 0; i < ep->nat; i++)
|
|
|
delAttr (ep->at[i]);
|
|
|
freemem (ep->at);
|
|
|
}
|
|
|
if (ep->el) {
|
|
|
for (i = 0; i < ep->nel; i++)
|
|
|
delXMLEle (ep->el[i]);
|
|
|
freemem (ep->el);
|
|
|
}
|
|
|
|
|
|
/* delete ep itself */
|
|
|
freemem (ep);
|
|
|
}
|
|
|
|
|
|
/* process one more character of an XML file.
|
|
|
* when find closure with outter element return root of complete tree.
|
|
|
* when find error return NULL with reason in errmsg[].
|
|
|
* when need more return NULL with errmsg[0] = '\0'.
|
|
|
* N.B. it is up to the caller to delete the tree delXMLEle().
|
|
|
*/
|
|
|
XMLEle *
|
|
|
readXMLEle (LilXML *lp, int newc, char errmsg[])
|
|
|
{
|
|
|
XMLEle *root;
|
|
|
int s;
|
|
|
|
|
|
/* start optimistic */
|
|
|
errmsg[0] = '\0';
|
|
|
|
|
|
/* EOF? */
|
|
|
if (newc == 0) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: XML EOF", lp->ln);
|
|
|
initParser(lp);
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* new line? */
|
|
|
if (newc == '\n')
|
|
|
lp->ln++;
|
|
|
|
|
|
/* skip comments and declarations. requires 1 char history */
|
|
|
if (!lp->skipping && lp->lastc == '<' && (newc == '?' || newc == '!')) {
|
|
|
lp->skipping = 1;
|
|
|
lp->lastc = newc;
|
|
|
return (NULL);
|
|
|
}
|
|
|
if (lp->skipping) {
|
|
|
if (newc == '>')
|
|
|
lp->skipping = 0;
|
|
|
lp->lastc = newc;
|
|
|
return (NULL);
|
|
|
}
|
|
|
if (newc == '<') {
|
|
|
lp->lastc = '<';
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* do a pending '<' first then newc */
|
|
|
if (lp->lastc == '<') {
|
|
|
if (oneXMLchar (lp, '<', errmsg) < 0) {
|
|
|
initParser(lp);
|
|
|
return (NULL);
|
|
|
}
|
|
|
/* N.B. we assume '<' will never result in closure */
|
|
|
}
|
|
|
|
|
|
/* process newc (at last!) */
|
|
|
s = oneXMLchar (lp, newc, errmsg);
|
|
|
if (s == 0) {
|
|
|
lp->lastc = newc;
|
|
|
return (NULL);
|
|
|
}
|
|
|
if (s < 0) {
|
|
|
initParser(lp);
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* Ok! return ce and we start over.
|
|
|
* N.B. up to caller to call delXMLEle with what we return.
|
|
|
*/
|
|
|
root = lp->ce;
|
|
|
lp->ce = NULL;
|
|
|
initParser(lp);
|
|
|
return (root);
|
|
|
}
|
|
|
|
|
|
/* search ep for an attribute with given name.
|
|
|
* return NULL if not found.
|
|
|
*/
|
|
|
XMLAtt *
|
|
|
findXMLAtt (XMLEle *ep, const char *name)
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
for (i = 0; i < ep->nat; i++)
|
|
|
if (!strcmp (ep->at[i]->name, name))
|
|
|
return (ep->at[i]);
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* search ep for an element with given tag.
|
|
|
* return NULL if not found.
|
|
|
*/
|
|
|
XMLEle *
|
|
|
findXMLEle (XMLEle *ep, const char *tag)
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
for (i = 0; i < ep->nel; i++)
|
|
|
if (!strcmp (ep->el[i]->tag, tag))
|
|
|
return (ep->el[i]);
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* iterate over each child element of ep.
|
|
|
* call first time with first set to 1, then 0 from then on.
|
|
|
* returns NULL when no more or err
|
|
|
*/
|
|
|
XMLEle *
|
|
|
nextXMLEle (XMLEle *ep, int init)
|
|
|
{
|
|
|
int eit;
|
|
|
|
|
|
if (init)
|
|
|
ep->eit = 0;
|
|
|
|
|
|
eit = ep->eit++;
|
|
|
if (eit < 0 || eit >= ep->nel)
|
|
|
return (NULL);
|
|
|
return (ep->el[eit]);
|
|
|
}
|
|
|
|
|
|
/* iterate over each attribute of ep.
|
|
|
* call first time with first set to 1, then 0 from then on.
|
|
|
* returns NULL when no more or err
|
|
|
*/
|
|
|
XMLAtt *
|
|
|
nextXMLAtt (XMLEle *ep, int init)
|
|
|
{
|
|
|
int ait;
|
|
|
|
|
|
if (init)
|
|
|
ep->ait = 0;
|
|
|
|
|
|
ait = ep->ait++;
|
|
|
if (ait < 0 || ait >= ep->nat)
|
|
|
return (NULL);
|
|
|
return (ep->at[ait]);
|
|
|
}
|
|
|
|
|
|
/* return parent of given XMLEle */
|
|
|
XMLEle *
|
|
|
parentXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->pe);
|
|
|
}
|
|
|
|
|
|
/* return parent element of given XMLAtt */
|
|
|
XMLEle *
|
|
|
parentXMLAtt (XMLAtt *ap)
|
|
|
{
|
|
|
return (ap->ce);
|
|
|
}
|
|
|
|
|
|
/* access functions */
|
|
|
|
|
|
/* return the tag name of the given element */
|
|
|
char *
|
|
|
tagXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->tag);
|
|
|
}
|
|
|
|
|
|
/* return the pcdata portion of the given element */
|
|
|
char *
|
|
|
pcdataXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->pcdata);
|
|
|
}
|
|
|
|
|
|
/* return the number of characters in the pcdata portion of the given element */
|
|
|
int
|
|
|
pcdatalenXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->pcdatal);
|
|
|
}
|
|
|
|
|
|
/* return the nanme of the given attribute */
|
|
|
char *
|
|
|
nameXMLAtt (XMLAtt *ap)
|
|
|
{
|
|
|
return (ap->name);
|
|
|
}
|
|
|
|
|
|
/* return the value of the given attribute */
|
|
|
char *
|
|
|
valuXMLAtt (XMLAtt *ap)
|
|
|
{
|
|
|
return (ap->valu);
|
|
|
}
|
|
|
|
|
|
/* return the number of child elements of the given element */
|
|
|
int
|
|
|
nXMLEle (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->nel);
|
|
|
}
|
|
|
|
|
|
/* return the number of attributes in the given element */
|
|
|
int
|
|
|
nXMLAtt (XMLEle *ep)
|
|
|
{
|
|
|
return (ep->nat);
|
|
|
}
|
|
|
|
|
|
|
|
|
/* search ep for an attribute with the given name and return its value.
|
|
|
* return "" if not found.
|
|
|
*/
|
|
|
const char *
|
|
|
findXMLAttValu (XMLEle *ep, char *name)
|
|
|
{
|
|
|
XMLAtt *a = findXMLAtt (ep, name);
|
|
|
return (a ? a->valu : "");
|
|
|
}
|
|
|
|
|
|
/* handy wrapper to read one xml file.
|
|
|
* return root element else NULL with report in errmsg[]
|
|
|
*/
|
|
|
XMLEle *
|
|
|
readXMLFile (FILE *fp, LilXML *lp, char errmsg[])
|
|
|
{
|
|
|
int c;
|
|
|
|
|
|
while ((c = fgetc(fp)) != EOF) {
|
|
|
XMLEle *root = readXMLEle (lp, c, errmsg);
|
|
|
if (root || errmsg[0])
|
|
|
return (root);
|
|
|
}
|
|
|
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
/* sample print ep to fp
|
|
|
* N.B. set level = 0 on first call
|
|
|
*/
|
|
|
#define PRINDENT 4 /* sample print indent each level */
|
|
|
void
|
|
|
prXMLEle (FILE *fp, XMLEle *ep, int level)
|
|
|
{
|
|
|
int indent = level*PRINDENT;
|
|
|
int i;
|
|
|
|
|
|
fprintf (fp, "%*s<%s", indent, "", ep->tag);
|
|
|
for (i = 0; i < ep->nat; i++)
|
|
|
fprintf (fp, " %s=\"%s\"", ep->at[i]->name, ep->at[i]->valu);
|
|
|
if (ep->nel > 0) {
|
|
|
fprintf (fp, ">\n");
|
|
|
for (i = 0; i < ep->nel; i++)
|
|
|
prXMLEle (fp, ep->el[i], level+1);
|
|
|
}
|
|
|
if (ep->pcdata[0]) {
|
|
|
char *nl;
|
|
|
if (ep->nel == 0)
|
|
|
fprintf (fp, ">\n");
|
|
|
/* indent if none or one line */
|
|
|
nl = strpbrk (ep->pcdata, "\n\r");
|
|
|
if (!nl || nl == &ep->pcdata[ep->pcdatal-1])
|
|
|
fprintf (fp, "%*s", indent+PRINDENT, "");
|
|
|
fprintf (fp, "%s", ep->pcdata);
|
|
|
if (!nl)
|
|
|
fprintf (fp, "\n");
|
|
|
}
|
|
|
if (ep->nel > 0 || ep->pcdata[0])
|
|
|
fprintf (fp, "%*s</%s>\n", indent, "", ep->tag);
|
|
|
else
|
|
|
fprintf (fp, "/>\n");
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* process one more char in XML file.
|
|
|
* if find final closure, return 1 and tree is in ce.
|
|
|
* if need more, return 0.
|
|
|
* if real trouble, return -1 and put reason in errmsg.
|
|
|
*/
|
|
|
static int
|
|
|
oneXMLchar (LilXML *lp, int c, char errmsg[])
|
|
|
{
|
|
|
switch (lp->cs) {
|
|
|
case LOOK4START: /* looking for first element start */
|
|
|
if (c == '<') {
|
|
|
pushXMLEle(lp);
|
|
|
lp->cs = LOOK4TAG;
|
|
|
}
|
|
|
/* silently ignore until resync */
|
|
|
break;
|
|
|
|
|
|
case LOOK4TAG: /* looking for element tag */
|
|
|
if (isTokenChar (1, c)) {
|
|
|
growString (&lp->ce->tag, c);
|
|
|
lp->cs = INTAG;
|
|
|
} else if (!isspace(c)) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus tag char %c", lp->ln, c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case INTAG: /* reading tag */
|
|
|
if (isTokenChar (0, c))
|
|
|
growString (&lp->ce->tag, c);
|
|
|
else if (c == '>')
|
|
|
lp->cs = LOOK4CON;
|
|
|
else if (c == '/')
|
|
|
lp->cs = SAWSLASH;
|
|
|
else
|
|
|
lp->cs = LOOK4ATTRN;
|
|
|
break;
|
|
|
|
|
|
case LOOK4ATTRN: /* looking for attr name, > or / */
|
|
|
if (c == '>')
|
|
|
lp->cs = LOOK4CON;
|
|
|
else if (c == '/')
|
|
|
lp->cs = SAWSLASH;
|
|
|
else if (isTokenChar (1, c)) {
|
|
|
addAttr(lp);
|
|
|
growString (&lp->ce->at[lp->ce->nat-1]->name, c);
|
|
|
lp->cs = INATTRN;
|
|
|
} else if (!isspace(c)) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus leading attr name char: %c",
|
|
|
lp->ln, c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case SAWSLASH: /* saw / in element opening */
|
|
|
if (c == '>') {
|
|
|
if (!lp->ce->pe)
|
|
|
return(1); /* root has no content */
|
|
|
popXMLEle(lp);
|
|
|
lp->cs = LOOK4CON;
|
|
|
} else {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus char %c before >", lp->ln, c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case INATTRN: /* reading attr name */
|
|
|
if (isTokenChar (0, c))
|
|
|
growString (&lp->ce->at[lp->ce->nat-1]->name, c);
|
|
|
else if (isspace(c) || c == '=')
|
|
|
lp->cs = LOOK4ATTRV;
|
|
|
else {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus attr name char: %c", lp->ln,c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case LOOK4ATTRV: /* looking for attr value */
|
|
|
if (c == '\'' || c == '"') {
|
|
|
lp->delim = c;
|
|
|
growString (&lp->ce->at[lp->ce->nat-1]->valu, '\0');
|
|
|
lp->cs = INATTRV;
|
|
|
} else if (!(isspace(c) || c == '=')) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: No value for attribute %.100s", lp->ln,
|
|
|
lp->ce->at[lp->ce->nat-1]->name);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case INATTRV: /* in attr value */
|
|
|
if (c == lp->delim)
|
|
|
lp->cs = LOOK4ATTRN;
|
|
|
else if (!iscntrl(c))
|
|
|
growString (&lp->ce->at[lp->ce->nat-1]->valu, c);
|
|
|
break;
|
|
|
|
|
|
case LOOK4CON: /* skipping leading content whitespace*/
|
|
|
if (c == '<')
|
|
|
lp->cs = LTINCON;
|
|
|
else if (!isspace(c)) {
|
|
|
growPCData (lp->ce, c);
|
|
|
lp->cs = INCON;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case INCON: /* reading content */
|
|
|
if (c == '<') {
|
|
|
/* if text contains a nl trim trailing blanks.
|
|
|
* chomp trailing nl if only one.
|
|
|
*/
|
|
|
char *nl = strpbrk (lp->ce->pcdata, "\n\r");
|
|
|
if (nl)
|
|
|
while (lp->ce->pcdatal > 0 &&
|
|
|
lp->ce->pcdata[lp->ce->pcdatal-1] == ' ')
|
|
|
lp->ce->pcdata[--lp->ce->pcdatal] = '\0';
|
|
|
if (nl == &lp->ce->pcdata[lp->ce->pcdatal-1])
|
|
|
lp->ce->pcdata[--lp->ce->pcdatal] = '\0'; /* safe! */
|
|
|
lp->cs = LTINCON;
|
|
|
} else
|
|
|
growPCData (lp->ce, c);
|
|
|
break;
|
|
|
|
|
|
case LTINCON: /* saw < in content */
|
|
|
if (c == '/') {
|
|
|
resetEndTag(lp);
|
|
|
lp->cs = LOOK4CLOSETAG;
|
|
|
} else {
|
|
|
pushXMLEle(lp);
|
|
|
if (isTokenChar(1,c)) {
|
|
|
growString (&lp->ce->tag, c);
|
|
|
lp->cs = INTAG;
|
|
|
} else
|
|
|
lp->cs = LOOK4TAG;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case LOOK4CLOSETAG: /* looking for closing tag after < */
|
|
|
if (isTokenChar (1, c)) {
|
|
|
growString (&lp->endtag, c);
|
|
|
lp->cs = INCLOSETAG;
|
|
|
} else if (!isspace(c)) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus preend tag char %c", lp->ln,c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case INCLOSETAG: /* reading closing tag */
|
|
|
if (isTokenChar(0, c))
|
|
|
growString (&lp->endtag, c);
|
|
|
else if (c == '>') {
|
|
|
if (strcmp (lp->ce->tag, lp->endtag)) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: closing tag %.64s does not match %.64s",
|
|
|
lp->ln, lp->endtag, lp->ce->tag);
|
|
|
return (-1);
|
|
|
} else if (lp->ce->pe) {
|
|
|
popXMLEle(lp);
|
|
|
lp->cs = LOOK4CON; /* back to content after nested elem */
|
|
|
} else
|
|
|
return (1); /* yes! */
|
|
|
} else if (!isspace(c)) {
|
|
|
snprintf (errmsg, ERRMSG_SIZE, "Line %d: Bogus end tag char %c", lp->ln, c);
|
|
|
return (-1);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
/* set up for a fresh start */
|
|
|
static void
|
|
|
initParser(LilXML *lp)
|
|
|
{
|
|
|
memset (lp, 0, sizeof(*lp));
|
|
|
lp->cs = LOOK4START;
|
|
|
lp->ln = 1;
|
|
|
delXMLEle (lp->ce);
|
|
|
lp->ce = NULL;
|
|
|
resetEndTag(lp);
|
|
|
lp->lastc = 0;
|
|
|
lp->skipping = 0;
|
|
|
}
|
|
|
|
|
|
/* start a new XMLEle.
|
|
|
* if ce already set up, add to its list of child elements.
|
|
|
* point ce to a new XMLEle.
|
|
|
* endtag no longer valid.
|
|
|
*/
|
|
|
static void
|
|
|
pushXMLEle(LilXML *lp)
|
|
|
{
|
|
|
XMLEle *newe = (XMLEle *) moremem (NULL, sizeof(XMLEle));
|
|
|
XMLEle *ce = lp->ce;
|
|
|
|
|
|
memset (newe, 0, sizeof(*newe));
|
|
|
newe->tag = newString();
|
|
|
newe->pcdata = newString();
|
|
|
newe->pe = ce;
|
|
|
|
|
|
if (ce) {
|
|
|
ce->el = (XMLEle **) moremem (ce->el, (ce->nel+1)*sizeof(XMLEle*));
|
|
|
ce->el[ce->nel++] = newe;
|
|
|
}
|
|
|
lp->ce = newe;
|
|
|
resetEndTag(lp);
|
|
|
}
|
|
|
|
|
|
/* point ce to parent of current ce.
|
|
|
* endtag no longer valid.
|
|
|
*/
|
|
|
static void
|
|
|
popXMLEle(LilXML *lp)
|
|
|
{
|
|
|
lp->ce = lp->ce->pe;
|
|
|
resetEndTag(lp);
|
|
|
}
|
|
|
|
|
|
/* add one new XMLAtt to the current element */
|
|
|
static void
|
|
|
addAttr(LilXML *lp)
|
|
|
{
|
|
|
XMLAtt *newa = (XMLAtt *) moremem (NULL, sizeof(XMLAtt));
|
|
|
XMLEle *ce = lp->ce;
|
|
|
|
|
|
memset (newa, 0, sizeof(*newa));
|
|
|
newa->name = newString();
|
|
|
newa->valu = newString();
|
|
|
newa->ce = ce;
|
|
|
|
|
|
ce->at = (XMLAtt **) moremem (ce->at, (ce->nat+1)*sizeof(XMLAtt *));
|
|
|
ce->at[ce->nat++] = newa;
|
|
|
}
|
|
|
|
|
|
/* delete a and all it holds */
|
|
|
static void
|
|
|
delAttr (XMLAtt *a)
|
|
|
{
|
|
|
if (!a)
|
|
|
return;
|
|
|
if (a->name)
|
|
|
freemem (a->name);
|
|
|
if (a->valu)
|
|
|
freemem (a->valu);
|
|
|
freemem(a);
|
|
|
}
|
|
|
|
|
|
/* delete endtag if appropriate */
|
|
|
static void
|
|
|
resetEndTag(LilXML *lp)
|
|
|
{
|
|
|
if (lp->endtag) {
|
|
|
freemem (lp->endtag);
|
|
|
lp->endtag = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 1 if c is a valid token character, else 0.
|
|
|
* it can be alpha or '_' or numeric unless start.
|
|
|
*/
|
|
|
static int
|
|
|
isTokenChar (int start, int c)
|
|
|
{
|
|
|
return (isalpha(c) || c == '_' || (!start && isdigit(c)));
|
|
|
}
|
|
|
|
|
|
/* grow the malloced string at *sp to append c */
|
|
|
static void
|
|
|
growString (char **sp, int c)
|
|
|
{
|
|
|
int l = *sp ? strlen(*sp) : 0;
|
|
|
*sp = (char *) moremem (*sp, l+2); /* c + '\0' */
|
|
|
(*sp)[l++] = (char)c;
|
|
|
(*sp)[l] = '\0';
|
|
|
}
|
|
|
|
|
|
/* special fast version of growString just for ep->pcdata that avoids all the
|
|
|
* strlens and tiny increments in allocated mem
|
|
|
*/
|
|
|
static void
|
|
|
growPCData (XMLEle *ep, int c)
|
|
|
{
|
|
|
int l = ep->pcdatal++;
|
|
|
if ((l%32) == 0) {
|
|
|
int nm = 32*(l/32+1) + 2; /* c + '\0' */
|
|
|
ep->pcdata = (char *) moremem (ep->pcdata, nm);
|
|
|
}
|
|
|
ep->pcdata[l++] = (char)c;
|
|
|
ep->pcdata[l] = '\0';
|
|
|
}
|
|
|
|
|
|
/* return a malloced string of one '\0' */
|
|
|
static char *
|
|
|
newString()
|
|
|
{
|
|
|
char *str;
|
|
|
|
|
|
*(str = (char *)moremem(NULL, 16)) = '\0'; /* expect more */
|
|
|
return (str);
|
|
|
}
|
|
|
|
|
|
static void *
|
|
|
moremem (void *old, int n)
|
|
|
{
|
|
|
return (old ? realloc (old, n) : malloc (n));
|
|
|
}
|
|
|
|
|
|
static void
|
|
|
freemem (void *m)
|
|
|
{
|
|
|
free (m);
|
|
|
}
|
|
|
|
|
|
#if defined(MAIN_TST)
|
|
|
int
|
|
|
main (int ac, char *av[])
|
|
|
{
|
|
|
LilXML *lp = newLilXML();
|
|
|
char errmsg[ERRMSG_SIZE];
|
|
|
XMLEle *root;
|
|
|
|
|
|
root = readXMLFile (stdin, lp, errmsg);
|
|
|
if (root) {
|
|
|
fprintf (stderr, "::::::::::::: %s\n", tagXMLEle(root));
|
|
|
prXMLEle (stdout, root, 0);
|
|
|
delXMLEle (root);
|
|
|
} else if (errmsg[0]) {
|
|
|
fprintf (stderr, "Error: %s\n", errmsg);
|
|
|
}
|
|
|
|
|
|
delLilXML (lp);
|
|
|
|
|
|
return (0);
|
|
|
}
|
|
|
#endif
|
|
|
|