---

xmlt.c

/*
 *  xmlt.c - XML data structure.
 *           This file is part of the FreeLCD package.
 *
 *  $Id: xmlt_8c-source.html,v 1.1 2003/02/16 22:50:41 unicorn Exp $
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *  Copyright (c) 2002, 2003, Jeroen van den Berg <unicorn@hippie.nu>
 */


#if HAVE_CONFIG_H
# include <config.h>
#endif

#if HAVE_STRING_H
# include <string.h>
#else
# if HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif

#include <assert.h>
#include <expat.h>
#include <stdio.h>

#include "common/dictionary.h"
#include "common/slist.h"
#include "common/xmalloc.h"
#include "xmlt.h"

typedef struct
{
  XML_Parser parser;            /* The Expat parser */
  xml_node *root_node;          /* First tag in the document is root */
  xml_node *curr_node;          /* Current node, used while parsing */
  void (*doc_finished) (void *, xml_node *);/* Callback for delivering finished
                                               documents */
  void *user_callback_data;     /* Data is passed to callback function */
  dictionary *known_tags;       /* The dictionary with the known tags,
                                   used for looking up a tag's index */
  dictionary *known_attributes; /* Same thing for attributes */
  int depth;                    /* Tree depth, used while parsing */
  int curr_is_cdata;            /* Working with character data at the
                                   moment, used while parsing */
  int valid;                    /* Document is still valid */
}
xml_context;


/*----------------------------------------------------- _cleanup_string --*/
static size_t
_cleanup_string (const char *text, char **_dest, int len)
{
  size_t i;
  size_t newlen = 0;
  char c;
  char* dest = *_dest;

  assert (text);
  assert (_dest && *_dest);

  if (len == 0)
    return 0;

  for (i = 0; i < len; ++i)
    {
      c = text[i];
      if (c == '\n' || c == '\r' || c == '\t')
        c = ' ';

      /* Don't put spaces at the beginning, or after another space */
      if (c != ' ' || newlen == 0 || dest[newlen - 1] != ' ')
        dest[newlen++] = c;
    }

  /* Don't store trailing spaces. */
  while (newlen > 0 && dest[newlen - 1] == ' ')
    --newlen;

  return newlen;
}

/*------------------------------------------------------- _attr_compare --*/
static int
_attr_compare (const void* data, const void* compare)
{
  const xml_attribute *attr = (const xml_attribute*)data;
  int attr_t = *(int*)compare;

  return    attr->attribute != XML_UNKNOWN_ATTRIBUTE 
         && attr->attribute == attr_t;
}

/*----------------------------------------------------- _rescan_attribs --*/
static void
_rescan_attrib (void *data, void *userdata)
{
  xml_attribute *attrib = (xml_attribute*)data; 
  dictionary *attr_dict = (dictionary*)userdata;
  int *lookup;
  
  if (attrib->attribute == XML_UNKNOWN_ATTRIBUTE)
    {
      lookup = dict_lookup (attr_dict, attrib->unknown_attrib);
      if (lookup != 0)
        {
          attrib->attribute = *lookup;
          free (attrib->unknown_attrib);
          attrib->unknown_attrib = 0;
        }
    }
}

/*------------------------------------------------------ _start_element --*/
static void
_start_element (void *cntxt, const char *name, const char **attr)
{
  xml_node *newnode = xmalloc (sizeof (xml_node));
  xml_context *context = (xml_context *) cntxt;
  int *node_t;

  newnode->type = NODE;
  
  /*  Look up the node name in the dictionary. If it's not there, mark
   *  it simply as an unknown node.
   */
  node_t = dict_lookup (context->known_tags, name);
  if (!node_t)
    {
      newnode->tag = XML_UNKNOWN_TAG;
      newnode->cdata = xstrdup (name);
    }
  else
    {
      newnode->tag = *(int *) node_t;
      newnode->cdata = 0;
    }

  slist_init (&newnode->children);
  slist_init (&newnode->attributes);

  if (! context->root_node)
    {
      context->root_node = newnode;
      newnode->parent = 0;
    }
  else
    {
      newnode->parent = context->curr_node;
      slist_append (&context->curr_node->children, newnode);
    }

  while (attr && *attr)
    {
      xml_attribute *new_attr = xmalloc (sizeof (xml_attribute));
      int *attr_t = dict_lookup (context->known_attributes, *attr);
      
      if (!attr_t)
        {
          new_attr->attribute = XML_UNKNOWN_ATTRIBUTE;
          new_attr->unknown_attrib = xstrdup (*attr);
        }
      else
        {
          new_attr->attribute = *(int*)attr_t;
          new_attr->unknown_attrib = 0;
        }
      
      new_attr->value = xstrdup(*(attr + 1));
      slist_append (&newnode->attributes, new_attr);
      attr += 2;
    }
  
  context->curr_node = newnode;
  context->curr_is_cdata = 0;
  ++context->depth;
}

