+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

pug Namespace Reference

Classes
struct	t_xml_attribute_struct
struct	t_xml_node_struct
class	pointer_array
class	indent_stack
class	xml_iterator
class	xml_tree_walker
class	xml_attribute
class	forward_class
class	xml_node
class	xml_parser
class	xml_node_list
Typedefs
typedef char	TCHAR
typedef char	_TCHAR
typedef pug::t_xml_attribute_struct	xml_attribute_struct
typedef enum pug::t_xml_node_type	xml_node_type
typedef pug::t_xml_node_struct	xml_node_struct
Enumerations
enum	t_xml_node_type {   node_null, node_document, node_element, node_pcdata,   node_cdata, node_comment, node_pi, node_include,   node_doctype, node_dtd_entity, node_dtd_attlist, node_dtd_element,   node_dtd_notation }
Functions
static unsigned long	lib_variant ()
static unsigned long	lib_version ()
static bool	strcatgrow (TCHAR **lhs, const TCHAR *rhs)
static bool	chartype_symbol (TCHAR c)
static bool	chartype_space (TCHAR c)
static bool	chartype_enter (TCHAR c)
static bool	chartype_leave (TCHAR c)
static bool	chartype_close (TCHAR c)
static bool	chartype_equals (TCHAR c)
static bool	chartype_special (TCHAR c)
static bool	chartype_pi (TCHAR c)
static bool	chartype_dash (TCHAR c)
static bool	chartype_quote (TCHAR c)
static bool	chartype_lbracket (TCHAR c)
static bool	chartype_rbracket (TCHAR c)
static bool	strwtrim (TCHAR **s)
static bool	strwnorm (TCHAR **s)
static bool	strcpyinsitu (TCHAR **dest, const TCHAR *src, bool *insitu)
int	strcmpwild_cset (const TCHAR **src, const TCHAR **dst)
int	strcmpwild_impl (const TCHAR *src, const TCHAR *dst)
int	strcmpwild_astr (const TCHAR **src, const TCHAR **dst)
int	strcmpwild (const TCHAR *src, const TCHAR *dst)
static xml_attribute_struct *	new_attribute (void)
static xml_node_struct *	new_node (xml_node_type type=node_element)
static xml_node_struct *	append_node (xml_node_struct *parent, const int grow, const xml_node_type type=node_element, xml_node_struct *xns_child=NULL)
static xml_attribute_struct *	append_attribute (xml_node_struct *node, long grow)
static void	free_node (xml_node_struct *node)
static void	free_node_recursive (xml_node_struct *root)
static bool	load_file (const TCHAR *path, TCHAR **buffer, unsigned long *size, unsigned long tempsize=4096)
static void	outer_xml (std::ostream &os, indent_stack &indent, xml_node_struct *node, bool breaks=true)
Variables
static const unsigned long	parse_grow = 4
static const unsigned long	parse_minimal = 0x00000000
static const unsigned long	parse_pi = 0x00000002
static const unsigned long	parse_doctype = 0x00000004
static const unsigned long	parse_comments = 0x00000008
static const unsigned long	parse_cdata = 0x00000010
static const unsigned long	parse_escapes = 0x00000020
static const unsigned long	parse_trim_pcdata = 0x00000040
static const unsigned long	parse_trim_attribute = 0x00000080
static const unsigned long	parse_trim_cdata = 0x00000100
static const unsigned long	parse_trim_entity = 0x00000200
static const unsigned long	parse_trim_doctype = 0x00000400
static const unsigned long	parse_trim_comment = 0x00000800
static const unsigned long	parse_wnorm = 0x00001000
static const unsigned long	parse_dtd = 0x00002000
static const unsigned long	parse_dtd_only = 0x00004000
static const unsigned long	parse_default = 0x0000FFFF
static const unsigned long	parse_noset = 0x80000000

---

Typedef Documentation

typedef char pug::_TCHAR

Definition at line 152 of file pugxml.h.

typedef char pug::TCHAR

Definition at line 151 of file pugxml.h.

typedef struct pug::t_xml_attribute_struct pug::xml_attribute_struct

typedef struct pug::t_xml_node_struct pug::xml_node_struct

typedef enum pug::t_xml_node_type pug::xml_node_type

---

Enumeration Type Documentation

enum pug::t_xml_node_type

Enumerator:

node_null
node_document
node_element
node_pcdata
node_cdata
node_comment
node_pi
node_include
node_doctype
node_dtd_entity
node_dtd_attlist
node_dtd_element
node_dtd_notation

