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