1 /*

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

     3  *  it under the terms of the GNU General Public License as published by

     4  *  the Free Software Foundation; either version 2 of the License, or

     5  *  (at your option) any later version.

     6  *

     7  *  This program is distributed in the hope that it will be useful,

     8  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

     9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    10  *  GNU General Public License for more details.

    11  *

    12  *  You should have received a copy of the GNU General Public License

    13  *  along with this program; if not, write to the Free Software

    14  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    15  *

    16  *  Jabber

    17  *  Copyright (C) 1998-1999 The Jabber Team http://jabber.org/

    18  */

    19 

    20 #include "libxode.h"

    21 

    22 /* Internal routines */

    23 xmlnode _xmlnode_new(pool p, const char* name, unsigned int type)

    24 {

    25     xmlnode result = NULL;

    26     if (type > NTYPE_LAST)

    27         return NULL;

    28 

    29     if (type != NTYPE_CDATA && name == NULL)

    30         return NULL;

    31 

    32     if (p == NULL)

    33     {

    34         p = pool_heap(1*1024);

    35     }

    36 

    37     /* Allocate & zero memory */

    38     result = (xmlnode)pmalloc(p, sizeof(_xmlnode));

    39     memset(result, '\0', sizeof(_xmlnode));

    40 

    41     /* Initialize fields */

    42     if (type != NTYPE_CDATA)

    43         result->name = pstrdup(p,name);

    44     result->type = type;

    45     result->p = p;

    46     return result;

    47 }

    48 

    49 static xmlnode _xmlnode_append_sibling(xmlnode lastsibling, const char* name, unsigned int type)

    50 {

    51     xmlnode result;

    52 

    53     result = _xmlnode_new(xmlnode_pool(lastsibling), name, type);

    54     if (result != NULL)

    55     {

    56         /* Setup sibling pointers */

    57         result->prev = lastsibling;

    58         lastsibling->next = result;

    59     }

    60     return result;

    61 }

    62 

    63 static xmlnode _xmlnode_insert(xmlnode parent, const char* name, unsigned int type)

    64 {

    65     xmlnode result;

    66 

    67     if(parent == NULL || name == NULL) return NULL;

    68 

    69     /* If parent->firstchild is NULL, simply create a new node for the first child */

    70     if (parent->firstchild == NULL)

    71     {

    72         result = _xmlnode_new(parent->p, name, type);

    73         parent->firstchild = result;

    74     }

    75     /* Otherwise, append this to the lastchild */

    76     else

    77     {

    78         result= _xmlnode_append_sibling(parent->lastchild, name, type);

    79     }

    80     result->parent = parent;

    81     parent->lastchild = result;

    82     return result;

    83 

    84 }

    85 

    86 static xmlnode _xmlnode_search(xmlnode firstsibling, const char* name, unsigned int type)

    87 {

    88     xmlnode current;

    89 

    90     /* Walk the sibling list, looking for a NTYPE_TAG xmlnode with

    91     the specified name */

    92     current = firstsibling;

    93     while (current != NULL)

    94     {

    95         if ((current->type == type) && (j_strcmp(current->name, name) == 0))

    96             return current;

    97         else

    98             current = current->next;

    99     }

   100     return NULL;

   101 }

   102 

   103 static char* _xmlnode_merge(pool p, char* dest, unsigned int destsize, const char* src, unsigned int srcsize)

   104 {

   105     char* result;

   106     result = (char*)pmalloc(p, destsize + srcsize + 1);

   107     memcpy(result, dest, destsize);

   108     memcpy(result+destsize, src, srcsize);

   109     result[destsize + srcsize] = '\0';

   110 

   111     /* WARNING: major ugly hack: since we're throwing the old data away, let's jump in the pool and subtract it from the size, this is for xmlstream's big-node checking */

   112     p->size -= destsize;

   113 

   114     return result;

   115 }

   116 

   117 static void _xmlnode_hide_sibling(xmlnode child)

   118 {

   119     if(child == NULL)

   120         return;

   121 

   122     if(child->prev != NULL)

   123         child->prev->next = child->next;

   124     if(child->next != NULL)

   125         child->next->prev = child->prev;

   126 }

   127 

   128 void _xmlnode_tag2str(spool s, xmlnode node, int flag)

   129 {

   130     xmlnode tmp;

   131 

   132     if(flag==0 || flag==1)

   133     {

   134 	    spooler(s,"<",xmlnode_get_name(node),s);

   135 	    tmp = xmlnode_get_firstattrib(node);

   136 	    while(tmp) {

   137 	        spooler(s," ",xmlnode_get_name(tmp),"='",strescape(xmlnode_pool(node),xmlnode_get_data(tmp)),"'",s);

   138 	        tmp = xmlnode_get_nextsibling(tmp);

   139 	    }

   140 	    if(flag==0)

   141 	        spool_add(s,"/>");

   142 	    else

   143 	        spool_add(s,">");

   144     }

   145     else

   146     {

   147 	    spooler(s,"</",xmlnode_get_name(node),">",s);

   148     }

   149 }

   150 

   151 spool _xmlnode2spool(xmlnode node)

   152 {

   153     spool s;

   154     int level=0,dir=0;

   155     xmlnode tmp;

   156 

   157     if(!node || xmlnode_get_type(node)!=NTYPE_TAG)

   158 	return NULL;

   159 

   160     s = spool_new(xmlnode_pool(node));

   161     if(!s) return(NULL);

   162 

   163     while(1)

   164     {

   165         if(dir==0)

   166         {

   167     	    if(xmlnode_get_type(node) == NTYPE_TAG)

   168             {

   169 		        if(xmlnode_has_children(node))

   170                 {

   171 		            _xmlnode_tag2str(s,node,1);

   172         		    node = xmlnode_get_firstchild(node);

   173 		            level++;

   174 		            continue;

   175         		}

   176                 else

   177                 {

   178 		            _xmlnode_tag2str(s,node,0);

   179 		        }

   180 	        }

   181             else

   182             {

   183 		        spool_add(s,strescape(xmlnode_pool(node),xmlnode_get_data(node)));

   184 	        }

   185 	    }

   186 

   187     	tmp = xmlnode_get_nextsibling(node);

   188 	    if(!tmp)

   189         {

   190 	        node = xmlnode_get_parent(node);

   191 	        level--;

   192 	        if(level>=0) _xmlnode_tag2str(s,node,2);

   193 	        if(level<1) break;

   194 	        dir = 1;

   195 	    }

   196         else

   197         {

   198 	        node = tmp;

   199 	        dir = 0;

   200 	    }

   201     }

   202 

   203     return s;

   204 }

   205 

   206 

   207 /* External routines */

   208 

   209 

   210 /*

   211  *  xmlnode_new_tag -- create a tag node

   212  *  Automatically creates a memory pool for the node.

   213  *

   214  *  parameters

   215  *      name -- name of the tag

   216  *

   217  *  returns

   218  *      a pointer to the tag node

   219  *      or NULL if it was unsuccessfull

   220  */

   221 xmlnode xmlnode_new_tag(const char* name)

   222 {

   223     return _xmlnode_new(NULL, name, NTYPE_TAG);

   224 }

   225 

   226 

   227 /*

   228  *  xmlnode_new_tag_pool -- create a tag node within given pool

   229  *

   230  *  parameters

   231  *      p -- previously created memory pool

   232  *      name -- name of the tag

   233  *

   234  *  returns

   235  *      a pointer to the tag node

   236  *      or NULL if it was unsuccessfull

   237  */

   238 xmlnode xmlnode_new_tag_pool(pool p, const char* name)

   239 {

   240     return _xmlnode_new(p, name, NTYPE_TAG);

   241 }

   242 

   243 

   244 /*

   245  *  xmlnode_insert_tag -- append a child tag to a tag

   246  *

   247  *  parameters

   248  *      parent -- pointer to the parent tag

   249  *      name -- name of the child tag

   250  *

   251  *  returns

   252  *      a pointer to the child tag node

   253  *      or NULL if it was unsuccessfull

   254  */

   255 xmlnode xmlnode_insert_tag(xmlnode parent, const char* name)

   256 {

   257     return _xmlnode_insert(parent, name, NTYPE_TAG);

   258 }

   259 

   260 

   261 /*

   262  *  xmlnode_insert_cdata -- append character data to a tag

   263  *  If last child of the parent is CDATA, merges CDATA nodes. Otherwise

   264  *  creates a CDATA node, and appends it to the parent's child list.

   265  *

   266  *  parameters

   267  *      parent -- parent tag

   268  *      CDATA -- character data

   269  *      size -- size of CDATA

   270  *              or -1 for null-terminated CDATA strings

   271  *

   272  *  returns

   273  *      a pointer to the child CDATA node

   274  *      or NULL if it was unsuccessfull

   275  */

   276 xmlnode xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size)

   277 {

   278     xmlnode result;

   279 

   280     if(CDATA == NULL || parent == NULL)

   281         return NULL;

   282 

   283     if(size == -1)

   284         size = strlen(CDATA);

   285 

   286     if ((parent->lastchild != NULL) && (parent->lastchild->type == NTYPE_CDATA))

   287     {

   288         result = parent->lastchild;

   289         result->data = _xmlnode_merge(result->p, result->data, result->data_sz, CDATA, size);

   290         result->data_sz = result->data_sz + size;

   291     }

   292     else

   293     {

   294         result = _xmlnode_insert(parent, "", NTYPE_CDATA);

   295         if (result != NULL)

   296         {

   297             result->data = (char*)pmalloc(result->p, size + 1);

   298             memcpy(result->data, CDATA, size);

   299             result->data[size] = '\0';

   300             result->data_sz = size;

   301         }

   302     }

   303 

   304     return result;

   305 }

   306 

   307 

   308 /*

   309  *  xmlnode_get_tag -- find given tag in an xmlnode tree

   310  *

   311  *  parameters

   312  *      parent -- pointer to the parent tag

   313  *      name -- "name" for the child tag of that name

   314  *              "name/name" for a sub child (recurses)

   315  *              "?attrib" to match the first tag with that attrib defined

   316  *              "?attrib=value" to match the first tag with that attrib and value

   317  *              or any combination: "name/name/?attrib", etc

   318  *

   319  *  results

   320  *      a pointer to the tag matching search criteria

   321  *      or NULL if search was unsuccessfull

   322  */

   323 xmlnode xmlnode_get_tag(xmlnode parent, const char* name)

   324 {

   325     char *str, *slash, *qmark, *equals;

   326     xmlnode step, ret;

   327 

   328     if(parent == NULL || parent->firstchild == NULL || name == NULL || name == '\0') return NULL;

   329 

   330     if(strstr(name, "/") == NULL && strstr(name,"?") == NULL)

   331         return _xmlnode_search(parent->firstchild, name, NTYPE_TAG);

   332 

   333     /* jer's note: why can't I modify the name directly, why do I have to strdup it?  damn c grrr! */

   334     str = strdup(name);

   335     slash = strstr(str, "/");

   336     qmark = strstr(str, "?");

   337     equals = strstr(str, "=");

   338 

   339     if(qmark != NULL && (slash == NULL || qmark < slash))

   340     { /* of type ?attrib */

   341 

   342         *qmark = '\0';

   343         qmark++;

   344         if(equals != NULL)

   345         {

   346             *equals = '\0';

   347             equals++;

   348         }

   349 

   350         for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))

   351         {

   352             if(xmlnode_get_type(step) != NTYPE_TAG)

   353                 continue;

   354 

   355             if(*str != '\0')

   356                 if(j_strcmp(xmlnode_get_name(step),str) != 0)

   357                     continue;

   358 

   359             if(xmlnode_get_attrib(step,qmark) == NULL)

   360                 continue;

   361 

   362             if(equals != NULL && j_strcmp(xmlnode_get_attrib(step,qmark),equals) != 0)

   363                 continue;

   364 

   365             break;

   366         }

   367 

   368         free(str);

   369         return step;

   370     }

   371 

   372 

   373     *slash = '\0';

   374     ++slash;

   375 

   376     for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))

   377     {

   378         if(xmlnode_get_type(step) != NTYPE_TAG) continue;

   379 

   380         if(j_strcmp(xmlnode_get_name(step),str) != 0)

   381             continue;

   382 

   383         ret = xmlnode_get_tag(step, slash);

   384         if(ret != NULL)

   385         {

   386             free(str);

   387             return ret;

   388         }

   389     }

   390 

   391     free(str);

   392     return NULL;

   393 }

   394 

   395 

   396 /* return the cdata from any tag */

   397 char *xmlnode_get_tag_data(xmlnode parent, const char *name)

   398 {

   399     xmlnode tag;

   400 

   401     tag = xmlnode_get_tag(parent, name);

   402     if(tag == NULL) return NULL;

   403 

   404     return xmlnode_get_data(tag);

   405 }

   406 

   407 

   408 void xmlnode_put_attrib(xmlnode owner, const char* name, const char* value)

   409 {

   410     xmlnode attrib;

   411 

   412     if(owner == NULL || name == NULL || value == NULL) return;

   413 

   414     /* If there are no existing attributs, allocate a new one to start

   415     the list */

   416     if (owner->firstattrib == NULL)

   417     {

   418         attrib = _xmlnode_new(owner->p, name, NTYPE_ATTRIB);

   419         owner->firstattrib = attrib;

   420         owner->lastattrib  = attrib;

   421     }

   422     else

   423     {

   424         attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);

   425         if(attrib == NULL)

   426         {

   427             attrib = _xmlnode_append_sibling(owner->lastattrib, name, NTYPE_ATTRIB);

   428             owner->lastattrib = attrib;

   429         }

   430     }

   431     /* Update the value of the attribute */

   432     attrib->data_sz = strlen(value);

   433     attrib->data    = pstrdup(owner->p, value);

   434 

   435 }

   436 

   437 char* xmlnode_get_attrib(xmlnode owner, const char* name)

   438 {

   439     xmlnode attrib;

   440 

   441     if (owner != NULL && owner->firstattrib != NULL)

   442     {

   443         attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);

   444         if (attrib != NULL)

   445             return (char*)attrib->data;

   446     }

   447     return NULL;

   448 }

   449 

   450 void xmlnode_put_vattrib(xmlnode owner, const char* name, void *value)

   451 {

   452     xmlnode attrib;

   453 

   454     if (owner != NULL)

   455     {

   456         attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);

   457         if (attrib == NULL)

   458         {

   459             xmlnode_put_attrib(owner, name, "");

   460             attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);

   461         }

   462         if (attrib != NULL)

   463             attrib->firstchild = (xmlnode)value;

   464     }

   465 }

   466 

   467 void* xmlnode_get_vattrib(xmlnode owner, const char* name)

   468 {

   469     xmlnode attrib;

   470 

   471     if (owner != NULL && owner->firstattrib != NULL)

   472     {

   473         attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);

   474         if (attrib != NULL)

   475             return (void*)attrib->firstchild;

   476     }

   477     return NULL;

   478 }

   479 

   480 xmlnode xmlnode_get_firstattrib(xmlnode parent)

   481 {

   482     if (parent != NULL)

   483         return parent->firstattrib;

   484     return NULL;

   485 }

   486 

   487 xmlnode xmlnode_get_firstchild(xmlnode parent)

   488 {

   489     if (parent != NULL)

   490         return parent->firstchild;

   491     return NULL;

   492 }

   493 

   494 xmlnode xmlnode_get_lastchild(xmlnode parent)

   495 {

   496     if (parent != NULL)

   497         return parent->lastchild;

   498     return NULL;

   499 }

   500 

   501 xmlnode xmlnode_get_nextsibling(xmlnode sibling)

   502 {

   503     if (sibling != NULL)

   504         return sibling->next;

   505     return NULL;

   506 }

   507 

   508 xmlnode xmlnode_get_prevsibling(xmlnode sibling)

   509 {

   510     if (sibling != NULL)

   511         return sibling->prev;

   512     return NULL;

   513 }

   514 

   515 xmlnode xmlnode_get_parent(xmlnode node)

   516 {

   517     if (node != NULL)

   518         return node->parent;

   519     return NULL;

   520 }

   521 

   522 char* xmlnode_get_name(xmlnode node)

   523 {

   524     if (node != NULL)

   525         return node->name;

   526     return NULL;

   527 }

   528 

   529 char* xmlnode_get_data(xmlnode node)

   530 {

   531     xmlnode cur;

   532 

   533     if(node == NULL) return NULL;

   534 

   535     if(xmlnode_get_type(node) == NTYPE_TAG) /* loop till we find a CDATA */

   536     {

   537         for(cur = xmlnode_get_firstchild(node); cur != NULL; cur = xmlnode_get_nextsibling(cur))

   538             if(xmlnode_get_type(cur) == NTYPE_CDATA)

   539                 return cur->data;

   540     }else{

   541         return node->data;

   542     }

   543     return NULL;

   544 }

   545 

   546 int xmlnode_get_datasz(xmlnode node)

   547 {

   548     if (node != NULL)

   549         return node->data_sz;

   550     return (int)NULL;

   551 }

   552 

   553 int xmlnode_get_type(xmlnode node)

   554 {

   555     if (node != NULL)

   556         return node->type;

   557     return (int)NULL;

   558 }

   559 

   560 int xmlnode_has_children(xmlnode node)

   561 {

   562     if ((node != NULL) && (node->firstchild != NULL))

   563         return 1;

   564     return 0;

   565 }

   566 

   567 int xmlnode_has_attribs(xmlnode node)

   568 {

   569     if ((node != NULL) && (node->firstattrib != NULL))

   570         return 1;

   571     return 0;

   572 }

   573 

   574 pool xmlnode_pool(xmlnode node)

   575 {

   576     if (node != NULL)

   577         return node->p;

   578     return (pool)NULL;

   579 }

   580 

   581 void xmlnode_hide(xmlnode child)

   582 {

   583     xmlnode parent;

   584 

   585     if(child == NULL || child->parent == NULL)

   586         return;

   587 

   588     parent = child->parent;

   589 

   590     /* first fix up at the child level */

   591     _xmlnode_hide_sibling(child);

   592 

   593     /* next fix up at the parent level */

   594     if(parent->firstchild == child)

   595         parent->firstchild = child->next;

   596     if(parent->lastchild == child)

   597         parent->lastchild = child->prev;

   598 }

   599 

   600 void xmlnode_hide_attrib(xmlnode parent, const char *name)

   601 {

   602     xmlnode attrib;

   603 

   604     if(parent == NULL || parent->firstattrib == NULL || name == NULL)

   605         return;

   606 

   607     attrib = _xmlnode_search(parent->firstattrib, name, NTYPE_ATTRIB);

   608     if(attrib == NULL)

   609         return;

   610 

   611     /* first fix up at the child level */

   612     _xmlnode_hide_sibling(attrib);

   613 

   614     /* next fix up at the parent level */

   615     if(parent->firstattrib == attrib)

   616         parent->firstattrib = attrib->next;

   617     if(parent->lastattrib == attrib)

   618         parent->lastattrib = attrib->prev;

   619 }

   620 

   621 

   622 

   623 /*

   624  *  xmlnode2str -- convert given xmlnode tree into a string

   625  *

   626  *  parameters

   627  *      node -- pointer to the xmlnode structure

   628  *

   629  *  results

   630  *      a pointer to the created string

   631  *      or NULL if it was unsuccessfull

   632  */

   633 char *xmlnode2str(xmlnode node)

   634 {

   635      return spool_print(_xmlnode2spool(node));

   636 }

   637 

   638 /*

   639  *  xmlnode2tstr -- convert given xmlnode tree into a newline terminated string

   640  *

   641  *  parameters

   642  *      node -- pointer to the xmlnode structure

   643  *

   644  *  results

   645  *      a pointer to the created string

   646  *      or NULL if it was unsuccessfull

   647  */

   648 char*    xmlnode2tstr(xmlnode node)

   649 {

   650      spool s = _xmlnode2spool(node);

   651      if (s != NULL)

   652 	  spool_add(s, "\n");

   653     return spool_print(s);

   654 }

   655 

   656 

   657 /* loop through both a and b comparing everything, attribs, cdata, children, etc */

   658 int xmlnode_cmp(xmlnode a, xmlnode b)

   659 {

   660     int ret = 0;

   661 

   662     while(1)

   663     {

   664         if(a == NULL && b == NULL)

   665             return 0;

   666 

   667         if(a == NULL || b == NULL)

   668             return -1;

   669 

   670         if(xmlnode_get_type(a) != xmlnode_get_type(b))

   671             return -1;

   672 

   673         switch(xmlnode_get_type(a))

   674         {

   675         case NTYPE_ATTRIB:

   676             ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));

   677             if(ret != 0)

   678                 return -1;

   679             ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));

   680             if(ret != 0)

   681                 return -1;

   682             break;

   683         case NTYPE_TAG:

   684             ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));

   685             if(ret != 0)

   686                 return -1;

   687             ret = xmlnode_cmp(xmlnode_get_firstattrib(a), xmlnode_get_firstattrib(b));

   688             if(ret != 0)

   689                 return -1;

   690             ret = xmlnode_cmp(xmlnode_get_firstchild(a), xmlnode_get_firstchild(b));

   691             if(ret != 0)

   692                 return -1;

   693             break;

   694         case NTYPE_CDATA:

   695             ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));

   696             if(ret != 0)

   697                 return -1;

   698         }

   699         a = xmlnode_get_nextsibling(a);

   700         b = xmlnode_get_nextsibling(b);

   701     }

   702 }

   703 

   704 

   705 xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node)

   706 {

   707     xmlnode child;

   708 

   709     child = xmlnode_insert_tag(parent, xmlnode_get_name(node));

   710     if (xmlnode_has_attribs(node))

   711         xmlnode_insert_node(child, xmlnode_get_firstattrib(node));

   712     if (xmlnode_has_children(node))

   713         xmlnode_insert_node(child, xmlnode_get_firstchild(node));

   714 

   715     return child;

   716 }

   717 

   718 /* places copy of node and node's siblings in parent */

   719 void xmlnode_insert_node(xmlnode parent, xmlnode node)

   720 {

   721     if(node == NULL || parent == NULL)

   722         return;

   723 

   724     while(node != NULL)

   725     {

   726         switch(xmlnode_get_type(node))

   727         {

   728         case NTYPE_ATTRIB:

   729             xmlnode_put_attrib(parent, xmlnode_get_name(node), xmlnode_get_data(node));

   730             break;

   731         case NTYPE_TAG:

   732             xmlnode_insert_tag_node(parent, node);

   733             break;

   734         case NTYPE_CDATA:

   735             xmlnode_insert_cdata(parent, xmlnode_get_data(node), xmlnode_get_datasz(node));

   736         }

   737         node = xmlnode_get_nextsibling(node);

   738     }

   739 }

   740 

   741 

   742 /* produce full duplicate of x with a new pool, x must be a tag! */

   743 xmlnode xmlnode_dup(xmlnode x)

   744 {

   745     xmlnode x2;

   746 

   747     if(x == NULL)

   748         return NULL;

   749 

   750     x2 = xmlnode_new_tag(xmlnode_get_name(x));

   751 

   752     if (xmlnode_has_attribs(x))

   753         xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));

   754     if (xmlnode_has_children(x))

   755         xmlnode_insert_node(x2, xmlnode_get_firstchild(x));

   756 

   757     return x2;

   758 }

   759 

   760 xmlnode xmlnode_dup_pool(pool p, xmlnode x)

   761 {

   762     xmlnode x2;

   763 

   764     if(x == NULL)

   765         return NULL;

   766 

   767     x2 = xmlnode_new_tag_pool(p, xmlnode_get_name(x));

   768 

   769     if (xmlnode_has_attribs(x))

   770         xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));

   771     if (xmlnode_has_children(x))

   772         xmlnode_insert_node(x2, xmlnode_get_firstchild(x));

   773 

   774     return x2;

   775 }

   776 

   777 xmlnode xmlnode_wrap(xmlnode x,const char *wrapper)

   778 {

   779     xmlnode wrap;

   780     if(x==NULL||wrapper==NULL) return NULL;

   781     wrap=xmlnode_new_tag_pool(xmlnode_pool(x),wrapper);

   782     if(wrap==NULL) return NULL;

   783     wrap->firstchild=x;

   784     wrap->lastchild=x;

   785     x->parent=wrap;

   786     return wrap;

   787 }

   788 

   789 void xmlnode_free(xmlnode node)

   790 {

   791     if(node == NULL)

   792         return;

   793 

   794     pool_free(node->p);

   795 }