EPSIAE » eneraptor

		<Unit filename="src/mxml/config.h" />

		<Unit filename="src/mxml/mxml-attr.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-entity.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-file.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-index.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-node.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-private.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-private.h" />

		<Unit filename="src/mxml/mxml-search.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-set.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml-string.c">

			<Option compilerVar="CC" />

		</Unit>

		<Unit filename="src/mxml/mxml.h" />

/*

 * "$Id: mxml-node.c 363 2008-10-26 18:28:05Z mike $"

 *

 * Node support code for Mini-XML, a small XML-like file parsing library.

 *

 * Copyright 2003-2007 by Michael Sweet.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2, 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.

 *

 * Contents:

 *

 *   mxmlAdd()        - Add a node to a tree.

 *   mxmlDelete()     - Delete a node and all of its children.

 *   mxmlNewCDATA()   - Create a new CDATA node.

 *   mxmlNewCustom()  - Create a new custom data node.

 *   mxmlNewElement() - Create a new element node.

 *   mxmlNewInteger() - Create a new integer node.

 *   mxmlNewOpaque()  - Create a new opaque string.

 *   mxmlNewReal()    - Create a new real number node.

 *   mxmlNewText()    - Create a new text fragment node.

 *   mxmlNewTextf()   - Create a new formatted text fragment node.

 *   mxmlNewXML()     - Create a new XML document tree.

 *   mxmlRelease()    - Release a node.

 *   mxmlRemove()     - Remove a node from its parent.

 *   mxmlRetain()     - Retain a node.

 *   mxml_new()       - Create a new node.

 */

/*

 * Include necessary headers...

 */

#include "config.h"

#include "mxml.h"

/*

 * Local functions...

 */

static mxml_node_t	*mxml_new(mxml_node_t *parent, mxml_type_t type);

/*

 * 'mxmlAdd()' - Add a node to a tree.

 *

 * Adds the specified node to the parent. If the child argument is not

 * NULL, puts the new node before or after the specified child depending

 * on the value of the where argument. If the child argument is NULL,

 * puts the new node at the beginning of the child list (MXML_ADD_BEFORE)

 * or at the end of the child list (MXML_ADD_AFTER). The constant

 * MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.

 */

void

mxmlAdd(mxml_node_t *parent,		/* I - Parent node */

        int         where,		/* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */

        mxml_node_t *child,		/* I - Child node for where or MXML_ADD_TO_PARENT */

	mxml_node_t *node)		/* I - Node to add */

{

#ifdef DEBUG

  fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,

          where, child, node);

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!parent || !node)

    return;

#if DEBUG > 1

  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);

  if (parent)

  {

    fprintf(stderr, "    BEFORE: parent->child=%p\n", parent->child);

    fprintf(stderr, "    BEFORE: parent->last_child=%p\n", parent->last_child);

    fprintf(stderr, "    BEFORE: parent->prev=%p\n", parent->prev);

    fprintf(stderr, "    BEFORE: parent->next=%p\n", parent->next);

  }

#endif /* DEBUG > 1 */

 /*

  * Remove the node from any existing parent...

  */

  if (node->parent)

    mxmlRemove(node);

 /*

  * Reset pointers...

  */

  node->parent = parent;

  switch (where)

  {

    case MXML_ADD_BEFORE :

        if (!child || child == parent->child || child->parent != parent)

	{

	 /*

	  * Insert as first node under parent...

	  */

	  node->next = parent->child;

	  if (parent->child)

	    parent->child->prev = node;

	  else

	    parent->last_child = node;

	  parent->child = node;

	}

	else

	{

	 /*

	  * Insert node before this child...

	  */

	  node->next = child;

	  node->prev = child->prev;

	  if (child->prev)

	    child->prev->next = node;

	  else

	    parent->child = node;

	  child->prev = node;

	}

        break;

    case MXML_ADD_AFTER :

        if (!child || child == parent->last_child || child->parent != parent)

	{

	 /*

	  * Insert as last node under parent...

	  */

	  node->parent = parent;

	  node->prev   = parent->last_child;

	  if (parent->last_child)

	    parent->last_child->next = node;

	  else

	    parent->child = node;

	  parent->last_child = node;

        }

	else

	{

	 /*

	  * Insert node after this child...

	  */

	  node->prev = child;

	  node->next = child->next;

	  if (child->next)

	    child->next->prev = node;

	  else

	    parent->last_child = node;

	  child->next = node;

	}

        break;

  }

