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