/*-------------------------------------------------------- _end_element --*/
static void
_end_element (void *cntxt, const char *name)
{
  xml_context *context = (xml_context *) cntxt;

  --context->depth;
  if (!context->depth)
    {
      context->doc_finished (context->user_callback_data, context->root_node);
      context->curr_node = 0;
      context->root_node = 0;
    }
  else
    {
      context->curr_node = context->curr_node->parent;
      context->curr_is_cdata = 0;
    }
}

/*----------------------------------------------------- _character_data --*/
static void
_character_data (void *cntxt, const char *text, int len)
{
  int         newlen;
  char        *newtext;
  xml_node    *new_node = xmalloc (sizeof (xml_node));
  xml_context *context = (xml_context *) cntxt;
  slist       *siblings;

  assert (cntxt);
  assert (text);
  
  newtext = xmalloc (len);
  newlen =_cleanup_string (text, &newtext, len);
  if (newlen == 0)
    {
      free (newtext);
      return;
    }
  
  xrealloc (newtext, newlen + 1);
  newtext[newlen] = 0;

  siblings = &(context->curr_node->children);
  if (context->curr_is_cdata)
    {
      /*  The parser was already handling character data. Just add this
       *  cdata to what was already there.
       */
      xml_node *last_node = slist_last (siblings);
      size_t cdata_len = strlen (last_node->cdata);

      last_node->cdata = xrealloc (last_node->cdata, cdata_len + newlen + 1);
      memcpy (last_node->cdata + cdata_len, newtext, newlen);
      last_node->cdata[cdata_len + cdata_len + newlen + 1] = 0;
    }
  else
    {
      new_node = xmalloc( sizeof (xml_node));
      new_node->type = CDATA;
      new_node->tag = -1;
      new_node->cdata = newtext;
      new_node->parent = context->curr_node;
  
      slist_append (siblings, new_node);
      context->curr_is_cdata = 1;
    }
}

/*----------------------------------------------------- _free_attribute --*/
static void
_free_attribute (void *_attr)
{
  xml_attribute *attr = (xml_attribute *) _attr;
  assert (attr);
  free (attr->value);
  free (attr->unknown_attrib);
  free (attr);
}


/*-------------------------------------------------- xml_create_context --*/
void *
xmlt_create_context (void (*cb) (void *, xml_node *), void *cb_data,
                     dictionary * tags, dictionary * attribs)
{
  xml_context *context = xmalloc (sizeof (xml_context));

  context->parser = XML_ParserCreate (0);
  if (!context->parser)
    return 0;

  XML_SetUserData (context->parser, context);
  XML_SetElementHandler (context->parser, _start_element, _end_element);
  XML_SetCharacterDataHandler (context->parser, _character_data);

  context->root_node          = 0;
  context->curr_node          = 0;
  context->user_callback_data = cb_data;
  context->known_tags         = tags;
  context->known_attributes   = attribs;
  context->depth              = 0;
  context->curr_is_cdata      = 0;
  context->doc_finished       = cb;
  context->valid              = 1;

  return context;
}

/*---------------------------------------------------------- xmlt_parse --*/
int
xmlt_parse (void *_context, const char *data, size_t len)
{
  xml_context *context = (xml_context *) _context;
  
  if (!context || !context->valid)
    return 0;

  if (len == 0)
    return 1;
  
  assert (context->parser);
  assert (data);

  if (!XML_Parse (context->parser, data, len, 0))
    {
      context->valid = 0;
      return 0;
    }

  return 1;
}

/*--------------------------------------------------- xmlt_free_context --*/
void
xmlt_free_context (void *context)
{
  assert (context);
  XML_ParserFree (((xml_context *) context)->parser);
}

