335 lines
8.7 KiB
C
335 lines
8.7 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "skin_parser.h"
|
|
#include "skin_debug.h"
|
|
#include "tag_table.h"
|
|
|
|
/* Global variables for debug output */
|
|
int debug_indent_level = 0;
|
|
extern int skin_line;
|
|
extern char* skin_start;
|
|
extern char* skin_buffer;
|
|
|
|
/* Global error variables */
|
|
static int error_line;
|
|
static int error_col;
|
|
static const char *error_line_start;
|
|
static char* error_message;
|
|
|
|
|
|
static inline struct skin_element*
|
|
get_child(OFFSETTYPE(struct skin_element**) children, int child)
|
|
{
|
|
struct skin_element **kids = SKINOFFSETTOPTR(skin_buffer, children);
|
|
return kids[child];
|
|
}
|
|
|
|
/* Debugging functions */
|
|
void skin_error(enum skin_errorcode error, const char* cursor)
|
|
{
|
|
|
|
error_col = 0;
|
|
|
|
while(cursor > skin_start && *cursor != '\n')
|
|
{
|
|
cursor--;
|
|
error_col++;
|
|
}
|
|
error_line_start = cursor+1;
|
|
|
|
error_line = skin_line;
|
|
|
|
switch(error)
|
|
{
|
|
case MEMORY_LIMIT_EXCEEDED:
|
|
error_line_start = NULL;
|
|
printf("Error: Memory limit exceeded at Line %d\n", skin_line);
|
|
error_message = "Memory limit exceeded";
|
|
break;
|
|
case NEWLINE_EXPECTED:
|
|
error_message = "Newline expected";
|
|
break;
|
|
case ILLEGAL_TAG:
|
|
error_message = "Illegal tag";
|
|
break;
|
|
case ARGLIST_EXPECTED:
|
|
error_message = "Argument list expected";
|
|
break;
|
|
case TOO_MANY_ARGS:
|
|
error_message = "Too many arguments given";
|
|
break;
|
|
case DEFAULT_NOT_ALLOWED:
|
|
error_message = "Argument can not be set to default";
|
|
break;
|
|
case UNEXPECTED_NEWLINE:
|
|
error_message = "Unexpected newline";
|
|
break;
|
|
case INSUFFICIENT_ARGS:
|
|
error_message = "Not enough arguments";
|
|
break;
|
|
case INT_EXPECTED:
|
|
error_message = "Expected integer";
|
|
break;
|
|
case DECIMAL_EXPECTED:
|
|
error_message = "Expected decimal";
|
|
break;
|
|
case SEPARATOR_EXPECTED:
|
|
error_message = "Expected argument separator";
|
|
break;
|
|
case CLOSE_EXPECTED:
|
|
error_message = "Expected list close";
|
|
break;
|
|
case MULTILINE_EXPECTED:
|
|
error_message = "Expected subline separator";
|
|
break;
|
|
case GOT_CALLBACK_ERROR:
|
|
error_message = "Parser callback returned error";
|
|
break;
|
|
};
|
|
|
|
}
|
|
|
|
int skin_error_line()
|
|
{
|
|
return error_line;
|
|
}
|
|
|
|
int skin_error_col()
|
|
{
|
|
return error_col;
|
|
}
|
|
|
|
char* skin_error_message()
|
|
{
|
|
return error_message;
|
|
}
|
|
|
|
void skin_clear_errors()
|
|
{
|
|
error_line = 0;
|
|
error_col = 0;
|
|
error_message = NULL;
|
|
}
|
|
|
|
#if !defined(ROCKBOX) || defined(__PCTOOL__)
|
|
void skin_debug_tree(struct skin_element* root)
|
|
{
|
|
int i;
|
|
char *text;
|
|
|
|
struct skin_element* current = root;
|
|
|
|
while(current)
|
|
{
|
|
skin_debug_indent();
|
|
|
|
switch(current->type)
|
|
{
|
|
case UNKNOWN:
|
|
printf("* Unknown element.. error *\n");
|
|
break;
|
|
|
|
case VIEWPORT:
|
|
printf("{ Viewport \n");
|
|
|
|
debug_indent_level++;
|
|
skin_debug_tree(get_child(current->children, 0));
|
|
debug_indent_level--;
|
|
|
|
printf("}");
|
|
break;
|
|
|
|
case TEXT:
|
|
text = SKINOFFSETTOPTR(skin_buffer, current->data);
|
|
printf("* Plain text on line %d: \"%s\"\n", current->line, text);
|
|
break;
|
|
|
|
case COMMENT:
|
|
printf("# Comment on line %d\n ", current->line);
|
|
break;
|
|
|
|
case TAG:
|
|
if (current->params_count)
|
|
{
|
|
printf("( %%%s tag on line %d with %d arguments\n",
|
|
current->tag->name,
|
|
current->line, current->params_count);
|
|
debug_indent_level++;
|
|
skin_debug_params(current->params_count, SKINOFFSETTOPTR(skin_buffer, current->params));
|
|
debug_indent_level--;
|
|
skin_debug_indent();
|
|
printf(")\n");
|
|
}
|
|
else
|
|
{
|
|
printf("[ %%%s tag on line %d ]\n",
|
|
current->tag->name, current->line);
|
|
}
|
|
|
|
break;
|
|
|
|
case LINE_ALTERNATOR:
|
|
printf("[ Alternator on line %d with %d sublines \n", current->line,
|
|
current->children_count);
|
|
debug_indent_level++;
|
|
for(i = 0; i < current->children_count; i++)
|
|
{
|
|
skin_debug_tree(get_child(current->children, i));
|
|
}
|
|
debug_indent_level--;
|
|
|
|
skin_debug_indent();
|
|
printf("]\n");
|
|
break;
|
|
|
|
case CONDITIONAL:
|
|
printf("< Conditional tag %%?%s on line %d with %d enumerations \n",
|
|
current->tag->name, current->line, current->children_count);
|
|
debug_indent_level++;
|
|
|
|
for(i = 0; i < current->children_count; i++)
|
|
{
|
|
skin_debug_indent();
|
|
printf("[ Enumeration %d\n", i);
|
|
debug_indent_level++;
|
|
skin_debug_tree(get_child(current->children, i));
|
|
debug_indent_level--;
|
|
skin_debug_indent();
|
|
printf("]\n");
|
|
}
|
|
|
|
debug_indent_level--;
|
|
skin_debug_indent();
|
|
printf(">\n");
|
|
|
|
|
|
break;
|
|
|
|
case LINE:
|
|
printf("[ Logical line on line %d\n", current->line);
|
|
|
|
debug_indent_level++;
|
|
if (current->children)
|
|
skin_debug_tree(get_child(current->children, 0));
|
|
debug_indent_level--;
|
|
|
|
skin_debug_indent();
|
|
printf("]\n");
|
|
break;
|
|
}
|
|
|
|
current = SKINOFFSETTOPTR(skin_buffer, current->next);
|
|
}
|
|
|
|
}
|
|
|
|
void skin_debug_params(int count, struct skin_tag_parameter params[])
|
|
{
|
|
int i;
|
|
for(i = 0; i < count; i++)
|
|
{
|
|
|
|
skin_debug_indent();
|
|
switch(params[i].type)
|
|
{
|
|
case DEFAULT:
|
|
printf("-");
|
|
break;
|
|
|
|
case STRING:
|
|
printf("string: \"%s\"", SKINOFFSETTOPTR(skin_buffer, params[i].data.text));
|
|
break;
|
|
|
|
case INTEGER:
|
|
printf("integer: %d", params[i].data.number);
|
|
break;
|
|
|
|
case DECIMAL:
|
|
printf("decimal: %d.%d", params[i].data.number/10,
|
|
params[i].data.number%10);
|
|
break;
|
|
|
|
case CODE:
|
|
printf("Skin Code: \n");
|
|
debug_indent_level++;
|
|
skin_debug_tree(SKINOFFSETTOPTR(skin_buffer, params[i].data.code));
|
|
debug_indent_level--;
|
|
skin_debug_indent();
|
|
break;
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
}
|
|
|
|
void skin_debug_indent(void)
|
|
{
|
|
int i;
|
|
for(i = 0; i < debug_indent_level; i++)
|
|
printf(" ");
|
|
}
|
|
|
|
#endif
|
|
|
|
#define MIN(a,b) ((a<b)?(a):(b))
|
|
void skin_error_format_message(void)
|
|
{
|
|
int i;
|
|
char text[128];
|
|
if (!error_line_start)
|
|
return;
|
|
char* line_end = strchr(error_line_start, '\n');
|
|
int len = MIN(line_end - error_line_start, 80);
|
|
if (!line_end)
|
|
len = strlen(error_line_start);
|
|
printf("Error on line %d.\n", error_line);
|
|
error_col--;
|
|
if (error_col <= 10)
|
|
{
|
|
strncpy(text, error_line_start, len);
|
|
text[len] = '\0';
|
|
}
|
|
else
|
|
{
|
|
int j;
|
|
/* make it fit nicely.. "<start few chars>...<10 chars><error>" */
|
|
strncpy(text, error_line_start, 6);
|
|
i = 5;
|
|
text[i++] = '.';
|
|
text[i++] = '.';
|
|
text[i++] = '.';
|
|
for (j=error_col-10; j < len && error_line_start[j] && error_line_start[j] != '\n'; j++)
|
|
text[i++] = error_line_start[j];
|
|
text[i] = '\0';
|
|
error_col = 18;
|
|
}
|
|
printf("%s\n", text);
|
|
for (i=0; i<error_col; i++)
|
|
text[i] = ' ';
|
|
snprintf(&text[i],64, "^ \'%s\' Here", error_message);
|
|
printf("%s\n", text);
|
|
}
|