#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "ezxml.h"
#include "util.h"

Include dependency graph for ezxml.c:

Macros
#define	EZXML_NOMMAP

#define	EZXML_WS "\t\r\n " /* whitespace */

Functions
static ezxml_t	ezxml_vget (ezxml_t xml, va_list ap)

static char *	ezxml_decode (char s, char *ent, char t)

static void	ezxml_open_tag (ezxml_root_t root, int line, char name, char *attr)

static void	ezxml_char_content (ezxml_root_t root, char *s, size_t len, char t)

static ezxml_t	ezxml_close_tag (ezxml_root_t root, char name, char s)

static int	ezxml_ent_ok (char name, char s, char **ent)

static void	ezxml_proc_inst (ezxml_root_t root, char *s, size_t len)

static short	ezxml_internal_dtd (ezxml_root_t root, char *s, size_t len)

static char *	ezxml_str2utf8 (char *s, size_t len)

static void	ezxml_free_attr (char **attr)

static char *	ezxml_ampencode (const char s, size_t len, char dst, size_t dlen, size_t *max, short a)

static char *	ezxml_toxml_r (ezxml_t xml, char *s, size_t len, size_t max, size_t start, char **attr)

ezxml_t	ezxml_child (ezxml_t xml, const char *name)

ezxml_t	ezxml_idx (ezxml_t xml, int idx)

const char *	ezxml_attr (ezxml_t xml, const char *attr)

ezxml_t	ezxml_get (ezxml_t xml,...)

char **	ezxml_pi (ezxml_t xml, const char *target)

static ezxml_t	ezxml_err (ezxml_root_t root, char s, const char err,...)

ezxml_t	ezxml_parse_str (char *s, size_t len)

ezxml_t	ezxml_parse_fp (FILE *fp)

ezxml_t	ezxml_parse_fd (int fd)

ezxml_t	ezxml_parse_file (const char *file)

char *	ezxml_toxml (ezxml_t xml)

void	ezxml_free (ezxml_t xml)

const char *	ezxml_error (ezxml_t xml)

ezxml_t	ezxml_new (char *name)

ezxml_t	ezxml_insert (ezxml_t xml, ezxml_t dest, size_t off)

ezxml_t	ezxml_add_child (ezxml_t xml, char *name, size_t off)

ezxml_t	ezxml_set_txt (ezxml_t xml, char *txt)

ezxml_t	ezxml_set_attr (ezxml_t xml, char name, char value)

ezxml_t	ezxml_set_flag (ezxml_t xml, short flag)

ezxml_t	ezxml_cut (ezxml_t xml)

Variables
char *	EZXML_NIL [] = { NULL }

Macro Definition Documentation

#define EZXML_NOMMAP

Definition at line 26 of file ezxml.c.

#define EZXML_WS "\t\r\n " /* whitespace */

Definition at line 64 of file ezxml.c.

Function Documentation

ezxml_t ezxml_add_child	(	ezxml_t	xml,
		char *	name,
		size_t	off
	)