#if DEBUG > 1

  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);

  if (parent)

  {

    fprintf(stderr, "    AFTER: parent->child=%p\n", parent->child);

    fprintf(stderr, "    AFTER: parent->last_child=%p\n", parent->last_child);

    fprintf(stderr, "    AFTER: parent->prev=%p\n", parent->prev);

    fprintf(stderr, "    AFTER: parent->next=%p\n", parent->next);

  }

#endif /* DEBUG > 1 */

}

/*

 * 'mxmlDelete()' - Delete a node and all of its children.

 *

 * If the specified node has a parent, this function first removes the

 * node from its parent using the mxmlRemove() function.

 */

void

mxmlDelete(mxml_node_t *node)		/* I - Node to delete */

{

  int	i;				/* Looping var */

#ifdef DEBUG

  fprintf(stderr, "mxmlDelete(node=%p)\n", node);

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!node)

    return;

 /*

  * Remove the node from its parent, if any...

  */

  mxmlRemove(node);

 /*

  * Delete children...

  */

  while (node->child)

    mxmlDelete(node->child);

 /*

  * Now delete any node data...

  */

  switch (node->type)

  {

    case MXML_ELEMENT :

        if (node->value.element.name)

	  free(node->value.element.name);

	if (node->value.element.num_attrs)

	{

	  for (i = 0; i < node->value.element.num_attrs; i ++)

	  {

	    if (node->value.element.attrs[i].name)

	      free(node->value.element.attrs[i].name);

	    if (node->value.element.attrs[i].value)

	      free(node->value.element.attrs[i].value);

	  }

          free(node->value.element.attrs);

	}

        break;

    case MXML_INTEGER :

       /* Nothing to do */

        break;

    case MXML_OPAQUE :

        if (node->value.opaque)

	  free(node->value.opaque);

        break;

    case MXML_REAL :

       /* Nothing to do */

        break;

    case MXML_TEXT :

        if (node->value.text.string)

	  free(node->value.text.string);

        break;

    case MXML_CUSTOM :

        if (node->value.custom.data &&

	    node->value.custom.destroy)

	  (*(node->value.custom.destroy))(node->value.custom.data);

	break;

    default :

        break;

  }

 /*

  * Free this node...

  */

  free(node);

}

/*

 * 'mxmlNewCDATA()' - Create a new CDATA node.

 *

 * The new CDATA node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * CDATA node has no parent. The data string must be nul-terminated and

 * is copied into the new node. CDATA nodes use the MXML_ELEMENT type.

 *

 * @since Mini-XML 2.3@

 */

mxml_node_t *				/* O - New node */

mxmlNewCDATA(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

	     const char  *data)		/* I - Data string */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewCDATA(parent=%p, data=\"%s\")\n",

          parent, data ? data : "(null)");

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!data)

    return (NULL);

 /*

  * Create the node and set the name value...

  */

  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)

    node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);

  return (node);

}

/*

 * 'mxmlNewCustom()' - Create a new custom data node.

 *

 * The new custom node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * element node has no parent. NULL can be passed when the data in the

 * node is not dynamically allocated or is separately managed.

 *

 * @since Mini-XML 2.1@

 */

mxml_node_t *				/* O - New node */

mxmlNewCustom(

    mxml_node_t              *parent,	/* I - Parent node or MXML_NO_PARENT */

    void                     *data,	/* I - Pointer to data */

    mxml_custom_destroy_cb_t destroy)	/* I - Function to destroy data */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,

          data, destroy);

#endif /* DEBUG */

 /*

  * Create the node and set the value...

  */

  if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)

  {

    node->value.custom.data    = data;

    node->value.custom.destroy = destroy;

  }

  return (node);

}

/*

 * 'mxmlNewElement()' - Create a new element node.

 *

 * The new element node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * element node has no parent.

 */

mxml_node_t *				/* O - New node */

mxmlNewElement(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

               const char  *name)	/* I - Name of element */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,

          name ? name : "(null)");

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!name)

    return (NULL);

 /*

  * Create the node and set the element name...

  */

  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)

    node->value.element.name = strdup(name);

  return (node);

}

/*

 * 'mxmlNewInteger()' - Create a new integer node.

 *

 * The new integer node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * integer node has no parent.

 */

mxml_node_t *				/* O - New node */

mxmlNewInteger(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

               int         integer)	/* I - Integer value */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);

#endif /* DEBUG */

 /*

  * Create the node and set the element name...

  */

  if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)

    node->value.integer = integer;

  return (node);

}

/*

 * 'mxmlNewOpaque()' - Create a new opaque string.

 *

 * The new opaque node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * opaque node has no parent. The opaque string must be nul-terminated and

 * is copied into the new node.

 */

mxml_node_t *				/* O - New node */

mxmlNewOpaque(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

              const char  *opaque)	/* I - Opaque string */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,

          opaque ? opaque : "(null)");

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!opaque)

    return (NULL);

 /*

  * Create the node and set the element name...

  */

  if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)

    node->value.opaque = strdup(opaque);

  return (node);

}

/*

 * 'mxmlNewReal()' - Create a new real number node.

 *

 * The new real number node is added to the end of the specified parent's

 * child list. The constant MXML_NO_PARENT can be used to specify that

 * the new real number node has no parent.

 */

mxml_node_t *				/* O - New node */

mxmlNewReal(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

            double      real)		/* I - Real number value */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);

#endif /* DEBUG */

 /*

  * Create the node and set the element name...

  */

  if ((node = mxml_new(parent, MXML_REAL)) != NULL)

    node->value.real = real;

  return (node);

}

/*

 * 'mxmlNewText()' - Create a new text fragment node.

 *

 * The new text node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * text node has no parent. The whitespace parameter is used to specify

 * whether leading whitespace is present before the node. The text

 * string must be nul-terminated and is copied into the new node.  

 */

mxml_node_t *				/* O - New node */

mxmlNewText(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

            int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */

	    const char  *string)	/* I - String */

{

  mxml_node_t	*node;			/* New node */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",

          parent, whitespace, string ? string : "(null)");

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!string)

    return (NULL);

 /*

  * Create the node and set the text value...

  */

  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)

  {

    node->value.text.whitespace = whitespace;

    node->value.text.string     = strdup(string);

  }

  return (node);

}

/*

 * 'mxmlNewTextf()' - Create a new formatted text fragment node.

 *

 * The new text node is added to the end of the specified parent's child

 * list. The constant MXML_NO_PARENT can be used to specify that the new

 * text node has no parent. The whitespace parameter is used to specify

 * whether leading whitespace is present before the node. The format

 * string must be nul-terminated and is formatted into the new node.  

 */

mxml_node_t *				/* O - New node */

mxmlNewTextf(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */

             int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */

	     const char  *format,	/* I - Printf-style frmat string */

	     ...)			/* I - Additional args as needed */

{

  mxml_node_t	*node;			/* New node */

  va_list	ap;			/* Pointer to arguments */

#ifdef DEBUG

  fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",

          parent, whitespace, format ? format : "(null)");

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!format)

    return (NULL);

 /*

  * Create the node and set the text value...

  */

  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)

  {

    va_start(ap, format);

    node->value.text.whitespace = whitespace;

    node->value.text.string     = _mxml_vstrdupf(format, ap);

    va_end(ap);

  }

  return (node);

}