Definition at line 216 of file pugxml.h.

    {
      node_null,        //An undifferentiated entity.
      node_document,    //A document tree's absolute root.
      node_element,     //E.g. '<...>'
      node_pcdata,      //E.g. '>...<'
      node_cdata,       //E.g. '<![CDATA[...]]>'
      node_comment,     //E.g. '<!--...-->'
      node_pi,          //E.g. '<?...?>'
      node_include,     //E.g. '<![INCLUDE[...]]>'
      node_doctype,     //E.g. '<!DOCTYPE ...>'.
      node_dtd_entity,  //E.g. '<!ENTITY ...>'.
      node_dtd_attlist, //E.g. '<!ATTLIST ...>'.
      node_dtd_element, //E.g. '<!ELEMENT ...>'.
      node_dtd_notation //E.g. '<!NOTATION ...>'.
    } xml_node_type;

---

Function Documentation

static xml_attribute_struct* pug::append_attribute	(	xml_node_struct *	node,
		long	grow
	)			[inline, static]

Definition at line 784 of file pugxml.h.

References pug::t_xml_node_struct::attribute, pug::t_xml_node_struct::attribute_space, pug::t_xml_node_struct::attributes, and new_attribute().

Referenced by pug::xml_node::append_attribute(), pug::xml_node::attribute(), and pug::xml_parser::parse().

    {
      if(!node) return NULL;
      xml_attribute_struct* a = new_attribute();
      if(!a) return NULL;
      if(node->attributes == node->attribute_space) //Out of space, so grow.
        {
          xml_attribute_struct** t = 
            (xml_attribute_struct**)realloc(node->attribute,
                                            sizeof(xml_node_struct*)*(node->attribute_space+grow));
          if(t)
            {
              node->attribute = t;
              node->attribute_space += grow;
            }
        }
      node->attribute[node->attributes] = a;
      node->attributes++;
      return a;
    }

Here is the call graph for this function:

static xml_node_struct* pug::append_node	(	xml_node_struct *	parent,
		const int	grow,
		const xml_node_type	type = node_element,
		xml_node_struct *	xns_child = NULL
	)			[inline, static]

Definition at line 747 of file pugxml.h.

References pug::t_xml_node_struct::child, pug::t_xml_node_struct::child_space, pug::t_xml_node_struct::children, new_node(), and pug::t_xml_node_struct::parent.

Referenced by pug::xml_node::append_child(), pug::xml_node::insert_child(), and pug::xml_parser::parse().

    {
      if(!parent)
        return NULL; //Must have a parent.

      if(parent->children == parent->child_space) //Out of pointer space.
        {
          //Grow pointer space.
          xml_node_struct** t = 
            (xml_node_struct**)realloc(parent->child, 
                                       sizeof(xml_node_struct*)*(parent->child_space+grow)); 
          if(t) //Reallocation succeeded.
            {
              parent->child = t;
              parent->child_space += grow; //Update the available space.
            }
          else  // NF 26 Jun 2003
            {
              assert( t );
              return NULL;
            }
        }
      xml_node_struct* child = xns_child != NULL ? xns_child : new_node( type ); //Allocate a new child.
      child->parent = parent; //Set it's parent pointer.
      parent->child[parent->children] = child; //Set the parent's child pointer.
      parent->children++; //One more child.
      return child;
    }

Here is the call graph for this function:

static bool pug::chartype_close

(

TCHAR

c

)

[inline, static]

Definition at line 355 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('/')); }

static bool pug::chartype_dash

(

TCHAR

c

)

[inline, static]

Definition at line 363 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('-')); }

static bool pug::chartype_enter

(

TCHAR

c

)

[inline, static]

Definition at line 351 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('<')); }

static bool pug::chartype_equals

(

TCHAR

c

)

[inline, static]

Definition at line 357 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('=')); }

static bool pug::chartype_lbracket

(

TCHAR

c

)

[inline, static]

Definition at line 367 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('[')); }

static bool pug::chartype_leave

(

TCHAR

c

)

[inline, static]

Definition at line 353 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('>')); }

static bool pug::chartype_pi

(

TCHAR

c

)

[inline, static]

Definition at line 361 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('?')); }

static bool pug::chartype_quote

(

TCHAR

c

)

[inline, static]

Definition at line 365 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('"')||c==_T('\'')); }

static bool pug::chartype_rbracket

(

TCHAR

c

)

[inline, static]

Definition at line 369 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T(']')); }

static bool pug::chartype_space

(

TCHAR

c

)

[inline, static]

Definition at line 349 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c>0 && c<_T('!')); }

static bool pug::chartype_special

(

TCHAR

c

)

[inline, static]

Definition at line 359 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    { return (c==_T('!')); }

static bool pug::chartype_symbol

(

TCHAR

c

)

[inline, static]

Definition at line 347 of file pugxml.h.

References _istalnum, and _T.

Referenced by pug::xml_parser::parse().

                                                                                           :', -or- '-', -or- '.'.
    { return (_istalnum(c)||c==_T('_')||c==_T(':')||c==_T('-')||c==_T('.')); }

