/* Releases the memory allocated for the AST and its subnodes */
void free_ast(ast_st* a) {
switch(a->en) {
case Plus:
case Minus:
case Mult:
case Div:
case Eq:
case Ne:
case Lt:
case Le:
case Gt:
case Ge:
free_ast(a->childs.left);
free_ast(a->childs.right);
free(a);
break;
case Integer:
case Real:
free(a);
break;
default: break;
}
}
void free_ast(Node* node) {
switch (node->type) {
case eVAR:
{
Var* var = (Var*) node;
free(var->value);
free(var);
break;
}
case eAND:
{
And* and = (And*) node;
free_ast(and->left);
free_ast(and->right);
free(and);
break;
}
case eOR:
{
Or* or = (Or*) node;
free_ast(or->left);
free_ast(or->right);
free(or);
break;
}
case eNOT:
{
Not* not = (Not*) node;
free_ast(not->other);
free(not);
break;
}
}
}
static void free_ast(ReAst *ast)
{
if (!ast) {
return;
}
free_ast(ast->lhs);
free_ast(ast->rhs);
free(ast);
}
struct ast_object* ast_remove_attribute(struct ast_object* ast, char* name)
{
struct ast_object** attr = &ast->u.on.attrs;
for (; *attr != NULL; attr = &(*attr)->u.an.next) {
assert((*attr)->type == nodeType_Attribute);
struct ast_object* pair = (*attr)->u.an.attr;
struct ast_object* left = pair->u.pn.left;
if (strcmp(left->u.in.str, name) == 0) {
struct ast_object* current_attr = *attr;
*attr = current_attr->u.an.next;
current_attr->u.an.next = NULL;
current_attr->u.an.attr = NULL;
free_ast(current_attr);
return pair;
}
}
return NULL;
}
void cycle_to_point(ast root , ast first_param , ast parent)
{
parent-> left = first_param;
free_ast(root);
return;
}
int main(int argc, char *argv[]) {
num_tokens = 0;
num_vars = 0;
// set yyin to file if passed by user
if(argc > 1) {
yyin = fopen(argv[1], "r");
if(yyin == NULL) {
printf("error: invalid file\n");
exit(1);
}
}
else {
printf("> "); // prompt
}
yyparse();
fclose(yyin);
generate_pla(root);
and_or_not(root);
freopen ("/dev/tty", "a", stdout); // make sure stdout is restored
free_ast(root);
empty_tokens();
reformat_output();
// print output
char *fname = (char *)"out.pla";
print_file(&fname);
return 0;
}
/* Does the action for the -test command */
int do_test (int argc, const char ** argv) {
int i, val, size = 0;
char * buffer;
for (i=0; i<argc; i++) size += strlen(argv[i]) + 1;
buffer = (char*) malloc(sizeof(char) * size);
strcpy(buffer, argv[0]);
for (i=1; i<argc; i++) {
strcat(buffer, " ");
strcat(buffer, argv[i]);
}
yy_scan_string(buffer);
yylex();
yyparse ();
if (result == NULL) return;
val = eval(result);
/* printf("%d\n", val); */
free_ast(result);
free(buffer);
yylex_destroy();
return val;
}
void exec_statements(env_t* env, ast_t* ast) {
size_t i;
for(i = 0; i < ast->data.statements.count; i++) {
switch(ast->data.statements.statements[i]->type) {
case at_assignment:
exec_assignment(env, ast->data.statements.statements[i]);
break;
case at_call: {
ast_t* tmp = eval_call(env, ast->data.statements.statements[i]);
if(tmp != NULL) {
if(tmp->ref_count == 0) {
free_ast(tmp);
}
}
break;
}
case at_conditional:
exec_conditional(env, ast->data.statements.statements[i]);
break;
case at_while:
exec_while(env, ast->data.statements.statements[i]);
break;
case at_dowhile:
exec_dowhile(env, ast->data.statements.statements[i]);
break;
default:
error_unexpected(NULL,get_ast_type_name(ast->data.statements.statements[i]->type));
break;
}
}
}
errval_t del_record(struct ast_object* ast, struct oct_query_state* sqs)
{
assert(ast != NULL);
assert(sqs != NULL);
for (size_t i = 0; i < MAX_RECORDS; i++) {
struct record* entry = &record_storage[i];
if (entry->name == NULL) {
continue;
}
if (strcmp(RECORD_NAME(ast), entry->name) == 0) {
assert(entry->record != NULL);
free(entry->name);
entry->name = NULL;
free_ast(entry->record);
entry->record = NULL;
// Free the waiting list, this should be NULL anyways I guess
struct wait_queue* cur = entry->waiting_parties;
while (cur != NULL) {
struct wait_queue* next = cur->next;
free(cur);
cur = next;
}
entry->waiting_parties = NULL;
return SYS_ERR_OK;
}
}
return OCT_ERR_NO_RECORD;
}
int ne_parse(const char *formula)
{
int err;
struct symbol_table *sym;
ne.buf = yy_scan_string(formula, ne.scanner);
yyset_lineno(1, ne.scanner);
yyset_column(1, ne.scanner);
__ne_clear_error(&ne);
err = yyparse(&ne);
if (!err) {
__ne_put_result(&ne, eval(&ne, ne.root));
sym = get_sym(&ne, "y");
if (sym && sym->dirty) {
__ne_put_result(&ne, __ne_get_y(&ne));
clean_output_sym(&ne);
}
}
if (ne.error != 0)
err = ne.error;
else if (ne.warrning != 0)
err = ne.warrning;
free_ast(ne.root);
ne.root = NULL;
ne.stop = 0;
yy_delete_buffer(ne.buf, ne.scanner);
return err;
}
/* Creates an ast node from the given operation and the two child nodes */
ast_st* create_node(kind_en op, ast_st* left, ast_st* right) {
ast_st *a;
if ((a = (ast_st*) malloc(sizeof(ast_st))) == NULL) {
free_ast(left);
free_ast(right);
exit(1);
}
a->childs.left = left;
a->childs.right = right;
a->en = op;
return a;
}
static void _delete_ast(ast *t){
for(size_t i = 0; i < t->size; ++i){
_delete_ast(t->children[i]);
}
free((char*)t->text);//discard const qualifier
free(t->children);
free_ast(t);
}
void re_free(Re *re)
{
free(re->tpool[0].threads);
free(re->tpool[1].threads);
free(re->insts);
free_ast(re->ast);
free(re);
}
void free_ast_lst(AST_lst *ptr) {
if (ptr == NULL) {
return;
} else {
free_ast(ptr->val);
free_ast_lst(ptr->next);
free(ptr);
}
}
ast *flatten_ast(ast *t){
ast *ret = t;
for(size_t i = 0; i < t->size; ++i){
t->children[i] = flatten_ast(t->children[i]);
}
if(t->size == 1){
if(t->children[0]->name){
ret = t->children[0];
free_ast(t);
}else{
t->text = t->children[0]->text;
t->length = t->children[0]->length;
free_ast(t->children[0]);
free(t->children);
t->size = 0;
}
}
return ret;
}
void binary_expr_to_number(ast root , ast parent)
{
int val = eval_binary_ast(root);
ast node = create_number_node(val);
if (root == parent-> left)
parent-> left = node;
else
parent-> right = node;
free_ast(root);
// return;
}
void free_ast (astree* root) {
while (not root->children.empty()) {
astree* child = root->children.back();
root->children.pop_back();
free_ast (child);
}
DEBUGF ('f', "free [%p]-> %d:%d.%d: %s: \"%s\")\n",
root, root->filenr, root->linenr, root->offset,
get_yytname (root->symbol), root->lexinfo->c_str());
delete root;
}
void remove_right(t_ast **ast)
{
t_ast *tmp;
t_ast *prev;
tmp = *ast;
prev = tmp;
while (tmp != NULL && tmp->right != NULL && tmp->right->oper != -1)
{
prev = tmp;
tmp = tmp->right;
}
if (tmp == prev && tmp != NULL)
{
free_ast(tmp->right);
*ast = (*ast)->left;
}
else if (tmp != NULL)
{
prev->right = tmp->left;
free_ast(tmp->right);
}
}
/* Takes a "${<calculus>}" and render the value associated */
int parseArithToValue (const char * arith) {
int val = 0;
yy_scan_string(arith);
yylex();
yyparse ();
val = eval(result);
free_ast(result);
yylex_destroy();
return val;
}
void free_ast(struct ast_object* p)
{
if (p == NULL) {
return;
}
switch (p->type) {
case nodeType_Object:
free_ast(p->u.on.name);
free_ast(p->u.on.attrs);
break;
case nodeType_Attribute:
free_ast(p->u.an.attr);
free_ast(p->u.an.next);
break;
case nodeType_String:
free(p->u.sn.str);
p->u.sn.str = NULL;
break;
case nodeType_Ident:
free(p->u.in.str);
p->u.in.str = NULL;
break;
case nodeType_Constraint:
free_ast(p->u.cnsn.value);
break;
case nodeType_Pair:
free_ast(p->u.pn.left);
free_ast(p->u.pn.right);
break;
case nodeType_Unset:
assert(!"nodeType_Unset encountered in free_ast!");
abort();
break;
default:
// Nothing special to do for value nodes
break;
}
free(p);
}
static VALUE Bool_parse(VALUE klass, VALUE r_expr) {
Node* ast;
char* expr;
if(NIL_P(klass)) {
rb_raise(rb_eRuntimeError, "Bool klass was nil");
}
// TODO: Verify that r_expr is a String
expr = RSTRING_PTR(r_expr);
ast = parse_ast(expr);
if(ast != NULL) {
VALUE result = transform(ast);
free_ast(ast);
return result;
} else {
rb_raise(rb_eParseError, "%s", last_error_msg);
}
}
int main(int argc, char *argv[])
{
if (argc <= 1) {
return 1;
}
// ./cc src.cmm out.s
FILE *file;
file = fopen(argv[1], "r");
asm_file = fopen(argv[2], "w");
if (!file) {
perror(argv[1]);
return 1;
}
else if (!asm_file) {
perror(argv[2]);
return 1;
}
init_strtab();
yyrestart(file);
yyparse();
if (!is_syn_error) {
semantic_analysis();
if (!semantic_error) {
translate();
}
}
free_ast();
return 0;
}
void merge_ast(ast *t, ast *c){
if(!t){
delete_ast(c);
return;
}
if(t->size){
size_t size = t->size + c->size;
void *tmp = realloc(t->children, size*sizeof(ast*));
if(!tmp){
//TODO: Handle error
return;
}
t->children = tmp;
memcpy(t->children + t->size, c->children, c->size*sizeof(ast*));
t->size = size;
free(c->children);
}else{
t->children = c->children;
t->size = c->size;
}
if(t->length){
size_t length = t->length + c->length;
void *tmp = realloc((void*)t->text, length*sizeof(char));
if(!tmp){
t->children = realloc(t->children, t->size*sizeof(ast*));
return;
}
t->text = tmp;
memcpy((void*)t->text + t->length, c->text, c->length*sizeof(char));
t->length = length;
free((char*)c->text);//discard const qualifier
}else{
t->text = c->text;
t->length = c->length;
}
free_ast(c);
}
void free_ast3 (astree* tree1, astree* tree2, astree* tree3) {
free_ast (tree1);
free_ast (tree2);
free_ast (tree3);
}
void free_ast2 (astree* tree1, astree* tree2) {
free_ast (tree1);
free_ast (tree2);
}
