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