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