uxmlstream.c

Go to the documentation of this file.

/*
 * Copyright (C) 2008 by egnite GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 */

/*
 * \file pro/uxmlstream.c
 * \brief Micro XML stream parser.
 *
 * \verbatim
 * $Id: uxmlstream.c 3452 2011-06-01 08:51:23Z haraldkipp $
 * \endverbatim
 */

#include <sys/types.h>
#include <sys/heap.h>

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <memdebug.h>

#include <pro/uxml.h>


#ifndef MAX_UXMLTAG_SIZE

#define MAX_UXMLTAG_SIZE     512
#endif

#ifndef MAX_UXMLTKN_SIZE

#define MAX_UXMLTKN_SIZE     64
#endif

static int UxmlReadTag(FILE * stream, char *data, size_t size)
{
    int rc = -1;
    int ch;
    int qc = 0;
    int state = 1;
    char *dp = NULL;

    while (state) {
        ch = fgetc(stream);
        if (ch == EOF || ch == 0) {
            break;
        }
        switch (state) {
        case 1:
            /* Searching first bracket. */
            if (ch == '<') {
                /* Opening bracket found. Start collecting. */
                dp = data;
                state = 4;
            } else if (ch == '"' || ch == '\'') {
                /* Quote found. Skip quoted string. */
                qc = ch;
                state++;
            }
            break;
        case 2:
            /* Skipping quoted string. */
        case 5:
            /* Collecting quoted string. */
            if (ch == qc) {
                /* End quote found. */
                state--;
            }
            break;
        case 3:
            /* Compressing spaces. */
            if (isspace(ch)) {
                ch = 0;
                break;
            }
            state = 4;
            /* Fall through. */
        case 4:
            /* Collecting data. */
            if (ch == '>') {
                rc = 0;
                state = 0;
            } else if (ch == '"' || ch == '\'') {
                qc = ch;
                state++;
            } else if (isspace(ch)) {
                ch = ' ';
                state = 3;
            }
            break;
        }
        if (dp && ch) {
            if (size > 1) {
                size--;
                *dp++ = ch;
            } else {
                break;
            }
        }
    }
    if (dp) {
        *dp = 0;
    }
    return rc;
}

UXML_NODE *UxmlParseStream(FILE * stream, char **f_tags, char **f_attr)
{
    char *tag;
    char *tkn;
    char *tp;
    UXML_NODE *root = NULL;
    UXML_NODE *node = NULL;
    UXML_NODE *nn;

    /* Allocate the tag buffer. */
    if ((tag = malloc(MAX_UXMLTAG_SIZE)) == NULL) {
        return NULL;
    }
    /* Allocate the token buffer. */
    if ((tkn = malloc(MAX_UXMLTKN_SIZE)) == NULL) {
        free(tag);
        return NULL;
    }
    for (;;) {
        if (NutHeapAvailable() < 8192) {
            break;
        }
        /* Read the next tag. */
        if (UxmlReadTag(stream, tag, MAX_UXMLTAG_SIZE)) {
            /* No more tags or error. */
            break;
        }
        /* Parse the tag. */
        if ((tp = UxmlParseTag(tag + 1, tkn, MAX_UXMLTKN_SIZE)) != NULL) {
            if (isalpha((unsigned char)*tkn) && UxmlFilterMatch(tkn, f_tags)) {
                /* Save pointer to tp because needed to determine self closing tag */
                char *old_tp = tp;

                /*
                 * New node.
                 */
                if ((nn = UxmlNodeCreate(tkn)) == NULL) {
                    break;
                }
                if (root == NULL) {
                    /* Root entry. */
                    root = nn;
                    node = nn;
                } else if (node == NULL) {
                    /* No active node. Add root siblings. */
                    node = UxmlTreeAddSibling(root, nn);
                } else {
                    /* New node is a child of the currently active one. */
                    node = UxmlTreeAddChild(node, nn);
                }
                /* Parse the attributes. */
                for (;;) {
                    if ((tp = UxmlParseTag(tp, tkn, MAX_UXMLTKN_SIZE)) == NULL || *tkn == '>') {
                        /* End of this tag or error. */
                        break;
                    }
                    if (isalpha((unsigned char)*tkn) && UxmlFilterMatch(tkn, f_attr)) {
                        char *name = strdup(tkn);

                        if (name) {
                            if ((tp = UxmlParseTag(tp, tkn, MAX_UXMLTKN_SIZE)) == NULL || *tkn != '=') {
                                free(name);
                                break;
                            }
                            if ((tp = UxmlParseTag(tp, tkn, MAX_UXMLTKN_SIZE)) == NULL || *tkn == '>') {
                                free(name);
                                break;
                            }
                            UxmlNodeAddAttrib(node, name, tkn);
                            free(name);
                        }
                    }
                }
                /* Check if tag is self closing */
                if (node && strlen(old_tp) > 1 && old_tp[strlen(old_tp) - 2]=='/') {
                    node = node->xmln_parent;
                }
            } else if (*tkn == '/') {
                /*
                 * End of the active node.
                 */
                tp = UxmlParseTag(tp, tkn, MAX_UXMLTKN_SIZE);
                if (tp && node && strcasecmp(node->xmln_name, tkn) == 0) {
                    node = node->xmln_parent;
                }
            }
        }
    }
    /* Clean up. */
    free(tag);
    free(tkn);

    return root;
}