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) == 'n' ||
 547                 tolower(*tag_args) == 's' || tolower(*tag_args) == 'f')
 548         {
 549             /* Scanning a string argument */
 550             element->params[i].type = STRING;
 551             element->params[i].data.text = scan_string(&cursor);
 552
 553         }
 554         else if(tolower(*tag_args) == 'c')
 555         {
 556             /* Recursively parsing a code argument */
 557             element->params[i].type = CODE;
 558             element->params[i].data.code = skin_parse_code_as_arg(&cursor);
 559             if(!element->params[i].data.code)
 560                 return 0;
 561         }
 562
 563         skip_whitespace(&cursor);
 564
 565         if(*cursor != ARGLISTSEPERATESYM && i < num_args - 1)
 566         {
 567             skin_error(SEPERATOR_EXPECTED);
 568             return 0;
 569         }
 570         else if(*cursor != ARGLISTCLOSESYM && i == num_args - 1)
 571         {
 572             skin_error(CLOSE_EXPECTED);
 573             return 0;
 574         }
 575         else
 576         {
 577             cursor++;
 578         }
 579
 580         if (*tag_args != 'N')
 581             tag_args++;
 582
 583         /* Checking for the optional bar */
 584         if(*tag_args == '|')
 585         {
 586             optional = 1;
 587             req_args = i + 1;
 588             tag_args++;
 589         }
 590
 591     }
 592
 593     /* Checking for a premature end */
 594     if(*tag_args != '\0' && !optional)
 595     {
 596         skin_error(INSUFFICIENT_ARGS);
 597         return 0;
 598     }
 599
 600     *document = cursor;
 601
 602     return 1;
 603 }
 604
 605 /*
 606  * If the conditional flag is set true, then parsing text will stop at an
 607  * ARGLISTSEPERATESYM.  Only set that flag when parsing within a conditional
 608  */
 609 int skin_parse_text(struct skin_element* element, char** document,
 610                     int conditional)
 611 {
 612     char* cursor = *document;
 613
 614     int length = 0;
 615
 616     int dest;
 617
 618     /* First figure out how much text we're copying */
 619     while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
 620           && *cursor != COMMENTSYM
 621           && !((*cursor == ARGLISTSEPERATESYM
 622                 || *cursor == ARGLISTCLOSESYM
 623                 || *cursor == ENUMLISTSEPERATESYM
 624                 || *cursor == ENUMLISTCLOSESYM)
 625                && conditional))
 626     {
 627         /* Dealing with possibility of escaped characters */
 628         if(*cursor == TAGSYM)
 629         {
 630             if(find_escape_character(cursor[1]))
 631                 cursor++;
 632             else
 633                 break;
 634         }
 635
 636         length++;
 637         cursor++;
 638     }
 639
 640     cursor = *document;
 641
 642     /* Copying the text into the element struct */
 643     element->type = TEXT;
 644     element->line = skin_line;
 645     element->next = NULL;
 646     element->text = skin_alloc_string(length);
 647
 648     for(dest = 0; dest < length; dest++)
 649     {
 650         /* Advancing cursor if we've encountered an escaped character */
 651         if(*cursor == TAGSYM)
 652             cursor++;
 653
 654         element->text[dest] = *cursor;
 655         cursor++;
 656     }
 657     element->text[length] = '\0';
 658
 659     *document = cursor;
 660
 661     return 1;
 662 }
 663
 664 int skin_parse_conditional(struct skin_element* element, char** document)
 665 {
 666
 667     char* cursor = *document + 1; /* Starting past the "%" */
 668     char* bookmark;
 669     struct skin_element* tag = skin_alloc_element(); /* The tag to evaluate */
 670     int children = 1;
 671     int i;
 672
 673     element->type = CONDITIONAL;
 674     element->line = skin_line;
 675
 676     /* Parsing the tag first */
 677     if(!skin_parse_tag(tag, &cursor))
 678         return 0;
 679
 680     /* Counting the children */
 681     if(*(cursor++) != ENUMLISTOPENSYM)
 682     {
 683         skin_error(ARGLIST_EXPECTED);
 684         return 0;
 685     }
 686     bookmark = cursor;
 687     while(*cursor != ENUMLISTCLOSESYM && *cursor != '\n' && *cursor != '\0')
 688     {
 689         if(*cursor == COMMENTSYM)
 690         {
 691             skip_comment(&cursor);
 692         }
 693         else if(*cursor == ENUMLISTOPENSYM)
 694         {
 695             skip_enumlist(&cursor);
 696         }
 697         else if(*cursor == TAGSYM)
 698         {
 699             cursor++;
 700             if(*cursor == '\0' || *cursor == '\n')
 701                 break;
 702             cursor++;
 703         }
 704         else if(*cursor == ENUMLISTSEPERATESYM)
 705         {
 706             children++;
 707             cursor++;
 708         }
 709         else
 710         {
 711             cursor++;
 712         }
 713     }
 714     cursor = bookmark;
 715
 716     /* Parsing the children */
 717     element->children_count = children + 1; /* Make sure to include the tag */
 718     element->children = skin_alloc_children(children + 1);
 719     element->children[0] = tag;
 720
 721     for(i = 1; i < children + 1; i++)
 722     {
 723         element->children[i] = skin_parse_code_as_arg(&cursor);
 724         skip_whitespace(&cursor);
 725
 726         if(i < children && *cursor != ENUMLISTSEPERATESYM)
 727         {
 728             skin_error(SEPERATOR_EXPECTED);
 729             return 0;
 730         }
 731         else if(i == children && *cursor != ENUMLISTCLOSESYM)
 732         {
 733             skin_error(CLOSE_EXPECTED);
 734             return 0;
 735         }
 736         else
 737         {
 738             cursor++;
 739         }
 740     }
 741
 742     *document = cursor;
 743
 744     return 1;
 745 }
 746
 747 int skin_parse_comment(struct skin_element* element, char** document)
 748 {
 749     char* cursor = *document;
 750
 751     int length;
 752     /*
 753      * Finding the index of the ending newline or null-terminator
 754      * The length of the string of interest doesn't include the leading #, the
 755      * length we need to reserve is the same as the index of the last character
 756      */
 757     for(length = 0; cursor[length] != '\n' && cursor[length] != '\0'; length++);
 758
 759     element->type = COMMENT;
 760     element->line = skin_line;
 761     element->text = skin_alloc_string(length);
 762     /* We copy from one char past cursor to leave out the # */
 763     memcpy((void*)(element->text), (void*)(cursor + 1),
 764            sizeof(char) * (length-1));
 765     element->text[length - 1] = '\0';
 766
 767     if(cursor[length] == '\n')
 768         skin_line++;
 769
 770     *document += (length); /* Move cursor up past # and all text */
 771     if(**document == '\n')
 772         (*document)++;
 773
 774     return 1;
 775 }
 776
 777 struct skin_element* skin_parse_code_as_arg(char** document)
 778 {
 779
 780     int sublines = 0;
 781     char* cursor = *document;
 782
 783     /* Checking for sublines */
 784     while(*cursor != '\n' && *cursor != '\0')
 785     {
 786         if(*cursor == MULTILINESYM)
 787         {
 788             sublines = 1;
 789             break;
 790         }
 791         else if(*cursor == TAGSYM)
 792         {
 793             /* A ';' directly after a '%' doesn't count */
 794             cursor ++;
 795
 796             if(*cursor == '\0')
 797                 break;
 798
 799             cursor++;
 800         }
 801         else
 802         {
 803             /* Advancing the cursor as normal */
 804             cursor++;
 805         }
 806     }
 807
 808     if(sublines)
 809         return skin_parse_sublines_optional(document, 1);
 810     else
 811         return skin_parse_line_optional(document, 1);
 812 }
 813
 814
 815 /* Memory management */
 816 struct skin_element* skin_alloc_element()
 817 {
 818
 819 #if 0
 820
 821     char* retval = &skin_parse_tree[skin_current_block * 4];
 822
 823     int delta = sizeof(struct skin_element) / (sizeof(char) * 4);
 824
 825     /* If one block is partially filled, make sure to advance to the
 826      * next one for the next allocation
 827      */
 828     if(sizeof(struct skin_element) % (sizeof(char) * 4) != 0)
 829         delta++;
 830
 831     skin_current_block += delta;
 832
 833     return (struct skin_element*)retval;
 834
 835 #endif
 836
 837     struct skin_element* retval =  (struct skin_element*)
 838                                    malloc(sizeof(struct skin_element));
 839     retval->next = NULL;
 840     retval->params_count = 0;
 841     retval->children_count = 0;
 842
 843     return retval;
 844
 845 }
 846
 847 struct skin_tag_parameter* skin_alloc_params(int count)
 848 {
 849 #if 0
 850
 851     char* retval = &skin_parse_tree[skin_current_block * 4];
 852
 853     int delta = sizeof(struct skin_tag_parameter) / (sizeof(char) * 4);
 854     delta *= count;
 855
 856     /* Correcting uneven alignment */
 857     if(count * sizeof(struct skin_tag_parameter) % (sizeof(char) * 4) != 0)
 858         delta++;
 859
 860     skin_current_block += delta;
 861
 862     return (struct skin_tag_parameter*) retval;
 863
 864 #endif
 865
 866     return (struct skin_tag_parameter*)malloc(sizeof(struct skin_tag_parameter)
 867                                               * count);
 868
 869 }
 870
 871 char* skin_alloc_string(int length)
 872 {
 873
 874 #if 0
 875     char* retval = &skin_parse_tree[skin_current_block * 4];
 876
 877     /* Checking alignment */
 878     length++; /* Accounting for the null terminator */
 879     int delta = length / 4;
 880     if(length % 4 != 0)
 881         delta++;
 882
 883     skin_current_block += delta;
 884
 885     if(skin_current_block >= SKIN_MAX_MEMORY / 4)
 886         skin_error(MEMORY_LIMIT_EXCEEDED);
 887
 888     return retval;
 889
 890 #endif
 891
 892     return (char*)malloc(sizeof(char) * (length + 1));
 893
 894 }
 895
 896 struct skin_element** skin_alloc_children(int count)
 897 {
 898     return (struct skin_element**) malloc(sizeof(struct skin_element*) * count);
 899 }
 900
 901 void skin_free_tree(struct skin_element* root)
 902 {
 903     int i;
 904
 905     /* First make the recursive call */
 906     if(!root)
 907         return;
 908     skin_free_tree(root->next);
 909
 910     /* Free any text */
 911     if(root->type == TEXT)
 912         free(root->text);
 913
 914     /* Then recursively free any children, before freeing their pointers */
 915     for(i = 0; i < root->children_count; i++)
 916         skin_free_tree(root->children[i]);
 917     if(root->children_count > 0)
 918         free(root->children);
 919
 920     /* Free any parameters, making sure to deallocate strings */
 921     for(i = 0; i < root->params_count; i++)
 922         if(root->params[i].type == STRING)
 923             free(root->params[i].data.text);
 924     if(root->params_count > 0)
 925         free(root->params);
 926
 927     /* Finally, delete root's memory */
 928     free(root);
 929 }