VPR-6.0

libvpr/ezxml.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include "ezxml.h"
#include "util.h"
Include dependency graph for ezxml.c:

Go to the source code of this file.

Defines

#define EZXML_WS   "\t\r\n "

Functions

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_vget (ezxml_t xml, va_list ap)
ezxml_t ezxml_get (ezxml_t xml,...)
const char ** ezxml_pi (ezxml_t xml, const char *target)
ezxml_t ezxml_err (ezxml_root_t root, char *s, const char *err,...)
char * ezxml_decode (int *cur_line, char *s, char **ent, char t)
void ezxml_open_tag (ezxml_root_t root, int line, char *name, char **attr)
void ezxml_char_content (ezxml_root_t root, int *cur_line, char *s, size_t len, char t)
ezxml_t ezxml_close_tag (ezxml_root_t root, char *name, char *s)
int ezxml_ent_ok (char *name, char *s, char **ent)
void ezxml_proc_inst (ezxml_root_t root, char *s, size_t len)
short ezxml_internal_dtd (ezxml_root_t root, int *cur_line, char *s, size_t len)
char * ezxml_str2utf8 (char **s, size_t *len)
void ezxml_free_attr (char **attr)
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_ampencode (const char *s, size_t len, char **dst, size_t *dlen, size_t *max, short a)
char * ezxml_toxml_r (ezxml_t xml, char **s, size_t *len, size_t *max, size_t start, char ***attr)
char * ezxml_toxml (ezxml_t xml)
void ezxml_free (ezxml_t xml)
const char * ezxml_error (ezxml_t xml)
ezxml_t ezxml_new (const char *name)
ezxml_t ezxml_insert (ezxml_t xml, ezxml_t dest, size_t off)
ezxml_t ezxml_add_child (ezxml_t xml, const char *name, size_t off)
ezxml_t ezxml_set_txt (ezxml_t xml, const char *txt)
ezxml_t ezxml_set_attr (ezxml_t xml, const char *name, const char *value)
ezxml_t ezxml_set_flag (ezxml_t xml, short flag)
ezxml_t ezxml_cut (ezxml_t xml)

Variables

char * EZXML_NIL [] = { NULL }

Detailed Description

Copyright 2004-2006 Aaron Voisine <aaron@voisine.org>

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Definition in file ezxml.c.


Define Documentation

#define EZXML_WS   "\t\r\n "

whitespace

Definition at line 65 of file ezxml.c.


Function Documentation

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

Adds a child tag. off is the offset of the child tag relative to the start of the parent tag's character content. Returns the child tag.

Definition at line 1317 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 = (char *)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:

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

Encodes ampersand sequences appending the results to *dst, reallocating *dst if length excedes max. a is non-zero for attribute encoding. Returns *dst

Definition at line 992 of file ezxml.c.

{
    const char *e;

    for(e = s + len; s != e; s++)
        {
            while(*dlen + 10 > *max)
                *dst = 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 
)

returns the value of the requested tag attribute or NULL if not found

Definition at line 93 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:

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

called when parser finds character content between open and closing tag. Jason Luu June 22, 2010, Added line number support

Definition at line 329 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(cur_line, 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 */
                ? realloc(xml->txt, (l = strlen(xml->txt)) + len)
                : strcpy(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 
)

returns the first child tag with the given name or NULL if not found

Definition at line 71 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:

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

called when parser finds closing tag

Definition at line 363 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)

removes a tag along with its subtags without freeing its memory

Definition at line 1426 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;
}
char* ezxml_decode ( int *  cur_line,
char *  s,
char **  ent,
char  t 
)

Recursively decodes entity and character references and normalizes new lines ent is a null terminated array of alternating entity names and values. set t to '&' for general entity decoding, '' for parameter entity decoding, 'c' for cdata sections, ' ' for attribute normalization, or '*' for non-cdata attribute normalization. Returns s, or if the decoded string is longer than s, returns a malloced string that must be freed. Jason Luu June 22, 2010, Added line number support

Definition at line 204 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));
                                (*cur_line)++;
                        }
                }
        }

    for(s = r;;)
        {
            while(*s && *s != '&' && (*s != '%' || t != '%') && !isspace(*s))
                s++;
                if(*s == '\n')
                        (*cur_line)++;
            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++) = 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++) = (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(malloc(l),
                                                          r) : 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:

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

checks for circular entity references, returns non-zero if no circular references are found, zero otherwise

Definition at line 378 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:

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

set an error string and return root

Definition at line 174 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)

return parser error message or empty string if none

Definition at line 1233 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)

free the memory allocated for the ezxml structure

Definition at line 1174 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 == -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:

void ezxml_free_attr ( char **  attr)

frees a tag attribute list

Definition at line 662 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,
  ... 
)

Traverses the xml tree to retrieve a specific subtag. Takes a variable length list of tag names and indexes. The argument list must be terminated by either an index of -1 or an empty string tag name. Example: title = ezxml_get(library, "shelf", 0, "book", 2, "title", -1); This retrieves the title of the 3rd book on the 1st shelf of library. Returns NULL if not found.

Definition at line 141 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 
)

returns the Nth tag with the same name in the same subsection or NULL if not found

Definition at line 83 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 
)

inserts an existing tag into an ezxml structure

Definition at line 1261 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:

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

called when the parser finds an internal doctype subset. Jason Luu June 22, 2010, Added line number support

Definition at line 453 of file ezxml.c.