static void pug::free_node

(

xml_node_struct *

node

)

[inline, static]

Definition at line 813 of file pugxml.h.

References pug::t_xml_node_struct::attributes, pug::t_xml_node_struct::child, and pug::t_xml_node_struct::children.

Referenced by pug::xml_parser::clear(), pug::xml_node::remove_child(), and pug::xml_parser::~xml_parser().

    {
      if(!node) return;

      /* register */ xml_node_struct* cursor = node;

      //Free all children of children.
      do
        {
        LOC_STEP_INTO:
          //Free each child in turn; 'children' keeps count while we jump around.
          for(; cursor->children>0; --cursor->children) 
            {
              /* register */ xml_node_struct* t = cursor->child[cursor->children-1]; //Take a pointer to the child.
              if(t && t->children) //If the child has children.
                {
                  cursor = t; //Step in.
                  goto LOC_STEP_INTO; //Step into this node.
                }
              else if(t)
                {
                  if(t->attributes) //Child has attributes.
                    {
                      /* register */ unsigned int n = t->attributes; //Free each attribute.
                      for(/* register */ unsigned int i=0; i<n; ++i)
                        {
                          if(t->attribute[i]->name && !t->attribute[i]->name_insitu)
                            free(t->attribute[i]->name);
                          if(t->attribute[i]->value && !t->attribute[i]->value_insitu)
                            free(t->attribute[i]->value);
                          free(t->attribute[i]);
                        }
                    }
                  if(t->attribute) free(t->attribute); //Free attribute pointer space.
                  if(t->child) free(t->child); //Free child pointer space.
                  if(t->name && !t->name_insitu) free(t->name);
                  if(t->value && !t->value_insitu) free(t->value);
                  free(t); //Free the child node.
                }
            }
          cursor = cursor->parent; //Step out.
        }
      while(cursor->children); //While there are children.
      //Finally, free the root's children & the root itself.
      if(cursor->attributes)
        {
          /* register */ unsigned int n = cursor->attributes;
          for(/* register */ unsigned int i=0; i<n; ++i)
            {
              if(cursor->attribute[i]->name && !cursor->attribute[i]->name_insitu)
                free(cursor->attribute[i]->name);
              if(cursor->attribute[i]->value && !cursor->attribute[i]->value_insitu)
                free(cursor->attribute[i]->value);
              free(cursor->attribute[i]);
            }
        }
      if(cursor->attribute) free(cursor->attribute); //Free attribute pointer space.
      if(cursor->child) free(cursor->child); //Free child pointer space.
      if(cursor->name && !cursor->name_insitu) free(cursor->name); //Free name & data.
      if(cursor->value && !cursor->value_insitu) free(cursor->value);
      free(cursor); //Free the root itself.
    }

static void pug::free_node_recursive

(

xml_node_struct *

root

)

[inline, static]

Definition at line 879 of file pugxml.h.

References pug::t_xml_node_struct::attribute, pug::t_xml_node_struct::attributes, pug::t_xml_node_struct::child, pug::t_xml_node_struct::children, pug::t_xml_node_struct::name, pug::t_xml_attribute_struct::name, pug::t_xml_node_struct::name_insitu, pug::t_xml_attribute_struct::name_insitu, pug::t_xml_node_struct::value, pug::t_xml_attribute_struct::value, pug::t_xml_node_struct::value_insitu, and pug::t_xml_attribute_struct::value_insitu.

    {
      if(root)
        {
          unsigned int n = root->attributes;
          /* register */ unsigned int i;
          for(i=0; i<n; i++)
            {
              if(root->attribute[i]->name && !root->attribute[i]->name_insitu)
                free(root->attribute[i]->name);
              if(root->attribute[i]->value && !root->attribute[i]->value_insitu)
                free(root->attribute[i]->value);
              free(root->attribute[i]);
            }
          free(root->attribute);
          n = root->children;
          for(i=0; i<n; i++)
            free_node_recursive(root->child[i]);
          free(root->child);
          if(root->name && !root->name_insitu) free(root->name);
          if(root->value && !root->value_insitu) free(root->value);
          free(root);
        }
    }

static unsigned long pug::lib_variant

(

)

[inline, static]

Definition at line 181 of file pugxml.h.

References PUGAPI_INTERNAL_VARIANT.

{ return PUGAPI_INTERNAL_VARIANT; }

static unsigned long pug::lib_version

(

)

[inline, static]

Definition at line 185 of file pugxml.h.

References PUGAPI_INTERNAL_VERSION.

{ return PUGAPI_INTERNAL_VERSION; }

static bool pug::load_file	(	const TCHAR *	path,
		TCHAR **	buffer,
		unsigned long *	size,
		unsigned long	tempsize = 4096
	)			[inline, static]

