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