//================================
// 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_tnxml_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_tnxml_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_tnxml_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_tnxml_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_tnxml_empty_doctype (nxml_doctype_t * doctype){  if (!doctype)    return NXML_ERR_DATA;  while (doctype)