Definition at line 930 of file pugxml.h.

References strcatgrow().

Referenced by pug::xml_parser::parse_file().

    {
      if(!path || !buffer || !size) return false;
      *size = 0;
      *buffer = 0;
#ifdef WIN32
      HANDLE file_handle = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL,
                                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
      if(file_handle == INVALID_HANDLE_VALUE) return false;
      TCHAR* temp = (TCHAR*) malloc(sizeof(TCHAR)*tempsize);
      if(!temp) return false;
      unsigned long read_bytes = 0;
      ZeroMemory(temp,sizeof(TCHAR)*tempsize);
      while(ReadFile(file_handle,(void*)temp,tempsize-sizeof(TCHAR),&read_bytes,0) && 
            read_bytes && strcatgrow(buffer,temp)) {
        *size += read_bytes;
        ZeroMemory(temp,sizeof(TCHAR)*tempsize);
      }
      CloseHandle(file_handle);
#else
      FILE* fname = fopen(path, "r");
      if(fname == NULL) return false;

      clearerr(fname);
      TCHAR* temp = (TCHAR*) malloc(sizeof(TCHAR)*tempsize);
      if(!temp) return false;
      // HARI unsigned long read_bytes = 0;
      bzero(temp, sizeof(TCHAR)*tempsize);
      size_t read_items = 0;
      while(!feof(fname) && !ferror(fname)) {
        read_items = fread((void*) temp, sizeof(TCHAR), tempsize-sizeof(TCHAR), fname);
        if(read_items > 0 && !ferror(fname)) {
          strcatgrow(buffer, temp);
          *size += read_items;
          bzero(temp, sizeof(TCHAR)*tempsize);
        }
      }
      fclose(fname);    
#endif
      free(temp);
      return (*size) ? true : false;
    }

Here is the call graph for this function:

static xml_attribute_struct* pug::new_attribute

(

void

)

[inline, static]

Definition at line 678 of file pugxml.h.

References pug::t_xml_attribute_struct::name, pug::t_xml_attribute_struct::name_insitu, pug::t_xml_attribute_struct::value, and pug::t_xml_attribute_struct::value_insitu.

Referenced by append_attribute().

    {
      //Allocate one attribute.
      xml_attribute_struct* p = (xml_attribute_struct*)malloc(sizeof(xml_attribute_struct)); 
      if(p) //If allocation succeeded.
        {
          p->name = p->value = 0; //No name or value.
#ifdef PUGOPT_NONSEG
          p->name_size = p->value_size = 0; //Lengths of zero.
#endif
          p->name_insitu = p->value_insitu = true; //Default to being in-situ of the parse string.
        }
      return p;
    }

static xml_node_struct* pug::new_node

(

xml_node_type

type = node_element

)

[inline, static]

Definition at line 697 of file pugxml.h.

References pug::t_xml_node_struct::attribute, pug::t_xml_node_struct::attribute_space, pug::t_xml_node_struct::attributes, pug::t_xml_node_struct::child, pug::t_xml_node_struct::child_space, pug::t_xml_node_struct::children, pug::t_xml_node_struct::name, pug::t_xml_node_struct::name_insitu, node_cdata, node_comment, node_doctype, node_document, node_element, node_include, node_pcdata, pug::t_xml_node_struct::type, pug::t_xml_node_struct::value, and pug::t_xml_node_struct::value_insitu.

Referenced by append_node(), pug::xml_parser::create(), Tree< T >::insert(), Tree< T >::insert_after(), pug::xml_parser::parse(), and pug::xml_parser::parse_file().

    {
      xml_node_struct* p = (xml_node_struct*)malloc(sizeof(xml_node_struct)); //Allocate one node.
      if(p) //If allocation succeeded.
        {
          p->name = p->value = 0; //No name or data.
#ifdef PUGOPT_NONSEG
          p->name_size = p->value_size = 0;
#endif
          p->type = type; //Set the desired type.
          p->attributes = p->children = 0; //No attributes or children.
          p->name_insitu = p->value_insitu = true; //Default to being in-situ of the parse string.
          if
            (
             type != node_document      && //None of these will have attributes.
             type != node_pcdata                &&
             type != node_cdata         &&
             type != node_include       &&
             type != node_comment
             )
            //Allocate one attribute.
            p->attribute = (xml_attribute_struct**)malloc(sizeof(xml_attribute_struct*)); 
          else p->attribute = NULL;
          p->attribute_space = (p->attribute) ? 1 : 0;
          if
            (
             type == node_element || //Only these will have children.
             type == node_doctype ||
             type == node_document
             )
            p->child = (xml_node_struct**)malloc(sizeof(xml_node_struct*)); //Allocate one child.
          else p->child = NULL;
          p->child_space = (p->child) ? 1 : 0;
#ifdef PUGOPT_NODE_FLAGS
          p->flags = 0x00;  // NF 19 Mar 2003
          p->set_visible_children( 1 );  // 17 Apr 2003
#endif
        }
      return p;
    }

