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