nxml.c

libnxml-no-curl-简化版2007-07-01,一个别很不错的XML生成和解析程序。

//================================
// File:nxml.c
// Modfied by seeker
// 2007-007-01 15:29
//================================
#ifdef HAVE_CONFIG_H
#include <config.h>
#else
# error Use configure; make; make install
#endif

#include "nxml.h"
//#include "nxml_internal.h"

//************************************************************
// EASY FUNTION
//************************************************************
nxml_data_t *nxmle_root_element (nxml_t * nxml, nxml_error_t * err)
{
  nxml_data_t *root;
  nxml_error_t ret;

  ret = nxml_root_element (nxml, &root);
  if (err)
    *err = ret;

  if (ret != NXML_OK)
    return NULL;

  return root;
}
//---------------------------------
char *nxmle_find_attribute (nxml_data_t * data, char *name, nxml_error_t * err)
{
  nxml_attr_t *attribute;
  nxml_error_t ret;
  char *str;

  ret = nxml_find_attribute (data, name, &attribute);
  if (err)
    *err = ret;

  if (ret != NXML_OK)
    return NULL;

  if (!attribute)
    return NULL;

  str = strdup (attribute->value);
  if (!str)
  {
    if (err)
      *err = NXML_ERR_POSIX;
    return NULL;
  }

  return str;
}
//************************************************************
// EDIT FUNTION
//************************************************************
nxml_error_t nxml_root_element (nxml_t * nxml, nxml_data_t ** data)
{
  nxml_data_t *tmp;

  if (!data || !nxml)
    return NXML_ERR_DATA;

  tmp = nxml->data;
  while (tmp)
  {

    if (tmp->type == NXML_TYPE_ELEMENT)
      break;

    tmp = tmp->next;
  }

  *data = tmp;

  return NXML_OK;
}
//---------------------------------
nxml_error_t nxml_find_element (nxml_t * nxml, nxml_data_t * data, char *name,
                                nxml_data_t ** element)
{
  nxml_data_t *tmp;

  if (!nxml || !name || !element)
    return NXML_ERR_DATA;

  if (data && data->type != NXML_TYPE_ELEMENT)
  {
    *element = NULL;
    return NXML_OK;
  }

  if (data)
    tmp = data->children;
  else
    tmp = nxml->data;

  while (tmp)
  {
    if (tmp->type == NXML_TYPE_ELEMENT && !strcmp (tmp->value, name))
    {
      *element = tmp;
      return NXML_OK;
    }

    tmp = tmp->next;
  }

  *element = NULL;
  return NXML_OK;
}
//---------------------------------
nxml_error_t nxml_find_attribute (nxml_data_t * data, char *name, nxml_attr_t ** attribute)
{
  nxml_attr_t *tmp;

  if (!data || !name || !attribute)
    return NXML_ERR_DATA;

  if (data->type != NXML_TYPE_ELEMENT)
  {
    *attribute = NULL;
    return NXML_OK;
  }

  tmp = data->attributes;

  while (tmp)
  {
    if (!strcmp (tmp->name, name))
    {
      *attribute = tmp;
      return NXML_OK;
    }

    tmp = tmp->next;
  }

  *attribute = NULL;
  return NXML_OK;
}
//************************************************************
// INIT FUNTION
//************************************************************
nxml_error_t
nxml_new (nxml_t ** nxml)
{
  if (!nxml)
    return NXML_ERR_DATA;

  if (!(*nxml = (nxml_t *) malloc (sizeof (nxml_t))))
    return NXML_ERR_POSIX;

  memset (*nxml, 0, sizeof (nxml_t));

  return NXML_OK;
}
//************************************************************
// ERROR FUNTION
//************************************************************
char *
nxml_strerror (nxml_error_t err)
{
  switch (err)
  {
  case NXML_OK:
    return "Success";

  case NXML_ERR_PARSER:
    return "Parser error";

  case NXML_ERR_DATA:
    return "No correct paramenter in the function";

  default:
    return strerror (errno);
  }
}
//************************************************************
// NAMESPACE FUNTION
//************************************************************
struct __nxml_data_ns_t
{
  nxml_namespace_t *ns;
  struct __nxml_data_ns_t *next;
};