static void pug::outer_xml	(	std::ostream &	os,
		indent_stack &	indent,
		xml_node_struct *	node,
		bool	breaks = true
	)			[inline, static]

Definition at line 1140 of file pugxml.h.

References _T, pug::t_xml_node_struct::attribute, pug::t_xml_node_struct::attributes, pug::t_xml_node_struct::child, pug::t_xml_node_struct::children, pug::indent_stack::depth(), pug::t_xml_attribute_struct::name, pug::t_xml_node_struct::name, node_cdata, node_comment, node_doctype, node_dtd_attlist, node_dtd_element, node_dtd_entity, node_dtd_notation, node_element, node_include, node_pcdata, node_pi, pug::indent_stack::pop(), pug::indent_stack::push(), pug::t_xml_node_struct::type, pug::t_xml_attribute_struct::value, and pug::t_xml_node_struct::value.

Referenced by pug::xml_node::outer_xml().

    {
      if(node && os.good()) //There is a node and ostream is OK.
        {
          /* register */ unsigned int n, i;
          os << indent.depth();
          switch(node->type)
            {
            case node_dtd_attlist:
              if(node->name)
                {
#ifdef PUGOPT_NONSEG
                  os << _T("<!ATTLIST ");
                  os.write( node->name, node->name_size );
#else
                  os << _T("<!ATTLIST ") << node->name;
#endif
                  if(node->value)
#ifdef PUGOPT_NONSEG
                    {
                      os << _T(" ");
                      os.write( node->value, node->value_size );
                    }
#else
                  os << _T(" ") << node->value;
#endif

                  os << _T(">");
                }
              break;
            case node_dtd_element:
              if(node->name)
                {
#ifdef PUGOPT_NONSEG
                  os << _T("<!ELEMENT ");
                  os.write( node->name, node->name_size );
                  if(node->value)
                    {
                      os << _T(" ");
                      os.write( node->value, node->value_size );
                    }
#else
                  os << _T("<!ELEMENT ") << node->name;
                  if(node->value) os << _T(" ") << node->value;
#endif
                  os << _T(">");
                }
              break;
            case node_dtd_entity:
              if(node->name)
                {
#ifdef PUGOPT_NONSEG
                  os << _T("<!ENTITY ");
                  os.write( node->name, node->name_size );
                  if(node->value)
                    {
                      os << _T(" ");
                      os.write( node->value, node->value_size );
                    }
#else
                  os << _T("<!ENTITY ") << node->name;
                  if(node->value) os << _T(" ") << node->value;
#endif
                  os << _T(">");
                }
              break;
            case node_dtd_notation:
              if(node->name)
                {
#ifdef PUGOPT_NONSEG
                  os << _T("<!NOTATION ");
                  os.write( node->name, node->name_size );
                  if(node->value)
                    {
                      os << _T(" ");
                      os.write( node->value, node->value_size );
                    }
#else
                  os << _T("<!NOTATION ") << node->name;
                  if(node->value) os << _T(" ") << node->value;
#endif
                  os << _T(">");
                }
              break;
            case node_doctype:
              os << _T("<!DOCTYPE");
              n = node->attributes;
              for(i=0; i<n; ++i)
                {
                  os << _T(" ");
                  if(node->attribute[i]->name)
#ifdef PUGOPT_NONSEG
                    os.write( node->attribute[i]->name, node->attribute[i]->name_size );
#else
                  os << node->attribute[i]->name;
#endif
                  else if(node->attribute[i]->value)
#ifdef PUGOPT_NONSEG
                    {
                      os << _T("\"");
                      os.write( node->attribute[i]->value, node->attribute[i]->value_size );
                      os << _T("\"");
                    }
#else
                  os << _T("\"") << node->attribute[i]->value << _T("\"");
#endif
                }
              if(node->children)
                {
                  if(breaks) os << std::endl;
                  else os << _T(" ");
                  os << _T("[");
                  if(breaks) os << std::endl;
                  else os << _T(" ");
                  n = node->children;
                  indent.push(); //Push the indent stack.
                  for(i=0; i<n; ++i)
                    {
                      if
                        (
                         node->child[i] && //There is a child at i.
                         (
                          node->child[i]->type == node_dtd_attlist      || //Skip all other types.
                          node->child[i]->type == node_dtd_element      ||
                          node->child[i]->type == node_dtd_entity               ||
                          node->child[i]->type == node_dtd_notation
                          )
                         )
                        outer_xml(os,indent,node->child[i],breaks);
                    }
                  indent.pop(); //Pop the indent stack.
                  os << _T("]");
                }
              else if(node->value)
#ifdef PUGOPT_NONSEG
                {
                  os << _T(" [");
                  os.write(node->value,node->value_size);
                  os << _T("]");
                }
#else
              os << _T(" [") << node->value << _T("]");
#endif
              os << _T(">");
              break;
            case node_pcdata:
#ifdef PUGOPT_NONSEG
              if(node->value) os.write(node->value,node->value_size);
#else
              if(node->value) os << node->value;
#endif
              break;
            case node_cdata:
#ifdef PUGOPT_NONSEG
              if(node->value)
                {
                  os << _T("<![CDATA[");
                  os.write(node->value,node->value_size);
                  os << _T("]]>");
                }
#else
              if(node->value) os << _T("<![CDATA[") << node->value << _T("]]>");
#endif
              break;
            case node_include:
#ifdef PUGOPT_NONSEG
              if(node->value)
                {
                  os << _T("<![INCLUDE[");
                  os.write(node->value, node->value_size);
                  os << _T("]]>");
                }
#else
              if(node->value) os << _T("<![INCLUDE[") << node->value << _T("]]>");
#endif
              break;
            case node_comment:
#ifdef PUGOPT_NONSEG
              if(node->value)
                {
                  os << _T("<!--");
                  os.write(node->value, node->value_size);
                  os << _T("-->");
                }
#else
              if(node->value) os << _T("<!--") << node->value << _T("-->");
#endif
              break;
            case node_element:
            case node_pi:
              os << _T("<");
              if(node->type==node_pi) os << _T("?");
              if(node->name)
#ifdef PUGOPT_NONSEG
                os.write(node->name,node->name_size);
#else
              os << node->name;
#endif
              else os << _T("anonymous");
              n = node->attributes;
              for(i=0; i<n; ++i)
                {
                  if(node->attribute[i] && node->attribute[i]->name)
                    {
#ifdef PUGOPT_NONSEG
                      os << _T(" ");
                      os.write(node->attribute[i]->name,node->attribute[i]->name_size);
                      if(node->attribute[i]->value)
                        {
                          os << _T("=\"");
                          os.write(node->attribute[i]->value,node->attribute[i]->value_size);
                          os << _T("\"");
                        }
#else
                      os << _T(" ") << node->attribute[i]->name;
                      if(node->attribute[i]->value) os << _T("=\"") << node->attribute[i]->value << _T("\"");
#endif
                    }
                }
              n = node->children;
              if(n && node->type == node_element)
                {
                  os << _T(">");
                  if(n == 1 && node->child[0]->type == node_pcdata)
                    {
                      if(node->child[0] && node->child[0]->value)
#ifdef PUGOPT_NONSEG
                        os.write(node->child[0]->value,node->child[0]->value_size);
#else
                      os << node->child[0]->value;
#endif
                    }
                  else
                    {
                      if(breaks) os << std::endl;
                      indent.push();
                      for(i=0; i<n; ++i) pug::outer_xml(os,indent,node->child[i],breaks);
                      indent.pop();
                      os << indent.depth();
                    }
                  os << _T("</");
#ifdef PUGOPT_NONSEG
                  if(node->name)
                    os.write(node->name, node->name_size);
#else
                  if(node->name) os << node->name;
#endif
                  os << _T(">");
                }
              else
                {
                  if(node->type==node_pi) os << _T("?>");
                  else os << _T("/>");
                }
              break;
            default: break;
            }
          if(breaks) os << std::endl;
          os.flush();
        }
    }

