xerox
5 years ago
parent
527a4143b6
commit
92f790f084
@ -1,80 +0,0 @@
|
|||||||
%{
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include "y.tab.h"
|
|
||||||
|
|
||||||
void yyerror(char *);
|
|
||||||
|
|
||||||
extern YYSTYPE yylval;
|
|
||||||
extern FILE *yyin;
|
|
||||||
int yylineno;
|
|
||||||
int _DEBUG;
|
|
||||||
|
|
||||||
%}
|
|
||||||
%%
|
|
||||||
[//]* { ; }
|
|
||||||
-?[0-9]+ { yylval.num = atoi(yytext); return INTEGER; }
|
|
||||||
\'[ -~]\' { yylval.character = yytext[1]; return CHAR; }
|
|
||||||
[-()<>=+*/:;,%{}\[\]] { return *yytext; }
|
|
||||||
"if" { return IF; }
|
|
||||||
"else" { return ELSE; }
|
|
||||||
"printf" { return PRINTF; }
|
|
||||||
"string" { return KEYWORD_S; }
|
|
||||||
"while" { return WHILE; }
|
|
||||||
"int" { return KEYWORD_I; }
|
|
||||||
"def" { return DEF;}
|
|
||||||
"call" { return CALL; }
|
|
||||||
"char" { return KEYWORD_C; }
|
|
||||||
"++" { return INCREASE; }
|
|
||||||
"--" { return DECREASE; }
|
|
||||||
\"(\\.|[^"\\])*\" { yytext++; yytext[strlen(yytext)-1] = 0; yylval.str = strdup(yytext); return STRING; }
|
|
||||||
[a-zA-Z0-9_]+ { yylval.str = strdup(yytext); return VARNAME; }
|
|
||||||
-?[0-9]*\.[0-9]+ { yylval.Double = atof(yytext); return DOUBLEVAR; }
|
|
||||||
"\n" { yylineno++; }
|
|
||||||
[ ?\t\n\r]
|
|
||||||
. printf("invalid character on line %d, '%s'\n", yylineno, yytext);
|
|
||||||
<<EOF>> { exit(0); }
|
|
||||||
%%
|
|
||||||
|
|
||||||
int yywrap(void) {
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(int argc, char* argv[])
|
|
||||||
{
|
|
||||||
FILE *fh;
|
|
||||||
if (argc > 1)
|
|
||||||
{
|
|
||||||
if (strcmp(argv[1],"help") == 0 || strcmp(argv[1],"-help") == 0
|
|
||||||
|| strcmp(argv[1],"--help") == 0 || strcmp(argv[1],"h") == 0
|
|
||||||
|| strcmp(argv[1],"-h") == 0)
|
|
||||||
{
|
|
||||||
printf("[ HELP ] put a file/path as the first flag.\n");
|
|
||||||
printf("[ HELP ] -h, -help, --help, help, h: Prints this.\n");
|
|
||||||
printf("[ HELP ] -d, d, -debug, debug: Enter REPL mode.\n");
|
|
||||||
}
|
|
||||||
else if (strcmp(argv[1],"-debug") == 0 || strcmp(argv[1],"-d") == 0
|
|
||||||
|| strcmp(argv[1],"d") == 0 || strcmp(argv[1],"debug") == 0)
|
|
||||||
{
|
|
||||||
_DEBUG = 1;
|
|
||||||
printf(">>> ");
|
|
||||||
yyparse();
|
|
||||||
}
|
|
||||||
else if (fh = fopen(argv[1], "r"))
|
|
||||||
{
|
|
||||||
yyin = fh;
|
|
||||||
yyparse();
|
|
||||||
fclose(fh);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
printf("[ ERROR ] please enter a correct command. try --help\n");
|
|
||||||
fclose(fh);
|
|
||||||
}
|
|
||||||
} else
|
|
||||||
printf("[ ERROR ] missing input file. Try --help?\n");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@ -1,130 +0,0 @@
|
|||||||
%{
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "parser/parser.c"
|
|
||||||
#include "functions/functions.c"
|
|
||||||
#include "logic/logic.c"
|
|
||||||
#include "print/print.c"
|
|
||||||
#include "includes/include.h"
|
|
||||||
|
|
||||||
int yylex(void);
|
|
||||||
void yyerror(char *);
|
|
||||||
|
|
||||||
extern int yylineno;
|
|
||||||
extern int _DEBUG;
|
|
||||||
|
|
||||||
//hashmaps/link list heads
|
|
||||||
map_void_t *_var_map = NULL;
|
|
||||||
node_info *_temp_statement_head = NULL;
|
|
||||||
//struct variable *_var_head = NULL;
|
|
||||||
map_void_t *_function_list = NULL;
|
|
||||||
|
|
||||||
%}
|
|
||||||
|
|
||||||
/* doing these before multiplication and division because
|
|
||||||
they have a lower presidence
|
|
||||||
*/
|
|
||||||
|
|
||||||
%left '<' '>'
|
|
||||||
|
|
||||||
%left '+' '-'
|
|
||||||
|
|
||||||
/* doing this last so they have a higher presidence */
|
|
||||||
|
|
||||||
%left '*' '/' '%'
|
|
||||||
|
|
||||||
%union {
|
|
||||||
|
|
||||||
char *str;
|
|
||||||
int num;
|
|
||||||
char character;
|
|
||||||
double Double;
|
|
||||||
struct node_info *nPtr;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
%token INCREASE DECREASE PRINTF IF END KEYWORD_S KEYWORD_I KEYWORD_C QUOTE ELSE WHILE DEF CALL
|
|
||||||
%token <num> INTEGER
|
|
||||||
%token <str> STRING VARNAME
|
|
||||||
%token <character> CHAR
|
|
||||||
%token <Double> DOUBLEVAR
|
|
||||||
%type <num> expr
|
|
||||||
%type <nPtr> statement print VARIABLE FUNC statement_list
|
|
||||||
|
|
||||||
%%
|
|
||||||
|
|
||||||
program:
|
|
||||||
|
|
||||||
main '\n'
|
|
||||||
|
|
|
||||||
;
|
|
||||||
|
|
||||||
main:
|
|
||||||
|
|
||||||
main FUNC ';' { if (_DEBUG == 1 ) { printf(">>> "); ex($2); } else { ex($2); } }
|
|
||||||
| FUNC ';' { if (_DEBUG == 1 ) { printf(">>> "); ex($1); } else { ex($1); } }
|
|
||||||
| statement ';' { if (_DEBUG == 1 ) { printf(">>> "); ex($1); } else { ex($1); } }
|
|
||||||
;
|
|
||||||
|
|
||||||
statement:
|
|
||||||
|
|
||||||
VARIABLE { $$ = $1; } //this is a real var dec.
|
|
||||||
| FUNC { $$ = $1; }
|
|
||||||
| IF '[' expr ']' ':' '{' statement_list '}' { $$ = create_logic(1, $3, $7, NULL); } //examples of logic in this language
|
|
||||||
| WHILE '[' expr ']' ':' '{' statement_list '}' { $$ = create_logic(2, $3, $7, NULL); }
|
|
||||||
| PRINTF'['print']' { $$ = $3; }
|
|
||||||
| '{' statement_list '}' { $$ = $2; }
|
|
||||||
;
|
|
||||||
|
|
||||||
statement_list:
|
|
||||||
|
|
||||||
statement ';' { $$ = create_compound_statement($1, _temp_statement_head); }
|
|
||||||
| statement_list statement ';' { $$ = add_to_compound_statement($2, $1); }
|
|
||||||
;
|
|
||||||
|
|
||||||
FUNC:
|
|
||||||
|
|
||||||
DEF VARNAME ':' '{' statement_list '}' { $$ = create_function($2, $5); } // defining functions
|
|
||||||
| CALL VARNAME { $$ = create_function_call($2); } // calling functions
|
|
||||||
;
|
|
||||||
|
|
||||||
VARIABLE:
|
|
||||||
|
|
||||||
VARNAME '=' STRING { $$ = create_var_assignment_string($1, $3);}
|
|
||||||
| VARNAME '=' expr { $$ = create_var_assignment_int($1, $3);}
|
|
||||||
| VARNAME '=' CHAR { $$ = create_var_assignment_char($1, $3);}
|
|
||||||
| VARNAME '=' DOUBLEVAR { $$ = create_var_assignment_double($1, $3);}
|
|
||||||
| VARNAME '=' '{' statement_list '}' { $$ = create_function($1, $4); } // you can also define functions like this
|
|
||||||
;
|
|
||||||
|
|
||||||
|
|
||||||
expr:
|
|
||||||
INTEGER { $$ = $1; }
|
|
||||||
| '{' KEYWORD_I '}' VARNAME { $$ = get_value($4, _var_map)->_int; }
|
|
||||||
| expr '+' expr { $$ = $1 + $3; } /* addition */
|
|
||||||
| expr '-' expr { $$ = $1 - $3; } /* subtration */
|
|
||||||
| expr '*' expr { $$ = $1 * $3; } /* multiplication */
|
|
||||||
| expr '/' expr { $$ = $1 / $3; } /* division */
|
|
||||||
| expr '%' expr { $$ = $1 % $3; }
|
|
||||||
| expr '>' expr { if ($1 > $3) { $$ = 1; } else { $$ = 0;}}
|
|
||||||
| expr '<' expr { if ($1 < $3) { $$ = 1; } else { $$ = 0;}}
|
|
||||||
| '(' expr ')' { $$ = $2; }
|
|
||||||
;
|
|
||||||
|
|
||||||
//TODO update this.
|
|
||||||
print:
|
|
||||||
|
|
||||||
VARNAME { $$ = create_print_var_node($1); }
|
|
||||||
| expr { $$ = create_print_statement(1, $1, NULL); }
|
|
||||||
| STRING { $$ = create_print_statement(2, 0, $1); }
|
|
||||||
;
|
|
||||||
|
|
||||||
%%
|
|
||||||
|
|
||||||
void yyerror(char *s) {
|
|
||||||
fprintf(stderr, "Error on line %d, %s\n", yylineno, s);
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,20 +0,0 @@
|
|||||||
// another function
|
|
||||||
def AnotherFunction : {
|
|
||||||
printf["Hello from another function!"];
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// every program needs a main :)
|
|
||||||
def Main : {
|
|
||||||
// define variables
|
|
||||||
a = 10;
|
|
||||||
b = 20;
|
|
||||||
|
|
||||||
// print statements
|
|
||||||
printf["a + b: "];
|
|
||||||
printf[{ int } a + b];
|
|
||||||
|
|
||||||
// calling functions
|
|
||||||
call AnotherFunction;
|
|
||||||
};
|
|
||||||
call Main;
|
|
||||||
@ -1,72 +0,0 @@
|
|||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
#include "functions.h"
|
|
||||||
#include "../linked_list/linked_list.h"
|
|
||||||
#include "../linked_list/linked_list.c"
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a function.
|
|
||||||
*
|
|
||||||
* @param char * to the name of the function
|
|
||||||
* @param nodeInfo * to statement list
|
|
||||||
* @return nodeInfo * to head
|
|
||||||
*/
|
|
||||||
node_info *create_function(char *p_name, node_info *p_stmts)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
new_node->opperation = 7;
|
|
||||||
new_node->type = FUNCTION;
|
|
||||||
new_node->name = p_name;
|
|
||||||
new_node->_function_body = malloc(sizeof(node_info));
|
|
||||||
new_node->_function_body->next = copy_linked_list(p_stmts);
|
|
||||||
_free_linked_list(p_stmts);
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a function
|
|
||||||
*
|
|
||||||
* @param name of the function
|
|
||||||
* @return a node_info pointer to the head of the function
|
|
||||||
*/
|
|
||||||
node_info *create_function_call(char *p_name)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
new_node->opperation = 7;
|
|
||||||
new_node->type = FUNCTION_CALL;
|
|
||||||
new_node->name = p_name;
|
|
||||||
new_node->next = NULL;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a linked list inside of a linked list
|
|
||||||
*
|
|
||||||
* @param new_statement_list to be appended to list
|
|
||||||
* @param statement_head of linked list to append to
|
|
||||||
*/
|
|
||||||
node_info *create_compound_statement(node_info *new_statement_list, node_info *statement_head)
|
|
||||||
{
|
|
||||||
if(!statement_head)
|
|
||||||
{
|
|
||||||
statement_head = malloc(sizeof(node_info));
|
|
||||||
node_info *newNode = malloc(sizeof(node_info));
|
|
||||||
statement_head->opperation = 5;
|
|
||||||
statement_head->next = new_statement_list;
|
|
||||||
statement_head->next->next = NULL;
|
|
||||||
statement_head->statement_list = NULL;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
node_info *p = statement_head;
|
|
||||||
//TODO update with doubly linked list
|
|
||||||
while(p->statement_list != NULL)
|
|
||||||
p = p->statement_list;
|
|
||||||
|
|
||||||
p->next = malloc(sizeof(node_info));
|
|
||||||
p->next = new_statement_list;
|
|
||||||
p->next->next = NULL;
|
|
||||||
}
|
|
||||||
return statement_head;
|
|
||||||
}
|
|
||||||
@ -1,8 +0,0 @@
|
|||||||
#ifndef FUNCTIONS
|
|
||||||
#define FUNCTIONS
|
|
||||||
#include "../includes/include.h"
|
|
||||||
|
|
||||||
node_info *create_function(char *p_name, node_info *p_stmts);
|
|
||||||
node_info *create_function_call(char *p_name);
|
|
||||||
node_info *create_compound_statement(node_info *new_statement_list, node_info *statement_head);
|
|
||||||
#endif
|
|
||||||
@ -1,186 +0,0 @@
|
|||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include "map.h"
|
|
||||||
|
|
||||||
struct map_node_t {
|
|
||||||
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 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 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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* 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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* 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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
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;
|
|
||||||
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--;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
map_iter_t map_iter_(void) {
|
|
||||||
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 {
|
|
||||||
nextBucket:
|
|
||||||
do {
|
|
||||||
if (++iter->bucketidx >= m->nbuckets) {
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
iter->node = m->buckets[iter->bucketidx];
|
|
||||||
} while (iter->node == NULL);
|
|
||||||
}
|
|
||||||
return (char*) (iter->node + 1);
|
|
||||||
}
|
|
||||||
@ -1,77 +0,0 @@
|
|||||||
/**
|
|
||||||
* Copyright (c) 2014 rxi
|
|
||||||
*
|
|
||||||
* This library is free software; you can redistribute it and/or modify it
|
|
||||||
* under the terms of the MIT license. See LICENSE for details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef MAP_H
|
|
||||||
#define MAP_H
|
|
||||||
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#define MAP_VERSION "0.1.0"
|
|
||||||
|
|
||||||
struct map_node_t;
|
|
||||||
typedef struct map_node_t map_node_t;
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
map_node_t **buckets;
|
|
||||||
unsigned nbuckets, nnodes;
|
|
||||||
} map_base_t;
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
unsigned bucketidx;
|
|
||||||
map_node_t *node;
|
|
||||||
} map_iter_t;
|
|
||||||
|
|
||||||
|
|
||||||
#define map_t(T)\
|
|
||||||
struct { map_base_t base; T *ref; T tmp; }
|
|
||||||
|
|
||||||
|
|
||||||
#define map_init(m)\
|
|
||||||
memset(m, 0, sizeof(*(m)))
|
|
||||||
|
|
||||||
|
|
||||||
#define map_deinit(m)\
|
|
||||||
map_deinit_(&(m)->base)
|
|
||||||
|
|
||||||
|
|
||||||
#define map_get(m, key)\
|
|
||||||
( (m)->ref = map_get_(&(m)->base, key) )
|
|
||||||
|
|
||||||
|
|
||||||
#define map_set(m, key, value)\
|
|
||||||
( (m)->tmp = (value),\
|
|
||||||
map_set_(&(m)->base, key, &(m)->tmp, sizeof((m)->tmp)) )
|
|
||||||
|
|
||||||
|
|
||||||
#define map_remove(m, key)\
|
|
||||||
map_remove_(&(m)->base, key)
|
|
||||||
|
|
||||||
|
|
||||||
#define map_iter(m)\
|
|
||||||
map_iter_()
|
|
||||||
|
|
||||||
|
|
||||||
#define map_next(m, iter)\
|
|
||||||
map_next_(&(m)->base, iter)
|
|
||||||
|
|
||||||
|
|
||||||
void map_deinit_(map_base_t *m);
|
|
||||||
void *map_get_(map_base_t *m, const char *key);
|
|
||||||
int map_set_(map_base_t *m, const char *key, void *value, int vsize);
|
|
||||||
void map_remove_(map_base_t *m, const char *key);
|
|
||||||
map_iter_t map_iter_(void);
|
|
||||||
const char *map_next_(map_base_t *m, map_iter_t *iter);
|
|
||||||
|
|
||||||
|
|
||||||
typedef map_t(void*) map_void_t;
|
|
||||||
typedef map_t(char*) map_str_t;
|
|
||||||
typedef map_t(int) map_int_t;
|
|
||||||
typedef map_t(char) map_char_t;
|
|
||||||
typedef map_t(float) map_float_t;
|
|
||||||
typedef map_t(double) map_double_t;
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,84 +0,0 @@
|
|||||||
#ifndef INCLUDE_H
|
|
||||||
#define INCLUDE_H
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdbool.h>
|
|
||||||
|
|
||||||
#include "../hashmap/map.h"
|
|
||||||
|
|
||||||
/**
|
|
||||||
* VariableType is a enum of varible types that will be inside of my language.
|
|
||||||
*/
|
|
||||||
typedef enum variable_type
|
|
||||||
{
|
|
||||||
VAR_STRING,
|
|
||||||
VAR_INT,
|
|
||||||
VAR_CHAR,
|
|
||||||
VAR_DOUBLE,
|
|
||||||
VAR_VOID
|
|
||||||
} variable_type;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* VariableValues is a struct that holds all possible variable values
|
|
||||||
*/
|
|
||||||
typedef struct variable_values
|
|
||||||
{
|
|
||||||
variable_type type;
|
|
||||||
char _char;
|
|
||||||
char *_string;
|
|
||||||
int _int;
|
|
||||||
double _double;
|
|
||||||
void* _void_pointer; //TODO create a concept of "void"
|
|
||||||
} variable_values;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Variables is a struct that has all the information needed for a variables
|
|
||||||
*/
|
|
||||||
typedef struct variable
|
|
||||||
{
|
|
||||||
char *name;
|
|
||||||
variable_values *value;
|
|
||||||
struct variable *next;
|
|
||||||
} variable;
|
|
||||||
|
|
||||||
typedef struct print
|
|
||||||
{
|
|
||||||
int opperation;
|
|
||||||
double value;
|
|
||||||
char *string;
|
|
||||||
} print;
|
|
||||||
|
|
||||||
typedef struct logic
|
|
||||||
{
|
|
||||||
int opperation;
|
|
||||||
int expr;
|
|
||||||
struct node_info *if_true;
|
|
||||||
struct node_info *else_false;
|
|
||||||
struct node_info *while_true;
|
|
||||||
} logic;
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct node_info
|
|
||||||
{
|
|
||||||
int opperation;
|
|
||||||
enum type{
|
|
||||||
|
|
||||||
ASSIGNMENT,
|
|
||||||
EXPRESSION,
|
|
||||||
STATEMENT,
|
|
||||||
LOGIC,
|
|
||||||
FUNCTION,
|
|
||||||
FUNCTION_CALL
|
|
||||||
|
|
||||||
}type;
|
|
||||||
char *name;
|
|
||||||
variable *var;
|
|
||||||
print printExpression;
|
|
||||||
logic logicalExpression;
|
|
||||||
struct node_info *next;
|
|
||||||
struct node_info *_function_body;
|
|
||||||
struct node_info *statement_list;
|
|
||||||
struct node_info *local_list;
|
|
||||||
struct map_void_t *_var_list;
|
|
||||||
} node_info;
|
|
||||||
#endif
|
|
||||||
@ -1,71 +0,0 @@
|
|||||||
#include "linked_list.h"
|
|
||||||
|
|
||||||
/**
|
|
||||||
* free's a linked list
|
|
||||||
* @param head of linked list to be freed
|
|
||||||
* @return void
|
|
||||||
*/
|
|
||||||
void _free_linked_list(node_info *p_list)
|
|
||||||
{
|
|
||||||
node_info *temp;
|
|
||||||
while(p_list->next)
|
|
||||||
{
|
|
||||||
temp = p_list;
|
|
||||||
p_list = p_list->next;
|
|
||||||
free(temp);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* returns a copy of list
|
|
||||||
* @param nodeInfo list to be copied
|
|
||||||
* @return copied list
|
|
||||||
*/
|
|
||||||
node_info *copy_linked_list(node_info *p_list)
|
|
||||||
{
|
|
||||||
node_info *new_list = malloc(sizeof(node_info));
|
|
||||||
new_list->next = NULL;
|
|
||||||
node_info *copy_list = new_list;
|
|
||||||
while(p_list->next)
|
|
||||||
{
|
|
||||||
p_list = p_list->next;
|
|
||||||
copy_list->next = p_list;
|
|
||||||
copy_list = copy_list->next;
|
|
||||||
}
|
|
||||||
return new_list;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
@return void
|
|
||||||
@param node_info* (head of linked list)
|
|
||||||
@param node_info* (node to add)
|
|
||||||
|
|
||||||
Adds link to linked list.
|
|
||||||
*/
|
|
||||||
void linked_list_add(node_info* p_head, node_info* new_node)
|
|
||||||
{
|
|
||||||
node_info* p_head_temp = p_head;
|
|
||||||
while (p_head->next)
|
|
||||||
p_head_temp = p_head_temp->next;
|
|
||||||
p_head_temp->next = p_head;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
@return bool (removed or not)
|
|
||||||
@param node_info* (head of linked list)
|
|
||||||
@param node_info* (node to delete from linked list)
|
|
||||||
*/
|
|
||||||
bool linked_list_remove(node_info* p_head, node_info* delete_node)
|
|
||||||
{
|
|
||||||
node_info* p_head_temp = p_head;
|
|
||||||
while (p_head_temp->next)
|
|
||||||
{
|
|
||||||
if (p_head_temp->next == delete_node)
|
|
||||||
{
|
|
||||||
p_head_temp->next = delete_node->next;
|
|
||||||
free(delete_node);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
@ -1,9 +0,0 @@
|
|||||||
#ifndef LINKED_LIST_H
|
|
||||||
#define LINKED_LIST_H
|
|
||||||
#include "../includes/include.h"
|
|
||||||
|
|
||||||
void _free_linked_list(node_info *p_list);
|
|
||||||
node_info *copy_linked_list(node_info *p_list);
|
|
||||||
void linked_list_add(node_info* p_head, node_info* new_node);
|
|
||||||
bool linked_list_remove(node_info* p_head, node_info* delete_node);
|
|
||||||
#endif
|
|
||||||
@ -1,40 +0,0 @@
|
|||||||
#include "../includes/include.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* WARNING! do not use this function, it is old and outdated, and is missing alot of new features!
|
|
||||||
*/
|
|
||||||
node_info *create_logic(int opperation, int expr, node_info *statement_list, node_info *else_false)
|
|
||||||
{
|
|
||||||
node_info *n = malloc(sizeof(node_info));
|
|
||||||
switch (opperation)
|
|
||||||
{
|
|
||||||
case 1: //if statement
|
|
||||||
n->opperation = 4;
|
|
||||||
logic a;
|
|
||||||
a.opperation = 1;
|
|
||||||
a.expr = expr;
|
|
||||||
while (statement_list->statement_list)
|
|
||||||
statement_list = statement_list->statement_list;
|
|
||||||
node_info *newNode = malloc(sizeof(node_info));
|
|
||||||
newNode->opperation = 5;
|
|
||||||
newNode->next = copy_linked_list(statement_list);
|
|
||||||
_free_linked_list(statement_list);
|
|
||||||
a.if_true = newNode;
|
|
||||||
statement_list = NULL;
|
|
||||||
n->logicalExpression = a;
|
|
||||||
return n;
|
|
||||||
|
|
||||||
case 2: //while loop
|
|
||||||
/*n->opperation = 4;
|
|
||||||
logic b;
|
|
||||||
b.opperation = 2;
|
|
||||||
b.expr = expr;
|
|
||||||
b.while_true = if_true;
|
|
||||||
|
|
||||||
n->logicalExpression = b;
|
|
||||||
return n;*/
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
printf("check your yacc file for logical statements\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,4 +0,0 @@
|
|||||||
#ifndef LOGIC_H
|
|
||||||
#define LOGIC_H
|
|
||||||
node_info *createLogic(int opperation, int expr, node_info *statement_list, node_info *else_false);
|
|
||||||
#endif
|
|
||||||
@ -1,3 +0,0 @@
|
|||||||
lex deon.l
|
|
||||||
yacc -d deon.y
|
|
||||||
gcc hashmap/map.c lex.yy.c y.tab.c -o deon
|
|
||||||
@ -1,211 +0,0 @@
|
|||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include "parser.h"
|
|
||||||
#include "../vars/vars.c"
|
|
||||||
|
|
||||||
//hashmaps/link list heads
|
|
||||||
extern map_void_t *_var_map;
|
|
||||||
extern node_info *_temp_statement_head;
|
|
||||||
//struct variable *_var_head = NULL;
|
|
||||||
extern map_void_t *_function_list;
|
|
||||||
|
|
||||||
node_info* create_var_assignment_string(char *p_name, char *value)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
variable *new_var = make_variable_string(p_name, value);
|
|
||||||
new_node->type = ASSIGNMENT;
|
|
||||||
new_node->opperation = 1;
|
|
||||||
new_node->var = new_var;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
node_info* create_var_assignment_int(char *p_name, int value)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
variable *new_var = make_variable_int(p_name, value);
|
|
||||||
new_node->type = ASSIGNMENT;
|
|
||||||
new_node->opperation = 1;
|
|
||||||
new_node->var = new_var;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
node_info* create_var_assignment_char(char *p_name, char value)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
variable *new_var = make_variable_char(p_name, value);
|
|
||||||
new_node->type = ASSIGNMENT;
|
|
||||||
new_node->opperation = 1;
|
|
||||||
new_node->var = new_var;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
node_info* create_var_assignment_double(char *p_name, double value)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
variable *new_var = make_variable_double(p_name, value);
|
|
||||||
//new node stuff
|
|
||||||
new_node->type = ASSIGNMENT;
|
|
||||||
new_node->opperation = 1;
|
|
||||||
new_node->var = new_var;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Adds statement to linked list.
|
|
||||||
|
|
||||||
@param nodeInfo link to be added.
|
|
||||||
@return head of linked list.
|
|
||||||
*/
|
|
||||||
node_info* add_to_compound_statement(node_info *new_statement, node_info *statement_head)
|
|
||||||
{
|
|
||||||
if(!statement_head)
|
|
||||||
{
|
|
||||||
statement_head = malloc(sizeof(node_info));
|
|
||||||
statement_head->opperation = 5;
|
|
||||||
statement_head->next = new_statement;
|
|
||||||
statement_head->next->next = NULL;
|
|
||||||
statement_head->statement_list = NULL;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
node_info *p = statement_head; //make a temp of list head, so we can traverse it
|
|
||||||
//TODO replace with double linked list end
|
|
||||||
while (p->statement_list)
|
|
||||||
p = p->statement_list;
|
|
||||||
|
|
||||||
//TODO replace with double linked list end
|
|
||||||
while (p->next)
|
|
||||||
p = p->next;
|
|
||||||
|
|
||||||
p->next = malloc(sizeof(node_info));
|
|
||||||
p->next = new_statement;
|
|
||||||
p->next->next = NULL;
|
|
||||||
}
|
|
||||||
return statement_head;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Executes a statment.
|
|
||||||
|
|
||||||
@param nodeInfo statement to be executed
|
|
||||||
@return void.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//TODO break this switch up into multiple functions
|
|
||||||
//TODO return status code possibly.
|
|
||||||
void ex(node_info *exec_node)
|
|
||||||
{
|
|
||||||
switch(exec_node->opperation)
|
|
||||||
{
|
|
||||||
case 1:
|
|
||||||
add_var(exec_node->var->name, exec_node->var->value, _var_map);
|
|
||||||
break;
|
|
||||||
//TODO expression stuff
|
|
||||||
case 2:
|
|
||||||
break;
|
|
||||||
//print
|
|
||||||
case 3:
|
|
||||||
switch(exec_node->printExpression.opperation) {
|
|
||||||
|
|
||||||
case 1:
|
|
||||||
printf("%d\n", (int) exec_node->printExpression.value);
|
|
||||||
break;
|
|
||||||
case 2:
|
|
||||||
printf("%s\n", exec_node->printExpression.string);
|
|
||||||
break;
|
|
||||||
case 3:
|
|
||||||
printf("%s%lf\n", exec_node->printExpression.string, exec_node->printExpression.value);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
printf("{ERROR} CHECK YACC FILE FOR INCORRECT PRINT\n");
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case 4:
|
|
||||||
{
|
|
||||||
switch(exec_node->logicalExpression.opperation) {
|
|
||||||
case 1:
|
|
||||||
if (exec_node->logicalExpression.expr == 1)
|
|
||||||
ex(exec_node->logicalExpression.if_true);
|
|
||||||
break;
|
|
||||||
case 2:
|
|
||||||
while (exec_node->logicalExpression.expr == 1)
|
|
||||||
ex(exec_node->logicalExpression.while_true);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
printf("{ERROR} SOMETHING WRONG WITH LOGICAL EXPRESSION CHECK YACC\n");
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 5:
|
|
||||||
{
|
|
||||||
while(exec_node->next)
|
|
||||||
{
|
|
||||||
exec_node = exec_node->next;
|
|
||||||
ex(exec_node);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 6:
|
|
||||||
{
|
|
||||||
variable_values *value = get_value(exec_node->name, _var_map);
|
|
||||||
switch(value->type)
|
|
||||||
{
|
|
||||||
case VAR_STRING:
|
|
||||||
printf("%s\n", value->_string);
|
|
||||||
break;
|
|
||||||
case VAR_INT:
|
|
||||||
printf("%d\n", value->_int);
|
|
||||||
break;
|
|
||||||
case VAR_CHAR:
|
|
||||||
printf("%c\n", value->_char);
|
|
||||||
break;
|
|
||||||
case VAR_DOUBLE:
|
|
||||||
printf("%f\n", value->_double);
|
|
||||||
break;
|
|
||||||
case VAR_VOID: //TODO add void variable type
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
printf("{ERROR} NO SUCH VARIABLE TYPE CHECK YACC!\n");
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 7:
|
|
||||||
{
|
|
||||||
switch(exec_node->type)
|
|
||||||
{
|
|
||||||
case FUNCTION_CALL:
|
|
||||||
{
|
|
||||||
node_info *_stmts = *map_get(&*((map_void_t* ) _function_list), exec_node->name);
|
|
||||||
while (_stmts->next != NULL)
|
|
||||||
{
|
|
||||||
_stmts = _stmts->next;
|
|
||||||
ex(_stmts);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case FUNCTION:
|
|
||||||
{
|
|
||||||
//if the list of functions already defined is null then we malloc space for it.
|
|
||||||
if (!_function_list)
|
|
||||||
{
|
|
||||||
_function_list = malloc(sizeof(map_void_t));
|
|
||||||
exec_node->_var_list = malloc(sizeof(node_info));
|
|
||||||
exec_node->next = NULL;
|
|
||||||
exec_node->local_list = NULL;
|
|
||||||
map_init(&*((map_void_t *) _function_list));
|
|
||||||
map_init(&*((map_void_t *) exec_node->_var_list));
|
|
||||||
//put the function in the hashmap
|
|
||||||
map_set(&*((map_void_t* ) _function_list), exec_node->name, &*exec_node->_function_body);
|
|
||||||
} else //else we dont malloc, we just put the function inside of the hashmap.
|
|
||||||
map_set(&*((map_void_t* ) _function_list), exec_node->name, &*exec_node->_function_body);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
;
|
|
||||||
//TODO add error here and close
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,11 +0,0 @@
|
|||||||
#ifndef PARSER_H
|
|
||||||
#define PARSER_H
|
|
||||||
#include "../includes/include.h"
|
|
||||||
|
|
||||||
node_info* create_var_assignment_string(char *p_name, char *value);
|
|
||||||
node_info* create_var_assignment_int(char *p_name, int value);
|
|
||||||
node_info* create_var_assignment_char(char *pName, char value);
|
|
||||||
node_info* create_var_assignment_double(char *pName, double value);
|
|
||||||
node_info* add_to_compound_statement(node_info *new_statement, node_info *statement_head);
|
|
||||||
void ex(node_info *exec_node);
|
|
||||||
#endif
|
|
||||||
@ -1,53 +0,0 @@
|
|||||||
#include "../includes/include.h"
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a print node
|
|
||||||
*
|
|
||||||
* @param pVarName name of variable to print
|
|
||||||
* @return node_info print statement
|
|
||||||
*/
|
|
||||||
node_info *create_print_var_node(char *p_var_name)
|
|
||||||
{
|
|
||||||
node_info *new_node = malloc(sizeof(node_info));
|
|
||||||
new_node->opperation = 6;
|
|
||||||
new_node->name = p_var_name;
|
|
||||||
return new_node;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
*
|
|
||||||
* @params opperation value, see print struct for info
|
|
||||||
* @params int value to be printed
|
|
||||||
* @params string to be printed
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
node_info *create_print_statement(int opperation, int value, char *string)
|
|
||||||
{
|
|
||||||
node_info *n = malloc(sizeof(node_info));
|
|
||||||
print a;
|
|
||||||
switch(opperation)
|
|
||||||
{
|
|
||||||
case 1:
|
|
||||||
n->opperation = 3;
|
|
||||||
a.value = value;
|
|
||||||
a.opperation = 1;
|
|
||||||
n->printExpression = a;
|
|
||||||
return n;
|
|
||||||
case 2:
|
|
||||||
n->opperation = 3;
|
|
||||||
a.string = string;
|
|
||||||
a.opperation = 2;
|
|
||||||
n->printExpression = a;
|
|
||||||
return n;
|
|
||||||
case 3:
|
|
||||||
n->opperation = 3;
|
|
||||||
a.string = string;
|
|
||||||
a.opperation = 3;
|
|
||||||
a.value = value;
|
|
||||||
n->printExpression = a;
|
|
||||||
return n;
|
|
||||||
default:
|
|
||||||
printf("{ERROR} PRINT STATEMENT ERROR IN YACC\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,5 +0,0 @@
|
|||||||
#ifndef PRINT_H
|
|
||||||
#define PRINT_H
|
|
||||||
node_info *create_print_var_node(char *pVarName);
|
|
||||||
node_info *create_print_statement(int opperation, int value, char *string);
|
|
||||||
#endif
|
|
||||||
@ -1,107 +0,0 @@
|
|||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include "vars.h"
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Version: 0.2
|
|
||||||
*
|
|
||||||
* adds var to hashmap if its not already set
|
|
||||||
* else it will update the var with provided values.
|
|
||||||
* @return null
|
|
||||||
* @param string for var name
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
void add_var(char *p_name, variable_values *p_values, map_void_t* p_var_map)
|
|
||||||
{
|
|
||||||
//if variable map is null
|
|
||||||
if(!p_var_map)
|
|
||||||
{
|
|
||||||
p_var_map = malloc(sizeof(map_void_t));
|
|
||||||
map_init(&*((map_void_t *) p_var_map));
|
|
||||||
}
|
|
||||||
map_set(&*((map_void_t* ) p_var_map), p_name, &*p_values);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* returns variables values from hashmap
|
|
||||||
*
|
|
||||||
* @see [variable_values]
|
|
||||||
* @see [char *string]
|
|
||||||
* @return [variable_values] containing variables data
|
|
||||||
* @param [char *string] Variable name.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
variable_values *get_value(char *p_name, map_void_t* p_var_map)
|
|
||||||
{
|
|
||||||
return *map_get(&*((map_void_t* ) p_var_map), p_name);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
*
|
|
||||||
* This makes an integer varible and adds it to the linked list of
|
|
||||||
* vars.
|
|
||||||
* @return the head of the linked list which just points to all of the vars
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
variable* make_variable_int(char *p_name, int value)
|
|
||||||
{
|
|
||||||
variable *p = malloc(sizeof(variable));
|
|
||||||
variable_values *int_value = malloc(sizeof(variable_values));
|
|
||||||
int_value->type = VAR_INT;
|
|
||||||
int_value->_int = value;
|
|
||||||
p->name = p_name;
|
|
||||||
p->value = int_value;
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* makes a variable of type double.
|
|
||||||
* @param name of the varible.
|
|
||||||
* @param double data to be stored in the variable.
|
|
||||||
*/
|
|
||||||
variable* make_variable_double(char *p_name, double value)
|
|
||||||
{
|
|
||||||
variable *new_var = malloc(sizeof(variable));
|
|
||||||
variable_values *double_value = malloc(sizeof(variable_values));
|
|
||||||
double_value->type = VAR_DOUBLE;
|
|
||||||
double_value->_double = value;
|
|
||||||
new_var->name = p_name;
|
|
||||||
new_var->value = double_value;
|
|
||||||
return new_var;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* makes a char variable.
|
|
||||||
*
|
|
||||||
* @param name of the variable.
|
|
||||||
* @param char value to be stored.
|
|
||||||
*/
|
|
||||||
variable* make_variable_char(char *p_name, char value)
|
|
||||||
{
|
|
||||||
variable *p = malloc(sizeof(variable));
|
|
||||||
variable_values *char_value = malloc(sizeof(variable_values));
|
|
||||||
char_value->type = VAR_CHAR;
|
|
||||||
char_value->_char = value;
|
|
||||||
p->name = p_name;
|
|
||||||
p->value = char_value;
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* makes a variable of type string.
|
|
||||||
*
|
|
||||||
* @param name of the variable.
|
|
||||||
* @param value to be stored.
|
|
||||||
*/
|
|
||||||
variable* make_variable_string(char *p_name, char *value)
|
|
||||||
{
|
|
||||||
variable *p = malloc(sizeof(variable));
|
|
||||||
variable_values *string_value = malloc(sizeof(variable_values));
|
|
||||||
string_value->type = VAR_STRING;
|
|
||||||
string_value->_string = value;
|
|
||||||
p->name = p_name;
|
|
||||||
p->value = string_value;
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
@ -1,10 +0,0 @@
|
|||||||
#ifndef VARS_H
|
|
||||||
#define VARS_H
|
|
||||||
#include "../includes/include.h"
|
|
||||||
void add_var(char *name, variable_values *values, map_void_t* p_var_map);
|
|
||||||
variable_values *get_value(char *p_name, map_void_t* p_var_map);
|
|
||||||
variable* make_variable_int(char *p_name, int value);
|
|
||||||
variable* make_variable_double(char *p_name, double value);
|
|
||||||
variable* make_variable_char(char *p_name, char value);
|
|
||||||
variable* make_variable_string(char *p_name, char *value);
|
|
||||||
#endif
|
|
||||||
@ -1,116 +0,0 @@
|
|||||||
/* A Bison parser, made by GNU Bison 3.0.4. */
|
|
||||||
|
|
||||||
/* Bison interface for Yacc-like parsers in C
|
|
||||||
|
|
||||||
Copyright (C) 1984, 1989-1990, 2000-2015 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 <http://www.gnu.org/licenses/>. */
|
|
||||||
|
|
||||||
/* 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. */
|
|
||||||
|
|
||||||
#ifndef YY_YY_Y_TAB_H_INCLUDED
|
|
||||||
# define YY_YY_Y_TAB_H_INCLUDED
|
|
||||||
/* Debug traces. */
|
|
||||||
#ifndef YYDEBUG
|
|
||||||
# define YYDEBUG 0
|
|
||||||
#endif
|
|
||||||
#if YYDEBUG
|
|
||||||
extern int yydebug;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Token type. */
|
|
||||||
#ifndef YYTOKENTYPE
|
|
||||||
# define YYTOKENTYPE
|
|
||||||
enum yytokentype
|
|
||||||
{
|
|
||||||
INCREASE = 258,
|
|
||||||
DECREASE = 259,
|
|
||||||
PRINTF = 260,
|
|
||||||
IF = 261,
|
|
||||||
END = 262,
|
|
||||||
KEYWORD_S = 263,
|
|
||||||
KEYWORD_I = 264,
|
|
||||||
KEYWORD_C = 265,
|
|
||||||
QUOTE = 266,
|
|
||||||
ELSE = 267,
|
|
||||||
WHILE = 268,
|
|
||||||
DEF = 269,
|
|
||||||
CALL = 270,
|
|
||||||
INTEGER = 271,
|
|
||||||
STRING = 272,
|
|
||||||
VARNAME = 273,
|
|
||||||
CHAR = 274,
|
|
||||||
DOUBLEVAR = 275
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
/* Tokens. */
|
|
||||||
#define INCREASE 258
|
|
||||||
#define DECREASE 259
|
|
||||||
#define PRINTF 260
|
|
||||||
#define IF 261
|
|
||||||
#define END 262
|
|
||||||
#define KEYWORD_S 263
|
|
||||||
#define KEYWORD_I 264
|
|
||||||
#define KEYWORD_C 265
|
|
||||||
#define QUOTE 266
|
|
||||||
#define ELSE 267
|
|
||||||
#define WHILE 268
|
|
||||||
#define DEF 269
|
|
||||||
#define CALL 270
|
|
||||||
#define INTEGER 271
|
|
||||||
#define STRING 272
|
|
||||||
#define VARNAME 273
|
|
||||||
#define CHAR 274
|
|
||||||
#define DOUBLEVAR 275
|
|
||||||
|
|
||||||
/* Value type. */
|
|
||||||
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
|
||||||
|
|
||||||
union YYSTYPE
|
|
||||||
{
|
|
||||||
#line 38 "deon.y" /* yacc.c:1909 */
|
|
||||||
|
|
||||||
|
|
||||||
char *str;
|
|
||||||
int num;
|
|
||||||
char character;
|
|
||||||
double Double;
|
|
||||||
struct node_info *nPtr;
|
|
||||||
|
|
||||||
|
|
||||||
#line 104 "y.tab.h" /* yacc.c:1909 */
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef union YYSTYPE YYSTYPE;
|
|
||||||
# define YYSTYPE_IS_TRIVIAL 1
|
|
||||||
# define YYSTYPE_IS_DECLARED 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
extern YYSTYPE yylval;
|
|
||||||
|
|
||||||
int yyparse (void);
|
|
||||||
|
|
||||||
#endif /* !YY_YY_Y_TAB_H_INCLUDED */
|
|
||||||
Loading…
Reference in new issue