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