{
    char q, *c, *t, *n = NULL, *v, **ent, **pe;
    int i, j;

    pe = 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 = 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(cur_line, 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++);

                    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 */
                            c = (strncmp(s, "CDATA", 5)) ? "*" : " ";   /* 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) ? malloc(2 *
                                                      sizeof(char **)) :
                                        realloc(root->attr,
                                                (i + 2) * sizeof(char **));
                                    root->attr[i] =
                                        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] = 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(cur_line, v, root->ent, *c) : NULL;
                            root->attr[i][j] = n;       /* attribute name  */
                        }
                }
            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 ( const char *  name)

returns a new empty ezxml structure with the given root tag name

Definition at line 1242 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 = (char *)name;
    root->cur = &root->xml;
    strcpy(root->err, root->xml.txt = "");
    root->ent = 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:

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

called when parser finds start of new tag. Jason Luu June 22, 2010, Added line number support

Definition at line 308 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)

A wrapper for ezxml_parse_str() that accepts a file descriptor. First attempts to mem map the file. Failing that, reads the file into memory. Returns NULL on failure.

Definition at line 941 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(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(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)

a wrapper for ezxml_parse_fd that accepts a file name

Definition at line 978 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)

Wrapper for ezxml_parse_str() that accepts a file stream. Reads the entire stream into memory and then parses it. For xml files, use ezxml_parse_file() or ezxml_parse_fd()

Definition at line 910 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 = malloc(EZXML_BUFSIZE);
    if(!s)
        return NULL;
    do
        {
            len += (l = fread((s + len), 1, EZXML_BUFSIZE, fp));
            if(l == EZXML_BUFSIZE)
                s = 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 
)

parse the given xml string and return an ezxml structure. Jason Luu June 22, 2010, Added line number support

Definition at line 687 of file ezxml.c.

{
    ezxml_root_t root = (ezxml_root_t) ezxml_new(NULL);
    char q, e, *d, **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) ? realloc(attr, (l + 4) * sizeof(char *)) : malloc(4 * sizeof(char *));  /* allocate space */
                            attr[l + 3] = (l) ? realloc(attr[l + 1], (l / 2) + 2) : 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(&line, 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 */
                    s = strstr(s + 3, "--");
                    if(!s || (*(s += 2) != '>' && *s) || (!*s && e != '>'))
                        return ezxml_err(root, d, "unclosed <!--");
                }
            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, &line, 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, &line, 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 != '<')
                        s++;
                    if(*s)
                        ezxml_char_content(root, &line, 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:

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

returns a null terminated array of processing instructions for the given target

Definition at line 157 of file ezxml.c.

{
    ezxml_root_t root = (ezxml_root_t) xml;
    int i = 0;

    if(!root)
        return (const char **)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 (const char **)((root->pi[i]) ? root->pi[i] + 1 : EZXML_NIL);
}
void ezxml_proc_inst ( ezxml_root_t  root,
char *  s,
size_t  len 
)

called when the parser finds a processing instruction

Definition at line 401 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 = 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 = realloc(root->pi, sizeof(char **) * (i + 2));
            root->pi[i] = 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] = realloc(root->pi[i], sizeof(char *) * (j + 3));
    root->pi[i][j + 2] = 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,
const char *  name,
const char *  value 
)

Sets the given tag attribute or adds a new attribute if not found. A value of NULL will remove the specified attribute. Returns the tag given.

Definition at line 1352 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 = 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 = realloc(xml->attr, (l + 4) * sizeof(char *));

            xml->attr[l] = (char *)name;        /* set attribute name */
            xml->attr[l + 2] = NULL;    /* null terminate attribute list */
            xml->attr[l + 3] = 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((char *)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] = (char *)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 = 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 
)

sets a flag for the given tag and returns the tag

Definition at line 1416 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,
const char *  txt 
)

sets the character content for the given tag and returns the tag

Definition at line 1336 of file ezxml.c.

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

Here is the caller graph for this function:

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

Converts a UTF-16 string to UTF-8. Returns a new string that must be freed or NULL if no conversion was needed.

Definition at line 619 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 = 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 = realloc(u, max += EZXML_BUFSIZE);
            if(c < 0x80)
                u[l++] = 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++] = (0xFF << (7 - b)) | (c >> (6 * b));        /* head */
                    while(b)
                        u[l++] = 0x80 | ((c >> (6 * --b)) & 0x3F);      /* payload */
                }
        }
    return *s = realloc(u, *len = l);
}

Here is the caller graph for this function:

char* ezxml_toxml ( ezxml_t  xml)

Converts an ezxml structure back to xml. Returns a string of xml data that must be freed.

Definition at line 1115 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(malloc(max), ""),
     *t,
     *n;
    int i, j, k;

    if(!xml || !xml->name)
        return 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 = 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 = realloc(s, max += EZXML_BUFSIZE);
                    len +=
                        sprintf(s + len, "\n<?%s%s%s?>", t, *n ? " " : "", n);
                }
        }
    return realloc(s, len + 1);
}

Here is the call graph for this function:

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

Recursively converts each tag to xml appending it to *s. Reallocates *s if its length excedes max. start is the location of the previous tag in the parent tag's character content. Returns *s.

Definition at line 1043 of file ezxml.c.

{
    int i, j;
    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 = 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 = 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 = 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 = 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 
)

same as ezxml_get but takes an already initialized va_list

Definition at line 118 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 }

empty, null terminated array of strings

Definition at line 66 of file ezxml.c.