Here is the call graph for this function:

static bool pug::strcatgrow	(	TCHAR **	lhs,
		const TCHAR *	rhs
	)			[inline, static]

Definition at line 329 of file pugxml.h.

References _tcslen.

Referenced by pug::xml_node::append_attribute(), pug::xml_node::first_element_by_path(), load_file(), pug::xml_node::path(), and strcpyinsitu().

    {
      if(!*lhs) //Null, so first allocate.
        {
          *lhs = (TCHAR*) malloc(1UL*sizeof(TCHAR));
          **lhs = 0; //Zero-terminate.
        }
      size_t ulhs = _tcslen(*lhs);
      size_t urhs = _tcslen(rhs);
      TCHAR* temp = (TCHAR*) realloc(*lhs,(ulhs+urhs+1UL)*sizeof(TCHAR));
      if(!temp) return false; //Realloc failed.
      memcpy(temp+ulhs,rhs,urhs*sizeof(TCHAR)); //Concatenate.
      temp[ulhs+urhs] = 0; //Terminate it.
      *lhs = temp;
      return true;
    }

int pug::strcmpwild	(	const TCHAR *	src,
		const TCHAR *	dst
	)			[inline]

Definition at line 669 of file pugxml.h.

References strcmpwild_impl().

Referenced by pug::xml_node::has_name(), pug::xml_node::matches_attribute_name(), pug::t_xml_attribute_struct::matches_attribute_name_value(), pug::xml_node::matches_child_name(), pug::xml_node::matches_name(), pug::xml_node::matches_value(), pug::xml_node::moveto_child(), and pug::xml_node::moveto_first_sibling().

    {
      if(!src || !dst) return -1;
      return (strcmpwild_impl(src,dst)==1)?0:1;
    }