Definition at line 1137 of file ezxml.c.

                                                              {
     ezxml_t child;
 
     if (!xml)
         return NULL;
     child = (ezxml_t) memset(malloc(sizeof(struct ezxml)), '\0',
             sizeof(struct ezxml));
     child->name = name;
     child->attr = EZXML_NIL;
     child->txt = "";
 
     return ezxml_insert(child, xml, off);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static char * ezxml_ampencode	(	const char *	s,
		size_t	len,
		char **	dst,
		size_t *	dlen,
		size_t *	max,
		short	a
	)

static

Definition at line 858 of file ezxml.c.

                                {
     const char *e;
 
     for (e = s + len; s != e; s++) {
         while (*dlen + 10 > *max)
             *dst = (char*)realloc(*dst, *max += EZXML_BUFSIZE);
 
         switch (*s) {
         case '\0':
             return *dst;
         case '&':
             *dlen += sprintf(*dst + *dlen, "&amp;");
             break;
         case '<':
             *dlen += sprintf(*dst + *dlen, "&lt;");
             break;
         case '>':
             *dlen += sprintf(*dst + *dlen, "&gt;");
             break;
         case '"':
             *dlen += sprintf(*dst + *dlen, (a) ? "&quot;" : "\"");
             break;
         case '\n':
             *dlen += sprintf(*dst + *dlen, (a) ? "&#xA;" : "\n");
             break;
         case '\t':
             *dlen += sprintf(*dst + *dlen, (a) ? "&#x9;" : "\t");
             break;
         case '\r':
             *dlen += sprintf(*dst + *dlen, "&#xD;");
             break;
         default:
             (*dst)[(*dlen)++] = *s;
         }
     }
     return *dst;
 }

Here is the caller graph for this function:

const char* ezxml_attr	(	ezxml_t	xml,
		const char *	attr
	)

Definition at line 102 of file ezxml.c.

                                           {
     int i = 0, j = 1;
     ezxml_root_t root = (ezxml_root_t) xml;
 
     if (!xml || !xml->attr)
         return NULL;
     while (xml->attr[i] && strcmp(attr, xml->attr[i]))
         i += 2;
     if (xml->attr[i])
         return xml->attr[i + 1]; /* found attribute */
 
     while (root->xml.parent)
         root = (ezxml_root_t) root->xml.parent; /* root tag */
     for (i = 0; root->attr[i] && strcmp(xml->name, root->attr[i][0]); i++)
         ;
     if (!root->attr[i])
         return NULL; /* no matching default attributes */
     while (root->attr[i][j] && strcmp(attr, root->attr[i][j]))
         j += 3;
     return (root->attr[i][j]) ? root->attr[i][j + 1] : NULL; /* found default */
 }

Here is the caller graph for this function:

static void ezxml_char_content	(	ezxml_root_t	root,
		char *	s,
		size_t	len,
		char	t
	)

static

Definition at line 290 of file ezxml.c.

                             {
     ezxml_t xml = root->cur;
     char *m = s;
     size_t l;
 
     if (!xml || !xml->name || !len)
         return; /* sanity check */
 
     s[len] = '\0'; /* null terminate text (calling functions anticipate this) */
     len = strlen(s = ezxml_decode(s, root->ent, t)) + 1;
 
     if (!*(xml->txt))
         xml->txt = s; /* initial character content */
     else { /* allocate our own memory and make a copy */
         xml->txt = (xml->flags & EZXML_TXTM) /* allocate some space */
         ? (char*)realloc(xml->txt, (l = strlen(xml->txt)) + len) : strcpy((char*)malloc((l =
                 strlen(xml->txt)) + len), xml->txt);
         strcpy(xml->txt + l, s); /* add new char content */
         if (s != m)
             free(s); /* free s if it was malloced by ezxml_decode() */
     }
 
     if (xml->txt != m)
         ezxml_set_flag(xml, EZXML_TXTM);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_child	(	ezxml_t	xml,
		const char *	name
	)

Definition at line 85 of file ezxml.c.

                                                    {
     xml = (xml) ? xml->child : NULL;
     while (xml && strcmp(name, xml->name))
         xml = xml->sibling;
     return xml;
 }

Here is the caller graph for this function:

static ezxml_t ezxml_close_tag	(	ezxml_root_t	root,
		char *	name,
		char *	s
	)

static

Definition at line 318 of file ezxml.c.

                                                                        {
     if (!root->cur || !root->cur->name || strcmp(name, root->cur->name))
         return ezxml_err(root, s, "unexpected closing tag </%s>", name);
 
     root->cur = root->cur->parent;
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_cut ( ezxml_t xml )

Definition at line 1227 of file ezxml.c.

                                {
     ezxml_t cur;
 
     if (!xml)
         return NULL; /* nothing to do */
     if (xml->next)
         xml->next->sibling = xml->sibling; /* patch sibling list */
 
     if (xml->parent) { /* not root tag */
         cur = xml->parent->child; /* find head of subtag list */
         if (cur == xml)
             xml->parent->child = xml->ordered; /* first subtag */
         else { /* not first subtag */
             while (cur->ordered != xml)
                 cur = cur->ordered;
             cur->ordered = cur->ordered->ordered; /* patch ordered list */
 
             cur = xml->parent->child; /* go back to head of subtag list */
             if (strcmp(cur->name, xml->name)) { /* not in first sibling list */
                 while (strcmp(cur->sibling->name, xml->name))
                     cur = cur->sibling;
                 if (cur->sibling == xml) { /* first of a sibling list */
                     cur->sibling =
                             (xml->next) ? xml->next : cur->sibling->sibling;
                 } else
                     cur = cur->sibling; /* not first of a sibling list */
             }
 
             while (cur->next && cur->next != xml)
                 cur = cur->next;
             if (cur->next)
                 cur->next = cur->next->next; /* patch next list */
         }
     }
     xml->ordered = xml->sibling = xml->next = NULL;
     return xml;
 }

static char * ezxml_decode	(	char *	s,
		char **	ent,
		char	t
	)

static

Definition at line 195 of file ezxml.c.

                                           {
     char *e, *r = s, *m = s;
     long b, c, d, l;
 
     for (; *s; s++) { /* normalize line endings */
         while (*s == '\r') {
             *(s++) = '\n';
             if (*s == '\n') {
                 memmove(s, (s + 1), strlen(s));
             }
         }
     }
 
     for (s = r;;) {
         while (*s && *s != '&' && (*s != '%' || t != '%') && !isspace(*s))
             s++;
         if (!*s)
             break;
         else if (t != 'c' && !strncmp(s, "&#", 2)) { /* character reference */
             if (s[2] == 'x')
                 c = strtol(s + 3, &e, 16); /* base 16 */
             else
                 c = strtol(s + 2, &e, 10); /* base 10 */
             if (!c || *e != ';') {
                 s++;
                 continue;
             }
             /* not a character ref */
             if (c < 0x80)
                 *(s++) = (char) c; /* US-ASCII subset */
             else { /* multi-byte UTF-8 sequence */
                 for (b = 0, d = c; d; d /= 2)
                     b++; /* number of bits in c */
                 b = (b - 2) / 5; /* number of bytes in payload */
                 *(s++) = (char)((0xFF << (7 - b)) | (c >> (6 * b))); /* head */
                 while (b)
                     *(s++) = 0x80 | ((c >> (6 * --b)) & 0x3F); /* payload */
             }
 
             memmove(s, strchr(s, ';') + 1, strlen(strchr(s, ';')));
         } else if ((*s == '&' && (t == '&' || t == ' ' || t == '*'))
                 || (*s == '%' && t == '%')) { /* entity reference */
             for (b = 0; ent[b] && strncmp(s + 1, ent[b], strlen(ent[b])); b +=
                     2)
                 ; /* find entity in entity list */
 
             if (ent[b++]) { /* found a match */
                 if ((c = strlen(ent[b])) - 1 > (e = strchr(s, ';')) - s) {
                     l = (d = (s - r)) + c + strlen(e); /* new length */
                     r = (r == m) ? strcpy((char*)malloc(l), r) : (char*)realloc(r, l);
                     e = strchr((s = r + d), ';'); /* fix up pointers */
                 }
 
                 memmove(s + c, e + 1, strlen(e)); /* shift rest of string */
                 strncpy(s, ent[b], c); /* copy in replacement text */
             } else
                 s++; /* not a known entity */
         } else if ((t == ' ' || t == '*') && isspace(*s))
             *(s++) = ' ';
         else
             s++; /* no decoding needed */
     }
 
     if (t == '*') { /* normalize spaces for non-cdata attributes */
         for (s = r; *s; s++) {
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             l = strspn(s, " ");
             if (l)
                 memmove(s, s + l, strlen(s + l) + 1);
             while (*s && *s != ' ')
                 s++;
         }
         if (--s >= r && *s == ' ')
             *s = '\0'; /* trim any trailing space */
     }
     return r;
 }

Here is the caller graph for this function:

static int ezxml_ent_ok	(	char *	name,
		char *	s,
		char **	ent
	)

static

Definition at line 328 of file ezxml.c.

                                                          {
     int i;
 
     for (;; s++) {
         while (*s && *s != '&')
             s++; /* find next entity reference */
         if (!*s)
             return 1;
         if (!strncmp(s + 1, name, strlen(name)))
             return 0; /* circular ref. */
         for (i = 0; ent[i] && strncmp(ent[i], s + 1, strlen(ent[i])); i += 2)
             ;
         if (ent[i] && !ezxml_ent_ok(name, ent[i + 1], ent))
             return 0;
     }
 }

Here is the caller graph for this function:

static ezxml_t ezxml_err	(	ezxml_root_t	root,
		char *	s,
		const char *	err,
			...
	)

static

Definition at line 170 of file ezxml.c.

                                                                            {
     va_list ap;
     int line = 1;
     char *t, fmt[EZXML_ERRL];
 
     for (t = root->s; t < s; t++)
         if (*t == '\n')
             line++;
     snprintf(fmt, EZXML_ERRL, "[error near line %d]: %s", line, err);
 
     va_start(ap, err);
     vsnprintf(root->err, EZXML_ERRL, fmt, ap);
     va_end(ap);
 
     return &root->xml;
 }

Here is the caller graph for this function:

const char* ezxml_error ( ezxml_t xml )

Definition at line 1067 of file ezxml.c.

                          {
     while (xml && xml->parent)
         xml = xml->parent; /* find root tag */
     return (xml) ? ((ezxml_root_t) xml)->err : "";
 }

void ezxml_free ( ezxml_t xml )

Definition at line 1011 of file ezxml.c.

                              {
     ezxml_root_t root = (ezxml_root_t) xml;
     int i, j;
     char **a, *s;
 
     if (!xml)
         return;
     ezxml_free(xml->child);
     ezxml_free(xml->ordered);
 
     if (!xml->parent) { /* free root tag allocations */
         for (i = 10; root->ent[i]; i += 2) /* 0 - 9 are default entites (<>&"') */
             if ((s = root->ent[i + 1]) < root->s || s > root->e)
                 free(s);
         free(root->ent); /* free list of general entities */
 
         for (i = 0; root->attr[i]; i++) {
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             a = root->attr[i];
             for (j = 1; a[j++]; j += 2) /* free malloced attribute values */
                 if (a[j] && (a[j] < root->s || a[j] > root->e))
                     free(a[j]);
             free(a);
         }
         if (root->attr[0])
             free(root->attr); /* free default attribute list */
 
         for (i = 0; root->pi[i]; i++) {
             for (j = 1; root->pi[i][j]; j++)
                 ;
             free(root->pi[i][j + 1]);
             free(root->pi[i]);
         }
         if (root->pi[0])
             free(root->pi); /* free processing instructions */
 
         if (root->len == (size_t)-1)
             free(root->m); /* malloced xml data */
 #ifndef EZXML_NOMMAP
         else if (root->len)
             munmap(root->m, root->len); /* mem mapped xml data */
 #endif /* EZXML_NOMMAP */
         if (root->u)
             free(root->u); /* utf8 conversion */
     }
 
     ezxml_free_attr(xml->attr); /* tag attributes */
     if ((xml->flags & EZXML_TXTM))
         free(xml->txt); /* character content */
     if ((xml->flags & EZXML_NAMEM))
         free(xml->name); /* tag name */
     free(xml);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ezxml_free_attr ( char ** attr )

static

Definition at line 575 of file ezxml.c.

                                          {
     int i = 0;
     char *m;
 
     if (!attr || attr == EZXML_NIL)
         return; /* nothing to free */
     while (attr[i])
         i += 2; /* find end of attribute list */
     m = attr[i + 1]; /* list of which names and values are malloced */
     for (i = 0; m[i]; i++) {
         if (m[i] & EZXML_NAMEM)
             free(attr[i * 2]);
         if (m[i] & EZXML_TXTM)
             free(attr[(i * 2) + 1]);
     }
     free(m);
     free(attr);
 }

Here is the caller graph for this function:

ezxml_t ezxml_get	(	ezxml_t	xml,
			...
	)

Definition at line 143 of file ezxml.c.

                                     {
     va_list ap;
     ezxml_t r;
 
     va_start(ap, xml);
     r = ezxml_vget(xml, ap);
     va_end(ap);
     return r;
 }

Here is the call graph for this function:

ezxml_t ezxml_idx	(	ezxml_t	xml,
		int	idx
	)

Definition at line 94 of file ezxml.c.

                                         {
     for (; xml && idx; idx--)
         xml = xml->next;
     return xml;
 }

Here is the caller graph for this function:

ezxml_t ezxml_insert	(	ezxml_t	xml,
		ezxml_t	dest,
		size_t	off
	)

Definition at line 1089 of file ezxml.c.

                                                             {
     ezxml_t cur, prev, head;
 
     xml->next = xml->sibling = xml->ordered = NULL;
     xml->off = off;
     xml->parent = dest;
 
     /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
     head = dest->child;
     if (head) { /* already have sub tags */
         if (head->off <= off) { /* not first subtag */
             for (cur = head; cur->ordered && cur->ordered->off <= off;
                     cur = cur->ordered)
                 ;
             xml->ordered = cur->ordered;
             cur->ordered = xml;
         } else { /* first subtag */
             xml->ordered = head;
             dest->child = xml;
         }
 
         for (cur = head, prev = NULL; cur && strcmp(cur->name, xml->name);
                 prev = cur, cur = cur->sibling)
             ; /* find tag type */
         if (cur && cur->off <= off) { /* not first of type */
             while (cur->next && cur->next->off <= off)
                 cur = cur->next;
             xml->next = cur->next;
             cur->next = xml;
         } else { /* first tag of this type */
             if (prev && cur)
                 prev->sibling = cur->sibling; /* remove old first */
             xml->next = cur; /* old first tag is now next */
             for (cur = head, prev = NULL; cur && cur->off <= off;
                     prev = cur, cur = cur->sibling)
                 ; /* new sibling insert point */
             xml->sibling = cur;
             if (prev)
                 prev->sibling = xml;
         }
     } else
         dest->child = xml; /* only sub tag */
 
     return xml;
 }

Here is the caller graph for this function:

static short ezxml_internal_dtd	(	ezxml_root_t	root,
		char *	s,
		size_t	len
	)

static

Definition at line 389 of file ezxml.c.

                     {
     char q, *c, *t, *n = NULL, *v, **ent, **pe;
     char temp[] = {'\0','\0','\0'};
     int i, j;
 
     pe = (char**)memcpy(malloc(sizeof(EZXML_NIL)), EZXML_NIL, sizeof(EZXML_NIL));
 
     for (s[len] = '\0'; s;) {
         while (*s && *s != '<' && *s != '%')
             s++; /* find next declaration */
 
         if (!*s)
             break;
         else if (!strncmp(s, "<!ENTITY", 8)) { /* parse entity definitions */
             c = s += strspn(s + 8, EZXML_WS) + 8; /* skip white space separator */
             n = s + strspn(s, EZXML_WS "%"); /* find name */
             *(s = n + strcspn(n, EZXML_WS)) = ';'; /* append ; to name */
 
             v = s + strspn(s + 1, EZXML_WS) + 1; /* find value */
             if ((q = *(v++)) != '"' && q != '\'') { /* skip externals */
                 s = strchr(s, '>');
                 continue;
             }
 
             for (i = 0, ent = (*c == '%') ? pe : root->ent; ent[i]; i++)
                 ;
             ent = (char**)realloc(ent, (i + 3) * sizeof(char *)); /* space for next ent */
             if (*c == '%')
                 pe = ent;
             else
                 root->ent = ent;
 
             *(++s) = '\0'; /* null terminate name */
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             s = strchr(v, q);
             if (s)
                 *(s++) = '\0'; /* null terminate value */
             ent[i + 1] = ezxml_decode(v, pe, '%'); /* set value */
             ent[i + 2] = NULL; /* null terminate entity list */
             if (!ezxml_ent_ok(n, ent[i + 1], ent)) { /* circular reference */
                 if (ent[i + 1] != v)
                     free(ent[i + 1]);
                 ezxml_err(root, v, "circular entity declaration &%s", n);
                 break;
             } else
                 ent[i] = n; /* set entity name */
         } else if (!strncmp(s, "<!ATTLIST", 9)) { /* parse default attributes */
             t = s + strspn(s + 9, EZXML_WS) + 9; /* skip whitespace separator */
             if (!*t) {
                 ezxml_err(root, t, "unclosed <!ATTLIST");
                 break;
             }
             if (*(s = t + strcspn(t, EZXML_WS ">")) == '>')
                 continue;
             else
                 *s = '\0'; /* null terminate tag name */
             for (i = 0; root->attr[i] && strcmp(n, root->attr[i][0]); i++)
                 ;
 
             ++s;
             while (*(n = s + strspn(s, EZXML_WS)) && *n != '>') {
                 if (*(s = n + strcspn(n, EZXML_WS)))
                     *s = '\0'; /* attr name */
                 else {
                     ezxml_err(root, t, "malformed <!ATTLIST");
                     break;
                 }
 
                 s += strspn(s + 1, EZXML_WS) + 1; /* find next token */
                 if ((strncmp(s, "CDATA", 5))) { 
                     temp[0] = '*';
                 } else {
                     temp[0]=' ';
                 }
                 c = temp; /* is it cdata? */
                 if (!strncmp(s, "NOTATION", 8))
                     s += strspn(s + 8, EZXML_WS) + 8;
                 s = (*s == '(') ? strchr(s, ')') : s + strcspn(s, EZXML_WS);
                 if (!s) {
                     ezxml_err(root, t, "malformed <!ATTLIST");
                     break;
                 }
 
                 s += strspn(s, EZXML_WS ")"); /* skip white space separator */
                 if (!strncmp(s, "#FIXED", 6))
                     s += strspn(s + 6, EZXML_WS) + 6;
                 if (*s == '#') { /* no default value */
                     s += strcspn(s, EZXML_WS ">") - 1;
                     if (*c == ' ')
                         continue; /* cdata is default, nothing to do */
                     v = NULL;
                 } else {
                     /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
                     s = strchr(v = s + 1, *s);
                     if ((*s == '"' || *s == '\'') && /* default value */
                     s)
                         *s = '\0';
                     else {
                         ezxml_err(root, t, "malformed <!ATTLIST");
                         break;
                     }
                 }
 
                 if (!root->attr[i]) { /* new tag name */
                     root->attr =
                             (!i) ? (char***)malloc(2 * sizeof(char **)) : (char***)realloc(
                                             root->attr,
                                             (i + 2) * sizeof(char **));
                     root->attr[i] = (char**)malloc(2 * sizeof(char *));
                     root->attr[i][0] = t; /* set tag name */
                     root->attr[i][1] = (char *) (root->attr[i + 1] = NULL);
                 }
 
                 for (j = 1; root->attr[i][j]; j += 3)
                     ; /* find end of list */
                 root->attr[i] = (char**)realloc(root->attr[i],
                         (j + 4) * sizeof(char *));
 
                 root->attr[i][j + 3] = NULL; /* null terminate list */
                 root->attr[i][j + 2] = c; /* is it cdata? */
                 root->attr[i][j + 1] =
                         (v) ? ezxml_decode(v, root->ent, *c) : NULL;
                 root->attr[i][j] = n; /* attribute name  */
 
                 ++s;
             }
         } else if (!strncmp(s, "<!--", 4)) {
             s = strstr(s + 4, "-->"); /* comments */
         }
         else if (!strncmp(s, "<?", 2)) { /* processing instructions */
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             s = strstr(c = s + 2, "?>");
             if (s)
                 ezxml_proc_inst(root, c, s++ - c);
         } else if (*s == '<')
             s = strchr(s, '>'); /* skip other declarations */
         else if (*(s++) == '%' && !root->standalone)
             break;
     }
 
     free(pe);
     return !*root->err;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_new ( char * name )

Definition at line 1074 of file ezxml.c.

                               {
     static char *ent[] = { "lt;", "&#60;", "gt;", "&#62;", "quot;", "&#34;",
             "apos;", "&#39;", "amp;", "&#38;", NULL };
     ezxml_root_t root = (ezxml_root_t) memset(malloc(sizeof(struct ezxml_root)),
             '\0', sizeof(struct ezxml_root));
 
     root->xml.name = name;
     root->cur = &root->xml;
     strcpy(root->err, root->xml.txt = "");
     root->ent = (char**)memcpy(malloc(sizeof(ent)), ent, sizeof(ent));
     root->attr = root->pi = (char ***) (root->xml.attr = EZXML_NIL);
     return &root->xml;
 }

Here is the caller graph for this function:

static void ezxml_open_tag	(	ezxml_root_t	root,
		int	line,
		char *	name,
		char **	attr
	)

static

Definition at line 275 of file ezxml.c.

                                                                                  {
     ezxml_t xml = root->cur;
 
     if (xml->name)
         xml = ezxml_add_child(xml, name, strlen(xml->txt));
     else
         xml->name = name; /* first open tag */
     xml->line = line;
     xml->attr = attr;
 
     root->cur = xml; /* update tag insertion point */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_parse_fd ( int fd )

Definition at line 816 of file ezxml.c.

                                {
     ezxml_root_t root;
     struct stat st;
     size_t l;
     void *m;
 
     if (fd < 0)
         return NULL;
     fstat(fd, &st);
 
 #ifndef EZXML_NOMMAP
     l = (st.st_size + sysconf(_SC_PAGESIZE) - 1) & ~(sysconf(_SC_PAGESIZE) - 1);
     if ((m = mmap(NULL, l, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0))
             != MAP_FAILED) {
         madvise(m, l, MADV_SEQUENTIAL); /* optimize for sequential access */
         root = (ezxml_root_t) ezxml_parse_str((char*)m, st.st_size);
         madvise(m, root->len = l, MADV_NORMAL); /* put it back to normal */
     } else { /* mmap failed, read file into memory */
 #endif /* EZXML_NOMMAP */
         l = read(fd, m = malloc(st.st_size), st.st_size);
         root = (ezxml_root_t) ezxml_parse_str((char*)m, l);
         /* Ted Campbell, Aug 14, 2007. Added explicit cast. */
         root->len = (size_t) (-1); /* so we know to free s in ezxml_free() */
 #ifndef EZXML_NOMMAP
     }
 #endif /* EZXML_NOMMAP */
     return &root->xml;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_parse_file ( const char * file )

Definition at line 846 of file ezxml.c.

                                            {
     int fd = open(file, O_RDONLY, 0);
     ezxml_t xml = ezxml_parse_fd(fd);
 
     if (fd >= 0)
         close(fd);
     return xml;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_parse_fp ( FILE * fp )

Definition at line 790 of file ezxml.c.

                                   {
     ezxml_root_t root;
     size_t l, len = 0;
     char *s;
 
     /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
     s = (char*)malloc(EZXML_BUFSIZE);
     if (!s)
         return NULL;
     do {
         len += (l = fread((s + len), 1, EZXML_BUFSIZE, fp));
         if (l == EZXML_BUFSIZE)
             s = (char*)realloc(s, len + EZXML_BUFSIZE);
     } while (s && l == EZXML_BUFSIZE);
 
     if (!s)
         return NULL;
     root = (ezxml_root_t) ezxml_parse_str(s, len);
     /* Ted Campbell, Aug 14, 2007. Added explicit cast. */
     root->len = (size_t) (-1); /* so we know to free s in ezxml_free() */
     return &root->xml;
 }

Here is the call graph for this function:

ezxml_t ezxml_parse_str	(	char *	s,
		size_t	len
	)

Definition at line 596 of file ezxml.c.

                                              {
     ezxml_root_t root = (ezxml_root_t) ezxml_new(0);
     char q, e, *d, *temp, **attr, **a = NULL; /* initialize a to avoid compile warning */
     int l, i, j;
     int line = 1;
 
     root->m = s;
     if (!len)
         return ezxml_err(root, NULL, "root tag missing");
     root->u = ezxml_str2utf8(&s, &len); /* convert utf-16 to utf-8 */
     root->e = (root->s = s) + len; /* record start and end of work area */
 
     e = s[len - 1]; /* save end char */
     s[len - 1] = '\0'; /* turn end char into null terminator */
 
     while (*s && *s != '<')
         s++; /* find first tag */
     if (!*s)
         return ezxml_err(root, s, "root tag missing");
 
     for (;;) {
         attr = (char **) EZXML_NIL;
         d = ++s;
 
         if (isalpha(*s) || *s == '_' || *s == ':' || *s < '\0') { /* new tag */
             if (!root->cur)
                 return ezxml_err(root, d, "markup outside of root element");
 
             s += strcspn(s, EZXML_WS "/>");
             while (isspace(*s)) {
                 if (*s == '\n')
                     line++;
                 *(s++) = '\0'; /* null terminate tag name */
             }
 
             if (*s && *s != '/' && *s != '>') { /* find tag in default attr list */
                 /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
                 a = root->attr[0];
                 for (i = 0; a && strcmp(a[0], d); i++) {
                     a = root->attr[i];
                 }
             }
 
             for (l = 0; *s && *s != '/' && *s != '>'; l += 2) { /* new attrib */
                 attr = (l) ?
                         (char**)realloc(attr, (l + 4) * sizeof(char *)) :
                         (char**)malloc(4 * sizeof(char *)); /* allocate space */
                 attr[l + 3] =
                         (l) ? (char*)realloc(attr[l + 1], (l / 2) + 2) : (char*)malloc(2); /* mem for list of maloced vals */
                 strcpy(attr[l + 3] + (l / 2), " "); /* value is not malloced */
                 attr[l + 2] = NULL; /* null terminate list */
                 attr[l + 1] = ""; /* temporary attribute value */
                 attr[l] = s; /* set attribute name */
 
                 s += strcspn(s, EZXML_WS "=/>");
                 if (*s == '=' || isspace(*s)) {
                     if (*s == '\n')
                         line++;
                     *(s++) = '\0'; /* null terminate tag attribute name */
                     q = *(s += strspn(s, EZXML_WS "="));
                     if (q == '"' || q == '\'') { /* attribute value */
                         attr[l + 1] = ++s;
                         while (*s && *s != q)
                             s++;
                         if (*s)
                             *(s++) = '\0'; /* null terminate attribute val */
                         else {
                             ezxml_free_attr(attr);
                             return ezxml_err(root, d, "missing %c", q);
                         }
 
                         for (j = 1; a && a[j] && strcmp(a[j], attr[l]); j += 3)
                             ;
                         attr[l + 1] = ezxml_decode(attr[l + 1],
                                 root->ent, (a && a[j]) ? *a[j + 2] : ' ');
                         if (attr[l + 1] < d || attr[l + 1] > s)
                             attr[l + 3][l / 2] = EZXML_TXTM; /* value malloced */
                     }
                 }
                 while (isspace(*s)) {
                     if (*s == '\n')
                         line++;
                     s++;
                 }
             }
 
             if (*s == '/') { /* self closing tag */
                 *(s++) = '\0';
                 if ((*s && *s != '>') || (!*s && e != '>')) {
                     if (l)
                         ezxml_free_attr(attr);
                     return ezxml_err(root, d, "missing >");
                 }
                 ezxml_open_tag(root, line, d, attr);
                 ezxml_close_tag(root, d, s);
             } else if ((q = *s) == '>' || (!*s && e == '>')) { /* open tag */
                 *s = '\0'; /* temporarily null terminate tag name */
                 ezxml_open_tag(root, line, d, attr);
                 *s = q;
             } else {
                 if (l)
                     ezxml_free_attr(attr);
                 return ezxml_err(root, d, "missing >");
             }
         } else if (*s == '/') { /* close tag */
             s += strcspn(d = s + 1, EZXML_WS ">") + 1;
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             q = *s;
             if (!q && e != '>')
                 return ezxml_err(root, d, "missing >");
             *s = '\0'; /* temporarily null terminate tag name */
             if (ezxml_close_tag(root, d, s))
                 return &root->xml;
             if (isspace(*s = q)) {
                 if (*s == '\n')
                     line++;
                 s += strspn(s, EZXML_WS);
             }
         } else if (!strncmp(s, "!--", 3)) { /* xml comment */
             temp = s;
             s = strstr(s + 3, "--");
             if (!s || (*(s += 2) != '>' && *s) || (!*s && e != '>'))
                 return ezxml_err(root, d, "unclosed <!--");
             while (temp != s && *temp != '\0') {
                 if (*temp == '\n') {
                     line++;
                 }
                 temp++;
             }
         } else if (!strncmp(s, "![CDATA[", 8)) { /* cdata */
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             s = strstr(s, "]]>");
             if (s)
                 ezxml_char_content(root, d + 8, (s += 2) - d - 10, 'c');
             else
                 return ezxml_err(root, d, "unclosed <![CDATA[");
         } else if (!strncmp(s, "!DOCTYPE", 8)) { /* dtd */
             for (l = 0;
                     *s
                             && ((!l && *s != '>')
                                     || (l
                                             && (*s != ']'
                                                     || *(s
                                                             + strspn(s + 1,
                                                                     EZXML_WS)
                                                             + 1) != '>')));
                     l = (*s == '[') ? 1 : l)
                 s += strcspn(s + 1, "[]>") + 1;
             if (!*s && e != '>')
                 return ezxml_err(root, d, "unclosed <!DOCTYPE");
             d = (l) ? strchr(d, '[') + 1 : d;
             if (l && !ezxml_internal_dtd(root, d, s++ - d))
                 return &root->xml;
         } else if (*s == '?') { /* <?...?> processing instructions */
             do {
                 s = strchr(s, '?');
             } while (s && *(++s) && *s != '>');
             if (!s || (!*s && e != '>'))
                 return ezxml_err(root, d, "unclosed <?");
             else
                 ezxml_proc_inst(root, d + 1, s - d - 2);
         } else
             return ezxml_err(root, d, "unexpected <");
 
         if (!s || !*s)
             break;
         *s = '\0';
         d = ++s;
         if (*s && *s != '<') { /* tag character content */
             while (*s && *s != '<') {
                 if (*s == '\n') {
                     line++;
                 }
                 s++;
             }
             if (*s)
                 ezxml_char_content(root, d, s - d, '&');
             else
                 break;
         } else if (!*s)
             break;
     }
 
     if (!root->cur)
         return &root->xml;
     else if (!root->cur->name)
         return ezxml_err(root, d, "root tag missing");
     else
         return ezxml_err(root, d, "unclosed tag <%s>", root->cur->name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

char** ezxml_pi	(	ezxml_t	xml,
		const char *	target
	)

Definition at line 156 of file ezxml.c.

                                           {
     ezxml_root_t root = (ezxml_root_t) xml;
     int i = 0;
 
     if (!root)
         return EZXML_NIL;
     while (root->xml.parent)
         root = (ezxml_root_t) root->xml.parent; /* root tag */
     while (root->pi[i] && strcmp(target, root->pi[i][0]))
         i++; /* find target */
     return ((root->pi[i]) ? root->pi[i] + 1 : EZXML_NIL);
 }

static void ezxml_proc_inst	(	ezxml_root_t	root,
		char *	s,
		size_t	len
	)

static

Definition at line 346 of file ezxml.c.

                                                                     {
     int i = 0, j = 1;
     char *target = s;
 
     s[len] = '\0'; /* null terminate instruction */
     if (*(s += strcspn(s, EZXML_WS))) {
         *s = '\0'; /* null terminate target */
         s += strspn(s + 1, EZXML_WS) + 1; /* skip whitespace after target */
     }
 
     if (!strcmp(target, "xml")) { /* <?xml ... ?> */
         /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
         s = strstr(s, "standalone");
         if (s && !strncmp(s + strspn(s + 10, EZXML_WS "='\"") + 10, "yes", 3))
             root->standalone = 1;
         return;
     }
 
     if (!root->pi[0])
         *(root->pi = (char***)malloc(sizeof(char **))) = NULL; /*first pi */
 
     while (root->pi[i] && strcmp(target, root->pi[i][0]))
         i++; /* find target */
     if (!root->pi[i]) { /* new target */
         root->pi = (char***)realloc(root->pi, sizeof(char **) * (i + 2));
         root->pi[i] = (char**)malloc(sizeof(char *) * 3);
         root->pi[i][0] = target;
         root->pi[i][1] = (char *) (root->pi[i + 1] = NULL); /* terminate pi list */
         /* Ted Campbell, Aug 14, 2007. Changed to use 'my_strdup' */
         root->pi[i][2] = my_strdup(""); /* empty document position list */
     }
 
     while (root->pi[i][j])
         j++; /* find end of instruction list for this target */
     root->pi[i] = (char**)realloc(root->pi[i], sizeof(char *) * (j + 3));
     root->pi[i][j + 2] = (char*)realloc(root->pi[i][j + 1], j + 1);
     strcpy(root->pi[i][j + 2] + j - 1, (root->xml.name) ? ">" : "<");
     root->pi[i][j + 1] = NULL; /* null terminate pi list for this target */
     root->pi[i][j] = s; /* set instruction */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_set_attr	(	ezxml_t	xml,
		char *	name,
		char *	value
	)

Definition at line 1165 of file ezxml.c.

                                                              {
     int l = 0, c;
 
     if (!xml)
         return NULL;
     while (xml->attr[l] && strcmp(xml->attr[l], name))
         l += 2;
     if (!xml->attr[l]) { /* not found, add as new attribute */
         if (!value)
             return xml; /* nothing to do */
         if (xml->attr == EZXML_NIL) { /* first attribute */
             xml->attr = (char**)malloc(4 * sizeof(char *));
             /* Ted Campbell, Aug 14, 2007. Changed to use 'my_strdup' */
             xml->attr[1] = my_strdup(""); /* empty list of malloced names/vals */
         } else
             xml->attr = (char**)realloc(xml->attr, (l + 4) * sizeof(char *));
 
         xml->attr[l] = name; /*set attribute name */
         xml->attr[l + 2] = NULL; /* null terminate attribute list */
         xml->attr[l + 3] = (char*)realloc(xml->attr[l + 1],
                 (c = strlen(xml->attr[l + 1])) + 2);
         strcpy(xml->attr[l + 3] + c, " "); /* set name/value as not malloced */
         if (xml->flags & EZXML_DUP)
             xml->attr[l + 3][c] = (char) (unsigned char) EZXML_NAMEM;
     } else if (xml->flags & EZXML_DUP)
         free(name); /* name was strduped */
     for (c = l; xml->attr[c]; c += 2)
         ; /* find end of attribute list */
     if (xml->attr[c + 1][l / 2] & EZXML_TXTM)
         free(xml->attr[l + 1]); /*old val */
     if (xml->flags & EZXML_DUP)
         xml->attr[c + 1][l / 2] |= EZXML_TXTM;
     else
         xml->attr[c + 1][l / 2] &= ~EZXML_TXTM;
 
     if (value)
         xml->attr[l + 1] = value; /* set attribute value */
     else { /* remove attribute */
         if (xml->attr[c + 1][l / 2] & EZXML_NAMEM)
             free(xml->attr[l]);
         /* Ted Campbell, Aug 14, 2007. It seems that the size should be 
          * (c + 2) - (l + 2) = (c - l) */
         memmove(xml->attr + l, xml->attr + l + 2, (c - l) * sizeof(char *));
         /* Ted Campbell, Aug 14, 2007. We need to adjust c to point to new
          * location it was moved to since its old location is undefined */
         c -= 2; /* We have one less elements */
         xml->attr = (char**)realloc(xml->attr, (c + 2) * sizeof(char *));
         memmove(xml->attr[c + 1] + (l / 2), xml->attr[c + 1] + (l / 2) + 1,
                 (c / 2) - (l / 2)); /* fix list of which name/vals are malloced */
     }
     xml->flags &= ~EZXML_DUP; /* clear strdup() flag */
     return xml;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_set_flag	(	ezxml_t	xml,
		short	flag
	)

Definition at line 1220 of file ezxml.c.

                                                 {
     if (xml)
         xml->flags |= flag;
     return xml;
 }

Here is the caller graph for this function:

ezxml_t ezxml_set_txt	(	ezxml_t	xml,
		char *	txt
	)

Definition at line 1152 of file ezxml.c.

                                               {
     if (!xml)
         return NULL;
     if (xml->flags & EZXML_TXTM)
         free(xml->txt); /* existing txt was malloced */
     xml->flags &= ~EZXML_TXTM;
     strcpy(xml->txt, txt);
     xml->txt = txt;
     return xml;
 }

Here is the caller graph for this function:

static char * ezxml_str2utf8	(	char **	s,
		size_t *	len
	)

static

Definition at line 537 of file ezxml.c.

                                        {
     char *u;
     size_t l = 0, sl, max = *len;
     long c, d;
     int b, be = (**s == '\xFE') ? 1 : (**s == '\xFF') ? 0 : -1;
 
     if (be == -1)
         return NULL; /* not UTF-16 */
 
     u = (char*)malloc(max);
     for (sl = 2; sl < *len - 1; sl += 2) {
         c = (be) ? (((*s)[sl] & 0xFF) << 8) | ((*s)[sl + 1] & 0xFF) /*UTF-16BE */
         :
                     (((*s)[sl + 1] & 0xFF) << 8) | ((*s)[sl] & 0xFF); /*UTF-16LE */
         if (c >= 0xD800 && c <= 0xDFFF && (sl += 2) < *len - 1) { /* high-half */
             d = (be) ?
                     (((*s)[sl] & 0xFF) << 8) | ((*s)[sl + 1] & 0xFF) :
                     (((*s)[sl + 1] & 0xFF) << 8) | ((*s)[sl] & 0xFF);
             c = (((c & 0x3FF) << 10) | (d & 0x3FF)) + 0x10000;
         }
 
         while (l + 6 > max)
             u = (char*)realloc(u, max += EZXML_BUFSIZE);
         if (c < 0x80)
             u[l++] = (char)c; /* US-ASCII subset */
         else { /* multi-byte UTF-8 sequence */
             for (b = 0, d = c; d; d /= 2)
                 b++; /* bits in c */
             b = (b - 2) / 5; /* bytes in payload */
             u[l++] = (char)((0xFF << (7 - b)) | (c >> (6 * b))); /* head */
             while (b)
                 u[l++] = 0x80 | ((c >> (6 * --b)) & 0x3F); /* payload */
         }
     }
     return *s = (char*)realloc(u, *len = l);
 }

Here is the caller graph for this function:

char* ezxml_toxml ( ezxml_t xml )

Definition at line 963 of file ezxml.c.

                          {
     ezxml_t p = (xml) ? xml->parent : NULL, o = (xml) ? xml->ordered : NULL;
     ezxml_root_t root = (ezxml_root_t) xml;
     size_t len = 0, max = EZXML_BUFSIZE;
     char *s = strcpy((char*)malloc(max), ""), *t, *n;
     int i, j, k;
 
     if (!xml || !xml->name)
         return (char*)realloc(s, len + 1);
     while (root->xml.parent)
         root = (ezxml_root_t) root->xml.parent; /* root tag */
 
     for (i = 0; !p && root->pi[i]; i++) { /* pre-root processing instructions */
         for (k = 2; root->pi[i][k - 1]; k++)
             ;
         for (j = 1; root->pi[i][j]; j++) {
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             n = root->pi[i][j];
             if (root->pi[i][k][j - 1] == '>')
                 continue; /* not pre-root */
             while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max)
                 s = (char*)realloc(s, max += EZXML_BUFSIZE);
             len += sprintf(s + len, "<?%s%s%s?>\n", t, *n ? " " : "", n);
         }
     }
 
     xml->parent = xml->ordered = NULL;
     s = ezxml_toxml_r(xml, &s, &len, &max, 0, root->attr);
     xml->parent = p;
     xml->ordered = o;
 
     for (i = 0; !p && root->pi[i]; i++) { /* post-root processing instructions */
         for (k = 2; root->pi[i][k - 1]; k++)
             ;
         for (j = 1; root->pi[i][j]; j++) {
             /* Jason Luu, Aug 29, 2007. Removed assignment in conditional statement */
             n = root->pi[i][j];
             if (root->pi[i][k][j - 1] == '<')
                 continue; /* not post-root */
             while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max)
                 s = (char*)realloc(s, max += EZXML_BUFSIZE);
             len += sprintf(s + len, "\n<?%s%s%s?>", t, *n ? " " : "", n);
         }
     }
     return (char*)realloc(s, len + 1);
 }

Here is the call graph for this function:

static char * ezxml_toxml_r	(	ezxml_t	xml,
		char **	s,
		size_t *	len,
		size_t *	max,
		size_t	start,
		char ***	attr
	)

static

Definition at line 901 of file ezxml.c.

                       {
     int i, j;
     const char *txt = (xml->parent) ? xml->parent->txt : "";
     size_t off = 0;
 
     /* parent character content up to this tag */
     *s = ezxml_ampencode(txt + start, xml->off - start, s, len, max, 0);
 
     while (*len + strlen(xml->name) + 4 > *max) /* reallocate s */
         *s = (char*)realloc(*s, *max += EZXML_BUFSIZE);
 
     *len += sprintf(*s + *len, "<%s", xml->name); /* open tag */
     for (i = 0; xml->attr[i]; i += 2) { /* tag attributes */
         if (ezxml_attr(xml, xml->attr[i]) != xml->attr[i + 1])
             continue;
         while (*len + strlen(xml->attr[i]) + 7 > *max) /* reallocate s */
             *s = (char*)realloc(*s, *max += EZXML_BUFSIZE);
 
         *len += sprintf(*s + *len, " %s=\"", xml->attr[i]);
         /* Ted Campbell, Aug 14, 2007. Added explicit cast to size_t. */
         ezxml_ampencode(xml->attr[i + 1], (size_t) (-1), s, len, max, 1);
         *len += sprintf(*s + *len, "\"");
     }
 
     for (i = 0; attr[i] && strcmp(attr[i][0], xml->name); i++)
         ;
     for (j = 1; attr[i] && attr[i][j]; j += 3) { /* default attributes */
         if (!attr[i][j + 1] || ezxml_attr(xml, attr[i][j]) != attr[i][j + 1])
             continue; /* skip duplicates and non-values */
         while (*len + strlen(attr[i][j]) + 7 > *max) /* reallocate s */
             *s = (char*)realloc(*s, *max += EZXML_BUFSIZE);
 
         *len += sprintf(*s + *len, " %s=\"", attr[i][j]);
         /* Ted Campbell, Aug 14, 2007. Added explicit cast to size_t. */
         ezxml_ampencode(attr[i][j + 1], (size_t) (-1), s, len, max, 1);
         *len += sprintf(*s + *len, "\"");
     }
     *len += sprintf(*s + *len, ">");
 
     /* Ted Campbell, Aug 14, 2007. Added explicit cast to size_t. */
     *s = (xml->child) ?
             ezxml_toxml_r(xml->child, s, len, max, 0, attr) /*child */
             :
             ezxml_ampencode(xml->txt, (size_t) (-1), s, len, max, 0); /*data */
 
     while (*len + strlen(xml->name) + 4 > *max) /* reallocate s */
         *s = (char*)realloc(*s, *max += EZXML_BUFSIZE);
 
     *len += sprintf(*s + *len, "</%s>", xml->name); /* close tag */
 
     while (txt[off] && off < xml->off)
         off++; /* make sure off is within bounds */
     /* Ted Campbell, Aug 14, 2007. Added explicit cast to size_t. */
     return (xml->ordered) ?
             ezxml_toxml_r(xml->ordered, s, len, max, off, attr) :
             ezxml_ampencode(txt + off, (size_t) (-1), s, len, max, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ezxml_t ezxml_vget	(	ezxml_t	xml,
		va_list	ap
	)

static

Definition at line 125 of file ezxml.c.

                                             {
     char *name = va_arg(ap, char *);
     int idx = -1;
 
     if (name && *name) {
         idx = va_arg(ap, int);
 
         xml = ezxml_child(xml, name);
     }
     return (idx < 0) ? xml : ezxml_vget(ezxml_idx(xml, idx), ap);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

char* EZXML_NIL[] = { NULL }

Definition at line 65 of file ezxml.c.

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation