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