Here is the call graph for this function:

int pug::strcmpwild_astr	(	const TCHAR **	src,
		const TCHAR **	dst
	)			[inline]

Definition at line 605 of file pugxml.h.

References _T, and strcmpwild_impl().

Referenced by strcmpwild_impl().

    {
      int find = 1;
      ++(*src);
      while((**dst != 0 && **src == _T('?')) || **src == _T('*'))
        {
          if(**src == _T('?')) ++(*dst);
          ++(*src);
        }
      while(**src == _T('*')) ++(*src);
      if(**dst == 0 && **src != 0) return 0;
      if(**dst == 0 && **src == 0) return 1;
      else
        {
          if(strcmpwild_impl(*src,*dst) == 0)
            {
              do
                {
                  ++(*dst);
                  while(**src != **dst && **src != _T('[') && **dst != 0) 
                    ++(*dst);
                }
              while((**dst != 0) ? strcmpwild_impl(*src,*dst) == 0 : 0 != (find=0));
            }
          if(**dst == 0 && **src == 0) find = 1;
          return find;
        }
    }

Here is the call graph for this function:

int pug::strcmpwild_cset	(	const TCHAR **	src,
		const TCHAR **	dst
	)			[inline]

Definition at line 565 of file pugxml.h.

References _T.

Referenced by strcmpwild_impl().

    {
      int find = 0;
      int excl = 0;
      int star = 1;
      if(**src == _T('!'))
        {
          excl = 1;
          ++(*src);
        }
      while(**src != _T(']') || star == 1)
        {
          if(find == 0)
            {
              if(**src == _T('-') && *(*src-1) < *(*src+1) && *(*src+1) != _T(']') && star == 0)
                {
                  if(**dst >= *(*src-1) && **dst <= *(*src+1))
                    {
                      find = 1;
                      ++(*src);
                    }
                }
              else if(**src == **dst) find = 1;
            }
          ++(*src);
          star = 0;
        }
      if(excl == 1) find = (1 - find);
      if(find == 1) ++(*dst);
      return find;
    }

int pug::strcmpwild_impl	(	const TCHAR *	src,
		const TCHAR *	dst
	)			[inline]

Definition at line 639 of file pugxml.h.

References _T, strcmpwild_astr(), and strcmpwild_cset().

Referenced by strcmpwild(), and strcmpwild_astr().

    {
      int find = 1;
      for(; *src != 0 && find == 1 && *dst != 0; ++src)
        {
          switch(*src)
            {
            case _T('?'): ++dst; break;
            case _T('['): ++src; find = strcmpwild_cset(&src,&dst); break;
            case _T('*'): find = strcmpwild_astr(&src,&dst); --src; break;
            default : find = (int) (*src == *dst); ++dst;
            }
        }
      while(*src == _T('*') && find == 1) ++src;
      return (int) (find == 1 && *dst == 0 && *src == 0);
    }

Here is the call graph for this function:

static bool pug::strcpyinsitu	(	TCHAR **	dest,
		const TCHAR *	src,
		bool *	insitu
	)			[inline, static]

Definition at line 524 of file pugxml.h.

References _tcscpy, _tcslen, strcatgrow(), and TRUE.

Referenced by pug::xml_node::name(), pug::xml_attribute::name(), pug::xml_node::value(), and pug::xml_attribute::value().

    {
      if(!dest || !src || !insitu) return false; //Bad argument(s), so fail.
#ifndef PUGOPT_NONSEG //Always use heap for our r/o string.
      size_t l = (*dest) ? _tcslen(*dest) : 0; //How long is destination?
      if(l >= _tcslen(src)) //Destination is large enough, so just copy.
        {
          _tcscpy(*dest,src); //Copy.
          return TRUE; //Success.
        }
      else //Destination is too small.
#endif
        {
          if(*dest && !*insitu) free(*dest); //If destination is not in-situ, then free it.
          *dest = NULL; //Mark destination as NULL, forcing 'StrCatGrow' to 'malloc.
#ifdef PUGOPT_NONSEG
          if(strcatgrown(dest,src,destlen)) //Allocate & copy source to destination
#else
            if(strcatgrow(dest,src)) //Allocate & copy source to destination
#endif
              {
                *insitu = false; //Mark as no longer being in-situ, so we can free it later.
                return TRUE; //Success.
              }
        }
      return false; //Failure.
    }

