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 <stdbool.h>
  25 #include <string.h>
  26 #include <ctype.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 char* skin_start = 0;
  38 int viewport_line = 0;
  39
  40 static int tag_recursion_level = 0;
  41
  42 #ifdef ROCKBOX
  43 static skin_callback callback = NULL;
  44 static void* callback_data;
  45 #endif
  46
  47 /* Auxiliary parsing functions (not visible at global scope) */
  48 static struct skin_element* skin_parse_viewport(const char** document);
  49 static struct skin_element* skin_parse_line(const char** document);
  50 static struct skin_element* skin_parse_line_optional(const char** document,
  51                                                      int conditional);
  52 static struct skin_element* skin_parse_sublines(const char** document);
  53 static struct skin_element* skin_parse_sublines_optional(const char** document,
  54                                                          int conditional);
  55
  56 static int skin_parse_tag(struct skin_element* element, const char** document);
  57 static int skin_parse_text(struct skin_element* element, const char** document,
  58                            int conditional);
  59 static int skin_parse_conditional(struct skin_element* element,
  60                                   const char** document);
  61 static int skin_parse_comment(struct skin_element* element, const char** document);
  62 static struct skin_element* skin_parse_code_as_arg(const char** document);
  63
  64
  65 static void skip_whitespace(const char** document)
  66 {
  67     while(**document == ' ' || **document == '\t')
  68         (*document)++;
  69 }
  70
  71 #ifdef ROCKBOX
  72 struct skin_element* skin_parse(const char* document,
  73                                 skin_callback cb, void* cb_data)
  74 {
  75     callback = cb;
  76     callback_data = cb_data;
  77 #else
  78 struct skin_element* skin_parse(const char* document)
  79 {
  80 #endif
  81     struct skin_element* root = NULL;
  82     struct skin_element* last = NULL;
  83
  84     struct skin_element** to_write = 0;
  85
  86     const char* cursor = document; /*Keeps track of location in the document*/
  87
  88     skin_line = 1;
  89     skin_start = (char*)document;
  90     viewport_line = 0;
  91
  92     skin_clear_errors();
  93
  94     while(*cursor != '\0')
  95     {
  96         if(!root)
  97             to_write = &root;
  98         else
  99             to_write = &(last->next);
 100
 101
 102         *to_write = skin_parse_viewport(&cursor);
 103         last = *to_write;
 104         if(!last)
 105         {
 106             skin_free_tree(root); /* Clearing any memory already used */
 107             return NULL;
 108         }
 109
 110         /* Making sure last is at the end */
 111         while(last->next)
 112             last = last->next;
 113
 114     }
 115     return root;
 116
 117 }
 118
 119 static struct skin_element* skin_parse_viewport(const char** document)
 120 {
 121     struct skin_element* root = NULL;
 122     struct skin_element* last = NULL;
 123     struct skin_element* retval = NULL;
 124
 125     tag_recursion_level = 0;
 126
 127     retval = skin_alloc_element();
 128     if (!retval)
 129         return NULL;
 130     retval->type = VIEWPORT;
 131     retval->children_count = 1;
 132     retval->line = skin_line;
 133     viewport_line = skin_line;
 134
 135     struct skin_element** to_write = 0;
 136
 137     const char* cursor = *document; /* Keeps track of location in the document */
 138     const char* bookmark; /* Used when we need to look ahead */
 139
 140     int sublines = 0; /* Flag for parsing sublines */
 141
 142     /* Parsing out the viewport tag if there is one */
 143     if(check_viewport(cursor))
 144     {
 145         if (!skin_parse_tag(retval, &cursor))
 146             return NULL;
 147         if(*cursor == '\n')
 148         {
 149             cursor++;
 150             skin_line++;
 151         }
 152     }
 153 #ifdef ROCKBOX
 154     else if (callback)
 155     {
 156         if (callback(retval, callback_data) == CALLBACK_ERROR)
 157             return NULL;
 158     }
 159 #endif
 160
 161     if (check_viewport(cursor))
 162     {
 163         retval->children_count = 0;
 164         *document = cursor;
 165         return retval;
 166     }
 167     retval->children_count = 1;
 168     retval->children = skin_alloc_children(1);
 169     if (!retval->children)
 170         return NULL;
 171     do
 172     {
 173
 174         /* First, we check to see if this line will contain sublines */
 175         bookmark = cursor;
 176         sublines = 0;
 177         while(*cursor != '\n' && *cursor != '\0'
 178               && !(check_viewport(cursor) && cursor != *document))
 179         {
 180             if(*cursor == MULTILINESYM)
 181             {
 182                 sublines = 1;
 183                 break;
 184             }
 185             else if(*cursor == TAGSYM)
 186             {
 187                 /* A ';' directly after a '%' doesn't count */
 188                 cursor ++;
 189
 190                 if(*cursor == '\0')
 191                     break;
 192
 193                 cursor++;
 194             }
 195             else if(*cursor == COMMENTSYM)
 196             {
 197                 skip_comment(&cursor);
 198             }
 199             else if(*cursor == ARGLISTOPENSYM)
 200             {
 201                 skip_arglist(&cursor);
 202             }
 203             else if(*cursor == ENUMLISTOPENSYM)
 204             {
 205                 skip_enumlist(&cursor);
 206             }
 207             else
 208             {
 209                 /* Advancing the cursor as normal */
 210                 cursor++;
 211             }
 212         }
 213         cursor = bookmark;
 214
 215         if(!root)
 216             to_write = &root;
 217         else
 218             to_write = &(last->next);
 219
 220         if(sublines)
 221         {
 222             *to_write = skin_parse_sublines(&cursor);
 223             last = *to_write;
 224             if(!last)
 225                 return NULL;
 226         }
 227         else
 228         {
 229 #ifdef ROCKBOX
 230             /* strip all leading comments */
 231             while(*cursor == '#')
 232             {
 233                 skip_comment(&cursor);
 234                 skin_line++;
 235
 236             }
 237             if (check_viewport(cursor))
 238                 break;
 239 #endif
 240             *to_write = skin_parse_line(&cursor);
 241             last = *to_write;
 242             if(!last)
 243                 return NULL;
 244
 245         }
 246         /* Making sure last is at the end */
 247         while(last->next)
 248             last = last->next;
 249
 250         if(*cursor == '\n')
 251         {
 252             cursor++;
 253             skin_line++;
 254         }
 255 #ifdef ROCKBOX
 256         /* strip all comments */
 257         while(*cursor == '#')
 258         {
 259             skip_comment(&cursor);
 260             skin_line++;
 261
 262         }
 263         if (check_viewport(cursor))
 264             break;
 265 #endif
 266
 267     }
 268     while(*cursor != '\0' && !(check_viewport(cursor) && cursor != *document));
 269
 270     *document = cursor;
 271
 272     retval->children[0] = root;
 273     return retval;
 274 }
 275
 276 /* Auxiliary Parsing Functions */
 277
 278 static struct skin_element* skin_parse_line(const char**document)
 279 {
 280     return skin_parse_line_optional(document, 0);
 281 }
 282
 283 /*
 284  * If conditional is set to true, then this will break upon encountering
 285  * SEPARATESYM.  This should only be used when parsing a line inside a
 286  * conditional, otherwise just use the wrapper function skin_parse_line()
 287  */
 288 static struct skin_element* skin_parse_line_optional(const char** document,
 289                                                      int conditional)
 290 {
 291     const char* cursor = *document;
 292
 293     struct skin_element* root = NULL;
 294     struct skin_element* current = NULL;
 295     struct skin_element* retval = NULL;
 296
 297     /* A wrapper for the line */
 298     retval = skin_alloc_element();
 299     if (!retval)
 300         return NULL;
 301     retval->type = LINE;
 302     retval->line = skin_line;
 303     if(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
 304        && !(conditional && (*cursor == ARGLISTSEPARATESYM
 305                             || *cursor == ARGLISTCLOSESYM
 306                             || *cursor == ENUMLISTSEPARATESYM
 307                             || *cursor == ENUMLISTCLOSESYM)))
 308     {
 309         retval->children_count = 1;
 310     }
 311     else
 312     {
 313         retval->children_count = 0;
 314     }
 315
 316     if(retval->children_count > 0)
 317     {
 318         retval->children = skin_alloc_children(1);
 319         if (!retval->children)
 320             return NULL;
 321     }
 322
 323 #ifdef ROCKBOX
 324     if (callback)
 325     {
 326         switch (callback(retval, callback_data))
 327         {
 328             case CALLBACK_ERROR:
 329                 return NULL;
 330             default:
 331                 break;
 332         }
 333     }
 334 #endif
 335
 336     while(*cursor != '\n' && *cursor != '\0' && *cursor != MULTILINESYM
 337           && !((*cursor == ARGLISTSEPARATESYM
 338                 || *cursor == ARGLISTCLOSESYM
 339                 || *cursor == ENUMLISTSEPARATESYM
 340                 || *cursor == ENUMLISTCLOSESYM)
 341                && conditional)
 342           && !(check_viewport(cursor) && cursor != *document))
 343     {
 344         /* Allocating memory if necessary */
 345         if(root)
 346         {
 347             current->next = skin_alloc_element();
 348             if (!current->next)
 349                 return NULL;
 350             current = current->next;
 351         }
 352         else
 353         {
 354             current = skin_alloc_element();
 355             if (!current)
 356                 return NULL;
 357             root = current;
 358         }
 359
 360         /* Parsing the current element */
 361         if(*cursor == TAGSYM && cursor[1] == CONDITIONSYM)
 362         {
 363             if(!skin_parse_conditional(current, &cursor))
 364                 return NULL;
 365         }
 366         else if(*cursor == TAGSYM && !find_escape_character(cursor[1]))
 367         {
 368             if(!skin_parse_tag(current, &cursor))
 369                 return NULL;
 370         }
 371         else if(*cursor == COMMENTSYM)
 372         {
 373             if(!skin_parse_comment(current, &cursor))
 374                 return NULL;
 375         }
 376         else
 377         {
 378             if(!skin_parse_text(current, &cursor, conditional))
 379                 return NULL;
 380         }
 381     }
 382
 383     /* Moving up the calling function's pointer */
 384     *document = cursor;
 385
 386     if(root)
 387         retval->children[0] = root;
 388     return retval;
 389 }
 390
 391 static struct skin_element* skin_parse_sublines(const char** document)
 392 {
 393     return skin_parse_sublines_optional(document, 0);
 394 }
 395
 396 static struct skin_element* skin_parse_sublines_optional(const char** document,
 397                                                   int conditional)
 398 {
 399     struct skin_element* retval;
 400     const char* cursor = *document;
 401     int sublines = 1;
 402     int i;
 403
 404     retval = skin_alloc_element();
 405     if (!retval)
 406         return NULL;
 407     retval->type = LINE_ALTERNATOR;
 408     retval->next = NULL;
 409     retval->line = skin_line;
 410
 411     /* First we count the sublines */
 412     while(*cursor != '\0' && *cursor != '\n'
 413           && !((*cursor == ARGLISTSEPARATESYM
 414                 || *cursor == ARGLISTCLOSESYM
 415                 || *cursor == ENUMLISTSEPARATESYM
 416                 || *cursor == ENUMLISTCLOSESYM)
 417                && conditional)
 418           && !(check_viewport(cursor) && cursor != *document))
 419     {
 420         if(*cursor == COMMENTSYM)
 421         {
 422             skip_comment(&cursor);
 423         }
 424         else if(*cursor == ENUMLISTOPENSYM)
 425         {
 426             skip_enumlist(&cursor);
 427         }
 428         else if(*cursor == ARGLISTOPENSYM)
 429         {
 430             skip_arglist(&cursor);
 431         }
 432         else if(*cursor == TAGSYM)
 433         {
 434             cursor++;
 435             if(*cursor == '\0' || *cursor == '\n')
 436                 break;
 437             cursor++;
 438         }
 439         else if(*cursor == MULTILINESYM)
 440         {
 441             sublines++;
 442             cursor++;
 443         }
 444         else
 445         {
 446             cursor++;
 447         }
 448     }
 449
 450     /* ...and then we parse them */
 451     retval->children_count = sublines;
 452     retval->children = skin_alloc_children(sublines);
 453     if (!retval->children)
 454         return NULL;
 455
 456     cursor = *document;
 457     for(i = 0; i < sublines; i++)
 458     {
 459         retval->children[i] = skin_parse_line_optional(&cursor, conditional);
 460         skip_whitespace(&cursor);
 461
 462         if(*cursor != MULTILINESYM && i != sublines - 1)
 463         {
 464             skin_error(MULTILINE_EXPECTED, cursor);
 465             return NULL;
 466         }
 467         else if(i != sublines - 1)
 468         {
 469             cursor++;
 470         }
 471     }
 472
 473 #ifdef ROCKBOX
 474     if (callback)
 475     {
 476         if (callback(retval, callback_data) == CALLBACK_ERROR)
 477             return NULL;
 478     }
 479 #endif
 480     *document = cursor;
 481
 482     return retval;
 483 }
 484
 485 static int skin_parse_tag(struct skin_element* element, const char** document)
 486 {
 487     const char* cursor = *document + 1;
 488     const char* bookmark;
 489
 490     char tag_name[3];
 491     char* tag_args;
 492     const struct tag_info *tag;
 493
 494     int num_args = 1;
 495     int i;
 496     int star = 0; /* Flag for the all-or-none option */
 497
 498     int optional = 0;
 499     tag_recursion_level++;
 500
 501     /* Checking the tag name */
 502     tag_name[0] = cursor[0];
 503     tag_name[1] = cursor[1];
 504     tag_name[2] = '\0';
 505
 506     /* First we check the two characters after the '%', then a single char */
 507     tag = find_tag(tag_name);
 508
 509     if(!tag)
 510     {
 511         tag_name[1] = '\0';
 512         tag = find_tag(tag_name);
 513         cursor++;
 514     }
 515     else
 516     {
 517         cursor += 2;
 518     }
 519
 520     if(!tag)
 521     {
 522         skin_error(ILLEGAL_TAG, cursor);
 523         return 0;
 524     }
 525
 526     /* Copying basic tag info */
 527     if(element->type != CONDITIONAL && element->type != VIEWPORT)
 528         element->type = TAG;
 529     element->tag = tag;
 530     tag_args = tag->params;
 531     element->line = skin_line;
 532
 533     /* Checking for the * flag */
 534     if(tag_args[0] == '*')
 535     {
 536         star = 1;
 537         tag_args++;
 538     }
 539
 540     /* If this tag has no arguments, we can bail out now */
 541     if(strlen(tag_args) == 0
 542        || (tag_args[0] == '|' && *cursor != ARGLISTOPENSYM)
 543        || (star && *cursor != ARGLISTOPENSYM))
 544     {
 545
 546 #ifdef ROCKBOX
 547         if (callback)
 548         {
 549             if (callback(element, callback_data) == CALLBACK_ERROR)
 550                 return 0;
 551         }
 552 #endif
 553         *document = cursor;
 554         return 1;
 555     }
 556
 557     /* Checking the number of arguments and allocating args */
 558     if(*cursor != ARGLISTOPENSYM && tag_args[0] != '|')
 559     {
 560         skin_error(ARGLIST_EXPECTED, cursor);
 561         return 0;
 562     }
 563     else
 564     {
 565         cursor++;
 566     }
 567
 568     bookmark = cursor;
 569     while(*cursor != '\n' && *cursor != '\0' && *cursor != ARGLISTCLOSESYM)
 570     {
 571         /* Skipping over escaped characters */
 572         if(*cursor == TAGSYM)
 573         {
 574             cursor++;
 575             if(*cursor == '\0')
 576                 break;
 577             cursor++;
 578         }
 579         else if(*cursor == COMMENTSYM)
 580         {
 581             skip_comment(&cursor);
 582         }
 583         else if(*cursor == ARGLISTOPENSYM)
 584         {
 585             skip_arglist(&cursor);
 586         }
 587         else if(*cursor == ARGLISTSEPARATESYM)
 588         {
 589             num_args++;
 590             cursor++;
 591         }
 592         else
 593         {
 594             cursor++;
 595         }
 596     }
 597
 598     cursor = bookmark; /* Restoring the cursor */
 599     element->params_count = num_args;
 600     element->params = skin_alloc_params(num_args, tag_recursion_level<=1);
 601     if (!element->params)
 602         return 0;
 603
 604     /* Now we have to actually parse each argument */
 605     for(i = 0; i < num_args; i++)
 606     {
 607         char type_code;
 608         /* Making sure we haven't run out of arguments */
 609         if(*tag_args == '\0')
 610         {
 611             skin_error(TOO_MANY_ARGS, cursor);
 612             return 0;
 613         }
 614
 615         /* Checking for the optional bar */
 616         if(*tag_args == '|')
 617         {
 618             optional = 1;
 619             tag_args++;
 620         }
 621
 622         /* Scanning the arguments */
 623         skip_whitespace(&cursor);
 624
 625         /* Checking for comments */
 626         if(*cursor == COMMENTSYM)
 627             skip_comment(&cursor);
 628
 629         if (*tag_args == '[')
 630         {
 631             /* we need to guess which type of param it is.
 632              * guess using this priority:
 633              * default > decimal/integer > single tag/code > string
 634              */
 635             int j=0;
 636             bool canbedefault = false;
 637             bool haspercent = false, number = true, hasdecimal = false;
 638             char temp_params[8];
 639             tag_args++;
 640             while (*tag_args != ']')
 641             {
 642                 if (*tag_args >= 'a' && *tag_args <= 'z')
 643                     canbedefault = true;
 644                 temp_params[j++] = tolower(*tag_args++);
 645             }
 646             temp_params[j] = '\0';
 647             j = 0;
 648             while (cursor[j] && cursor[j] != ',' && cursor[j] != ')')
 649             {
 650                 haspercent = haspercent || (cursor[j] == '%');
 651                 hasdecimal = hasdecimal || (cursor[j] == '.');
 652                 number = number && (isdigit(cursor[j]) ||
 653                                     (cursor[j] == '.') ||
 654                                     (cursor[j] == '-'));
 655                 j++;
 656             }
 657             type_code = '*';
 658             if (canbedefault && *cursor == DEFAULTSYM && !isdigit(cursor[1]))
 659             {
 660                 type_code = 'i';
 661             }
 662             else if (number && hasdecimal && strchr(temp_params, 'd'))
 663             {
 664                 type_code = 'd';
 665             }
 666             else if (number &&
 667                      (strchr(temp_params, 'i') || strchr(temp_params, 'd')))
 668             {
 669                 type_code = strchr(temp_params, 'i') ? 'i' : 'd';
 670             }
 671             else if (haspercent &&
 672                     (strchr(temp_params, 't') || strchr(temp_params, 'c')))
 673             {
 674                 type_code = strchr(temp_params, 't') ? 't' : 'c';
 675             }
 676             else if (strchr(temp_params, 's'))
 677             {
 678                 type_code = 's';
 679             }
 680             if (type_code == '*')
 681             {
 682                 skin_error(INSUFFICIENT_ARGS, cursor);
 683                 return 0;
 684             }
 685         }
 686         else
 687             type_code = *tag_args;
 688         /* Storing the type code */
 689         element->params[i].type_code = type_code;
 690
 691         /* Checking a nullable argument for null. */
 692         if(*cursor == DEFAULTSYM && !isdigit(cursor[1]))
 693         {
 694             if(islower(type_code))
 695             {
 696                 element->params[i].type = DEFAULT;
 697                 cursor++;
 698             }
 699             else
 700             {
 701                 skin_error(DEFAULT_NOT_ALLOWED, cursor);
 702                 return 0;
 703             }
 704         }
 705         else if(tolower(type_code) == 'i')
 706         {
 707             /* Scanning an int argument */
 708             if(!isdigit(*cursor) && *cursor != '-')
 709             {
 710                 skin_error(INT_EXPECTED, cursor);
 711                 return 0;
 712             }
 713
 714             element->params[i].type = INTEGER;
 715             element->params[i].data.number = scan_int(&cursor);
 716         }
 717         else if(tolower(type_code) == 'd')
 718         {
 719             int val = 0;
 720             bool have_point = false;
 721             bool have_tenth = false;
 722             while ( isdigit(*cursor) || *cursor == '.' )
 723             {
 724                 if (*cursor != '.')
 725                 {
 726                     val *= 10;
 727                     val += *cursor - '0';
 728                     if (have_point)
 729                     {
 730                         have_tenth = true;
 731                         cursor++;
 732                         break;
 733                     }
 734                 }
 735                 else
 736                     have_point = true;
 737                 cursor++;
 738             }
 739             if (have_tenth == false)
 740                 val *= 10;
 741             element->params[i].type = DECIMAL;
 742             element->params[i].data.number = val;
 743         }
 744         else if(tolower(type_code) == 'n' ||
 745                 tolower(type_code) == 's' || tolower(type_code) == 'f')
 746         {
 747             /* Scanning a string argument */
 748             element->params[i].type = STRING;
 749             element->params[i].data.text = scan_string(&cursor);
 750
 751         }
 752         else if(tolower(type_code) == 'c')
 753         {
 754             /* Recursively parsing a code argument */
 755             element->params[i].type = CODE;
 756             element->params[i].data.code = skin_parse_code_as_arg(&cursor);
 757             if(!element->params[i].data.code)
 758                 return 0;
 759         }
 760         else if (tolower(type_code) == 't')
 761         {
 762             struct skin_element* child = skin_alloc_element();
 763             child->type = TAG;
 764             if (!skin_parse_tag(child, &cursor))
 765                 return 0;
 766             child->next = NULL;
 767             element->params[i].type = CODE;
 768             element->params[i].data.code = child;
 769         }
 770
 771
 772         skip_whitespace(&cursor);
 773
 774         if(*cursor != ARGLISTSEPARATESYM && i < num_args - 1)
 775         {
 776             skin_error(SEPARATOR_EXPECTED, cursor);
 777             return 0;
 778         }
 779         else if(*cursor != ARGLISTCLOSESYM && i == num_args - 1)
 780         {
 781             skin_error(CLOSE_EXPECTED, cursor);
 782             return 0;
 783         }
 784         else
 785         {
 786             cursor++;
 787         }
 788
 789         if (*tag_args != 'N')
 790             tag_args++;
 791
 792         /* Checking for the optional bar */
 793         if(*tag_args == '|')
 794         {
 795             optional = 1;
 796             tag_args++;
 797         }
 798     }
 799
 800     /* Checking for a premature end */
 801     if(*tag_args != '\0' && !optional)
 802     {
 803         skin_error(INSUFFICIENT_ARGS, cursor);
 804         return 0;
 805     }
 806 #ifdef ROCKBOX
 807     if (callback)
 808     {
 809         if (callback(element, callback_data) == CALLBACK_ERROR)
 810             return 0;
 811     }
 812 #endif
 813     *document = cursor;
 814     tag_recursion_level--;
 815
 816     return 1;
 817 }
 818
 819 /*
 820  * If the conditional flag is set true, then parsing text will stop at an
 821  * ARGLISTSEPARATESYM.  Only set that flag when parsing within a conditional
 822  */
 823 static int skin_parse_text(struct skin_element* element, const char** document,
 824                            int conditional)
 825 {
 826     const char* cursor = *document;
 827     int length = 0;
 828     int dest;
 829     char *text = NULL;
 830
 831     /* First figure out how much text we're copying */
 832     while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
 833           && *cursor != COMMENTSYM
 834           && !((*cursor == ARGLISTSEPARATESYM
 835                 || *cursor == ARGLISTCLOSESYM
 836                 || *cursor == ENUMLISTSEPARATESYM
 837                 || *cursor == ENUMLISTCLOSESYM)
 838                && conditional))
 839     {
 840         /* Dealing with possibility of escaped characters */
 841         if(*cursor == TAGSYM)
 842         {
 843             if(find_escape_character(cursor[1]))
 844                 cursor++;
 845             else
 846                 break;
 847         }
 848
 849         length++;
 850         cursor++;
 851     }
 852
 853     cursor = *document;
 854
 855     /* Copying the text into the element struct */
 856     element->type = TEXT;
 857     element->line = skin_line;
 858     element->next = NULL;
 859     element->data = text = skin_alloc_string(length);
 860     if (!element->data)
 861         return 0;
 862
 863     for(dest = 0; dest < length; dest++)
 864     {
 865         /* Advancing cursor if we've encountered an escaped character */
 866         if(*cursor == TAGSYM)
 867             cursor++;
 868
 869         text[dest] = *cursor;
 870         cursor++;
 871     }
 872     text[length] = '\0';
 873
 874 #ifdef ROCKBOX
 875     if (callback)
 876     {
 877         if (callback(element, callback_data) == CALLBACK_ERROR)
 878             return 0;
 879     }
 880 #endif
 881
 882     *document = cursor;
 883
 884     return 1;
 885 }
 886
 887 static int skin_parse_conditional(struct skin_element* element, const char** document)
 888 {
 889     const char* cursor = *document + 1; /* Starting past the "%" */
 890     const char* bookmark;
 891     int children = 1;
 892     int i;
 893
 894 #ifdef ROCKBOX
 895     bool feature_available = true;
 896     const char *false_branch = NULL;
 897     const char *conditional_end = NULL;
 898 #endif
 899
 900     /* Some conditional tags allow for target feature checking,
 901      * so to handle that call the callback as usual with type == TAG
 902      * then call it a second time with type == CONDITIONAL and check the return
 903      * value */
 904     element->type = TAG;
 905     element->line = skin_line;
 906
 907     /* Parsing the tag first */
 908     if(!skin_parse_tag(element, &cursor))
 909         return 0;
 910
 911     element->type = CONDITIONAL;
 912 #ifdef ROCKBOX
 913     if (callback)
 914     {
 915         switch (callback(element, callback_data))
 916         {
 917             case FEATURE_NOT_AVAILABLE:
 918                 feature_available = false;
 919                 break;
 920             case CALLBACK_ERROR:
 921                 return 0;
 922             default:
 923                 break;
 924         }
 925     }
 926 #endif
 927
 928     /* Counting the children */
 929     if(*(cursor++) != ENUMLISTOPENSYM)
 930     {
 931         skin_error(ARGLIST_EXPECTED, cursor);
 932         return 0;
 933     }
 934     bookmark = cursor;
 935     while(*cursor != ENUMLISTCLOSESYM && *cursor != '\n' && *cursor != '\0')
 936     {
 937         if(*cursor == COMMENTSYM)
 938         {
 939             skip_comment(&cursor);
 940         }
 941         else if(*cursor == ENUMLISTOPENSYM)
 942         {
 943             skip_enumlist(&cursor);
 944         }
 945         else if(*cursor == TAGSYM)
 946         {
 947             cursor++;
 948             if(*cursor == '\0' || *cursor == '\n')
 949                 break;
 950             cursor++;
 951         }
 952         else if(*cursor == ENUMLISTSEPARATESYM)
 953         {
 954             children++;
 955             cursor++;
 956 #ifdef ROCKBOX
 957             if (false_branch == NULL && !feature_available)
 958             {
 959                 false_branch = cursor;
 960                 children--;
 961             }
 962 #endif
 963         }
 964         else
 965         {
 966             cursor++;
 967         }
 968     }
 969 #ifdef ROCKBOX
 970     if (*cursor == ENUMLISTCLOSESYM &&
 971         false_branch == NULL && !feature_available)
 972     {
 973         false_branch = cursor+1;
 974         children--;
 975     }
 976     if (element->tag->flags&FEATURE_TAG)
 977     {
 978         if (feature_available && children > 1)
 979             children--;
 980     }
 981     conditional_end = cursor;
 982     /* if we are skipping the true branch fix that up */
 983     cursor = false_branch ? false_branch : bookmark;
 984 #else
 985     cursor = bookmark;
 986 #endif
 987     /* Parsing the children */
 988
 989     /* Feature tags could end up having 0 children which breaks
 990      * the render in dangerous ways. Minor hack, but insert an empty
 991      * child.  (e.g %?xx<foo> when xx isnt available ) */
 992
 993     if (children == 0)
 994     {
 995                 const char* emptyline= "";
 996                 children = 1;
 997                 element->children = skin_alloc_children(children);
 998                 if (!element->children)
 999                         return 0;
1000                 element->children_count = children;
1001                 element->children[0] = skin_parse_code_as_arg(&emptyline);
1002         }
1003         else
1004         {
1005                 element->children = skin_alloc_children(children);
1006                 if (!element->children)
1007                         return 0;
1008                 element->children_count = children;
1009
1010                 for(i = 0; i < children; i++)
1011                 {
1012                         element->children[i] = skin_parse_code_as_arg(&cursor);
1013                         if (element->children[i] == NULL)
1014                                 return 0;
1015                         skip_whitespace(&cursor);
1016 #ifdef ROCKBOX
1017                         if ((element->tag->flags&FEATURE_TAG) && feature_available)
1018                                 cursor = conditional_end;
1019 #endif
1020
1021                         if(i < children - 1 && *cursor != ENUMLISTSEPARATESYM)
1022                         {
1023                                 skin_error(SEPARATOR_EXPECTED, cursor);
1024                                 return 0;
1025                         }
1026                         else if(i == children - 1 && *cursor != ENUMLISTCLOSESYM)
1027                         {
1028                                 skin_error(CLOSE_EXPECTED, cursor);
1029                                 return 0;
1030                         }
1031                         else
1032                         {
1033                                 cursor++;
1034                         }
1035                 }
1036         }
1037     *document = cursor;
1038
1039     return 1;
1040 }
1041
1042 static int skin_parse_comment(struct skin_element* element, const char** document)
1043 {
1044     const char* cursor = *document;
1045 #ifndef ROCKBOX
1046     char* text = NULL;
1047 #endif
1048     int length;
1049     /*
1050      * Finding the index of the ending newline or null-terminator
1051      * The length of the string of interest doesn't include the leading #, the
1052      * length we need to reserve is the same as the index of the last character
1053      */
1054     for(length = 0; cursor[length] != '\n' && cursor[length] != '\0'; length++);
1055
1056     element->type = COMMENT;
1057     element->line = skin_line;
1058 #ifdef ROCKBOX
1059     element->data = NULL;
1060 #else
1061     element->data = text = skin_alloc_string(length);
1062     if (!element->data)
1063         return 0;
1064     /* We copy from one char past cursor to leave out the # */
1065     memcpy((void*)text, (void*)(cursor + 1),
1066            sizeof(char) * (length-1));
1067     text[length - 1] = '\0';
1068 #endif
1069     if(cursor[length] == '\n')
1070         skin_line++;
1071
1072     *document += (length); /* Move cursor up past # and all text */
1073     if(**document == '\n')
1074         (*document)++;
1075
1076     return 1;
1077 }
1078
1079 static struct skin_element* skin_parse_code_as_arg(const char** document)
1080 {
1081     int sublines = 0;
1082     const char* cursor = *document;
1083
1084     /* Checking for sublines */
1085     while(*cursor != '\n' && *cursor != '\0'
1086           && *cursor != ENUMLISTSEPARATESYM && *cursor != ARGLISTSEPARATESYM
1087           && *cursor != ENUMLISTCLOSESYM && *cursor != ARGLISTCLOSESYM)
1088     {
1089         if(*cursor == MULTILINESYM)
1090         {
1091             sublines = 1;
1092             break;
1093         }
1094         else if(*cursor == TAGSYM)
1095         {
1096             /* A ';' directly after a '%' doesn't count */
1097             cursor ++;
1098
1099             if(*cursor == '\0')
1100                 break;
1101
1102             cursor++;
1103         }
1104         else if(*cursor == ARGLISTOPENSYM)
1105         {
1106             skip_arglist(&cursor);
1107         }
1108         else if(*cursor == ENUMLISTOPENSYM)
1109         {
1110             skip_enumlist(&cursor);
1111         }
1112         else
1113         {
1114             /* Advancing the cursor as normal */
1115             cursor++;
1116         }
1117     }
1118
1119     if(sublines)
1120         return skin_parse_sublines_optional(document, 1);
1121     else
1122         return skin_parse_line_optional(document, 1);
1123 }
1124
1125
1126 /* Memory management */
1127 struct skin_element* skin_alloc_element()
1128 {
1129     struct skin_element* retval =  (struct skin_element*)
1130                                    skin_buffer_alloc(sizeof(struct skin_element));
1131     if (!retval)
1132         return NULL;
1133     retval->type = UNKNOWN;
1134     retval->next = NULL;
1135     retval->tag = NULL;
1136     retval->params_count = 0;
1137     retval->children_count = 0;
1138
1139     return retval;
1140
1141 }
1142 /* On a ROCKBOX build we try to save space as much as possible
1143  * so if we can, use a shared param pool which should be more then large
1144  * enough for any tag. params should be used straight away by the callback
1145  * so this is safe.
1146  */
1147 struct skin_tag_parameter* skin_alloc_params(int count, bool use_shared_params)
1148 {
1149 #ifdef ROCKBOX
1150     static struct skin_tag_parameter params[MAX_TAG_PARAMS];
1151     if (use_shared_params && count <= MAX_TAG_PARAMS)
1152     {
1153         memset(params, 0, sizeof(params));
1154         return params;
1155     }
1156 #endif
1157     size_t size = sizeof(struct skin_tag_parameter) * count;
1158     return (struct skin_tag_parameter*)skin_buffer_alloc(size);
1159
1160 }
1161
1162 char* skin_alloc_string(int length)
1163 {
1164     return (char*)skin_buffer_alloc(sizeof(char) * (length + 1));
1165 }
1166
1167 struct skin_element** skin_alloc_children(int count)
1168 {
1169     return (struct skin_element**)
1170             skin_buffer_alloc(sizeof(struct skin_element*) * count);
1171 }
1172
1173 void skin_free_tree(struct skin_element* root)
1174 {
1175 #ifndef ROCKBOX
1176     int i;
1177
1178     /* First make the recursive call */
1179     if(!root)
1180         return;
1181     skin_free_tree(root->next);
1182
1183     /* Free any text */
1184     if(root->type == TEXT || root->type == COMMENT)
1185         free(root->data);
1186
1187     /* Then recursively free any children, before freeing their pointers */
1188     for(i = 0; i < root->children_count; i++)
1189         skin_free_tree(root->children[i]);
1190     if(root->children_count > 0)
1191         free(root->children);
1192
1193     /* Free any parameters, making sure to deallocate strings */
1194     for(i = 0; i < root->params_count; i++)
1195         if(root->params[i].type == STRING)
1196             free(root->params[i].data.text);
1197     if(root->params_count > 0)
1198         free(root->params);
1199
1200     /* Finally, delete root's memory */
1201     free(root);
1202 #else
1203     (void)root;
1204 #endif
1205 }