static void
__nxml_namespace_free_item (nxml_data_t * e)
{
  nxml_namespace_t *ns;
  nxml_data_t *child;

  while (e->ns_list)
  {
    ns = e->ns_list->next;

    if (e->ns_list->prefix)
      free (e->ns_list->prefix);

    if (e->ns_list->ns)
      free (e->ns_list->ns);

    free (e->ns_list);

    e->ns_list = ns;
  }

  e->ns = NULL;

  child = e->children;
  while (child)
  {
    __nxml_namespace_free_item (child);
    child = child->next;
  }
}
//---------------------------------
static void
__nxml_namespace_free (nxml_t * nxml)
{
  nxml_data_t *e;

  e = nxml->data;
  while (e)
  {
    __nxml_namespace_free_item (e);

    e = e->next;
  }
}
//---------------------------------
int
__nxml_namespace_parse_add (nxml_data_t * data, char *prefix, char *namespace)
{
  nxml_namespace_t *ns;

  if (!(ns = (nxml_namespace_t *) malloc (sizeof (nxml_namespace_t))))
    return 1;
  memset (ns, 0, sizeof (nxml_namespace_t));

  if (prefix && !(ns->prefix = strdup (prefix)))
  {
    free (ns);
    return 1;
  }

  if (!(ns->ns = strdup (namespace)))
  {
    if (ns->prefix)
      free (ns->prefix);
    free (ns);
    return 1;
  }

  ns->next = data->ns_list;
  data->ns_list = ns;

  return 0;
}
//---------------------------------
static int
__nxml_namespace_find_item (nxml_t * nxml, nxml_data_t * e)
{
  nxml_data_t *child;
  nxml_attr_t *att;

  att = e->attributes;
  while (att)
  {
    if (!strcmp (att->name, "xmlns"))
    {
      if (__nxml_namespace_parse_add (e, NULL, att->value))
      {
        __nxml_namespace_free (nxml);
        return 1;
      }
    }
    else if (!strncmp (att->name, "xmlns:", 6))
    {
      if (__nxml_namespace_parse_add (e, att->name + 6, att->value))
      {
        __nxml_namespace_free (nxml);
        return 1;
      }
    }

    att = att->next;
  }

  child = e->children;
  while (child)
  {
    if (child->type == NXML_TYPE_ELEMENT)
      __nxml_namespace_find_item (nxml, child);
    child = child->next;
  }

  return 0;
}
//---------------------------------
static int
__nxml_namespace_find (nxml_t * nxml)
{
  nxml_data_t *e;

  e = nxml->data;
  while (e)
  {
    if (e->type == NXML_TYPE_ELEMENT)
      __nxml_namespace_find_item (nxml, e);
    e = e->next;
  }

  return 0;

}
//---------------------------------
static void
__nxml_namespace_associate_attribute (struct __nxml_data_ns_t *list,
                                      nxml_attr_t * e)
{
  int i;
  int len = strlen (e->name);
  int k;

  for (i = k = 0; i < len; i++)
    if (e->name[i] == ':')
    {
      k = i;
      break;
    }

    if (!k)
    {
      while (list)
      {
        if (!list->ns->prefix)
        {
          e->ns = list->ns;
          return;
        }
        list = list->next;
      }

      return;
    }

    else
    {
      while (list)
      {
        if (list->ns->prefix && !strncmp (list->ns->prefix, e->name, k))
        {
          char *a = strdup (e->name + strlen (list->ns->prefix) + 1);

          if (!a)
            return;

          free (e->name);
          e->name = a;

          e->ns = list->ns;
          return;
        }
        list = list->next;
      }
    }
}
//---------------------------------
static void
__nxml_namespace_associate_item (struct __nxml_data_ns_t *list,
                                 nxml_data_t * e)
{
  int i;
  int len;
  int k;
  nxml_attr_t *attr;

  attr = e->attributes;
  while (attr)
  {
    __nxml_namespace_associate_attribute (list, attr);
    attr = attr->next;
  }

  len = strlen (e->value);

  for (i = k = 0; i < len; i++)
    if (e->value[i] == ':')
    {
      k = i;
      break;
    }

    if (!k)
    {
      while (list)
      {
        if (!list->ns->prefix)
        {
          e->ns = list->ns;
          return;
        }
        list = list->next;
      }

      return;
    }

    else
    {
      while (list)
      {
        if (list->ns->prefix && !strncmp (list->ns->prefix, e->value, k))
        {
          char *a = strdup (e->value + strlen (list->ns->prefix) + 1);

          if (!a)
            return;

          free (e->value);
          e->value = a;

          e->ns = list->ns;
          return;
        }
        list = list->next;
      }
    }
}
//---------------------------------
static void
__nxml_namespace_associate (struct __nxml_data_ns_t **list,
                            nxml_data_t * root)
{
  nxml_data_t *e;
  nxml_namespace_t *ns;
  struct __nxml_data_ns_t *tmp, *old;

  ns = root->ns_list;
  while (ns)
  {
    if (!
      (tmp =
      (struct __nxml_data_ns_t *)
      malloc (sizeof (struct __nxml_data_ns_t))))
      return;
    memset (tmp, 0, sizeof (struct __nxml_data_ns_t));

    tmp->ns = ns;
    tmp->next = (*list);
    (*list) = tmp;

    ns = ns->next;
  }

  __nxml_namespace_associate_item (*list, root);

  e = root->children;
  while (e)
  {
    if (e->type == NXML_TYPE_ELEMENT)
      __nxml_namespace_associate (list, e);

    e = e->next;
  }

  ns = root->ns_list;
  while (ns)
  {
    tmp = *list;
    old = NULL;

    while (tmp)
    {
      if (tmp->ns == ns)
      {
        if (old)
          old->next = tmp->next;
        else
          *list = tmp->next;

        free (tmp);
        break;
      }

      old = tmp;
      tmp = tmp->next;
    }

    ns = ns->next;
  }
}
//---------------------------------
static void
__nxml_namespace_connect (nxml_t * nxml)
{
  nxml_data_t *e;
  struct __nxml_data_ns_t *list = NULL;

  e = nxml->data;
  while (e)
  {
    if (e->type == NXML_TYPE_ELEMENT)
      __nxml_namespace_associate (&list, e);

    e = e->next;
  }
}