Here is the call graph for this function:

static bool pug::strwnorm

(

TCHAR **

s

)

[inline, static]

Definition at line 470 of file pugxml.h.

References _T, _tcsncpy, and claraty::norm().

Referenced by pug::xml_parser::parse().

    {
      if(!s || !*s) return false; //No string to normalize.
      while(**s > 0 && **s < _T('!')) ++(*s); //As long as we hit whitespace, increment the string pointer.
      const TCHAR* temp = *s;
      while(0 != *temp++); //Find the terminating null.
      long n = (long)(temp-*s-1);
      TCHAR* norm = (TCHAR*)malloc(sizeof(TCHAR)*(n+1)); //Allocate a temporary normalization buffer.
      if(!norm) return false; //Allocation failed.
      memset(norm,0,sizeof(TCHAR)*(n+1)); //Zero it.
      long j = 1;
      long i;
      norm[0] = (*s)[0];
      for(i=1; i<n; ++i) //For each character, starting at offset 1.
        {
          if((*s)[i] < _T('!')) //Whitespace-like.
            {
              if((*s)[i-1] >= _T('!')) //Previous was not whitespace-like.
                {
                  norm[j] = _T(' '); //Convert to a space TCHAR.
                  ++j; //Normalization buffer grew by one TCHAR.
                }
            }
          else { norm[j] = (*s)[i]; ++j; } //Not whitespace, so just copy over.
        }
      if(j < n) //Normalization buffer is actually different that input.
        {
          _tcsncpy(*s,norm,j); //So, copy it back to input.
          (*s)[j] = 0; //Zero-terminate.
        }
      free(norm); //Don't need this anymore.
      --n; //Start from the last string TCHAR.
      for(i=n; (i > -1) && (*s)[i] > 0 && (*s)[i] < _T('!'); --i); //Find the first non-whitespace from the end.
      if(i<n) (*s)[i+1] = 0; //Truncate it.
      return true;

    }

Here is the call graph for this function:

static bool pug::strwtrim

(

TCHAR **

s

)

[inline, static]

Definition at line 450 of file pugxml.h.

References _T.

Referenced by pug::xml_parser::parse().

    {
      if(!s || !*s) return false;
      while(**s > 0 && **s < _T('!')) ++*s; //As long as we hit whitespace, increment the string pointer.
      const TCHAR* temp = *s;
      while(0 != *temp++); //Find the terminating null.
      long i, n = (long)(temp-*s-1);
      --n; //Start from the last string TCHAR.
      for(i=n; (i > -1) && (*s)[i] > 0 && (*s)[i] < _T('!'); --i); //As long as we hit whitespace, decrement.
      if(i<n) (*s)[i+1] = 0; //Zero-terminate.
      return true;
    }

---

Variable Documentation

const unsigned long pug::parse_cdata = 0x00000010 [static]

Definition at line 242 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_comments = 0x00000008 [static]

Definition at line 241 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_default = 0x0000FFFF [static]

Definition at line 253 of file pugxml.h.

const unsigned long pug::parse_doctype = 0x00000004 [static]

Definition at line 240 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_dtd = 0x00002000 [static]

Definition at line 251 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_dtd_only = 0x00004000 [static]

Definition at line 252 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_escapes = 0x00000020 [static]

Definition at line 243 of file pugxml.h.

const unsigned long pug::parse_grow = 4 [static]

Definition at line 234 of file pugxml.h.

const unsigned long pug::parse_minimal = 0x00000000 [static]

Definition at line 238 of file pugxml.h.

const unsigned long pug::parse_noset = 0x80000000 [static]

Definition at line 254 of file pugxml.h.

Referenced by pug::xml_parser::parse(), and pug::xml_parser::parse_file().

const unsigned long pug::parse_pi = 0x00000002 [static]

Definition at line 239 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_trim_attribute = 0x00000080 [static]

Definition at line 245 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_trim_cdata = 0x00000100 [static]

Definition at line 246 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_trim_comment = 0x00000800 [static]

Definition at line 249 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_trim_doctype = 0x00000400 [static]

Definition at line 248 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_trim_entity = 0x00000200 [static]

Definition at line 247 of file pugxml.h.

Referenced by pug::xml_parser::parse().

const unsigned long pug::parse_trim_pcdata = 0x00000040 [static]

Definition at line 244 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), and pug::xml_parser::parse().

const unsigned long pug::parse_wnorm = 0x00001000 [static]

Definition at line 250 of file pugxml.h.

Referenced by claraty::Parameter_Parser::Parameter_Parser(), pug::xml_parser::parse(), and pug::xml_parser::parse_file().

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635