You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
eon/parser/parser.c

205 lines
6.7 KiB

#include <stdio.h>
#include <stdlib.h>
#include "../vars/vars.c"
//hashmaps/link list heads
extern map_void_t *_var_map;
extern node_info *_temp_statement_head;
//struct variable *_var_head = NULL;
extern map_void_t *_function_list;
node_info* create_var_assignment_string(char *p_name, char *value)
{
node_info *new_node = malloc(sizeof(node_info));
variable *new_var = make_variable_string(p_name, value);
newNode->type = ASSIGNMENT;
newNode->opperation = 1;
newNode->var = new_var;
return new_node;
}
node_info* create_var_assignment_int(char *p_name, int value)
{
node_info *new_node = malloc(sizeof(node_info));
variable *new_var = make_variable_int(p_name, value);
newNode->type = ASSIGNMENT;
newNode->opperation = 1;
newNode->var = new_var;
return new_node;
}
node_info* create_var_assignment_char(char *p_name, char value)
{
node_info *new_node = malloc(sizeof(node_info));
variable *new_var = make_variable_char(p_name, value);
newNode->type = ASSIGNMENT;
newNode->opperation = 1;
newNode->var = new_var;
return new_node;
}
node_info* create_var_assignment_double(char *p_name, double value)
{
node_info *new_node = malloc(sizeof(node_info));
variable *new_var = make_variable_double(p_name, value);
//new node stuff
newNode->type = ASSIGNMENT;
newNode->opperation = 1;
newNode->var = newVar;
return new_node;
}
/*
Adds statement to linked list.
@param nodeInfo link to be added.
@return head of linked list.
*/
node_info* add_to_compound_statement(node_info *new_statement, node_info *statement_head)
{
if(!statement_head)
{
statement_head = malloc(sizeof(node_info));
statement_head->opperation = 5;
statement_head->next = new_statement;
statement_head->next->next = NULL;
statement_head->statement_list = NULL;
}
else
{
node_info *p = statement_head; //make a temp of list head, so we can traverse it
//TODO replace with double linked list end
while (p->statement_list)
p = p->statement_list;
//TODO replace with double linked list end
while (p->next)
p = p->next;
p->next = malloc(sizeof(node_info));
p->next = new_statement;
p->next->next = NULL;
}
return statement_head;
}
/*
Executes a statment.
@param nodeInfo statement to be executed
@return void.
*/
//TODO break this switch up into multiple functions
//TODO return status code possibly.
void ex(node_info *exec_node)
{
switch(exec_node->opperation)
{
case 1:
add_var(exec_node->var->name, exec_node->var->value, _var_map);
break;
//TODO expression stuff
case 2:
break;
//print
case 3:
switch(exec_node->printExpression.opperation) {
case 1:
printf("%d\n", (int) exec_node->printExpression.value);
break;
case 2:
printf("%s\n", exec_node->printExpression.string);
break;
case 3:
printf("%s%lf\n", exec_node->printExpression.string, exec_node->printExpression.value);
break;
default:
printf("{ERROR} CHECK YACC FILE FOR INCORRECT PRINT\n");
}
break;
//logic (if, while, for, etc)
case 4:
switch(exec_node->logicalExpression.opperation) {
case 1:
if (exec_node->logicalExpression.expr == 1)
ex(exec_node->logicalExpression.if_true);
break;
case 2:
while (exec_node->logicalExpression.expr == 1)
ex(exec_node->logicalExpression.while_true);
break;
default:
printf("{ERROR} SOMETHING WRONG WITH LOGICAL EXPRESSION CHECK YACC\n");
}
break;
case 5:
while(exec_node->next != NULL)
{
exec_node = exec_node->next;
ex(exec_node);
}
break;
case 6:
;
variable_values *value = get_value(exec_node->name, _var_map);
switch(value->type)
{
case VAR_STRING:
printf("%s\n", value->_string);
break;
case VAR_INT:
printf("%d\n", value->_int);
break;
case VAR_CHAR:
printf("%c\n", value->_char);
break;
case VAR_DOUBLE:
printf("%f\n", value->_double);
break;
case VAR_VOID: //TODO add void variable type
break;
default:
printf("{ERROR} NO SUCH VARIABLE TYPE CHECK YACC!\n");
}
break;
//TODO update default to case 7 for functions
default:
;
switch(exec_node->type)
{
case FUNCTION_CALL:
;
//gets the statements of a function with the provided name
node_info *_stmts = *map_get(&*((map_void_t* ) _function_list), exec_node->name);
while (_stmts->next != NULL) { //loop over all the statements and execute them
_stmts = _stmts->next;
ex(_stmts);
}
break;
case FUNCTION:
;
//if the list of functions already defined is null then we malloc space for it.
if (!_function_list)
{
_function_list = malloc(sizeof(map_void_t));
exec_node->_var_list = malloc(sizeof(node_info));
exec_node->next = NULL;
exec_node->local_list = NULL;
map_init(&*((map_void_t *) _function_list));
map_init(&*((map_void_t *) exec_node->_var_list));
//put the function in the hashmap
map_set(&*((map_void_t* ) _function_list), exec_node->name, &*exec_node->_function_body);
} else //else we dont malloc, we just put the function inside of the hashmap.
map_set(&*((map_void_t* ) _function_list), exec_node->name, &*exec_node->_function_body);
break;
default:
;
//TODO add error here and close
}
}
}