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