From 7e4819c5443f8b4c662a81031184b5ae14d3e606 Mon Sep 17 00:00:00 2001 From: xerox Date: Sat, 16 May 2020 02:07:05 -0700 Subject: [PATCH] added update to linux --- deon-unix/deon.l | 4 +- deon-unix/deon.y | 77 +- deon-unix/functions/functions.c | 36 +- deon-unix/functions/functions.h | 2 +- deon-unix/hashmap/map.c | 275 ++-- deon-unix/linked_list/linked_list.c | 19 +- deon-unix/linked_list/linked_list.h | 2 +- deon-unix/logic/logic.c | 24 +- deon-unix/logic/logic.h | 3 +- deon-unix/make.sh | 3 +- deon-unix/make32.sh | 4 + deon-unix/parser/parser.c | 127 +- deon-unix/parser/parser.h | 3 - deon-unix/print/print.c | 22 +- deon-unix/print/print.h | 2 +- deon-unix/types.h | 2 +- deon-unix/vars/vars.c | 77 +- deon-unix/vars/vars.h | 2 + deon-win/deon/deon.tab.c | 2071 --------------------------- deon-win/deon/vars/vars.c | 3 +- 20 files changed, 339 insertions(+), 2419 deletions(-) mode change 100644 => 100755 deon-unix/make.sh create mode 100755 deon-unix/make32.sh delete mode 100644 deon-win/deon/deon.tab.c diff --git a/deon-unix/deon.l b/deon-unix/deon.l index d4ee70e..43c0fe5 100644 --- a/deon-unix/deon.l +++ b/deon-unix/deon.l @@ -6,7 +6,6 @@ #include "y.tab.h" void yyerror(char *); - extern YYSTYPE yylval; extern FILE *yyin; int yylineno; @@ -28,6 +27,8 @@ "char" { return KEYWORD_C; } "++" { return INCREASE; } "--" { return DECREASE; } +"<=" { return LESS_THAN_OR_EQUAL; } +">=" { return GREATER_THAN_OR_EQUAL; } \"(\\.|[^"\\])*\" { yytext++; yytext[strlen(yytext)-1] = 0; yylval.str_ptr = strdup(yytext); return STRING; } [a-zA-Z0-9_]+ { yylval.str_ptr = strdup(yytext); return VARNAME; } -?[0-9]*\.[0-9]+ { yylval.double_num = atof(yytext); return DOUBLEVAR; } @@ -64,7 +65,6 @@ int main(int argc, char* argv[]) || strcmp(argv[1],"d") == 0 || strcmp(argv[1],"debug") == 0) { _DEON_DEBUG = 1; - printf(">>> "); yyparse(); } else if (fh = fopen(argv[1], "r")) diff --git a/deon-unix/deon.y b/deon-unix/deon.y index 98cbe16..7aac019 100644 --- a/deon-unix/deon.y +++ b/deon-unix/deon.y @@ -13,7 +13,6 @@ int yylex(void); void yyerror(char *); extern int yylineno; - %} /* doing these before multiplication and division because they have a lower presidence */ @@ -33,14 +32,21 @@ extern int yylineno; struct node_info *node_ptr; } +%token INCREASE PRINT_TOKEN IF END KEYWORD_S KEYWORD_I KEYWORD_C QUOTE ELSE WHILE DEF CALL +%token LESS_THAN_OR_EQUAL +%token GREATER_THAN_OR_EQUAL +%token DECREASE -%token INCREASE DECREASE PRINT_TOKEN IF END KEYWORD_S KEYWORD_I KEYWORD_C QUOTE ELSE WHILE DEF CALL %token INTEGER +%type EXPR_I + %token STRING VARNAME %token CHAR + %token DOUBLEVAR +%type EXPR_D + %token FLOAT_NUM -%type EXPR %type STMT PRINT VARIABLE FUNC STMT_LIST LOGIC %% @@ -51,7 +57,7 @@ PROGRAM: ; MAIN: - MAIN FUNC ';' { if (_DEON_DEBUG == true ) { printf(">>> "); exec_stmt($2); } else { exec_stmt($2); } } + MAIN FUNC ';' { exec_stmt($2); } | ; @@ -77,43 +83,62 @@ LOGIC: IF '[' VARNAME ']' ':' '{' STMT_LIST '}' { $$ = create_logic_node(create_logic(IF_LOGIC, $7, $3)); } | WHILE '[' VARNAME ']' ':' '{' STMT_LIST '}' { $$ = create_logic_node(create_logic(WHILE_LOGIC, $7, $3)); } ; - VARIABLE: - VARNAME '=' STRING { $$ = create_variable_const($1, (void *) $3, VAR_STRING);} - | VARNAME '=' EXPR { $$ = create_variable_const($1, alloc_value(&$3, VAR_INT), VAR_INT);} - | VARNAME '=' CHAR { $$ = create_variable_const($1, alloc_value(&$3, VAR_BYTE), VAR_BYTE);} - | VARNAME '=' DOUBLEVAR { $$ = create_variable_const($1, alloc_value(&$3, VAR_DOUBLE), VAR_DOUBLE);} + VARNAME '=' STRING { $$ = create_variable($1, (void *) $3, VAR_STRING);} + | VARNAME '=' EXPR_I { $$ = create_variable($1, alloc_value(&$3, VAR_INT), VAR_INT);} + | VARNAME '=' EXPR_D { $$ = create_variable($1, alloc_value(&$3, VAR_DOUBLE), VAR_DOUBLE);} + | VARNAME '=' CHAR { $$ = create_variable($1, alloc_value(&$3, VAR_BYTE), VAR_BYTE);} + | VARNAME '=' DOUBLEVAR { $$ = create_variable($1, alloc_value(&$3, VAR_DOUBLE), VAR_DOUBLE);} | VARNAME '=' '{' STMT_LIST '}' { $$ = create_function($1, $4); } | VARNAME '=' VARNAME { $$ = move_value($1, $3); } ; -EXPR: +EXPR_I: INTEGER { $$ = $1; } - | EXPR '+' EXPR { $$ = $1 + $3; } - | EXPR '-' EXPR { $$ = $1 - $3; } - | EXPR '*' EXPR { $$ = $1 * $3; } - | EXPR '/' EXPR { $$ = $1 / $3; } - | EXPR '%' EXPR { $$ = $1 % $3; } - | EXPR '>' EXPR { if ($1 > $3) { $$ = 1; } else { $$ = 0;}} - | EXPR '<' EXPR { if ($1 < $3) { $$ = 1; } else { $$ = 0;}} - | INCREASE EXPR { $$ = $2 + 1; } - | EXPR INCREASE { $$ = $1 + 1; } - | DECREASE EXPR { $$ = $2 - 1; } - | EXPR DECREASE { $$ = $1 - 1; } - | '(' EXPR ')' { $$ = $2; } + | EXPR_I '+' EXPR_I { $$ = $1 + $3; } + | EXPR_I '-' EXPR_I { $$ = $1 - $3; } + | EXPR_I '*' EXPR_I { $$ = $1 * $3; } + | EXPR_I '/' EXPR_I { $$ = $1 / $3; } + | EXPR_I '%' EXPR_I { $$ = $1 % $3; } + | EXPR_I LESS_THAN_OR_EQUAL EXPR_I { $$ = $1 <= $3; } + | EXPR_I GREATER_THAN_OR_EQUAL EXPR_I { $$ = $1 >= $3; } + | EXPR_I '>' EXPR_I { $$ = $1 > $3; } + | EXPR_I '<' EXPR_I { $$ = $1 < $3; } + | INCREASE EXPR_I { $$ = $2 + 1; } + | EXPR_I INCREASE { $$ = $1 + 1; } + | DECREASE EXPR_I { $$ = $2 - 1; } + | EXPR_I DECREASE { $$ = $1 - 1; } + | '(' EXPR_I ')' { $$ = $2; } + | EXPR_I { $$ = $1; } + ; + +EXPR_D: + DOUBLEVAR + | EXPR_D '+' EXPR_D { $$ = $1 + $3; } + | EXPR_D '-' EXPR_D { $$ = $1 - $3; } + | EXPR_D '*' EXPR_D { $$ = $1 * $3; } + | EXPR_D '/' EXPR_D { $$ = $1 / $3; } + | EXPR_D LESS_THAN_OR_EQUAL EXPR_D { $$ = $1 <= $3; } + | EXPR_D GREATER_THAN_OR_EQUAL EXPR_D { $$ = $1 >= $3; } + | EXPR_D '>' EXPR_D { $$ = $1 > $3; } + | EXPR_D '<' EXPR_D { $$ = $1 < $3; } + | INCREASE EXPR_D { $$ = $2 + 1; } + | EXPR_D INCREASE { $$ = $1 + 1; } + | DECREASE EXPR_D { $$ = $2 - 1; } + | EXPR_D DECREASE { $$ = $1 - 1; } + | '(' EXPR_D ')' { $$ = $2; } + | EXPR_D { $$ = $1; } ; PRINT: VARNAME { $$ = create_print_variable($1); } - | EXPR { $$ = create_print_statement(VAR_INT, alloc_value(&$1, VAR_INT)); } + | EXPR_I { $$ = create_print_statement(VAR_INT, alloc_value(&$1, VAR_INT)); } | STRING { $$ = create_print_statement(VAR_STRING, $1); } ; - %% void yyerror(char *s) { fprintf(stderr, "Error on line %d, %s\n", yylineno, s); -} - +} \ No newline at end of file diff --git a/deon-unix/functions/functions.c b/deon-unix/functions/functions.c index 55e3e5c..b51b43c 100644 --- a/deon-unix/functions/functions.c +++ b/deon-unix/functions/functions.c @@ -8,18 +8,13 @@ create a function given the name of the function and the statements */ -static node_info *create_function(char *p_name, node_info *p_stmts) +static node_info* create_function(char* p_name, node_info* p_stmts) { - node_info *new_node = malloc(sizeof(node_info)); - if (!p_name || !p_stmts || !new_node) + if (!p_name || !p_stmts) return NULL; - memset(new_node, NULL, sizeof(*new_node)); + node_info *new_node = malloc(sizeof(node_info)); new_node->function_body = malloc(sizeof(node_info)); - if (!new_node->function_body) - return NULL; - - memset(new_node->function_body, NULL, sizeof(*new_node->function_body)); new_node->operation = FUNCTION_OPERATION; new_node->operation_type.func = FUNCTION; new_node->name = p_name; @@ -35,13 +30,12 @@ static node_info *create_function(char *p_name, node_info *p_stmts) create a function call given the name TODO add scope. */ -static node_info *create_function_call(char *p_name) +static node_info* create_function_call(char* p_name) { - node_info *new_node = malloc(sizeof(node_info)); - if (!new_node || !p_name) + if (!p_name) return NULL; - memset(new_node, NULL, sizeof(*new_node)); + node_info *new_node = malloc(sizeof(node_info)); new_node->operation = FUNCTION_OPERATION; new_node->operation_type.func = FUNCTION_CALL; new_node->name = p_name; @@ -55,7 +49,7 @@ static node_info *create_function_call(char *p_name) create compound statement given statement list and head of linked list. */ -static node_info *create_compound_statement(node_info *new_statement_list, node_info *statement_head) +static node_info* create_compound_statement(node_info* new_statement_list, node_info* statement_head) { if (!new_statement_list) return NULL; @@ -64,20 +58,13 @@ static node_info *create_compound_statement(node_info *new_statement_list, node_ { statement_head = malloc(sizeof(node_info)); node_info* new_node = malloc(sizeof(node_info)); - if (!new_node || !statement_head) - return NULL; - memset(statement_head, NULL, sizeof(*statement_head)); - memset(new_node, NULL, sizeof(*new_node)); statement_head->statement_list = malloc(sizeof(node_info)); - if (!statement_head->statement_list) - return NULL; - memset(statement_head->statement_list, NULL, - sizeof(*statement_head->statement_list)); - statement_head->operation = EXEC_STMT_LIST_OPERATION; statement_head->statement_list->operation = EXEC_STMT_LIST_OPERATION; statement_head->statement_list->next = new_statement_list; + + statement_head->next = NULL; statement_head->statement_list->statement_list = NULL; } else @@ -88,12 +75,9 @@ static node_info *create_compound_statement(node_info *new_statement_list, node_ p_temp_head = p_temp_head->statement_list; p_temp_head->statement_list = malloc(sizeof(node_info)); - if (!p_temp_head->statement_list) - return NULL; - memset(p_temp_head->statement_list, NULL, sizeof(*p_temp_head->statement_list)); - p_temp_head->operation = EXEC_STMT_LIST_OPERATION; p_temp_head->statement_list->operation = EXEC_STMT_LIST_OPERATION; + p_temp_head->statement_list->next = new_statement_list; p_temp_head->statement_list->statement_list = NULL; } diff --git a/deon-unix/functions/functions.h b/deon-unix/functions/functions.h index 9ec7406..c3527f0 100644 --- a/deon-unix/functions/functions.h +++ b/deon-unix/functions/functions.h @@ -8,4 +8,4 @@ static node_info *create_function(char *p_name, node_info *p_stmts); static node_info *create_function_call(char *p_name); static node_info *create_compound_statement(node_info *new_statement_list, node_info *statement_head); static node_info* add_to_compound_statement(node_info* new_statement, node_info* statement_head); -#endif \ No newline at end of file +#endif diff --git a/deon-unix/hashmap/map.c b/deon-unix/hashmap/map.c index 6a2a228..784465f 100644 --- a/deon-unix/hashmap/map.c +++ b/deon-unix/hashmap/map.c @@ -6,185 +6,186 @@ #include "map.h" struct map_node_t { - unsigned hash; - void *value; - map_node_t *next; - /* char key[]; */ - /* char value[]; */ + unsigned hash; + void* value; + map_node_t* next; + /* char key[]; */ + /* char value[]; */ }; -static unsigned map_hash(const char *str) { - unsigned hash = 5381; - while (*str) { - hash = ((hash << 5) + hash) ^ *str++; - } - return hash; +static unsigned map_hash(const char* str) { + unsigned hash = 5381; + while (*str) { + hash = ((hash << 5) + hash) ^ *str++; + } + return hash; } -static map_node_t *map_newnode(const char *key, void *value, int vsize) { - map_node_t *node; - int ksize = strlen(key) + 1; - int voffset = ksize + ((sizeof(void*) - ksize) % sizeof(void*)); - node = malloc(sizeof(*node) + voffset + vsize); - if (!node) return NULL; - memcpy(node + 1, key, ksize); - node->hash = map_hash(key); - node->value = ((char*) (node + 1)) + voffset; - memcpy(node->value, value, vsize); - return node; +static map_node_t* map_newnode(const char* key, void* value, int vsize) { + map_node_t* node; + int ksize = strlen(key) + 1; + int voffset = ksize + ((sizeof(void*) - ksize) % sizeof(void*)); + node = malloc(sizeof(*node) + voffset + vsize); + if (!node) return NULL; + memcpy(node + 1, key, ksize); + node->hash = map_hash(key); + node->value = ((char*)(node + 1)) + voffset; + memcpy(node->value, value, vsize); + return node; } -static int map_bucketidx(map_base_t *m, unsigned hash) { - /* If the implementation is changed to allow a non-power-of-2 bucket count, - * the line below should be changed to use mod instead of AND */ - return hash & (m->nbuckets - 1); +static int map_bucketidx(map_base_t* m, unsigned hash) { + /* If the implementation is changed to allow a non-power-of-2 bucket count, + * the line below should be changed to use mod instead of AND */ + return hash & (m->nbuckets - 1); } -static void map_addnode(map_base_t *m, map_node_t *node) { - int n = map_bucketidx(m, node->hash); - node->next = m->buckets[n]; - m->buckets[n] = node; +static void map_addnode(map_base_t* m, map_node_t* node) { + int n = map_bucketidx(m, node->hash); + node->next = m->buckets[n]; + m->buckets[n] = node; } -static int map_resize(map_base_t *m, int nbuckets) { - map_node_t *nodes, *node, *next; - map_node_t **buckets; - int i; - /* Chain all nodes together */ - nodes = NULL; - i = m->nbuckets; - while (i--) { - node = (m->buckets)[i]; - while (node) { - next = node->next; - node->next = nodes; - nodes = node; - node = next; +static int map_resize(map_base_t* m, int nbuckets) { + map_node_t* nodes, * node, * next; + map_node_t** buckets; + int i; + /* Chain all nodes together */ + nodes = NULL; + i = m->nbuckets; + while (i--) { + node = (m->buckets)[i]; + while (node) { + next = node->next; + node->next = nodes; + nodes = node; + node = next; + } + } + /* Reset buckets */ + buckets = realloc(m->buckets, sizeof(*m->buckets) * nbuckets); + if (buckets != NULL) { + m->buckets = buckets; + m->nbuckets = nbuckets; } - } - /* Reset buckets */ - buckets = realloc(m->buckets, sizeof(*m->buckets) * nbuckets); - if (buckets != NULL) { - m->buckets = buckets; - m->nbuckets = nbuckets; - } - if (m->buckets) { - memset(m->buckets, 0, sizeof(*m->buckets) * m->nbuckets); - /* Re-add nodes to buckets */ - node = nodes; - while (node) { - next = node->next; - map_addnode(m, node); - node = next; + if (m->buckets) { + memset(m->buckets, 0, sizeof(*m->buckets) * m->nbuckets); + /* Re-add nodes to buckets */ + node = nodes; + while (node) { + next = node->next; + map_addnode(m, node); + node = next; + } } - } - /* Return error code if realloc() failed */ - return (buckets == NULL) ? -1 : 0; + /* Return error code if realloc() failed */ + return (buckets == NULL) ? -1 : 0; } -static map_node_t **map_getref(map_base_t *m, const char *key) { - unsigned hash = map_hash(key); - map_node_t **next; - if (m->nbuckets > 0) { - next = &m->buckets[map_bucketidx(m, hash)]; - while (*next) { - if ((*next)->hash == hash && !strcmp((char*) (*next + 1), key)) { - return next; - } - next = &(*next)->next; +static map_node_t** map_getref(map_base_t* m, const char* key) { + unsigned hash = map_hash(key); + map_node_t** next; + if (m->nbuckets > 0) { + next = &m->buckets[map_bucketidx(m, hash)]; + while (*next) { + if ((*next)->hash == hash && !strcmp((char*)(*next + 1), key)) { + return next; + } + next = &(*next)->next; + } } - } - return NULL; + return NULL; } -void map_deinit_(map_base_t *m) { - map_node_t *next, *node; - int i; - i = m->nbuckets; - while (i--) { - node = m->buckets[i]; - while (node) { - next = node->next; - free(node); - node = next; +void map_deinit_(map_base_t* m) { + map_node_t* next, * node; + int i; + i = m->nbuckets; + while (i--) { + node = m->buckets[i]; + while (node) { + next = node->next; + free(node); + node = next; + } } - } - free(m->buckets); + free(m->buckets); } -void *map_get_(map_base_t *m, const char *key) { - map_node_t **next = map_getref(m, key); - return next ? (*next)->value : NULL; +void* map_get_(map_base_t* m, const char* key) { + map_node_t** next = map_getref(m, key); + return next ? (*next)->value : NULL; } -int map_set_(map_base_t *m, const char *key, void *value, int vsize) { - int n, err; - map_node_t **next, *node; - /* Find & replace existing node */ - next = map_getref(m, key); - if (next) { - memcpy((*next)->value, value, vsize); +int map_set_(map_base_t* m, const char* key, void* value, int vsize) { + int n, err; + map_node_t** next, * node; + /* Find & replace existing node */ + next = map_getref(m, key); + if (next) { + memcpy((*next)->value, value, vsize); + return 0; + } + /* Add new node */ + node = map_newnode(key, value, vsize); + if (node == NULL) goto fail; + if (m->nnodes >= m->nbuckets) { + n = (m->nbuckets > 0) ? (m->nbuckets << 1) : 1; + err = map_resize(m, n); + if (err) goto fail; + } + map_addnode(m, node); + m->nnodes++; return 0; - } - /* Add new node */ - node = map_newnode(key, value, vsize); - if (node == NULL) goto fail; - if (m->nnodes >= m->nbuckets) { - n = (m->nbuckets > 0) ? (m->nbuckets << 1) : 1; - err = map_resize(m, n); - if (err) goto fail; - } - map_addnode(m, node); - m->nnodes++; - return 0; - fail: - if (node) free(node); - return -1; +fail: + if (node) free(node); + return -1; } -void map_remove_(map_base_t *m, const char *key) { - map_node_t *node; - map_node_t **next = map_getref(m, key); - if (next) { - node = *next; - *next = (*next)->next; - free(node); - m->nnodes--; - } +void map_remove_(map_base_t* m, const char* key) { + map_node_t* node; + map_node_t** next = map_getref(m, key); + if (next) { + node = *next; + *next = (*next)->next; + free(node); + m->nnodes--; + } } map_iter_t map_iter_(void) { - map_iter_t iter; - iter.bucketidx = -1; - iter.node = NULL; - return iter; + map_iter_t iter; + iter.bucketidx = -1; + iter.node = NULL; + return iter; } -const char *map_next_(map_base_t *m, map_iter_t *iter) { - if (iter->node) { - iter->node = iter->node->next; - if (iter->node == NULL) goto nextBucket; - } else { +const char* map_next_(map_base_t* m, map_iter_t* iter) { + if (iter->node) { + iter->node = iter->node->next; + if (iter->node == NULL) goto nextBucket; + } + else { nextBucket: - do { - if (++iter->bucketidx >= m->nbuckets) { - return NULL; - } - iter->node = m->buckets[iter->bucketidx]; - } while (iter->node == NULL); - } - return (char*) (iter->node + 1); + do { + if (++iter->bucketidx >= m->nbuckets) { + return NULL; + } + iter->node = m->buckets[iter->bucketidx]; + } while (iter->node == NULL); + } + return (char*)(iter->node + 1); } #endif \ No newline at end of file diff --git a/deon-unix/linked_list/linked_list.c b/deon-unix/linked_list/linked_list.c index 955b954..896d116 100644 --- a/deon-unix/linked_list/linked_list.c +++ b/deon-unix/linked_list/linked_list.c @@ -12,6 +12,7 @@ static void free_linked_list(node_info *p_list) { if (!p_list) return; + node_info* temp; while (p_list->next) { @@ -23,19 +24,19 @@ static void free_linked_list(node_info *p_list) /* Author: xerox - Update: 1/20/2020 + Update: 5/13/2020 - updates linked list. + shallow copy linked list. */ -static node_info *copy_linked_list(node_info *p_list) +static node_info* shallow_copy_linked_list(node_info* p_list) { - node_info* new_list = malloc(sizeof(node_info)); - if (!new_list || !p_list) + if (!p_list) return NULL; + node_info* new_list = malloc(sizeof(node_info)); new_list->next = NULL; - node_info *copy_list = new_list; - //TODO update with doubly linked list + node_info* copy_list = new_list; + while(p_list->next) { p_list = p_list->next; @@ -54,10 +55,12 @@ static void linked_list_append(node_info* p_head, node_info* new_node) { if (!p_head || !new_node) return; + node_info* p_head_temp = p_head; while (p_head->next) p_head_temp = p_head_temp->next; - p_head->next = NULL; //sanity check + + p_head->next = NULL; p_head_temp->next = p_head; } diff --git a/deon-unix/linked_list/linked_list.h b/deon-unix/linked_list/linked_list.h index adb8467..69d2277 100644 --- a/deon-unix/linked_list/linked_list.h +++ b/deon-unix/linked_list/linked_list.h @@ -3,7 +3,7 @@ #include "../types.h" static void free_linked_list(node_info *p_list); -static node_info *copy_linked_list(node_info *p_list); +static node_info *shallow_copy_linked_list(node_info *p_list); static void linked_list_append(node_info* p_head, node_info* new_node); static bool linked_list_remove(node_info* p_head, node_info* delete_node); #endif diff --git a/deon-unix/logic/logic.c b/deon-unix/logic/logic.c index 33a4880..a388f07 100644 --- a/deon-unix/logic/logic.c +++ b/deon-unix/logic/logic.c @@ -8,13 +8,31 @@ */ static logic* create_logic(logic_type type, node_info* stmt_list, char* var_name) { - logic* new_logic = malloc(sizeof(logic)); - if (!new_logic || !stmt_list || !var_name) + if (!stmt_list || !var_name) return NULL; - memset(new_logic, NULL, sizeof(*new_logic)); + logic* new_logic = malloc(sizeof(logic)); new_logic->type = type; new_logic->condition_var = var_name; new_logic->stmt_list = stmt_list; return new_logic; +} + +/* + Author: xerox + Updated: 1/19/2020 + + create logic node (logical expression) +*/ +static node_info* create_logic_node(logic* logic_expr) +{ + if (!logic_expr) + return NULL; + + node_info* new_node = malloc(sizeof(node_info)); + new_node->operation = LOGIC_OPERATION; + new_node->logical_expr = logic_expr; + new_node->statement_list = NULL; + new_node->next = NULL; + return new_node; } \ No newline at end of file diff --git a/deon-unix/logic/logic.h b/deon-unix/logic/logic.h index 2bd1454..8b6f26e 100644 --- a/deon-unix/logic/logic.h +++ b/deon-unix/logic/logic.h @@ -2,4 +2,5 @@ #define LOGIC_H #include "../types.h" static logic* create_logic(logic_type type, node_info* stmt_list, char* var_name); -#endif \ No newline at end of file +static node_info* create_logic_node(logic* logic_expr); +#endif diff --git a/deon-unix/make.sh b/deon-unix/make.sh old mode 100644 new mode 100755 index 316e335..c4f1d34 --- a/deon-unix/make.sh +++ b/deon-unix/make.sh @@ -1,3 +1,4 @@ +echo -e "\e[31m[WARNING] if this fails to build, its because lex output a bad C file. Please put a '}' at the end of the erroring functions!\e[0m" lex deon.l yacc -d deon.y -gcc lex.yy.c y.tab.c -o deon +gcc lex.yy.c y.tab.c hashmap/map.c -o deon64 diff --git a/deon-unix/make32.sh b/deon-unix/make32.sh new file mode 100755 index 0000000..b0f576a --- /dev/null +++ b/deon-unix/make32.sh @@ -0,0 +1,4 @@ +echo -e "\e[31m[WARNING] if this fails to build, its because lex output a bad C file. Please put a '}' at the end of the erroring functions!\e[0m" +lex deon.l +yacc -d deon.y +gcc -m32 lex.yy.c y.tab.c hashmap/map.c -o deon diff --git a/deon-unix/parser/parser.c b/deon-unix/parser/parser.c index b9067f5..9d22deb 100644 --- a/deon-unix/parser/parser.c +++ b/deon-unix/parser/parser.c @@ -2,72 +2,6 @@ #define PARSER_C #include "parser.h" -/* - Author: xerox - Updated: 1/19/2020 - - create variable given name, value, and type. -*/ -static node_info* create_variable_const(char* p_name, void* value, variable_type var_type) -{ - node_info* new_node = malloc(sizeof(*new_node)); - if (!new_node) - return NULL; - memset(new_node, NULL, sizeof(*new_node)); - variable* new_var = make_variable(p_name, value, var_type); - if (!new_var) - return NULL; - new_node->assignment = (assignment_operation*)malloc(sizeof(assignment_operation)); - if (!new_node->assignment) - return NULL; - memset(new_node->assignment, NULL, sizeof(*new_node->assignment)); - new_node->operation = ASSIGNMENT_OPERATION; - new_node->operation_type.assignment = ASSIGN_FROM_CONST; - new_node->assignment->var = new_var; - return new_node; -} - -/* - Author: xerox - Updated: 1/20/2020 - - Move value from one variable to another. -*/ -static node_info* move_value(char* to, char* from) -{ - node_info* new_node = (node_info *)malloc(sizeof(node_info)); - if (!from || !new_node || !to) - return NULL; - memset(new_node, NULL, sizeof(*new_node)); - new_node->assignment = (assignment_operation*)malloc(sizeof(*new_node->assignment)); - if (!new_node->assignment) - return NULL; - memset(new_node->assignment, NULL, sizeof(*new_node->assignment)); - new_node->operation = ASSIGNMENT_OPERATION; - new_node->operation_type.assignment = ASSIGN_FROM_VAR; - new_node->assignment->from = from; - new_node->assignment->to = to; - return new_node; -} - -/* - Author: xerox - Updated: 1/19/2020 - - create logic node (logical expression) -*/ -static node_info* create_logic_node(logic* logic_expr) -{ - node_info* new_node = malloc(sizeof(node_info)); - if (!new_node || !logic_expr) - return NULL; - - memset(new_node, NULL, sizeof(*new_node)); - new_node->operation = LOGIC_OPERATION; - new_node->logical_expr = logic_expr; - return new_node; -} - /* Author: xerox Updated: 1/20/2020 @@ -89,17 +23,20 @@ static void exec_stmt(node_info *exec_node) switch (exec_node->operation_type.assignment) { case ASSIGN_FROM_CONST: - add_var(exec_node->assignment->var->name, exec_node->assignment->var->value, _var_map); + add_var( + exec_node->assignment->var->name, + exec_node->assignment->var->value, + _var_map + ); break; case ASSIGN_FROM_VAR: add_var(exec_node->assignment->to, - get_value(exec_node->assignment->from, _var_map), _var_map); + get_value(exec_node->assignment->from, _var_map), + _var_map + ); break; default: - ; -#if DEON_DEBUGGING - printf("[error] unkown assignment operation: 0x%x", exec_node->operation_type.assignment); -#endif + break; } break; case LOGIC_OPERATION: @@ -108,10 +45,12 @@ static void exec_stmt(node_info *exec_node) { case IF_LOGIC: { - variable_values* p_var_values = get_value(exec_node->logical_expr->condition_var, _var_map); - if (!p_var_values) - return; - if (*(unsigned char*)p_var_values->data_ptr) + variable_values* p_var_values = get_value( + exec_node->logical_expr->condition_var, + _var_map + ); + + if (p_var_values && *(unsigned char*)p_var_values->data_ptr) exec_stmt(exec_node->logical_expr->stmt_list); break; } @@ -120,6 +59,7 @@ static void exec_stmt(node_info *exec_node) variable_values* p_var_values = get_value(exec_node->logical_expr->condition_var, _var_map); if (!p_var_values) return; + while (*(unsigned char*)p_var_values->data_ptr) { exec_stmt(exec_node->logical_expr->stmt_list); @@ -128,17 +68,16 @@ static void exec_stmt(node_info *exec_node) break; } default: - ; -#if DEON_DEBUGGING - printf("[error] unknown logic operation\n"); -#endif + break; } + break; } // execute statement list. case EXEC_STMT_LIST_OPERATION: { - if(exec_node->statement_list) + if (exec_node->statement_list) exec_node = exec_node->statement_list; + while (exec_node->next) { exec_node = exec_node->next; @@ -153,6 +92,7 @@ static void exec_stmt(node_info *exec_node) { case PRINT_CONSTANT: { + // TODO replace with puts to add more modularity switch (exec_node->print_expr->type) { case VAR_STRING: @@ -170,10 +110,7 @@ static void exec_stmt(node_info *exec_node) case VAR_VOID: //TODO add void variable type break; default: - ; -#if DEON_DEBUGGING - printf("[error] unable to print variable of type: 0x%x\n", exec_node->print_expr->type); -#endif + break; } break; } @@ -197,18 +134,12 @@ static void exec_stmt(node_info *exec_node) case VAR_VOID: //TODO add void variable type break; default: - ; -#if DEON_DEBUGGING - printf("[error] unable to print variable of type: 0x%x\n", p_var->type); -#endif + break; } break; } default: - ; -#if DEON_DEBUGGING - printf("[error] unknown print type: 0x%x\n", exec_node->operation_type.print); -#endif + break; } break; } @@ -240,18 +171,12 @@ static void exec_stmt(node_info *exec_node) break; } default: - ; -#if DEON_DEBUGGING - printf("[error] unknown function operation: 0x%x\n", exec_node->operation_type.func); -#endif + break; } break; } default: - ; -#if DEON_DEBUGGING - printf("[error] unknown operation: 0x%x\n", exec_node->operation); -#endif + break; } } #endif \ No newline at end of file diff --git a/deon-unix/parser/parser.h b/deon-unix/parser/parser.h index 02f280d..f3a68b1 100644 --- a/deon-unix/parser/parser.h +++ b/deon-unix/parser/parser.h @@ -2,8 +2,5 @@ #define PARSER_H #include "../types.h" #include "../vars/vars.h" -static node_info* create_variable_const(char* p_name, void* value, variable_type var_type); -static node_info* move_value(char* to, char* from); -static node_info* create_logic_node(logic* logic_expr); static void exec_stmt(node_info *exec_node); #endif diff --git a/deon-unix/print/print.c b/deon-unix/print/print.c index ee82467..c3d06c6 100644 --- a/deon-unix/print/print.c +++ b/deon-unix/print/print.c @@ -9,20 +9,19 @@ creates a print statement given variable type and value. */ -static node_info *create_print_statement(variable_type operation, void* value) +static node_info* create_print_statement(variable_type operation, void* value) { - node_info* new_print_stmt = (node_info*)malloc(sizeof(node_info)); - print* new_print = malloc(sizeof(print)); - if (!new_print_stmt || !new_print) + if (!value) return NULL; - memset(new_print_stmt, NULL, sizeof(*new_print_stmt)); - memset(new_print, NULL, sizeof(*new_print)); + node_info* new_print_stmt = (node_info*)malloc(sizeof(node_info)); + print* new_print = malloc(sizeof(print)); new_print_stmt->operation = PRINT_OPERATION; new_print_stmt->operation_type.print = PRINT_CONSTANT; new_print->type = operation; new_print->value = value; new_print_stmt->print_expr = new_print; + new_print_stmt->statement_list = NULL; new_print_stmt->next = NULL; return new_print_stmt; } @@ -35,19 +34,16 @@ static node_info *create_print_statement(variable_type operation, void* value) */ static node_info* create_print_variable(char* var_name) { - node_info* new_print_stmt = (node_info*)malloc(sizeof(node_info)); - if (!new_print_stmt || !var_name) + if (!var_name) return NULL; - memset(new_print_stmt, NULL, sizeof(*new_print_stmt)); + node_info* new_print_stmt = (node_info*)malloc(sizeof(node_info)); new_print_stmt->var = malloc(sizeof(variable)); - if (!new_print_stmt->var) - return NULL; - memset(new_print_stmt->var, NULL, sizeof(*new_print_stmt->var)); - new_print_stmt->operation = PRINT_OPERATION; new_print_stmt->operation_type.print = PRINT_VARIABLE; new_print_stmt->var->name = var_name; + + new_print_stmt->statement_list = NULL; new_print_stmt->next = NULL; return new_print_stmt; } diff --git a/deon-unix/print/print.h b/deon-unix/print/print.h index 4d5ee89..72fba4f 100644 --- a/deon-unix/print/print.h +++ b/deon-unix/print/print.h @@ -3,4 +3,4 @@ #include "../types.h" static node_info* create_print_statement(variable_type operation, void* value); static node_info* create_print_variable(char* var_name); -#endif \ No newline at end of file +#endif diff --git a/deon-unix/types.h b/deon-unix/types.h index f81047e..3439282 100644 --- a/deon-unix/types.h +++ b/deon-unix/types.h @@ -54,7 +54,7 @@ typedef enum _operation EXEC_STMT_LIST_OPERATION, PRINT_OPERATION, FUNCTION_OPERATION, -}; +} operation; //--- variable value details typedef struct _variable_values diff --git a/deon-unix/vars/vars.c b/deon-unix/vars/vars.c index cdad775..f15ef7b 100644 --- a/deon-unix/vars/vars.c +++ b/deon-unix/vars/vars.c @@ -8,7 +8,7 @@ add var to hashmap of variables. */ -static void add_var(char *p_name, variable_values *p_values, map_void_t* p_var_map) +static void add_var(char* p_name, variable_values* p_values, map_void_t* p_var_map) { if (!p_name || !p_values) return; @@ -22,7 +22,7 @@ static void add_var(char *p_name, variable_values *p_values, map_void_t* p_var_m get value given name and hashmap. */ -static variable_values* get_value(char *p_name, map_void_t* p_var_map) +static variable_values* get_value(char* p_name, map_void_t* p_var_map) { if (!p_name) return NULL; @@ -35,15 +35,13 @@ static variable_values* get_value(char *p_name, map_void_t* p_var_map) makes a variable struct and define it. */ -static variable* make_variable(char *p_name, void* value, variable_type var_type) +static variable* make_variable(char* p_name, void* value, variable_type var_type) { - variable *new_var = malloc(sizeof(variable)); - variable_values *new_value = malloc(sizeof(variable_values)); - if (!new_var || !new_value || !p_name || !value) + if (!p_name || !value) return NULL; - memset(new_var, NULL, sizeof(*new_var)); - memset(new_value, NULL, sizeof(*new_value)); + variable* new_var = malloc(sizeof(variable)); + variable_values* new_value = malloc(sizeof(variable_values)); new_value->type = var_type; new_value->data_ptr = value; new_var->name = p_name; @@ -59,23 +57,20 @@ static variable* make_variable(char *p_name, void* value, variable_type var_type */ static void* alloc_value(void* value, variable_type var_type) { + if (!value) + return NULL; + switch (var_type) { case VAR_INT: { - int* p_int = (int*)malloc(sizeof(int)); - if (!p_int) - return NULL; - memset(p_int, NULL, sizeof(*p_int)); + int* p_int = malloc(sizeof(int)); *p_int = *(int*)value; return p_int; } case VAR_SHORT: { - short* p_short = (short*)malloc(sizeof(short)); - if (!p_short) - return NULL; - memset(p_short, NULL, sizeof(*p_short)); + short* p_short = malloc(sizeof(short)); *p_short = *(short*)value; return p_short; } @@ -84,16 +79,12 @@ static void* alloc_value(void* value, variable_type var_type) char* p_char = malloc(sizeof(char)); if (!p_char) return NULL; - memset(p_char, NULL, sizeof(*p_char)); *p_char = *(char*)value; return p_char; } case VAR_DOUBLE: { double* p_double = malloc(sizeof(double)); - if (!p_double) - return NULL; - memset(p_double, NULL, sizeof(*p_double)); *p_double = *(double*)value; return p_double; } @@ -101,4 +92,48 @@ static void* alloc_value(void* value, variable_type var_type) return NULL; } } -#endif \ No newline at end of file + +/* + Author: xerox + Updated: 1/19/2020 + + create variable given name, value, and type. +*/ +static node_info* create_variable(char* p_name, void* value, variable_type var_type) +{ + if (!p_name || !value) + return NULL; + + node_info* new_node = malloc(sizeof(node_info)); + variable* new_var = make_variable(p_name, value, var_type); + new_node->assignment = malloc(sizeof(assignment_operation)); + new_node->operation = ASSIGNMENT_OPERATION; + new_node->operation_type.assignment = ASSIGN_FROM_CONST; + new_node->assignment->var = new_var; + new_node->statement_list = NULL; + new_node->next = NULL; + return new_node; +} + +/* + Author: xerox + Updated: 1/20/2020 + + Move value from one variable to another. +*/ +static node_info* move_value(char* to, char* from) +{ + if (!from || !to) + return NULL; + + node_info* new_node = malloc(sizeof(node_info)); + new_node->assignment = malloc(sizeof(*new_node->assignment)); + new_node->operation = ASSIGNMENT_OPERATION; + new_node->operation_type.assignment = ASSIGN_FROM_VAR; + new_node->assignment->from = from; + new_node->assignment->to = to; + new_node->statement_list = NULL; + new_node->next = NULL; + return new_node; +} +#endif diff --git a/deon-unix/vars/vars.h b/deon-unix/vars/vars.h index 910790e..98d238b 100644 --- a/deon-unix/vars/vars.h +++ b/deon-unix/vars/vars.h @@ -5,4 +5,6 @@ static void add_var(char* name, variable_values* values, map_void_t* p_var_map); static variable* make_variable(char* p_name, void* value, variable_type var_type); static variable_values* get_value(char* p_name, map_void_t* p_var_map); static void* alloc_value(void* value, variable_type var_type); +static node_info* create_variable(char* p_name, void* value, variable_type var_type); +static node_info* move_value(char* to, char* from); #endif diff --git a/deon-win/deon/deon.tab.c b/deon-win/deon/deon.tab.c deleted file mode 100644 index 864cbc4..0000000 --- a/deon-win/deon/deon.tab.c +++ /dev/null @@ -1,2071 +0,0 @@ - -/* A Bison parser, made by GNU Bison 2.4.1. */ - -/* Skeleton implementation for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - 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 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.4.1" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Push parsers. */ -#define YYPUSH 0 - -/* Pull parsers. */ -#define YYPULL 1 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Copy the first part of user declarations. */ - -/* Line 189 of yacc.c */ -#line 1 "deon.y" - -#include -#include -#include - -#include "types.h" -#include "parser/parser.c" -#include "functions/functions.c" -#include "logic/logic.c" -#include "print/print.c" -#include "vars/vars.c" - -int yylex(void); -void yyerror(char *); -extern int yylineno; - - -/* Line 189 of yacc.c */ -#line 91 "deon.tab.c" - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE 0 -#endif - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - INCREASE = 258, - PRINT_TOKEN = 259, - IF = 260, - END = 261, - KEYWORD_S = 262, - KEYWORD_I = 263, - KEYWORD_C = 264, - QUOTE = 265, - ELSE = 266, - WHILE = 267, - DEF = 268, - CALL = 269, - LESS_THAN_OR_EQUAL = 270, - GREATER_THAN_OR_EQUAL = 271, - DECREASE = 272, - INTEGER = 273, - STRING = 274, - VARNAME = 275, - CHAR = 276, - DOUBLEVAR = 277, - FLOAT_NUM = 278 - }; -#endif - - - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -{ - -/* Line 214 of yacc.c */ -#line 25 "deon.y" - - char* str_ptr; - int int_num; - unsigned uint_num; - char byte_num; - double double_num; - float float_num; - struct node_info *node_ptr; - - - -/* Line 214 of yacc.c */ -#line 162 "deon.tab.c" -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -#endif - - -/* Copy the second part of user declarations. */ - - -/* Line 264 of yacc.c */ -#line 174 "deon.tab.c" - -#ifdef short -# undef short -#endif - -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; -#endif - -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -typedef signed char yytype_int8; -#else -typedef short int yytype_int8; -#endif - -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; -#else -typedef unsigned short int yytype_uint16; -#endif - -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; -#else -typedef short int yytype_int16; -#endif - -#ifndef YYSIZE_T -# ifdef __SIZE_TYPE__ -# define YYSIZE_T __SIZE_TYPE__ -# elif defined size_t -# define YYSIZE_T size_t -# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# else -# define YYSIZE_T unsigned int -# endif -#endif - -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) - -#ifndef YY_ -# if YYENABLE_NLS -# if ENABLE_NLS -# include /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) -# endif -# endif -# ifndef YY_ -# define YY_(msgid) msgid -# endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) -#else -# define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(n) (n) -#else -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static int -YYID (int yyi) -#else -static int -YYID (yyi) - int yyi; -#endif -{ - return yyi; -} -#endif - -#if ! defined yyoverflow || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# elif defined __BUILTIN_VA_ARG_INCR -# include /* INFRINGES ON USER NAME SPACE */ -# elif defined _AIX -# define YYSTACK_ALLOC __alloca -# elif defined _MSC_VER -# include /* INFRINGES ON USER NAME SPACE */ -# define alloca _alloca -# else -# define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) -# ifndef YYSTACK_ALLOC_MAXIMUM - /* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -# endif -# else -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# ifndef YYSTACK_ALLOC_MAXIMUM -# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -# endif -# if (defined __cplusplus && ! defined _STDLIB_H \ - && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -# include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - - -#if (! defined yyoverflow \ - && (! defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - yytype_int16 yyss_alloc; - YYSTYPE yyvs_alloc; -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (YYID (0)) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ - Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (YYID (0)) - -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 3 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 265 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 41 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 11 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 57 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 116 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 278 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const yytype_uint8 yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 31, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, - 39, 40, 7, 5, 2, 6, 2, 8, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 33, 32, - 3, 38, 4, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 36, 2, 37, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 34, 2, 35, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30 -}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const yytype_uint8 yyprhs[] = -{ - 0, 0, 3, 6, 7, 11, 12, 19, 22, 25, - 29, 31, 33, 35, 40, 44, 53, 62, 66, 70, - 74, 78, 82, 88, 92, 94, 98, 102, 106, 110, - 114, 118, 122, 126, 130, 133, 136, 139, 142, 146, - 148, 150, 154, 158, 162, 166, 170, 174, 178, 182, - 185, 188, 191, 194, 198, 200, 202, 204 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int8 yyrhs[] = -{ - 42, 0, -1, 43, 31, -1, -1, 43, 44, 32, - -1, -1, 20, 27, 33, 34, 45, 35, -1, 21, - 27, -1, 46, 32, -1, 45, 46, 32, -1, 48, - -1, 47, -1, 44, -1, 11, 36, 51, 37, -1, - 34, 45, 35, -1, 12, 36, 27, 37, 33, 34, - 45, 35, -1, 19, 36, 27, 37, 33, 34, 45, - 35, -1, 27, 38, 26, -1, 27, 38, 49, -1, - 27, 38, 50, -1, 27, 38, 28, -1, 27, 38, - 29, -1, 27, 38, 34, 45, 35, -1, 27, 38, - 27, -1, 25, -1, 49, 5, 49, -1, 49, 6, - 49, -1, 49, 7, 49, -1, 49, 8, 49, -1, - 49, 9, 49, -1, 49, 22, 49, -1, 49, 23, - 49, -1, 49, 4, 49, -1, 49, 3, 49, -1, - 10, 49, -1, 49, 10, -1, 24, 49, -1, 49, - 24, -1, 39, 49, 40, -1, 49, -1, 29, -1, - 50, 5, 50, -1, 50, 6, 50, -1, 50, 7, - 50, -1, 50, 8, 50, -1, 50, 22, 50, -1, - 50, 23, 50, -1, 50, 4, 50, -1, 50, 3, - 50, -1, 10, 50, -1, 50, 10, -1, 24, 50, - -1, 50, 24, -1, 39, 50, 40, -1, 50, -1, - 27, -1, 49, -1, 26, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const yytype_uint8 yyrline[] = -{ - 0, 55, 55, 56, 60, 61, 65, 66, 70, 71, - 75, 76, 77, 78, 79, 83, 84, 88, 89, 90, - 91, 92, 93, 94, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 135, 136, 137 -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", - "'%'", "INCREASE", "PRINT_TOKEN", "IF", "END", "KEYWORD_S", "KEYWORD_I", - "KEYWORD_C", "QUOTE", "ELSE", "WHILE", "DEF", "CALL", - "LESS_THAN_OR_EQUAL", "GREATER_THAN_OR_EQUAL", "DECREASE", "INTEGER", - "STRING", "VARNAME", "CHAR", "DOUBLEVAR", "FLOAT_NUM", "'\\n'", "';'", - "':'", "'{'", "'}'", "'['", "']'", "'='", "'('", "')'", "$accept", - "PROGRAM", "MAIN", "FUNC", "STMT_LIST", "STMT", "LOGIC", "VARIABLE", - "EXPR_I", "EXPR_D", "PRINT", 0 -}; -#endif - -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const yytype_uint16 yytoknum[] = -{ - 0, 256, 257, 60, 62, 43, 45, 42, 47, 37, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 10, 59, 58, 123, 125, 91, 93, 61, 40, - 41 -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = -{ - 0, 41, 42, 42, 43, 43, 44, 44, 45, 45, - 46, 46, 46, 46, 46, 47, 47, 48, 48, 48, - 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, - 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, - 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, - 50, 50, 50, 50, 50, 51, 51, 51 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = -{ - 0, 2, 2, 0, 3, 0, 6, 2, 2, 3, - 1, 1, 1, 4, 3, 8, 8, 3, 3, 3, - 3, 3, 5, 3, 1, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 2, 2, 2, 2, 3, 1, - 1, 3, 3, 3, 3, 3, 3, 3, 3, 2, - 2, 2, 2, 3, 1, 1, 1, 1 -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const yytype_uint8 yydefact[] = -{ - 5, 0, 0, 1, 0, 0, 2, 0, 0, 7, - 4, 0, 0, 0, 0, 0, 0, 0, 12, 0, - 0, 11, 10, 0, 0, 0, 0, 0, 6, 0, - 8, 0, 0, 24, 57, 55, 0, 39, 0, 0, - 0, 0, 0, 17, 23, 20, 40, 0, 0, 18, - 19, 14, 9, 34, 36, 0, 0, 0, 0, 0, - 0, 0, 0, 35, 0, 0, 37, 13, 0, 0, - 40, 49, 51, 0, 0, 0, 0, 0, 0, 0, - 0, 50, 0, 0, 52, 38, 33, 32, 25, 26, - 27, 28, 29, 30, 31, 0, 0, 22, 53, 0, - 0, 0, 48, 47, 41, 42, 43, 44, 45, 46, - 0, 0, 0, 0, 15, 16 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int8 yydefgoto[] = -{ - -1, 1, 2, 18, 19, 20, 21, 22, 53, 71, - 38 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -23 -static const yytype_int16 yypact[] = -{ - 3, 7, 107, -23, -18, -14, -23, -16, -21, -23, - -23, -13, 153, -9, -3, 17, -7, 153, -23, 102, - 9, -23, -23, 51, 46, 52, 73, 105, -23, 53, - -23, 5, 5, -23, -23, -23, 5, 185, 47, 55, - 72, 81, 81, -23, -23, -23, 83, 153, 81, 185, - 193, -23, -23, 185, 185, 42, 5, 5, 5, 5, - 5, 5, 5, -23, 5, 5, -23, -23, 78, 86, - -23, 193, 193, 122, 64, 79, 79, 79, 79, 79, - 79, -23, 79, 79, -23, -23, 213, 213, 223, 223, - -5, -5, -5, 185, 185, 96, 97, -23, -23, 79, - 79, 79, 219, 219, 241, 241, 1, 1, 193, 193, - 153, 153, 133, 150, -23, -23 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = -{ - -23, -23, -23, 144, -15, -19, -23, -23, -22, -20, - -23 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -22 -static const yytype_int8 yytable[] = -{ - 29, 37, 27, -3, 49, 63, 50, 3, 29, 8, - 54, 81, 11, 9, 55, 31, 10, 64, 65, 66, - 54, 12, 72, 82, 83, 84, 55, 23, 74, 32, - 33, 26, 73, 24, 86, 87, 88, 89, 90, 91, - 92, 30, 93, 94, 36, 56, 57, 58, 59, 60, - 61, 62, 63, 25, 29, 102, 103, 104, 105, 106, - 107, 31, 108, 109, 64, 65, 66, 75, 76, 77, - 78, 79, 80, 39, 81, 32, 33, 34, 35, 40, - 72, 74, 85, 41, 67, 52, 82, 83, 84, 99, - 36, 41, 68, 29, 29, 112, 113, 42, 33, 43, - 44, 45, 46, 100, 98, 42, 33, 47, 70, 69, - 70, 95, 48, 13, 14, -21, 13, 14, 101, 96, - 48, 15, 4, 5, 15, 4, 5, 4, 5, 16, - 110, 111, 16, 13, 14, 0, 17, 28, 6, 17, - 51, 15, 4, 5, 13, 14, 7, 0, 0, 16, - 0, 0, 15, 4, 5, 0, 17, 97, 0, 0, - 16, 13, 14, 0, 13, 14, 0, 17, 114, 15, - 4, 5, 15, 4, 5, 0, 0, 16, 0, 0, - 16, 0, 0, 0, 17, 115, 0, 17, 56, 57, - 58, 59, 60, 61, 62, 63, 75, 76, 77, 78, - 79, 80, 0, 81, 0, 0, 0, 64, 65, 66, - 0, 0, 0, 0, 0, 82, 83, 84, 58, 59, - 60, 61, 62, 63, 77, 78, 79, 80, 0, 81, - 60, 61, 62, 63, 0, 64, 65, 66, 0, 0, - 0, 82, 83, 84, 0, 64, 65, 66, 79, 80, - 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 82, 83, 84 -}; - -static const yytype_int8 yycheck[] = -{ - 19, 23, 17, 0, 26, 10, 26, 0, 27, 27, - 32, 10, 33, 27, 36, 10, 32, 22, 23, 24, - 42, 34, 42, 22, 23, 24, 48, 36, 48, 24, - 25, 38, 47, 36, 56, 57, 58, 59, 60, 61, - 62, 32, 64, 65, 39, 3, 4, 5, 6, 7, - 8, 9, 10, 36, 73, 75, 76, 77, 78, 79, - 80, 10, 82, 83, 22, 23, 24, 3, 4, 5, - 6, 7, 8, 27, 10, 24, 25, 26, 27, 27, - 100, 101, 40, 10, 37, 32, 22, 23, 24, 10, - 39, 10, 37, 112, 113, 110, 111, 24, 25, 26, - 27, 28, 29, 24, 40, 24, 25, 34, 29, 37, - 29, 33, 39, 11, 12, 32, 11, 12, 39, 33, - 39, 19, 20, 21, 19, 20, 21, 20, 21, 27, - 34, 34, 27, 11, 12, -1, 34, 35, 31, 34, - 35, 19, 20, 21, 11, 12, 2, -1, -1, 27, - -1, -1, 19, 20, 21, -1, 34, 35, -1, -1, - 27, 11, 12, -1, 11, 12, -1, 34, 35, 19, - 20, 21, 19, 20, 21, -1, -1, 27, -1, -1, - 27, -1, -1, -1, 34, 35, -1, 34, 3, 4, - 5, 6, 7, 8, 9, 10, 3, 4, 5, 6, - 7, 8, -1, 10, -1, -1, -1, 22, 23, 24, - -1, -1, -1, -1, -1, 22, 23, 24, 5, 6, - 7, 8, 9, 10, 5, 6, 7, 8, -1, 10, - 7, 8, 9, 10, -1, 22, 23, 24, -1, -1, - -1, 22, 23, 24, -1, 22, 23, 24, 7, 8, - -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24 -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = -{ - 0, 42, 43, 0, 20, 21, 31, 44, 27, 27, - 32, 33, 34, 11, 12, 19, 27, 34, 44, 45, - 46, 47, 48, 36, 36, 36, 38, 45, 35, 46, - 32, 10, 24, 25, 26, 27, 39, 49, 51, 27, - 27, 10, 24, 26, 27, 28, 29, 34, 39, 49, - 50, 35, 32, 49, 49, 49, 3, 4, 5, 6, - 7, 8, 9, 10, 22, 23, 24, 37, 37, 37, - 29, 50, 50, 45, 50, 3, 4, 5, 6, 7, - 8, 10, 22, 23, 24, 40, 49, 49, 49, 49, - 49, 49, 49, 49, 49, 33, 33, 35, 40, 10, - 24, 39, 50, 50, 50, 50, 50, 50, 50, 50, - 34, 34, 45, 45, 35, 35 -}; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto yyerrlab - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ - YYPOPSTACK (1); \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (YYID (0)) - - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (N)) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (YYID (0)) -#endif - - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -# define YYLEX yylex (YYLEX_PARAM) -#else -# define YYLEX yylex () -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Type, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) -#else -static void -yy_symbol_value_print (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE const * const yyvaluep; -#endif -{ - if (!yyvaluep) - return; -# ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# else - YYUSE (yyoutput); -# endif - switch (yytype) - { - default: - break; - } -} - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) -#else -static void -yy_symbol_print (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE const * const yyvaluep; -#endif -{ - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - - yy_symbol_value_print (yyoutput, yytype, yyvaluep); - YYFPRINTF (yyoutput, ")"); -} - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) -#else -static void -yy_stack_print (yybottom, yytop) - yytype_int16 *yybottom; - yytype_int16 *yytop; -#endif -{ - YYFPRINTF (stderr, "Stack now"); - for (; yybottom <= yytop; yybottom++) - { - int yybot = *yybottom; - YYFPRINTF (stderr, " %d", yybot); - } - YYFPRINTF (stderr, "\n"); -} - -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (YYID (0)) - - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_reduce_print (YYSTYPE *yyvsp, int yyrule) -#else -static void -yy_reduce_print (yyvsp, yyrule) - YYSTYPE *yyvsp; - int yyrule; -#endif -{ - int yynrhs = yyr2[yyrule]; - int yyi; - unsigned long int yylno = yyrline[yyrule]; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", - yyrule - 1, yylno); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], - &(yyvsp[(yyi + 1) - (yynrhs)]) - ); - YYFPRINTF (stderr, "\n"); - } -} - -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (yyvsp, Rule); \ -} while (YYID (0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - - - -#if YYERROR_VERBOSE - -# ifndef yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static YYSIZE_T -yystrlen (const char *yystr) -#else -static YYSIZE_T -yystrlen (yystr) - const char *yystr; -#endif -{ - YYSIZE_T yylen; - for (yylen = 0; yystr[yylen]; yylen++) - continue; - return yylen; -} -# endif -# endif - -# ifndef yystpcpy -# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static char * -yystpcpy (char *yydest, const char *yysrc) -#else -static char * -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -#endif -{ - char *yyd = yydest; - const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -# endif -# endif - -# ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T -yytnamerr (char *yyres, const char *yystr) -{ - if (*yystr == '"') - { - YYSIZE_T yyn = 0; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes: ; - } - - if (! yyres) - return yystrlen (yystr); - - return yystpcpy (yyres, yystr) - yyres; -} -# endif - -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) -{ - int yyn = yypact[yystate]; - - if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else - { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; - } -} -#endif /* YYERROR_VERBOSE */ - - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) -#else -static void -yydestruct (yymsg, yytype, yyvaluep) - const char *yymsg; - int yytype; - YYSTYPE *yyvaluep; -#endif -{ - YYUSE (yyvaluep); - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - - default: - break; - } -} - -/* Prevent warnings from -Wmissing-prototypes. */ -#ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int yyparse (void *YYPARSE_PARAM); -#else -int yyparse (); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus -int yyparse (void); -#else -int yyparse (); -#endif -#endif /* ! YYPARSE_PARAM */ - - -/* The lookahead symbol. */ -int yychar; - -/* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs; - - - -/*-------------------------. -| yyparse or yypush_parse. | -`-------------------------*/ - -#ifdef YYPARSE_PARAM -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (void *YYPARSE_PARAM) -#else -int -yyparse (YYPARSE_PARAM) - void *YYPARSE_PARAM; -#endif -#else /* ! YYPARSE_PARAM */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (void) -#else -int -yyparse () - -#endif -#endif -{ - - - int yystate; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - - /* The stacks and their tools: - `yyss': related to states. - `yyvs': related to semantic values. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs; - YYSTYPE *yyvsp; - - YYSIZE_T yystacksize; - - int yyn; - int yyresult; - /* Lookahead token as an internal (translated) token number. */ - int yytoken; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - -#if YYERROR_VERBOSE - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; -#endif - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) - - /* The number of symbols on the RHS of the reduced rule. - Keep to zero when no symbol should be popped. */ - int yylen = 0; - - yytoken = 0; - yyss = yyssa; - yyvs = yyvsa; - yystacksize = YYINITDEPTH; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - yyssp = yyss; - yyvsp = yyvs; - - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. So pushing a state here evens the stacks. */ - yyssp++; - - yysetstate: - *yyssp = yystate; - - if (yyss + yystacksize - 1 <= yyssp) - { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else - /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; - yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; - - { - yytype_int16 *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss_alloc, yyss); - YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); - - if (yyss + yystacksize - 1 <= yyssp) - YYABORT; - } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - - if (yystate == YYFINAL) - YYACCEPT; - - goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - - /* Do appropriate processing given the current state. Read a - lookahead token if we need one and don't already have one. */ - - /* First try to decide what to do without reference to lookahead token. */ - yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) - goto yydefault; - - /* Not known => get a lookahead token if don't already have one. */ - - /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - if (yychar <= YYEOF) - { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); - } - - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) - { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - /* Shift the lookahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token. */ - yychar = YYEMPTY; - - yystate = yyn; - *++yyvsp = yylval; - - goto yynewstate; - - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; - - - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - case 4: - -/* Line 1455 of yacc.c */ -#line 60 "deon.y" - { exec_stmt((yyvsp[(2) - (3)].node_ptr)); ;} - break; - - case 6: - -/* Line 1455 of yacc.c */ -#line 65 "deon.y" - { (yyval.node_ptr) = create_function((yyvsp[(2) - (6)].str_ptr), (yyvsp[(5) - (6)].node_ptr)); ;} - break; - - case 7: - -/* Line 1455 of yacc.c */ -#line 66 "deon.y" - { (yyval.node_ptr) = create_function_call((yyvsp[(2) - (2)].str_ptr)); ;} - break; - - case 8: - -/* Line 1455 of yacc.c */ -#line 70 "deon.y" - { (yyval.node_ptr) = create_compound_statement((yyvsp[(1) - (2)].node_ptr), _temp_statement_head); ;} - break; - - case 9: - -/* Line 1455 of yacc.c */ -#line 71 "deon.y" - { (yyval.node_ptr) = add_to_compound_statement((yyvsp[(2) - (3)].node_ptr), (yyvsp[(1) - (3)].node_ptr)); ;} - break; - - case 10: - -/* Line 1455 of yacc.c */ -#line 75 "deon.y" - { (yyval.node_ptr) = (yyvsp[(1) - (1)].node_ptr); ;} - break; - - case 11: - -/* Line 1455 of yacc.c */ -#line 76 "deon.y" - { (yyval.node_ptr) = (yyvsp[(1) - (1)].node_ptr); ;} - break; - - case 12: - -/* Line 1455 of yacc.c */ -#line 77 "deon.y" - { (yyval.node_ptr) = (yyvsp[(1) - (1)].node_ptr); ;} - break; - - case 13: - -/* Line 1455 of yacc.c */ -#line 78 "deon.y" - { (yyval.node_ptr) = (yyvsp[(3) - (4)].node_ptr); ;} - break; - - case 14: - -/* Line 1455 of yacc.c */ -#line 79 "deon.y" - { (yyval.node_ptr) = (yyvsp[(2) - (3)].node_ptr); ;} - break; - - case 15: - -/* Line 1455 of yacc.c */ -#line 83 "deon.y" - { (yyval.node_ptr) = create_logic_node(create_logic(IF_LOGIC, (yyvsp[(7) - (8)].node_ptr), (yyvsp[(3) - (8)].str_ptr))); ;} - break; - - case 16: - -/* Line 1455 of yacc.c */ -#line 84 "deon.y" - { (yyval.node_ptr) = create_logic_node(create_logic(WHILE_LOGIC, (yyvsp[(7) - (8)].node_ptr), (yyvsp[(3) - (8)].str_ptr))); ;} - break; - - case 17: - -/* Line 1455 of yacc.c */ -#line 88 "deon.y" - { (yyval.node_ptr) = create_variable((yyvsp[(1) - (3)].str_ptr), (void *) (yyvsp[(3) - (3)].str_ptr), VAR_STRING);;} - break; - - case 18: - -/* Line 1455 of yacc.c */ -#line 89 "deon.y" - { (yyval.node_ptr) = create_variable((yyvsp[(1) - (3)].str_ptr), alloc_value(&(yyvsp[(3) - (3)].int_num), VAR_INT), VAR_INT);;} - break; - - case 19: - -/* Line 1455 of yacc.c */ -#line 90 "deon.y" - { (yyval.node_ptr) = create_variable((yyvsp[(1) - (3)].str_ptr), alloc_value(&(yyvsp[(3) - (3)].double_num), VAR_DOUBLE), VAR_DOUBLE);;} - break; - - case 20: - -/* Line 1455 of yacc.c */ -#line 91 "deon.y" - { (yyval.node_ptr) = create_variable((yyvsp[(1) - (3)].str_ptr), alloc_value(&(yyvsp[(3) - (3)].byte_num), VAR_BYTE), VAR_BYTE);;} - break; - - case 21: - -/* Line 1455 of yacc.c */ -#line 92 "deon.y" - { (yyval.node_ptr) = create_variable((yyvsp[(1) - (3)].str_ptr), alloc_value(&(yyvsp[(3) - (3)].double_num), VAR_DOUBLE), VAR_DOUBLE);;} - break; - - case 22: - -/* Line 1455 of yacc.c */ -#line 93 "deon.y" - { (yyval.node_ptr) = create_function((yyvsp[(1) - (5)].str_ptr), (yyvsp[(4) - (5)].node_ptr)); ;} - break; - - case 23: - -/* Line 1455 of yacc.c */ -#line 94 "deon.y" - { (yyval.node_ptr) = move_value((yyvsp[(1) - (3)].str_ptr), (yyvsp[(3) - (3)].str_ptr)); ;} - break; - - case 24: - -/* Line 1455 of yacc.c */ -#line 98 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (1)].int_num); ;} - break; - - case 25: - -/* Line 1455 of yacc.c */ -#line 99 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) + (yyvsp[(3) - (3)].int_num); ;} - break; - - case 26: - -/* Line 1455 of yacc.c */ -#line 100 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) - (yyvsp[(3) - (3)].int_num); ;} - break; - - case 27: - -/* Line 1455 of yacc.c */ -#line 101 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) * (yyvsp[(3) - (3)].int_num); ;} - break; - - case 28: - -/* Line 1455 of yacc.c */ -#line 102 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) / (yyvsp[(3) - (3)].int_num); ;} - break; - - case 29: - -/* Line 1455 of yacc.c */ -#line 103 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) % (yyvsp[(3) - (3)].int_num); ;} - break; - - case 30: - -/* Line 1455 of yacc.c */ -#line 104 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) <= (yyvsp[(3) - (3)].int_num); ;} - break; - - case 31: - -/* Line 1455 of yacc.c */ -#line 105 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) >= (yyvsp[(3) - (3)].int_num); ;} - break; - - case 32: - -/* Line 1455 of yacc.c */ -#line 106 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) > (yyvsp[(3) - (3)].int_num); ;} - break; - - case 33: - -/* Line 1455 of yacc.c */ -#line 107 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (3)].int_num) < (yyvsp[(3) - (3)].int_num); ;} - break; - - case 34: - -/* Line 1455 of yacc.c */ -#line 108 "deon.y" - { (yyval.int_num) = (yyvsp[(2) - (2)].int_num) + 1; ;} - break; - - case 35: - -/* Line 1455 of yacc.c */ -#line 109 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (2)].int_num) + 1; ;} - break; - - case 36: - -/* Line 1455 of yacc.c */ -#line 110 "deon.y" - { (yyval.int_num) = (yyvsp[(2) - (2)].int_num) - 1; ;} - break; - - case 37: - -/* Line 1455 of yacc.c */ -#line 111 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (2)].int_num) - 1; ;} - break; - - case 38: - -/* Line 1455 of yacc.c */ -#line 112 "deon.y" - { (yyval.int_num) = (yyvsp[(2) - (3)].int_num); ;} - break; - - case 39: - -/* Line 1455 of yacc.c */ -#line 113 "deon.y" - { (yyval.int_num) = (yyvsp[(1) - (1)].int_num); ;} - break; - - case 41: - -/* Line 1455 of yacc.c */ -#line 118 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) + (yyvsp[(3) - (3)].double_num); ;} - break; - - case 42: - -/* Line 1455 of yacc.c */ -#line 119 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) - (yyvsp[(3) - (3)].double_num); ;} - break; - - case 43: - -/* Line 1455 of yacc.c */ -#line 120 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) * (yyvsp[(3) - (3)].double_num); ;} - break; - - case 44: - -/* Line 1455 of yacc.c */ -#line 121 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) / (yyvsp[(3) - (3)].double_num); ;} - break; - - case 45: - -/* Line 1455 of yacc.c */ -#line 122 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) <= (yyvsp[(3) - (3)].double_num); ;} - break; - - case 46: - -/* Line 1455 of yacc.c */ -#line 123 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) >= (yyvsp[(3) - (3)].double_num); ;} - break; - - case 47: - -/* Line 1455 of yacc.c */ -#line 124 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) > (yyvsp[(3) - (3)].double_num); ;} - break; - - case 48: - -/* Line 1455 of yacc.c */ -#line 125 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (3)].double_num) < (yyvsp[(3) - (3)].double_num); ;} - break; - - case 49: - -/* Line 1455 of yacc.c */ -#line 126 "deon.y" - { (yyval.double_num) = (yyvsp[(2) - (2)].double_num) + 1; ;} - break; - - case 50: - -/* Line 1455 of yacc.c */ -#line 127 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (2)].double_num) + 1; ;} - break; - - case 51: - -/* Line 1455 of yacc.c */ -#line 128 "deon.y" - { (yyval.double_num) = (yyvsp[(2) - (2)].double_num) - 1; ;} - break; - - case 52: - -/* Line 1455 of yacc.c */ -#line 129 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (2)].double_num) - 1; ;} - break; - - case 53: - -/* Line 1455 of yacc.c */ -#line 130 "deon.y" - { (yyval.double_num) = (yyvsp[(2) - (3)].double_num); ;} - break; - - case 54: - -/* Line 1455 of yacc.c */ -#line 131 "deon.y" - { (yyval.double_num) = (yyvsp[(1) - (1)].double_num); ;} - break; - - case 55: - -/* Line 1455 of yacc.c */ -#line 135 "deon.y" - { (yyval.node_ptr) = create_print_variable((yyvsp[(1) - (1)].str_ptr)); ;} - break; - - case 56: - -/* Line 1455 of yacc.c */ -#line 136 "deon.y" - { (yyval.node_ptr) = create_print_statement(VAR_INT, alloc_value(&(yyvsp[(1) - (1)].int_num), VAR_INT)); ;} - break; - - case 57: - -/* Line 1455 of yacc.c */ -#line 137 "deon.y" - { (yyval.node_ptr) = create_print_statement(VAR_STRING, (yyvsp[(1) - (1)].str_ptr)); ;} - break; - - - -/* Line 1455 of yacc.c */ -#line 1854 "deon.tab.c" - default: break; - } - YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); - - YYPOPSTACK (yylen); - yylen = 0; - YY_STACK_PRINT (yyss, yyssp); - - *++yyvsp = yyval; - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; - - goto yynewstate; - - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; -#if ! YYERROR_VERBOSE - yyerror (YY_("syntax error")); -#else - { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void) yysyntax_error (yymsg, yystate, yychar); - yyerror (yymsg); - } - else - { - yyerror (YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } -#endif - } - - - - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } - else - { - yydestruct ("Error: discarding", - yytoken, &yylval); - yychar = YYEMPTY; - } - } - - /* Else will try to reuse lookahead token after shifting the error - token. */ - goto yyerrlab1; - - -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; - - /* Do not reclaim the symbols of the rule which action triggered - this YYERROR. */ - YYPOPSTACK (yylen); - yylen = 0; - YY_STACK_PRINT (yyss, yyssp); - yystate = *yyssp; - goto yyerrlab1; - - -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ - - for (;;) - { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; - - - yydestruct ("Error: popping", - yystos[yystate], yyvsp); - YYPOPSTACK (1); - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); - } - - *++yyvsp = yylval; - - - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); - - yystate = yyn; - goto yynewstate; - - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#if !defined(yyoverflow) || YYERROR_VERBOSE -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ -yyexhaustedlab: - yyerror (YY_("memory exhausted")); - yyresult = 2; - /* Fall through. */ -#endif - -yyreturn: - if (yychar != YYEMPTY) - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); - /* Do not reclaim the symbols of the rule which action triggered - this YYABORT or YYACCEPT. */ - YYPOPSTACK (yylen); - YY_STACK_PRINT (yyss, yyssp); - while (yyssp != yyss) - { - yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp); - YYPOPSTACK (1); - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif -#if YYERROR_VERBOSE - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); -#endif - /* Make sure YYID is used. */ - return YYID (yyresult); -} - - - -/* Line 1675 of yacc.c */ -#line 139 "deon.y" - - -void yyerror(char *s) -{ - fprintf(stderr, "Error on line %d, %s\n", yylineno, s); -} diff --git a/deon-win/deon/vars/vars.c b/deon-win/deon/vars/vars.c index f0b821d..f15ef7b 100644 --- a/deon-win/deon/vars/vars.c +++ b/deon-win/deon/vars/vars.c @@ -79,7 +79,6 @@ static void* alloc_value(void* value, variable_type var_type) char* p_char = malloc(sizeof(char)); if (!p_char) return NULL; - memset(p_char, NULL, sizeof(*p_char)); *p_char = *(char*)value; return p_char; } @@ -137,4 +136,4 @@ static node_info* move_value(char* to, char* from) new_node->next = NULL; return new_node; } -#endif \ No newline at end of file +#endif