/*-------------------------------------------------- xmlt_free_document --*/
void
xmlt_free_document (xml_node * doc)
{
  slist_iter iter;
  int is_cdata = 1;
  void *p;

  assert (doc);
  iter = slist_begin_iter (&doc->children);
  slist_delete_special (&doc->attributes, _free_attribute);

  while (iter.curr)
    {
      p = slist_iter_and_next (&iter);

      if (is_cdata)
        free (p);
      else
        xmlt_free_document (p);

      /* Toggle is_cdata between 0 and 1 */
      is_cdata = -is_cdata + 1;
    }

  free (doc->cdata);
  free (doc);
}

/*------------------------------------------------------- xmlt_get_next --*/
xml_node *
xmlt_get_next (xml_node *iter, xml_node *doc)
{
  assert (iter);
  assert (doc);
  
  if (iter->children.head)
    return (xml_node*)iter->children.head->data;
  
  while (iter->parent)
    {
      if (iter == doc)
        return 0;

      slist_iter i = slist_find (&(iter->parent->children), iter);
      if (i.curr->next)
        return (xml_node *) (i.curr->next->data);

      iter = iter->parent;
    }

  /* We shouldn't get here in theory, but, just in case. */
  return 0;
}

/*------------------------------------------------ xmlt_get_next_shallow --*/
xml_node *
xmlt_get_next_shallow (xml_node *iter)
{
  slist_iter siblings;
  assert (iter);
  
  siblings = slist_find (&(iter->parent->children), iter);

  if (siblings.curr->next)
    iter = (xml_node *)(siblings.curr->next->data);
  else
    iter = 0;

  return iter;
}

/*------------------------------------------------ xmlt_rescan_document --*/
void
xmlt_rescan_document (xml_node * doc, dictionary * tags, dictionary * attribs)
{
  int *tag_ptr;
  xml_node *curr_node  = doc;

  while (curr_node)
    {
      if (curr_node->type == NODE && curr_node->tag == XML_UNKNOWN_TAG)
        {
          /*  The unknown tag is stored as a string in 'cdata'.  If we
           *  can find it back in our own dictionary, replace the value in
           *  'tag' (which is XML_UNKNOWN_TAG) with the value from our
           *  dictionary, and free the memory that was allocated for the
           *  string. 
           */
          tag_ptr = dict_lookup (tags, curr_node->cdata);
          if (tag_ptr != 0)
            {
              curr_node->tag = *tag_ptr;
              free (curr_node->cdata);
              curr_node->cdata = 0;

              if (attribs)
                {
                  slist_for_each (&curr_node->attributes, _rescan_attrib, 
                                  attribs);
                }
            }
        }

      curr_node = xmlt_get_next (curr_node, doc);
    }
}

/*----------------------------------------------------------- xmlt_find --*/
xml_node *
xmlt_find (xml_node *doc, xml_node* iter, int tag)
{
  if (!iter)
    iter = xmlt_get_next (doc, doc);
  else
    iter = xmlt_get_next_shallow (iter);

  while (iter && iter->tag != tag)
    iter = xmlt_get_next_shallow (iter);
  
  return iter;
}

/*-------------------------------------------------------- xmlt_find_if --*/
xml_node *
xmlt_find_if (xml_node *doc, xml_node* iter, int(*compare)(xml_node*))
{
  if (!iter)
    iter = xmlt_get_next (doc, doc);
  else
    iter = xmlt_get_next_shallow (iter);

  while (iter && !compare (iter))
    iter = xmlt_get_next_shallow (iter);
  
  return iter;
}

/*----------------------------------------------------- xmlt_get_attrib --*/
const char*
xmlt_get_attrib (xml_node *node, int attribute)
{
  slist_iter i = slist_find_if (&node->attributes, &attribute, _attr_compare);
  
  if(i.curr)
    return ((xml_attribute*)i.curr->data)->value;

  return 0;
} 

/*------------------------------------------------ xmlt_get_first_cdata --*/
const char*
xmlt_get_first_cdata (xml_node *node)
{
  xml_node *first_child;

  if (!node)
    return 0;
  
  first_child = (xml_node*)node->children.head->data;

  return (first_child && first_child->cdata) ? first_child->cdata : 0;
}


#ifdef UNIT_TEST_XMLT_C

/* UNIT_CFLAGS -O -lexpat */
/* UNIT_EXTRA  ../common/xmalloc.c ../common/slist.c ../common/dictionary.c */

void test_callback (void *userdata, xml_node *document)
{
  *(xml_node**)userdata = document;
}

