Index: tag_table.c =================================================================== --- tag_table.c (revision 0) +++ tag_table.c (revision 0) @@ -0,0 +1,74 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2010 Robert Bieber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include "tag_table.h" + +#include + +/* The tag definition table */ +struct tag_info legal_tags[] = +{ + { "V" , "IIiii|ss" }, + { "Vi" , "S?IIiii2s?" }, + { "Vd" , "S" }, + { "" , ""} /* Keep this here to mark the end of the table */ +}; + +/* A table of legal escapable characters */ +char legal_escape_characters[] = "%<|>;#,"; + +/* + * Just does a straight search through the tag table to find one by + * the given name + */ +char* find_tag(char* name) +{ + + struct tag_info* current = legal_tags; + + /* + * Continue searching so long as we have a non-empty name string + * and the name of the current element doesn't match the name + * we're searching for + */ + + while(strcmp(current->name, name) && current->name[0] != '\0') + current++; + + if(current->name[0] == '\0') + return NULL; + else + return current->params; + +} + +/* Searches through the legal escape characters string */ +int find_escape_character(char lookup) +{ + char* current = legal_escape_characters; + while(*current != lookup && *current != '\0') + current++; + + if(*current == lookup) + return 1; + else + return 0; +} Property changes on: tag_table.c ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Index: main.c =================================================================== --- main.c (revision 0) +++ main.c (revision 0) @@ -0,0 +1,16 @@ +#include "generic_parser.h" + +#include +#include + +int main(int argc, char* argv[]) +{ + char* doc = "This is a sample, WPS d%;ocument#SOME COMMENTS HERE\nMore text" + "\nAnd some more"; + + struct skin_element* test = skin_parse(doc); + + skin_debug_tree(test); + + return 0; +} Property changes on: main.c ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Index: tag_table.h =================================================================== --- tag_table.h (revision 0) +++ tag_table.h (revision 0) @@ -0,0 +1,79 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2010 Robert Bieber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef TAG_TABLE_H +#define TAG_TABLE_H + +/* + * Struct for tag parsing information + * name - The name of the tag, i.e. V for %V + * params - A string specifying all of the tags parameters, each + * character representing a single parameter. Valid + * characters for parameters are: + * I - Required integer + * i - Nullable integer + * S - Required string + * s - Nullable string + * F - Required file name + * f - Nullable file name + * C - Required WPS code + * Any nullable parameter may be replaced in the WPS file + * with a '-'. To specify that parameters may be left off + * altogether, place a '|' in the parameter string. For + * instance, with the parameter string... + * Ii|Ss + * one integer must be specified, one integer can be + * specified or set to default with '-', and the user can + * stop providing parameters at any time after that. + * To specify multiple instances of the same type, put a + * number before the character. For instance, the string... + * 2s + * will specify two strings. To make a single parameter + * optional, place a ? after it. For instance, the string... + * I? + * specifies a single, non-nullable integer. The two may be + * combined into forms such as... + * 2s? + * which specifies an optional group of two strings + * + */ +struct tag_info +{ + + char* name; + char* params; + +}; + +/* + * Finds a tag by name and returns its parameter list, or an empty + * string if the tag is not found in the table + */ +char* find_tag(char* name); + +/* + * Determines whether a character is legal to escape or not. If + * lookup is not found in the legal escape characters string, returns + * false, otherwise returns true + */ +int find_escape_character(char lookup); + +#endif /* TAG_TABLE_H */ Property changes on: tag_table.h ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Index: themeeditor.pro =================================================================== --- themeeditor.pro (revision 0) +++ themeeditor.pro (revision 0) @@ -0,0 +1,6 @@ +HEADERS += tag_table.h \ + symbols.h \ + generic_parser.h +SOURCES += tag_table.c \ + main.c \ + generic_parser.c Index: generic_parser.c =================================================================== --- generic_parser.c (revision 0) +++ generic_parser.c (revision 0) @@ -0,0 +1,500 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2010 Robert Bieber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include +#include +#include +#include + +#include "generic_parser.h" +#include "tag_table.h" +#include "symbols.h" + +/* Declaration of parse tree buffer */ +char skin_parse_tree[SKIN_MAX_MEMORY]; +int skin_current_block = 0; + +/* Global variables for the parser */ +int skin_line = 0; + +/* Global variables for debug output */ +int debug_indent_level = 0; + +/* Auxiliary parsing functions (not visible at global scope) */ +struct skin_element* skin_parse_line(char** document); +struct skin_element* skin_parse_line_optional(char** document, int conditional); +struct skin_element* skin_parse_sublines(char** document); + +int skin_parse_tag(struct skin_element* element, char** document); +int skin_parse_text(struct skin_element* element, char** document, + int conditional); +int skin_parse_conditional(struct skin_element* element, char** document); +int skin_parse_newline(struct skin_element* element, char** document); +int skin_parse_comment(struct skin_element* element, char** document); + +struct skin_element* skin_parse(char* document) +{ + + struct skin_element* root = NULL; + struct skin_element* last = NULL; + + struct skin_element** to_write = 0; + + char* cursor = document; /* Keeps track of location in the document */ + char* bookmark; /* Used when we need to look ahead */ + + int sublines = 0; /* Flag for parsing sublines */ + + skin_line = 1; + + while(*cursor != '\0') + { + + //First, we check to see if this line will contain sublines + bookmark = cursor; + sublines = 0; + while(*cursor != '\n' && *cursor != '\0') + { + if(*cursor == MULTILINESYM) + { + sublines = 1; + break; + } + else if(*cursor == TAGSYM) + { + /* A ';' directly after a '%' doesn't count */ + cursor += 2; + } + else + { + /* Advancing the cursor as normal */ + cursor++; + } + } + cursor = bookmark; + + if(!root) + to_write = &root; + else + to_write = &(last->next); + + if(sublines) + { + *to_write = skin_parse_sublines(&cursor); + last = *to_write; + if(!last) + return NULL; + } + else + { + + *to_write = skin_parse_line(&cursor); + last = *to_write; + if(!last) + return NULL; + + } + + /* Making sure last is at the end */ + while(last->next) + last = last->next; + + } + + return root; + +} + +/* Auxiliary Parsing Functions */ + +struct skin_element* skin_parse_line(char**document) +{ + + return skin_parse_line_optional(document, 0); + +} + + +/* + * If conditional is set to true, then this will break upon encountering + * SEPERATESYM. This should only be used when parsing a line inside a + * conditional, otherwise just use the wrapper function skin_parse_line() + */ +struct skin_element* skin_parse_line_optional(char** document, int conditional) +{ + char* cursor = *document; + + struct skin_element* root = NULL; + struct skin_element* current = NULL; + + while(*cursor != '\n' && *cursor != '\0' && *cursor != MULTILINESYM + && !(*cursor == ARGLISTSEPERATESYM && conditional)) + { + /* Allocating memory if necessary */ + if(root) + { + current->next = skin_alloc_element(); + current = current->next; + } + else + { + current = skin_alloc_element(); + root = current; + } + + /* Parsing the current element */ + if(*cursor == TAGSYM && cursor[1] == CONDITIONSYM) + { + if(!skin_parse_conditional(current, &cursor)) + return NULL; + } + else if(*cursor == TAGSYM) + { + if(!skin_parse_tag(current, &cursor)) + return NULL; + } + else if(*cursor == COMMENTSYM) + { + if(!skin_parse_comment(current, &cursor)) + return NULL; + } + else + { + if(!skin_parse_text(current, &cursor, conditional)) + return NULL; + } + } + + if(*cursor == '\n') + { + /* Allocating memory if necessary */ + if(root) + { + current->next = skin_alloc_element(); + current = current->next; + } + else + { + current = skin_alloc_element(); + root = current; + } + if(!skin_parse_newline(current, &cursor)) + return NULL; + } + else if(*cursor == ARGLISTSEPERATESYM) + cursor++; + + /* Moving up the calling function's pointer */ + *document = cursor; + + return root; +} + +struct skin_element* skin_parse_sublines(char** document) +{ + return NULL; +} + +int skin_parse_tag(struct skin_element* element, char** document) +{ + + char* cursor = *document + 1; + + char tag_name[3]; + char* tag_args; + + /* Checking the tag name */ + tag_name[0] = cursor[0]; + tag_name[1] = cursor[1]; + tag_name[2] = '\0'; + + /* First we check the two characters after the '%', then a single char */ + tag_args = find_tag(tag_name); + + if(!tag_args) + { + tag_name[1] = '\0'; + tag_args = find_tag(tag_name); + cursor++; + } + else + { + cursor += 2; + } + + if(!tag_args) + { + skin_error(ILLEGAL_TAG); + return 0; + } + + return 1; +} + +/* + * If the conditional flag is set true, then parsing text will stop at an + * ARGLISTSEPERATESYM. Only set that flag when parsing within a conditional + */ +int skin_parse_text(struct skin_element* element, char** document, + int conditional) +{ + char* cursor = *document; + + int length = 0; + + int dest; + + /* First figure out how much text we're copying */ + while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM + && *cursor != COMMENTSYM + && !(*cursor == ARGLISTSEPERATESYM && conditional)) + { + /* Dealing with possibility of escaped characters */ + if(*cursor == TAGSYM) + { + if(find_escape_character(cursor[1])) + cursor++; + else + break; + } + + length++; + cursor++; + } + + cursor = *document; + + /* Copying the text into the element struct */ + element->type = TEXT; + element->line = skin_line; + element->next = NULL; + element->text = skin_alloc_string(length); + + for(dest = 0; dest < length; dest++) + { + /* Advancing cursor if we've encountered an escaped character */ + if(*cursor == TAGSYM) + cursor++; + + element->text[dest] = *cursor; + cursor++; + } + element->text[length] = '\0'; + + *document = cursor; + + return 1; +} + +int skin_parse_conditional(struct skin_element* element, char** document) +{ + return 0; +} + +int skin_parse_newline(struct skin_element* element, char** document) +{ + + char* cursor = *document; + if(*cursor != '\n') + { + skin_error(NEWLINE_EXPECTED); + return 0; + } + cursor++; + + /* Assembling a skin_element struct for a newline */ + element->type = NEWLINE; + element->line = skin_line; + skin_line++; + element->text = skin_alloc_string(1); + element->text[0] = '\n'; + element->text[1] = '\0'; + element->next = NULL; + + *document = cursor; + + return 1; +} + +int skin_parse_comment(struct skin_element* element, char** document) +{ + char* cursor = *document; + + int length; + /* + * Finding the index of the ending newline or null-terminator + * The length of the string of interest doesn't include the leading #, the + * length we need to reserve is the same as the index of the last character + */ + for(length = 0; cursor[length] != '\n' && cursor[length] != '\0'; length++); + + element->type = COMMENT; + element->line = skin_line; + element->text = skin_alloc_string(length); + /* We copy from one char past cursor to leave out the # */ + memcpy((void*)(element->text), (void*)(cursor + 1), sizeof(char) * length); + element->text[length] = '\0'; + + if(cursor[length] == '\n') + skin_line++; + + *document += (length + 1); /* Move cursor up past # and all text */ + + return 1; +} + +/* Memory management */ +struct skin_element* skin_alloc_element() +{ + +#if 0 + + char* retval = &skin_parse_tree[skin_current_block * 4]; + + int delta = sizeof(struct skin_element) / (sizeof(char) * 4); + + /* If one block is partially filled, make sure to advance to the + * next one for the next allocation + */ + if(sizeof(struct skin_element) % (sizeof(char) * 4) != 0) + delta++; + + skin_current_block += delta; + + return (struct skin_element*)retval; + +#endif + + return (struct skin_element*)malloc(sizeof(struct skin_element)); + +} + +struct skin_tag_parameter* skin_alloc_params(int count) +{ + #if 0 + + char* retval = &skin_parse_tree[skin_current_block * 4]; + + int delta = sizeof(struct skin_tag_parameter) / (sizeof(char) * 4); + delta *= count; + + /* Correcting uneven alignment */ + if(count * sizeof(struct skin_tag_parameter) % (sizeof(char) * 4) != 0) + delta++; + + skin_current_block += delta; + + return (struct skin_tag_parameter*) retval; + + #endif + + return (struct skin_tag_parameter*)malloc(sizeof(struct skin_tag_parameter) + * count); + +} + +char* skin_alloc_string(int length) +{ + +#if 0 + char* retval = &skin_parse_tree[skin_current_block * 4]; + + /* Checking alignment */ + length++; /* Accounting for the null terminator */ + int delta = length / 4; + if(length % 4 != 0) + delta++; + + skin_current_block += delta; + + if(skin_current_block >= SKIN_MAX_MEMORY / 4) + skin_error(MEMORY_LIMIT_EXCEEDED); + + return retval; + +#endif + + return (char*)malloc((sizeof(char) + 1) * length); + +} + +/* Debugging functions */ +void skin_error(enum skin_errorcode error) +{ + + fprintf(stderr, "Error on line %d: ", skin_line); + + switch(error) + { + case MEMORY_LIMIT_EXCEEDED: + fprintf(stderr, "Memory limit exceeded\n"); + break; + case NEWLINE_EXPECTED: + fprintf(stderr, "Newline expected\n"); + break; + case ILLEGAL_TAG: + fprintf(stderr, "Illegal tag\n"); + break; + }; + +} + +void skin_debug_tree(struct skin_element* root) +{ + int i; + + struct skin_element* current = root; + + while(current) + { + for(i = 0; i < debug_indent_level; i++) + printf(" "); + + switch(current->type) + { + + case TEXT: + printf("[ Plain text on line %d : %s ]\n", current->line, + current->text); + break; + + case NEWLINE: + printf("[ Newline on line %d ]\n", current->line); + break; + + case COMMENT: + printf("[ Comment on line %d: ", current->line); + for(i = 0; i < (int)strlen(current->text); i++) + { + if(current->text[i] == '\n') + printf("\\n"); + else + printf("%c", current->text[i]); + } + printf(" ]\n"); + break; + + } + + current = current->next; + } + +} Property changes on: generic_parser.c ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Index: generic_parser.h =================================================================== --- generic_parser.h (revision 0) +++ generic_parser.h (revision 0) @@ -0,0 +1,116 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2010 Robert Bieber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef GENERIC_PARSER_H +#define GENERIC_PARSER_H + +#define SKIN_MAX_MEMORY 1048576 + +/******************************************************************** + ****** A global buffer will be used to store the parse tree ******* + *******************************************************************/ +extern char skin_parse_tree[]; + +/******************************************************************** + ****** Data Structures ********************************************* + *******************************************************************/ + +/* Possible types of element in a WPS file */ +enum skin_element_type +{ + TEXT, + NEWLINE, + COMMENT, + TAG, + CONDITIONAL, + SUBLINES +}; + +enum skin_errorcode +{ + MEMORY_LIMIT_EXCEEDED, + NEWLINE_EXPECTED, + ILLEGAL_TAG +}; + +/* Holds a tag parameter, either numeric or text */ +struct skin_tag_parameter +{ + enum + { + NUMERIC, + STRING, + DEFAULT + } type; + + union + { + int numeric; + char* text; + } data; + +}; + +/* Defines an element of a SKIN file */ +struct skin_element +{ + /* Defines what type of element it is */ + enum skin_element_type type; + + /* The line on which it's defined in the source file */ + int line; + + /* The original text of the tag */ + char* text; + + /* The tag or conditional name */ + char* name; + + /* Pointer to and size of an array of parameters */ + int params_count; + struct skin_tag_parameter* params; + + /* Pointer to and size of an array of children */ + int children_count; + struct skin_element* children; + + /* Link to the next element */ + struct skin_element* next; +}; + +/*********************************************************************** + ***** Functions ******************************************************* + **********************************************************************/ + +/* Parses a SKIN document and returns a list of skin_element + structures. */ +struct skin_element* skin_parse(char* document); + +/* Memory management functions */ +struct skin_element* skin_alloc_element(); +struct skin_tag_parameter* skin_alloc_params(int count); +char* skin_alloc_string(int length); + +/* Debugging functions */ +void skin_error(enum skin_errorcode error); +void skin_debug_tree(struct skin_element* root); + +#endif /* GENERIC_PARSER_H */ Property changes on: generic_parser.h ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Index: symbols.h =================================================================== --- symbols.h (revision 0) +++ symbols.h (revision 0) @@ -0,0 +1,35 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2010 Robert Bieber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef SYMBOLS_H +#define SYMBOLS_H + +/* Symbol definitions for WPS parsing */ + +#define TAGSYM '%' +#define COMMENTSYM '#' +#define CONDITIONSYM '?' +#define MULTILINESYM ';' +#define ARGLISTOPENSYM '(' +#define ARGLISTCLOSESYM ')' +#define ARGLISTSEPERATESYM ',' + +#endif /* SYMBOLS_H */ Property changes on: symbols.h ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision