utils/themeeditor/skin_parser.c

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