void
__nxml_namespace_parse (nxml_t * nxml)
{
  __nxml_namespace_free (nxml);

  if (__nxml_namespace_find (nxml))
    return;

  __nxml_namespace_connect (nxml);
}

//************************************************************
// FREE FUNTION
//************************************************************

nxml_error_t
nxml_free_data (nxml_data_t * data)
{
  nxml_namespace_t *_namespace;
  nxml_attr_t *attr;
  nxml_data_t *tmp;
  void *old;

  if (!data)
    return NXML_ERR_DATA;

  if (data->value)
    free (data->value);

  _namespace = data->ns_list;
  while (_namespace)
  {
    old = _namespace;
    _namespace = _namespace->next;

    nxml_free_namespace (old);
  }

  attr = data->attributes;
  while (attr)
  {
    old = attr;
    attr = attr->next;

    nxml_free_attribute (old);
  }

  tmp = data->children;
  while (tmp)
  {
    old = tmp;
    tmp = tmp->next;

    nxml_free_data (old);
  }

  free (data);

  return NXML_OK;
}
//---------------------------------
nxml_error_t
nxml_free_attribute (nxml_attr_t * t)
{
  if (!t)
    return NXML_ERR_DATA;

  if (t->name)
    free (t->name);

  if (t->value)
    free (t->value);

  free (t);

  return NXML_OK;
}
//---------------------------------
nxml_error_t
nxml_free_namespace (nxml_namespace_t * t)
{
  if (!t)
    return NXML_ERR_DATA;

  if (t->prefix)
    free (t->prefix);

  if (t->ns)
    free (t->ns);

  free (t);

  return NXML_OK;
}
//---------------------------------
nxml_error_t
nxml_free_doctype (nxml_doctype_t * doctype)
{
  nxml_doctype_t *tmp;

  if (!doctype)
    return NXML_ERR_DATA;

  while (doctype)
  {
    nxml_empty_doctype (doctype);

    if (doctype->value)
      free (doctype->value);

    if (doctype->name)
      free (doctype->name);

    tmp = doctype;
    doctype = doctype->next;

    free (tmp);
  }

  return NXML_OK;
}
//---------------------------------
nxml_error_t
nxml_empty_doctype (nxml_doctype_t * doctype)
{
  if (!doctype)
    return NXML_ERR_DATA;

  while (doctype)