utils/themeeditor/skin_parser.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 Robert Bieber
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26
  27 #include "skin_parser.h"
  28 #include "skin_debug.h"
  29 #include "tag_table.h"
  30 #include "symbols.h"
  31 #include "skin_scan.h"
  32
  33 /* Declaration of parse tree buffer */
  34 char skin_parse_tree[SKIN_MAX_MEMORY];
  35 int skin_current_block = 0;
  36
  37 /* Global variables for the parser */
  38 int skin_line = 0;
  39
  40 /* Auxiliary parsing functions (not visible at global scope) */
  41 struct skin_element* skin_parse_viewport(char** document);
  42 struct skin_element* skin_parse_line(char** document);
  43 struct skin_element* skin_parse_line_optional(char** document, int conditional);
  44 struct skin_element* skin_parse_sublines(char** document);
  45 struct skin_element* skin_parse_sublines_optional(char** document,
  46                                                   int conditional);
  47
  48 int skin_parse_tag(struct skin_element* element, char** document);
  49 int skin_parse_text(struct skin_element* element, char** document,
  50                     int conditional);
  51 int skin_parse_conditional(struct skin_element* element, char** document);
  52 int skin_parse_comment(struct skin_element* element, char** document);
  53 struct skin_element* skin_parse_code_as_arg(char** document);
  54
  55 struct skin_element* skin_parse(const char* document)
  56 {
  57
  58     struct skin_element* root = NULL;
  59     struct skin_element* last = NULL;
  60
  61     struct skin_element** to_write = 0;
  62
  63     char* cursor = (char*)document; /*Keeps track of location in the document*/
  64
  65     skin_line = 1;
  66
  67     while(*cursor != '\0')
  68     {
  69
  70         if(!root)
  71             to_write = &root;
  72         else
  73             to_write = &(last->next);
  74
  75
  76         *to_write = skin_parse_viewport(&cursor);
  77         last = *to_write;
  78         if(!last)
  79             return NULL;
  80
  81         /* Making sure last is at the end */
  82         while(last->next)
  83             last = last->next;
  84
  85     }
  86
  87     return root;
  88
  89 }
  90
  91 struct skin_element* skin_parse_viewport(char** document)
  92 {
  93
  94     struct skin_element* root = NULL;
  95     struct skin_element* last = NULL;
  96     struct skin_element* retval = NULL;
  97
  98     retval = skin_alloc_element();
  99     retval->type = VIEWPORT;
 100     retval->children_count = 1;
 101     retval->line = skin_line;
 102
 103     struct skin_element** to_write = 0;
 104
 105     char* cursor = *document; /* Keeps track of location in the document */
 106     char* bookmark; /* Used when we need to look ahead */
 107
 108     int sublines = 0; /* Flag for parsing sublines */
 109
 110     /* Parsing out the viewport tag if there is one */
 111     if(check_viewport(cursor))
 112     {
 113         retval->children_count = 2;
 114         retval->children = skin_alloc_children(2);
 115         retval->children[0] = skin_alloc_element();
 116         skin_parse_tag(retval->children[0], &cursor);
 117     }
 118     else
 119     {
 120         retval->children_count = 1;
 121         retval->children = skin_alloc_children(1);
 122     }
 123
 124
 125     while(*cursor != '\0' && !(check_viewport(cursor) && cursor != *document))
 126     {
 127
 128         /* First, we check to see if this line will contain sublines */
 129         bookmark = cursor;
 130         sublines = 0;
 131         while(*cursor != '\n' && *cursor != '\0'
 132               && !(check_viewport(cursor) && cursor != *document))
 133         {
 134             if(*cursor == MULTILINESYM)
 135             {
 136                 sublines = 1;
 137                 break;
 138             }
 139             else if(*cursor == TAGSYM)
 140             {
 141                 /* A ';' directly after a '%' doesn't count */
 142                 cursor ++;
 143
 144                 if(*cursor == '\0')
 145                     break;
 146
 147                 cursor++;
 148             }
 149             else if(*cursor == COMMENTSYM)
 150             {
 151                 skip_comment(&cursor);
 152             }
 153             else
 154             {
 155                 /* Advancing the cursor as normal */
 156                 cursor++;
 157             }
 158         }
 159         cursor = bookmark;
 160
 161         if(!root)
 162             to_write = &root;
 163         else
 164             to_write = &(last->next);
 165
 166         if(sublines)
 167         {
 168             *to_write = skin_parse_sublines(&cursor);
 169             last = *to_write;
 170             if(!last)
 171                 return NULL;
 172         }
 173         else
 174         {
 175
 176             *to_write = skin_parse_line(&cursor);
 177             last = *to_write;
 178             if(!last)
 179                 return NULL;
 180
 181         }
 182
 183         /* Making sure last is at the end */
 184         while(last->next)
 185             last = last->next;
 186
 187         if(*cursor == '\n')
 188             cursor++;
 189
 190     }
 191
 192     *document = cursor;
 193
 194     retval->children[retval->children_count - 1] = root;
 195     return retval;
 196
 197 }
 198
 199 /* Auxiliary Parsing Functions */
 200
 201 struct skin_element* skin_parse_line(char**document)
 202 {
 203
 204     return skin_parse_line_optional(document, 0);
 205
 206 }
 207
 208
 209 /*
 210  * If conditional is set to true, then this will break upon encountering
 211  * SEPERATESYM.  This should only be used when parsing a line inside a
 212  * conditional, otherwise just use the wrapper function skin_parse_line()
 213  */
 214 struct skin_element* skin_parse_line_optional(char** document, int conditional)
 215 {
 216     char* cursor = *document;
 217
 218     struct skin_element* root = NULL;
 219     struct skin_element* current = NULL;
 220     struct skin_element* retval = NULL;
 221
 222     /* A wrapper for the line */
 223     retval = skin_alloc_element();
 224     retval->type = LINE;
 225     retval->line = skin_line;
 226     retval->children_count = 1;
 227     retval->children = skin_alloc_children(1);
 228
 229     while(*cursor != '\n' && *cursor != '\0' && *cursor != MULTILINESYM
 230           && !((*cursor == ARGLISTSEPERATESYM
 231                 || *cursor == ARGLISTCLOSESYM
 232                 || *cursor == ENUMLISTSEPERATESYM
 233                 || *cursor == ENUMLISTCLOSESYM)
 234                && conditional)
 235           && !(check_viewport(cursor) && cursor != *document))
 236     {
 237         /* Allocating memory if necessary */
 238         if(root)
 239         {
 240             current->next = skin_alloc_element();
 241             current = current->next;
 242         }
 243         else
 244         {
 245             current = skin_alloc_element();
 246             root = current;
 247         }
 248
 249         /* Parsing the current element */
 250         if(*cursor == TAGSYM && cursor[1] == CONDITIONSYM)
 251         {
 252             if(!skin_parse_conditional(current, &cursor))
 253                 return NULL;
 254         }
 255         else if(*cursor == TAGSYM && !find_escape_character(cursor[1]))
 256         {
 257             if(!skin_parse_tag(current, &cursor))
 258                 return NULL;
 259         }
 260         else if(*cursor == COMMENTSYM)
 261         {
 262             if(!skin_parse_comment(current, &cursor))
 263                 return NULL;
 264         }
 265         else
 266         {
 267             if(!skin_parse_text(current, &cursor, conditional))
 268                 return NULL;
 269         }
 270     }
 271
 272     /* Moving up the calling function's pointer */
 273     *document = cursor;
 274
 275     retval->children[0] = root;
 276     return retval;
 277 }
 278
 279 struct skin_element* skin_parse_sublines(char** document)
 280 {
 281     return skin_parse_sublines_optional(document, 0);
 282 }
 283
 284 struct skin_element* skin_parse_sublines_optional(char** document,
 285                                                   int conditional)
 286 {
 287     struct skin_element* retval;
 288     char* cursor = *document;
 289     int sublines = 1;
 290     int i;
 291
 292     retval = skin_alloc_element();
 293     retval->type = SUBLINES;
 294     retval->next = NULL;
 295     retval->line = skin_line;
 296
 297     /* First we count the sublines */
 298     while(*cursor != '\0' && *cursor != '\n'
 299           && !((*cursor == ARGLISTSEPERATESYM
 300                 || *cursor == ARGLISTCLOSESYM
 301                 || *cursor == ENUMLISTSEPERATESYM
 302                 || *cursor == ENUMLISTCLOSESYM)
 303                && conditional)
 304           && !(check_viewport(cursor) && cursor != *document))
 305     {
 306         if(*cursor == COMMENTSYM)
 307             skip_comment(&cursor);
 308
 309         /* Accounting for escaped subline symbols */
 310         if(*cursor == TAGSYM)
 311         {
 312             cursor++;
 313             if(*cursor == '\0' || *cursor == '\n')
 314                 break;
 315         }
 316
 317         if(*cursor == MULTILINESYM)
 318         {
 319             sublines++;
 320         }
 321
 322         cursor++;
 323     }
 324
 325     /* ...and then we parse them */
 326     retval->children_count = sublines;
 327     retval->children = skin_alloc_children(sublines);
 328
 329     cursor = *document;
 330     for(i = 0; i < sublines; i++)
 331     {
 332         retval->children[i] = skin_parse_line_optional(&cursor, conditional);
 333         skip_whitespace(&cursor);
 334
 335         if(*cursor != MULTILINESYM && i != sublines - 1)
 336         {
 337             skin_error(MULTILINE_EXPECTED);
 338             return NULL;
 339         }
 340         else if(i != sublines - 1)
 341         {
 342             cursor++;
 343         }
 344     }
 345
 346     *document = cursor;
 347
 348     return retval;
 349 }
 350
 351 int skin_parse_tag(struct skin_element* element, char** document)
 352 {
 353
 354     char* cursor = *document + 1;
 355     char* bookmark;
 356
 357     char tag_name[3];
 358     char* tag_args;
 359     struct tag_info *tag;
 360
 361     int num_args = 1;
 362     int i;
 363     int star = 0; /* Flag for the all-or-none option */
 364     int req_args; /* To mark when we enter optional arguments */
 365
 366     int optional = 0;
 367
 368     /* Checking the tag name */
 369     tag_name[0] = cursor[0];
 370     tag_name[1] = cursor[1];
 371     tag_name[2] = '\0';
 372
 373     /* First we check the two characters after the '%', then a single char */
 374     tag = find_tag(tag_name);
 375
 376     if(!tag)
 377     {
 378         tag_name[1] = '\0';
 379         tag = find_tag(tag_name);
 380         cursor++;
 381     }
 382     else
 383     {
 384         cursor += 2;
 385     }
 386
 387     if(!tag)
 388     {
 389         skin_error(ILLEGAL_TAG);
 390         return 0;
 391     }
 392
 393     /* Copying basic tag info */
 394     element->type = TAG;
 395     element->tag = tag;
 396     tag_args = tag->params;
 397     element->line = skin_line;
 398
 399     /* Checking for the * flag */
 400     if(tag_args[0] == '*')
 401     {
 402         star = 1;
 403         tag_args++;
 404     }
 405
 406     /* If this tag has no arguments, we can bail out now */
 407     if(strlen(tag_args) == 0
 408        || (tag_args[0] == '|' && *cursor != ARGLISTOPENSYM)
 409        || (star && *cursor != ARGLISTOPENSYM))
 410     {
 411         *document = cursor;
 412         return 1;
 413     }
 414
 415     /* Checking the number of arguments and allocating args */
 416     if(*cursor != ARGLISTOPENSYM && tag_args[0] != '|')
 417     {
 418         skin_error(ARGLIST_EXPECTED);
 419         return 0;
 420     }
 421     else
 422     {
 423         cursor++;
 424     }
 425
 426     for(bookmark = cursor; *cursor != '\n' && *cursor != '\0' &&
 427         *cursor != ARGLISTCLOSESYM; cursor++)
 428     {
 429         /* Skipping over escaped characters */
 430         if(*cursor == TAGSYM)
 431         {
 432             cursor++;
 433             if(*cursor == '\0')
 434                 break;
 435         }
 436
 437         /* Skipping comments */
 438         if(*cursor == COMMENTSYM)
 439             skip_comment(&cursor);
 440
 441         /* Commas inside of contained lists don't count */
 442         if(*cursor == ARGLISTOPENSYM)
 443             while(*cursor != ARGLISTCLOSESYM && *cursor != '\0')
 444                 cursor++;
 445
 446         if(*cursor == ARGLISTSEPERATESYM)
 447             num_args++;
 448
 449     }
 450     cursor = bookmark; /* Restoring the cursor */
 451     element->params_count = num_args;
 452     element->params = skin_alloc_params(num_args);
 453
 454     /* Now we have to actually parse each argument */
 455     for(i = 0; i < num_args; i++)
 456     {
 457         /* Making sure we haven't run out of arguments */
 458         if(*tag_args == '\0')
 459         {
 460             skin_error(TOO_MANY_ARGS);
 461             return 0;
 462         }
 463
 464         /* Checking for the optional bar */
 465         if(*tag_args == '|')
 466         {
 467             optional = 1;
 468             req_args = i;
 469             tag_args++;
 470         }
 471
 472         /* Scanning the arguments */
 473         skip_whitespace(&cursor);
 474
 475
 476         /* Checking for comments */
 477         if(*cursor == COMMENTSYM)
 478             skip_comment(&cursor);
 479
 480         /* Storing the type code */
 481         element->params[i].type_code = *tag_args;
 482
 483         /* Checking a nullable argument for null */
 484         if(*cursor == DEFAULTSYM)
 485         {
 486             if(islower(*tag_args))
 487             {
 488                 element->params[i].type = DEFAULT;
 489                 cursor++;
 490             }
 491             else
 492             {
 493                 skin_error(DEFAULT_NOT_ALLOWED);
 494                 return 0;
 495             }
 496         }
 497         else if(tolower(*tag_args) == 'i')
 498         {
 499             /* Scanning an int argument */
 500             if(!isdigit(*cursor))
 501             {
 502                 skin_error(INT_EXPECTED);
 503                 return 0;
 504             }
 505
 506             element->params[i].type = NUMERIC;
 507             element->params[i].data.numeric = scan_int(&cursor);
 508         }
 509         else if(tolower(*tag_args) == 's' || tolower(*tag_args) == 'f')
 510         {
 511             /* Scanning a string argument */
 512             element->params[i].type = STRING;
 513             element->params[i].data.text = scan_string(&cursor);
 514
 515         }
 516         else if(tolower(*tag_args) == 'c')
 517         {
 518             /* Recursively parsing a code argument */
 519             element->params[i].type = CODE;
 520             element->params[i].data.code = skin_parse_code_as_arg(&cursor);
 521             if(!element->params[i].data.code)
 522                 return 0;
 523         }
 524
 525         skip_whitespace(&cursor);
 526
 527         if(*cursor != ARGLISTSEPERATESYM && i < num_args - 1)
 528         {
 529             skin_error(SEPERATOR_EXPECTED);
 530             return 0;
 531         }
 532         else if(*cursor != ARGLISTCLOSESYM && i == num_args - 1)
 533         {
 534             skin_error(CLOSE_EXPECTED);
 535             return 0;
 536         }
 537         else
 538         {
 539             cursor++;
 540         }
 541
 542         tag_args++;
 543
 544         /* Checking for the optional bar */
 545         if(*tag_args == '|')
 546         {
 547             optional = 1;
 548             req_args = i + 1;
 549             tag_args++;
 550         }
 551
 552     }
 553
 554     /* Checking for a premature end */
 555     if(*tag_args != '\0' && !optional)
 556     {
 557         skin_error(INSUFFICIENT_ARGS);
 558         return 0;
 559     }
 560
 561     *document = cursor;
 562
 563     return 1;
 564 }
 565
 566 /*
 567  * If the conditional flag is set true, then parsing text will stop at an
 568  * ARGLISTSEPERATESYM.  Only set that flag when parsing within a conditional
 569  */
 570 int skin_parse_text(struct skin_element* element, char** document,
 571                     int conditional)
 572 {
 573     char* cursor = *document;
 574
 575     int length = 0;
 576
 577     int dest;
 578
 579     /* First figure out how much text we're copying */
 580     while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
 581           && *cursor != COMMENTSYM
 582           && !((*cursor == ARGLISTSEPERATESYM
 583                 || *cursor == ARGLISTCLOSESYM
 584                 || *cursor == ENUMLISTSEPERATESYM
 585                 || *cursor == ENUMLISTCLOSESYM)
 586                && conditional))
 587     {
 588         /* Dealing with possibility of escaped characters */
 589         if(*cursor == TAGSYM)
 590         {
 591             if(find_escape_character(cursor[1]))
 592                 cursor++;
 593             else
 594                 break;
 595         }
 596
 597         length++;
 598         cursor++;
 599     }
 600
 601     cursor = *document;
 602
 603     /* Copying the text into the element struct */
 604     element->type = TEXT;
 605     element->line = skin_line;
 606     element->next = NULL;
 607     element->text = skin_alloc_string(length);
 608
 609     for(dest = 0; dest < length; dest++)
 610     {
 611         /* Advancing cursor if we've encountered an escaped character */
 612         if(*cursor == TAGSYM)
 613             cursor++;
 614
 615         element->text[dest] = *cursor;
 616         cursor++;
 617     }
 618     element->text[length] = '\0';
 619
 620     *document = cursor;
 621
 622     return 1;
 623 }
 624
 625 int skin_parse_conditional(struct skin_element* element, char** document)
 626 {
 627
 628     char* cursor = *document + 1; /* Starting past the "%" */
 629     char* bookmark;
 630     struct skin_element* tag = skin_alloc_element(); /* The tag to evaluate */
 631     int children = 1;
 632     int i;
 633
 634     element->type = CONDITIONAL;
 635     element->line = skin_line;
 636
 637     /* Parsing the tag first */
 638     if(!skin_parse_tag(tag, &cursor))
 639         return 0;
 640
 641     /* Counting the children */
 642     if(*(cursor++) != ENUMLISTOPENSYM)
 643     {
 644         skin_error(ARGLIST_EXPECTED);
 645         return 0;
 646     }
 647     bookmark = cursor;
 648     while(*cursor != ENUMLISTCLOSESYM && *cursor != '\n' && *cursor != '\0')
 649     {
 650         if(*cursor == COMMENTSYM)
 651         {
 652             skip_comment(&cursor);
 653             continue;
 654         }
 655
 656         if(*cursor == TAGSYM)
 657         {
 658             cursor++;
 659             if(*cursor == '\0' || *cursor == '\n')
 660                 break;
 661             cursor++;
 662             continue;
 663         }
 664
 665         if(*cursor == ENUMLISTSEPERATESYM)
 666             children++;
 667
 668         cursor++;
 669     }
 670     cursor = bookmark;
 671
 672     /* Parsing the children */
 673     element->children_count = children + 1; /* Make sure to include the tag */
 674     element->children = skin_alloc_children(children + 1);
 675     element->children[0] = tag;
 676
 677     for(i = 1; i < children + 1; i++)
 678     {
 679         element->children[i] = skin_parse_code_as_arg(&cursor);
 680         skip_whitespace(&cursor);
 681
 682         if(i < children && *cursor != ENUMLISTSEPERATESYM)
 683         {
 684             skin_error(SEPERATOR_EXPECTED);
 685             return 0;
 686         }
 687         else if(i == children && *cursor != ENUMLISTCLOSESYM)
 688         {
 689             skin_error(CLOSE_EXPECTED);
 690             return 0;
 691         }
 692         else
 693         {
 694             cursor++;
 695         }
 696     }
 697
 698     *document = cursor;
 699
 700     return 1;
 701 }
 702
 703 int skin_parse_comment(struct skin_element* element, char** document)
 704 {
 705     char* cursor = *document;
 706
 707     int length;
 708     /*
 709      * Finding the index of the ending newline or null-terminator
 710      * The length of the string of interest doesn't include the leading #, the
 711      * length we need to reserve is the same as the index of the last character
 712      */
 713     for(length = 0; cursor[length] != '\n' && cursor[length] != '\0'; length++);
 714
 715     element->type = COMMENT;
 716     element->line = skin_line;
 717     element->text = skin_alloc_string(length);
 718     /* We copy from one char past cursor to leave out the # */
 719     memcpy((void*)(element->text), (void*)(cursor + 1),
 720            sizeof(char) * (length-1));
 721     element->text[length - 1] = '\0';
 722
 723     if(cursor[length] == '\n')
 724         skin_line++;
 725
 726     *document += (length); /* Move cursor up past # and all text */
 727     if(**document == '\n')
 728         (*document)++;
 729
 730     return 1;
 731 }
 732
 733 struct skin_element* skin_parse_code_as_arg(char** document)
 734 {
 735
 736     int sublines = 0;
 737     char* cursor = *document;
 738
 739     /* Checking for sublines */
 740     while(*cursor != '\n' && *cursor != '\0')
 741     {
 742         if(*cursor == MULTILINESYM)
 743         {
 744             sublines = 1;
 745             break;
 746         }
 747         else if(*cursor == TAGSYM)
 748         {
 749             /* A ';' directly after a '%' doesn't count */
 750             cursor ++;
 751
 752             if(*cursor == '\0')
 753                 break;
 754
 755             cursor++;
 756         }
 757         else
 758         {
 759             /* Advancing the cursor as normal */
 760             cursor++;
 761         }
 762     }
 763
 764     if(sublines)
 765         return skin_parse_sublines_optional(document, 1);
 766     else
 767         return skin_parse_line_optional(document, 1);
 768 }
 769
 770
 771 /* Memory management */
 772 struct skin_element* skin_alloc_element()
 773 {
 774
 775 #if 0
 776
 777     char* retval = &skin_parse_tree[skin_current_block * 4];
 778
 779     int delta = sizeof(struct skin_element) / (sizeof(char) * 4);
 780
 781     /* If one block is partially filled, make sure to advance to the
 782      * next one for the next allocation
 783      */
 784     if(sizeof(struct skin_element) % (sizeof(char) * 4) != 0)
 785         delta++;
 786
 787     skin_current_block += delta;
 788
 789     return (struct skin_element*)retval;
 790
 791 #endif
 792
 793     struct skin_element* retval =  (struct skin_element*)
 794                                    malloc(sizeof(struct skin_element));
 795     retval->next = NULL;
 796     retval->params_count = 0;
 797     retval->children_count = 0;
 798
 799     return retval;
 800
 801 }
 802
 803 struct skin_tag_parameter* skin_alloc_params(int count)
 804 {
 805 #if 0
 806
 807     char* retval = &skin_parse_tree[skin_current_block * 4];
 808
 809     int delta = sizeof(struct skin_tag_parameter) / (sizeof(char) * 4);
 810     delta *= count;
 811
 812     /* Correcting uneven alignment */
 813     if(count * sizeof(struct skin_tag_parameter) % (sizeof(char) * 4) != 0)
 814         delta++;
 815
 816     skin_current_block += delta;
 817
 818     return (struct skin_tag_parameter*) retval;
 819
 820 #endif
 821
 822     return (struct skin_tag_parameter*)malloc(sizeof(struct skin_tag_parameter)
 823                                               * count);
 824
 825 }
 826
 827 char* skin_alloc_string(int length)
 828 {
 829
 830 #if 0
 831     char* retval = &skin_parse_tree[skin_current_block * 4];
 832
 833     /* Checking alignment */
 834     length++; /* Accounting for the null terminator */
 835     int delta = length / 4;
 836     if(length % 4 != 0)
 837         delta++;
 838
 839     skin_current_block += delta;
 840
 841     if(skin_current_block >= SKIN_MAX_MEMORY / 4)
 842         skin_error(MEMORY_LIMIT_EXCEEDED);
 843
 844     return retval;
 845
 846 #endif
 847
 848     return (char*)malloc(sizeof(char) * (length + 1));
 849
 850 }
 851
 852 struct skin_element** skin_alloc_children(int count)
 853 {
 854     return (struct skin_element**) malloc(sizeof(struct skin_element*) * count);
 855 }
 856
 857 void skin_free_tree(struct skin_element* root)
 858 {
 859     int i;
 860
 861     /* First make the recursive call */
 862     if(!root)
 863         return;
 864     skin_free_tree(root->next);
 865
 866     /* Free any text */
 867     if(root->type == TEXT)
 868         free(root->text);
 869
 870     /* Then recursively free any children, before freeing their pointers */
 871     for(i = 0; i < root->children_count; i++)
 872         skin_free_tree(root->children[i]);
 873     if(root->children_count > 0)
 874         free(root->children);
 875
 876     /* Free any parameters, making sure to deallocate strings */
 877     for(i = 0; i < root->params_count; i++)
 878         if(root->params[i].type == STRING)
 879             free(root->params[i].data.text);
 880     if(root->params_count > 0)
 881         free(root->params);
 882
 883     /* Finally, delete root's memory */
 884     free(root);
 885 }