static void _build_siblings_with_children(Fsm *fsm)
{
FsmBuilder builder;
Symbol *t_down = symbol_table_get(&fix.parser.table, "__tdown", 7);
Symbol *t_up = symbol_table_get(&fix.parser.table, "__tup", 5);
fsm_builder_init(&builder, fsm, REF_STRATEGY_MERGE);
fsm_builder_define(&builder, nzs("rule"));
fsm_builder_terminal(&builder, 0);
fsm_builder_terminal(&builder, t_down->id);
fsm_builder_terminal(&builder, 'a');
fsm_builder_terminal(&builder, t_down->id);
fsm_builder_terminal(&builder, 'b');
fsm_builder_terminal(&builder, 'c');
fsm_builder_terminal(&builder, t_up->id);
fsm_builder_terminal(&builder, 'd');
fsm_builder_terminal(&builder, t_down->id);
fsm_builder_terminal(&builder, 'e');
fsm_builder_terminal(&builder, 'f');
fsm_builder_end(&builder);
fsm_builder_done(&builder, L_EOF);
fsm_builder_dispose(&builder);
}
static void _build_child_rule_fsm(Fsm *fsm)
{
FsmBuilder builder;
Symbol *t_down = symbol_table_get(&fix.parser.table, "__tdown", 7);
fsm_builder_init(&builder, fsm, REF_STRATEGY_MERGE);
fsm_builder_define(&builder, nzs("child"));
fsm_builder_terminal(&builder, 'b');
fsm_builder_terminal(&builder, 'c');
fsm_builder_end(&builder);
fsm_builder_define(&builder, nzs("main"));
fsm_builder_terminal(&builder, 0);
fsm_builder_terminal(&builder, t_down->id);
fsm_builder_terminal(&builder, 'a');
fsm_builder_terminal(&builder, t_down->id);
fsm_builder_nonterminal(&builder, nzs("child"));
fsm_builder_end(&builder);
fsm_builder_done(&builder, L_EOF);
fsm_builder_dispose(&builder);
}
symbol_table *symbol_table_add_with_reg(symbol_table *table, char *id, symbol_dimensions dimensions, bool check, char *reg) {
symbol_table *result = malloc(sizeof(symbol_table));
if (result == NULL) {
fprintf(stderr, "Out of memory adding symbol '%s' to table %p, malloc failed (tried to allocate %lu bytes).", id, table, sizeof(symbol_table));
exit(42);
}
else if (check && symbol_table_get(table, id) != NULL) {
fprintf(stderr, "Duplicate symbol '%s'.\n", id);
exit(3);
}
#ifdef DEBUG
printf("Added symbol '%s' with register '%s'.\n", id, reg);
print_var_usage();
#endif
result->next = table;
result->id = strdup(id);
if (reg != NULL)
result->reg = strdup(reg);
result->dimensions = dimensions;
return result;
}
symbol_dimensions symbol_table_get_dimensions(symbol_table *table, char *id) {
table = symbol_table_get(table, id);
if (table == NULL) {
fprintf(stderr, "Unknown symbol '%s'.\n", id);
symbol_table_print(table);
exit(3);
}
return table->dimensions;
}
void variable_exists(symbol_table *table, char *id) {
symbol_table *element = symbol_table_get(table, id);
if (element == NULL) {
fprintf(stderr, "Unknown symbol '%s'.\n", id);
symbol_table_print(table);
exit(3);
}
printf("Identified '%s' as %p in register '%s'.\n", id, element, element->reg);
}
ast_node *node_new_definition(char *name, symbol_table *table, ast_node *value) {
ast_node *result = malloc(sizeof(ast_node));
result->op = O_VARDEF;
result->left = value;
result->right = NULL;
result->name = strdup(name);
result->reg = symbol_table_get(table, name)->reg;
result->is_imm = false;
return result;
}
ast_node *node_new_id(char *name, symbol_table *table) {
ast_node *result = malloc(sizeof(ast_node));
result->op = O_ID;
result->left = NULL;
result->right = NULL;
result->name = strdup(name);
result->is_imm = false;
table = symbol_table_get(table, name);
if (table != NULL)
result->reg = table->reg;
return result;
}
// delit to bez tech mezer
int parametrizer::tokens_get(DATA_FILE_SECTION *p_line, array<PARAM_NODE> &nodes)
{
assert(p_line);
char *p_start = p_line->line_raw_string_get();
char *p_current = p_line->line_raw_string_get();
TOKEN_STATE state = STATE_TOKEN_START;
do {
switch(state) {
case STATE_TOKEN_START:
{
assert(p_start == p_current);
char c = *p_start;
if(c == '\0') {
state = STATE_STRING_END;
}
else if(isspace(c)) {
p_start++;
}
else if(is_token_delim(c)) {
state = STATE_TOKEN_END;
} else {
state = STATE_TOKEN_IN;
}
p_current++;
break;
}
case STATE_TOKEN_IN:
{
char c = *p_current;
if(c == '\0' || is_token_delim(c) || isspace(c)) {
state = STATE_TOKEN_END;
}
else {
p_current++;
}
break;
}
case STATE_TOKEN_END:
{
PARAM_NODE token;
memset(&token,0,sizeof(token));
char c = *p_start;
int length = p_current - p_start;
assert(c != '\0' && !isspace(c));
assert(length != 0);
if(is_token(p_start, length, token) ||
is_number(p_start, length, token)) {
// It's a number or token
nodes.append(token);
}
else {
if(!is_token_delim(p_start[0])) {
// We have a variable here
if(p_start[length-2] == '.') {
// it's a part of color variable (.r .g .b .a)
// or a vector variable (.x .y .z)
switch(p_start[length-1]) {
case 'r':
token.content_type = NODE_VAR_VARIABLE_R;
length -= 2;
break;
case 'g':
token.content_type = NODE_VAR_VARIABLE_G;
length -= 2;
break;
case 'b':
token.content_type = NODE_VAR_VARIABLE_B;
length -= 2;
break;
case 'a':
token.content_type = NODE_VAR_VARIABLE_A;
length -= 2;
break;
case 'x':
token.content_type = NODE_VAR_VARIABLE_X;
length -= 2;
break;
case 'y':
token.content_type = NODE_VAR_VARIABLE_Y;
length -= 2;
break;
case 'z':
token.content_type = NODE_VAR_VARIABLE_Z;
length -= 2;
break;
default:
p_line->ppline();
pperror(TRUE, "wrong tail .%c",p_start[length-1]);
break;
}
}
else {
token.content_type = NODE_VAR_VARIABLE;
}
SYMBOL_TABLE_NODE *p_variable = symbol_table_get(symbol_table_get_active(), p_start, length);
if(!p_variable) {
p_variable = symbol_table_add(symbol_table_get_active(), p_start, length);
}
if(token.content_type == NODE_VAR_VARIABLE_R ||
token.content_type == NODE_VAR_VARIABLE_G ||
token.content_type == NODE_VAR_VARIABLE_B ||
token.content_type == NODE_VAR_VARIABLE_A)
{
if(p_variable->value.type == VARIABLE_UNSET) {
p_variable->value.type = VARIABLE_RGBAF;
}
if(p_variable->value.type != VARIABLE_RGBAF) {
p_line->ppline();
pperror(TRUE, "variable %s has to be a color type! (is %s)",
p_variable->name,
variable_type_translate(p_variable->value.type));
}
}
else if(token.content_type == NODE_VAR_VARIABLE_X ||
token.content_type == NODE_VAR_VARIABLE_Y ||
token.content_type == NODE_VAR_VARIABLE_Z)
{
if(p_variable->value.type == VARIABLE_UNSET) {
p_variable->value.type = VARIABLE_VECT3DF;
}
if(p_variable->value.type != VARIABLE_VECT3DF) {
p_line->ppline();
pperror(TRUE, "variable %s has to be a vector type! (is %s)",
p_variable->name,
variable_type_translate(p_variable->value.type));
}
}
token.node_type = NODE_VARIABLE;
token.p_cvariable = p_variable;
// Append it
nodes.append(token);
}
}
p_start = p_current;
state = STATE_TOKEN_START;
break;
}
default:
break;
}
} while(state != STATE_STRING_END);
return(nodes.num_get());
}