/*

 * 'mxmlRemove()' - Remove a node from its parent.

 *

 * Does not free memory used by the node - use mxmlDelete() for that.

 * This function does nothing if the node has no parent.

 */

void

mxmlRemove(mxml_node_t *node)		/* I - Node to remove */

{

#ifdef DEBUG

  fprintf(stderr, "mxmlRemove(node=%p)\n", node);

#endif /* DEBUG */

 /*

  * Range check input...

  */

  if (!node || !node->parent)

    return;

 /*

  * Remove from parent...

  */

#if DEBUG > 1

  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);

  if (node->parent)

  {

    fprintf(stderr, "    BEFORE: node->parent->child=%p\n", node->parent->child);

    fprintf(stderr, "    BEFORE: node->parent->last_child=%p\n", node->parent->last_child);

  }

  fprintf(stderr, "    BEFORE: node->child=%p\n", node->child);

  fprintf(stderr, "    BEFORE: node->last_child=%p\n", node->last_child);

  fprintf(stderr, "    BEFORE: node->prev=%p\n", node->prev);

  fprintf(stderr, "    BEFORE: node->next=%p\n", node->next);

#endif /* DEBUG > 1 */

  if (node->prev)

    node->prev->next = node->next;

  else

    node->parent->child = node->next;

  if (node->next)

    node->next->prev = node->prev;

  else

    node->parent->last_child = node->prev;

  node->parent = NULL;

  node->prev   = NULL;

  node->next   = NULL;

#if DEBUG > 1

  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);

  if (node->parent)

  {

    fprintf(stderr, "    AFTER: node->parent->child=%p\n", node->parent->child);

    fprintf(stderr, "    AFTER: node->parent->last_child=%p\n", node->parent->last_child);

  }

  fprintf(stderr, "    AFTER: node->child=%p\n", node->child);

  fprintf(stderr, "    AFTER: node->last_child=%p\n", node->last_child);

  fprintf(stderr, "    AFTER: node->prev=%p\n", node->prev);

  fprintf(stderr, "    AFTER: node->next=%p\n", node->next);

#endif /* DEBUG > 1 */

}

/*

 * 'mxmlNewXML()' - Create a new XML document tree.

 *

 * The "version" argument specifies the version number to put in the

 * ?xml element node. If NULL, version 1.0 is assumed.

 *

 * @since Mini-XML 2.3@

 */

mxml_node_t *				/* O - New ?xml node */

mxmlNewXML(const char *version)		/* I - Version number to use */

{

  char	element[1024];			/* Element text */

  snprintf(element, sizeof(element), "?xml version=\"%s\" encoding=\"utf-8\"?",

           version ? version : "1.0");

  return (mxmlNewElement(NULL, element));

}

/*

 * 'mxmlRelease()' - Release a node.

 *

 * When the reference count reaches zero, the node (and any children)

 * is deleted via mxmlDelete().

 *

 * @since Mini-XML 2.3@

 */

int					/* O - New reference count */

mxmlRelease(mxml_node_t *node)		/* I - Node */

{

  if (node)

  {

    if ((-- node->ref_count) <= 0)

    {

      mxmlDelete(node);

      return (0);

    }

    else

      return (node->ref_count);

  }

  else

    return (-1);

}

/*

 * 'mxmlRetain()' - Retain a node.

 *

 * @since Mini-XML 2.3@

 */

int					/* O - New reference count */

mxmlRetain(mxml_node_t *node)		/* I - Node */

{

  if (node)

    return (++ node->ref_count);

  else

    return (-1);

}

/*

 * 'mxml_new()' - Create a new node.

 */

static mxml_node_t *			/* O - New node */

mxml_new(mxml_node_t *parent,		/* I - Parent node */

         mxml_type_t type)		/* I - Node type */

{

  mxml_node_t	*node;			/* New node */

#if DEBUG > 1

  fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);

#endif /* DEBUG > 1 */

 /*

  * Allocate memory for the node...

  */

  if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)

  {

#if DEBUG > 1

    fputs("    returning NULL\n", stderr);

#endif /* DEBUG > 1 */

    return (NULL);

  }

#if DEBUG > 1

  fprintf(stderr, "    returning %p\n", node);

#endif /* DEBUG > 1 */

 /*

  * Set the node type...

  */

  node->type      = type;

  node->ref_count = 1;

 /*

  * Add to the parent if present...

  */

  if (parent)

    mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);

 /*

  * Return the new node...

  */

  return (node);

}

/*

 * End of "$Id: mxml-node.c 363 2008-10-26 18:28:05Z mike $".

 */

/*

 * "$Id: mxml-search.c 297 2007-09-09 07:16:52Z mike $"

 *

 * Search/navigation functions for Mini-XML, a small XML-like file

 * parsing library.

 *

 * Copyright 2003-2007 by Michael Sweet.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2, 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.

 *

 * Contents:

 *

 *   mxmlFindElement() - Find the named element.

 *   mxmlWalkNext()    - Walk to the next logical node in the tree.

 *   mxmlWalkPrev()    - Walk to the previous logical node in the tree.

 */

/*

 * Include necessary headers...

 */

#include "config.h"

#include "mxml.h"

/*

 * 'mxmlFindElement()' - Find the named element.

 *

 * The search is constrained by the name, attribute name, and value; any

 * NULL names or values are treated as wildcards, so different kinds of

 * searches can be implemented by looking for all elements of a given name

 * or all elements with a specific attribute. The descend argument determines

 * whether the search descends into child nodes; normally you will use

 * MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find

 * additional direct descendents of the node. The top node argument

 * constrains the search to a particular node's children.

 */

mxml_node_t *				/* O - Element node or NULL */

