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