void
test_next_tag (xml_node **doc_iter, xml_node *doc, int tag)
{
  *doc_iter = xmlt_get_next (*doc_iter, doc);
  
  if (!doc_iter || !*doc_iter)
    {
      printf ("xmlt_get_next() failed, iterator is NULL\n");
      exit (1);
    }

  if ((**doc_iter).type != NODE)
    {
      printf ("xmlt_get_next() failed, got CDATA, expected NODE\n");
      exit (1);
    }

  if ((**doc_iter).tag != tag)
    {
      printf ("xmlt_get_next() failed, tag is %i instead of %i\n",
              (**doc_iter).tag, tag);
      exit (1);
    }
}

void
test_next_cdata (xml_node **doc_iter, xml_node *doc, const char* cdata)
{
  *doc_iter = xmlt_get_next (*doc_iter, doc);
  
  if (!doc_iter || !*doc_iter)
    {
      printf ("xmlt_get_next() failed, iterator is NULL\n");
      exit (1);
    }

  if ((**doc_iter).type != CDATA)
    {
      printf ("xmlt_get_next() failed, got NODE, expected CDATA\n");
      exit (1);
    }

  if (strcmp((**doc_iter).cdata, cdata))
    {
      printf ("xmlt_get_next() failed, cdata is '%s' instead of '%s'.\n",
              (**doc_iter).cdata, cdata);
      exit (1);
    }
}

int main (int argc, char **argv)
{
  int tag_array[]  = { 1, 2, 3, 4 };
  int attr_array[] = { 10, 20, 30, 40 };
  xml_node *finished_doc = 0;
  xml_node *doc_iter;
  const char* attr_value;
  
  dict_pair tag_dict[] = 
    {
      { "four", &tag_array[3] },
      { "one", &tag_array[0] },
      { "three", &tag_array[2] },
      { "two", &tag_array[1] }
    };
  
  dict_pair attr_dict[] = 
    {
        { "dos", &attr_array[1] },
        { "quatro", &attr_array[3] },
        { "tres", &attr_array[2] },
        { "uno", &attr_array[0] }
    };
  
  dictionary tags  = { tag_dict , 4 };
  dictionary attrs = { attr_dict, 4 };
  
  int read;
  
  char *xmldata = "<one><two>Inside two</two><three uno=\"een\" dos=\"twee\">" \
    "<four tres=\"drie\" quatro=\"vier\">Inside four</four></three>" \
    "<nonexistent />Closing</one>";
  
  xml_context* context = xmlt_create_context (test_callback, &finished_doc, 
                                              &tags, &attrs);
  
  if (!context)
    {
      printf ("xmlt_create_context() failed\n");
      exit (1);
    }

  if (!xmlt_parse (context, xmldata, strlen(xmldata)))
    {
      printf ("xmlt_parse() failed\n");
      exit (1);
    }

  if (!finished_doc)
    {
      printf ("xmlt_parse() failed, no document returned\n");
      exit (1);
    }

  doc_iter = finished_doc;
  if (doc_iter->tag != tag_array[0])
    {
      printf ("xmlt_parse() failed, root tag is %i instead of %i\n",
              doc_iter->tag, tag_array[0]);
      exit (1);
    }
  
  if (doc_iter->parent != 0)
    {
      printf ("xmlt_parse() failed, first tag is not root tag\n");
      exit (1);
    }
  
  test_next_tag(&doc_iter, finished_doc, tag_array[1]);
  
  attr_value = xmlt_get_attrib (doc_iter, attr_array[0]);
  if (attr_value)
    {
      printf ("xmlt_get_attribute() returned something.\n");
      exit (1);
    }
  
  test_next_cdata(&doc_iter, finished_doc, "Inside two");
  test_next_tag(&doc_iter, finished_doc, tag_array[2]);

  attr_value = xmlt_get_attrib (doc_iter, attr_array[0]);
  if (!attr_value)
    {
      printf ("xmlt_get_attribute() didn't return anything.\n");
      exit (1);
    }
  
  if (strcmp(attr_value, "een"))
      {
        printf ("xmlt_get_attribute() returned '%s' instead of 'een'.\n",
                attr_value);
        exit (1);
      }
      
  test_next_tag(&doc_iter, finished_doc, tag_array[3]);
  test_next_cdata(&doc_iter, finished_doc, "Inside four");
  
  
  return 0;
}

#endif

---