mxmlFindElement(mxml_node_t *node,	/* I - Current node */

                mxml_node_t *top,	/* I - Top node */

                const char  *name,	/* I - Element name or NULL for any */

		const char  *attr,	/* I - Attribute name, or NULL for none */

		const char  *value,	/* I - Attribute value, or NULL for any */

		int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */

{

  const char	*temp;			/* Current attribute value */

 /*

  * Range check input...

  */

  if (!node || !top || (!attr && value))

    return (NULL);

 /*

  * Start with the next node...

  */

  node = mxmlWalkNext(node, top, descend);

 /*

  * Loop until we find a matching element...

  */

  while (node != NULL)

  {

   /*

    * See if this node matches...

    */

    if (node->type == MXML_ELEMENT &&

        node->value.element.name &&

	(!name || !strcmp(node->value.element.name, name)))

    {

     /*

      * See if we need to check for an attribute...

      */

      if (!attr)

        return (node);			/* No attribute search, return it... */

     /*

      * Check for the attribute...

      */

      if ((temp = mxmlElementGetAttr(node, attr)) != NULL)

      {

       /*

        * OK, we have the attribute, does it match?

	*/

	if (!value || !strcmp(value, temp))

	  return (node);		/* Yes, return it... */

      }

    }

   /*

    * No match, move on to the next node...

    */

    if (descend == MXML_DESCEND)

      node = mxmlWalkNext(node, top, MXML_DESCEND);

    else

      node = node->next;

  }

  return (NULL);

}

/*

 * 'mxmlWalkNext()' - Walk to the next logical node in the tree.

 *

 * The descend argument controls whether the first child is considered

 * to be the next node. The top node argument constrains the walk to

 * the node's children.

 */

mxml_node_t *				/* O - Next node or NULL */

mxmlWalkNext(mxml_node_t *node,		/* I - Current node */

             mxml_node_t *top,		/* I - Top node */

             int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */

{

  if (!node)

    return (NULL);

  else if (node->child && descend)

    return (node->child);

  else if (node == top)

    return (NULL);

  else if (node->next)

    return (node->next);

  else if (node->parent && node->parent != top)

  {

    node = node->parent;

    while (!node->next)

      if (node->parent == top || !node->parent)

        return (NULL);

      else

        node = node->parent;

    return (node->next);

  }

  else

    return (NULL);

}

/*

 * 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.

 *

 * The descend argument controls whether the previous node's last child

 * is considered to be the previous node. The top node argument constrains

 * the walk to the node's children.

 */

mxml_node_t *				/* O - Previous node or NULL */

mxmlWalkPrev(mxml_node_t *node,		/* I - Current node */

             mxml_node_t *top,		/* I - Top node */

             int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */

{

  if (!node || node == top)

    return (NULL);

  else if (node->prev)

  {

    if (node->prev->last_child && descend)

    {

     /*

      * Find the last child under the previous node...

      */

      node = node->prev->last_child;

      while (node->last_child)

        node = node->last_child;

      return (node);

    }

    else

      return (node->prev);

  }

  else if (node->parent != top)

    return (node->parent);

  else

    return (NULL);

}

/*

 * End of "$Id: mxml-search.c 297 2007-09-09 07:16:52Z mike $".

 */

/*

 * "$Id: mxml-string.c 387 2009-04-18 17:05:52Z mike $"

 *

 * String functions for Mini-XML, a small XML-like file parsing library.

 *

 * Copyright 2003-2009 by Michael Sweet.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2, 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.

 *

 * Contents:

 *

 *   _mxml_snprintf()  - Format a string.

 *   _mxml_strdup()    - Duplicate a string.

 *   _mxml_strdupf()   - Format and duplicate a string.

 *   _mxml_vsnprintf() - Format a string into a fixed size buffer.

 *   _mxml_vstrdupf()  - Format and duplicate a string.

 */

/*

 * Include necessary headers...

 */

#include "config.h"

#ifndef HAVE_SNPRINTF

/*

 * '_mxml_snprintf()' - Format a string.

 */

int					/* O - Number of bytes formatted */

_mxml_snprintf(char       *buffer,	/* I - Output buffer */

               size_t     bufsize,	/* I - Size of output buffer */

	       const char *format,	/* I - Printf-style format string */

	       ...)			/* I - Additional arguments as needed */

{

  va_list	ap;			/* Argument list */

  int		bytes;			/* Number of bytes formatted */

  va_start(ap, format);

  bytes = vsnprintf(buffer, bufsize, format, ap);

  va_end(ap);

  return (bytes);

}

#endif /* !HAVE_SNPRINTF */

/*

 * '_mxml_strdup()' - Duplicate a string.

 */

#ifndef HAVE_STRDUP

char 	*				/* O - New string pointer */

_mxml_strdup(const char *s)		/* I - String to duplicate */

{

  char	*t;				/* New string pointer */

  if (s == NULL)

    return (NULL);

  if ((t = malloc(strlen(s) + 1)) == NULL)

    return (NULL);

  return (strcpy(t, s));

}

#endif /* !HAVE_STRDUP */

/*

 * '_mxml_strdupf()' - Format and duplicate a string.

 */

char *					/* O - New string pointer */

_mxml_strdupf(const char *format,	/* I - Printf-style format string */

              ...)			/* I - Additional arguments as needed */

{

  va_list	ap;			/* Pointer to additional arguments */

  char		*s;			/* Pointer to formatted string */

 /*

  * Get a pointer to the additional arguments, format the string,

  * and return it...

  */

  va_start(ap, format);

  s = _mxml_vstrdupf(format, ap);

  va_end(ap);

  return (s);

}

#ifndef HAVE_VSNPRINTF

/*

 * '_mxml_vsnprintf()' - Format a string into a fixed size buffer.

 */

int					/* O - Number of bytes formatted */

_mxml_vsnprintf(char       *buffer,	/* O - Output buffer */

                size_t     bufsize,	/* O - Size of output buffer */

		const char *format,	/* I - Printf-style format string */

 		va_list    ap)		/* I - Pointer to additional arguments */

{

  char		*bufptr,		/* Pointer to position in buffer */

		*bufend,		/* Pointer to end of buffer */

		sign,			/* Sign of format width */

		size,			/* Size character (h, l, L) */

		type;			/* Format type character */

  int		width,			/* Width of field */

		prec;			/* Number of characters of precision */

  char		tformat[100],		/* Temporary format string for sprintf() */

		*tptr,			/* Pointer into temporary format */

		temp[1024];		/* Buffer for formatted numbers */

  char		*s;			/* Pointer to string */

  int		slen;			/* Length of string */

  int		bytes;			/* Total number of bytes needed */

 /*

  * Loop through the format string, formatting as needed...

  */

  bufptr = buffer;

  bufend = buffer + bufsize - 1;

  bytes  = 0;

  while (*format)

  {

    if (*format == '%')

    {

      tptr = tformat;

      *tptr++ = *format++;

      if (*format == '%')

      {

        if (bufptr && bufptr < bufend) *bufptr++ = *format;

        bytes ++;

        format ++;

	continue;

      }

      else if (strchr(" -+#\'", *format))

      {

        *tptr++ = *format;

        sign = *format++;

      }

      else

        sign = 0;

      if (*format == '*')

      {

       /*

        * Get width from argument...

	*/

	format ++;

	width = va_arg(ap, int);

	snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", width);

	tptr += strlen(tptr);

      }

      else

      {

	width = 0;

	while (isdigit(*format & 255))

	{

	  if (tptr < (tformat + sizeof(tformat) - 1))

	    *tptr++ = *format;

	  width = width * 10 + *format++ - '0';

	}

      }

      if (*format == '.')

      {

	if (tptr < (tformat + sizeof(tformat) - 1))

	  *tptr++ = *format;

        format ++;

        if (*format == '*')

	{

         /*

	  * Get precision from argument...

	  */

	  format ++;

	  prec = va_arg(ap, int);

	  snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", prec);

	  tptr += strlen(tptr);

	}

	else

	{

	  prec = 0;

	  while (isdigit(*format & 255))

	  {

	    if (tptr < (tformat + sizeof(tformat) - 1))

	      *tptr++ = *format;

	    prec = prec * 10 + *format++ - '0';

	  }

	}

      }

      else

        prec = -1;

      if (*format == 'l' && format[1] == 'l')

      {

        size = 'L';

	if (tptr < (tformat + sizeof(tformat) - 2))

	{

	  *tptr++ = 'l';

	  *tptr++ = 'l';

	}

	format += 2;

      }

      else if (*format == 'h' || *format == 'l' || *format == 'L')

      {

	if (tptr < (tformat + sizeof(tformat) - 1))

	  *tptr++ = *format;

        size = *format++;

      }

      if (!*format)

        break;

      if (tptr < (tformat + sizeof(tformat) - 1))

        *tptr++ = *format;

      type  = *format++;

      *tptr = '\0';

      switch (type)

      {

	case 'E' : /* Floating point formats */

	case 'G' :

	case 'e' :

	case 'f' :

	case 'g' :

	    if ((width + 2) > sizeof(temp))

	      break;

	    sprintf(temp, tformat, va_arg(ap, double));

            bytes += strlen(temp);

            if (bufptr)

	    {

	      if ((bufptr + strlen(temp)) > bufend)

	      {

		strncpy(bufptr, temp, (size_t)(bufend - bufptr));

		bufptr = bufend;

	      }

	      else

	      {

		strcpy(bufptr, temp);

		bufptr += strlen(temp);

	      }

	    }

	    break;

        case 'B' : /* Integer formats */

	case 'X' :

	case 'b' :

        case 'd' :

	case 'i' :

	case 'o' :

	case 'u' :

	case 'x' :

	    if ((width + 2) > sizeof(temp))

	      break;

#ifdef HAVE_LONG_LONG

	    if (size == 'L')

	      sprintf(temp, tformat, va_arg(ap, long long));

	    else

#endif /* HAVE_LONG_LONG */

	    sprintf(temp, tformat, va_arg(ap, int));

            bytes += strlen(temp);

	    if (bufptr)

	    {

	      if ((bufptr + strlen(temp)) > bufend)

	      {

		strncpy(bufptr, temp, (size_t)(bufend - bufptr));

		bufptr = bufend;

	      }

	      else

	      {

		strcpy(bufptr, temp);

		bufptr += strlen(temp);

	      }

	    }

	    break;

	case 'p' : /* Pointer value */

	    if ((width + 2) > sizeof(temp))

	      break;

	    sprintf(temp, tformat, va_arg(ap, void *));

            bytes += strlen(temp);

	    if (bufptr)

	    {

	      if ((bufptr + strlen(temp)) > bufend)

	      {

		strncpy(bufptr, temp, (size_t)(bufend - bufptr));

		bufptr = bufend;

	      }

	      else

	      {

		strcpy(bufptr, temp);

		bufptr += strlen(temp);

	      }

	    }

	    break;

        case 'c' : /* Character or character array */

	    bytes += width;

	    if (bufptr)

	    {

	      if (width <= 1)

	        *bufptr++ = va_arg(ap, int);

	      else

	      {

		if ((bufptr + width) > bufend)

		  width = bufend - bufptr;

		memcpy(bufptr, va_arg(ap, char *), (size_t)width);

		bufptr += width;

	      }

	    }

	    break;

	case 's' : /* String */

	    if ((s = va_arg(ap, char *)) == NULL)

	      s = "(null)";

	    slen = strlen(s);

	    if (slen > width && prec != width)

	      width = slen;

            bytes += width;

	    if (bufptr)

	    {

	      if ((bufptr + width) > bufend)

	        width = bufend - bufptr;

              if (slen > width)

	        slen = width;

	      if (sign == '-')

	      {

		strncpy(bufptr, s, (size_t)slen);

		memset(bufptr + slen, ' ', (size_t)(width - slen));

	      }

	      else

	      {

		memset(bufptr, ' ', (size_t)(width - slen));

		strncpy(bufptr + width - slen, s, (size_t)slen);

	      }

	      bufptr += width;

	    }

	    break;

	case 'n' : /* Output number of chars so far */

	    *(va_arg(ap, int *)) = bytes;

	    break;

      }

    }

    else

    {

      bytes ++;

      if (bufptr && bufptr < bufend)

        *bufptr++ = *format;

      format ++;

    }

  }

 /*

  * Nul-terminate the string and return the number of characters needed.

  */

  *bufptr = '\0';

  return (bytes);

}

#endif /* !HAVE_VSNPRINTF */

/*

 * '_mxml_vstrdupf()' - Format and duplicate a string.

 */

char *					/* O - New string pointer */

_mxml_vstrdupf(const char *format,	/* I - Printf-style format string */

               va_list    ap)		/* I - Pointer to additional arguments */

{

  int	bytes;				/* Number of bytes required */

  char	*buffer,			/* String buffer */

	temp[256];			/* Small buffer for first vsnprintf */

 /*

  * First format with a tiny buffer; this will tell us how many bytes are

  * needed...

  */

  bytes = vsnprintf(temp, sizeof(temp), format, ap);

  if (bytes < sizeof(temp))

  {

   /*

    * Hey, the formatted string fits in the tiny buffer, so just dup that...

    */

    return (strdup(temp));

  }

 /*

  * Allocate memory for the whole thing and reformat to the new, larger

  * buffer...

  */

  if ((buffer = calloc(1, bytes + 1)) != NULL)

    vsnprintf(buffer, bytes + 1, format, ap);

 /*

  * Return the new string...

  */

  return (buffer);