summaryrefslogtreecommitdiffstats
path: root/dimension
diff options
context:
space:
mode:
Diffstat (limited to 'dimension')
-rw-r--r--dimension/bison.y303
-rw-r--r--dimension/parse.h4
2 files changed, 289 insertions, 18 deletions
diff --git a/dimension/bison.y b/dimension/bison.y
index 8b67669..426bc29 100644
--- a/dimension/bison.y
+++ b/dimension/bison.y
@@ -61,6 +61,21 @@ typedef union YYSTYPE {
} while (0)
/* Create a new astnode, populating filename, line, and col */
+
+static dmnsn_astnode
+dmnsn_copy_astnode(dmnsn_astnode astnode)
+{
+ dmnsn_astnode copy = {
+ .type = astnode.type,
+ .children = dmnsn_new_array(sizeof(dmnsn_astnode)),
+ .ptr = NULL,
+ .filename = astnode.filename,
+ .line = astnode.line,
+ .col = astnode.col
+ };
+ return copy;
+}
+
static dmnsn_astnode
dmnsn_new_astnode(dmnsn_astnode_type type, YYLTYPE lloc)
{
@@ -75,6 +90,35 @@ dmnsn_new_astnode(dmnsn_astnode_type type, YYLTYPE lloc)
return astnode;
}
+static dmnsn_astnode
+dmnsn_new_astnode1(dmnsn_astnode_type type, YYLTYPE lloc, dmnsn_astnode n1)
+{
+ dmnsn_astnode astnode = dmnsn_new_astnode(type, lloc);
+ dmnsn_array_push(astnode.children, &n1);
+ return astnode;
+}
+
+static dmnsn_astnode
+dmnsn_new_astnode2(dmnsn_astnode_type type, YYLTYPE lloc,
+ dmnsn_astnode n1, dmnsn_astnode n2)
+{
+ dmnsn_astnode astnode = dmnsn_new_astnode(type, lloc);
+ dmnsn_array_push(astnode.children, &n1);
+ dmnsn_array_push(astnode.children, &n2);
+ return astnode;
+}
+
+static dmnsn_astnode
+dmnsn_new_astnode3(dmnsn_astnode_type type, YYLTYPE lloc,
+ dmnsn_astnode n1, dmnsn_astnode n2, dmnsn_astnode n3)
+{
+ dmnsn_astnode astnode = dmnsn_new_astnode(type, lloc);
+ dmnsn_array_push(astnode.children, &n1);
+ dmnsn_array_push(astnode.children, &n2);
+ dmnsn_array_push(astnode.children, &n3);
+ return astnode;
+}
+
/* Delete a single, unused astnode */
static void
dmnsn_delete_astnode(dmnsn_astnode astnode)
@@ -625,14 +669,16 @@ yyerror(YYLTYPE *locp, dmnsn_array *astree, dmnsn_token_iterator *iterator,
%type <astnode> BOX
%type <astnode> SPHERE
-/* Vectors */
-%type <astnode> VECTOR
-%type <astnode> VECTOR_LITERAL
-
/* Floats */
%type <astnode> FLOAT
+%type <astnode> FLOAT_TERM
+%type <astnode> FLOAT_FACTOR
%type <astnode> FLOAT_LITERAL
+/* Vectors */
+%type <astnode> VECTOR
+%type <astnode> VECTOR_LITERAL
+
%destructor { dmnsn_delete_astnode($$); } <astnode>
%%
@@ -650,55 +696,93 @@ OBJECT: FINITE_SOLID_OBJECT
;
FINITE_SOLID_OBJECT: BOX
- | SPHERE
+ | SPHERE
;
BOX: "box" "{"
VECTOR "," VECTOR
"}"
{
- $$ = dmnsn_new_astnode(DMNSN_AST_BOX, @$);
- dmnsn_array_push($$.children, &$3);
- dmnsn_array_push($$.children, &$5);
+ $$ = dmnsn_new_astnode2(DMNSN_AST_BOX, @$, $3, $5);
}
;
SPHERE: "sphere" "{"
+ VECTOR "," FLOAT
"}"
{
- $$ = dmnsn_new_astnode(DMNSN_AST_SPHERE, @$);
+ $$ = dmnsn_new_astnode2(DMNSN_AST_SPHERE, @$, $3, $5);
}
;
-VECTOR: VECTOR_LITERAL
+FLOAT: FLOAT_TERM
+ {
+ $$ = dmnsn_eval_scalar($1);
+ dmnsn_delete_astnode($1);
+ }
+ | FLOAT "+" FLOAT_TERM
+ {
+ dmnsn_astnode sum = dmnsn_new_astnode2(DMNSN_AST_ADD, @$, $1, $3);
+ $$ = dmnsn_eval_scalar(sum);
+ dmnsn_delete_astnode(sum);
+ }
+ | FLOAT "-" FLOAT_TERM
+ {
+ dmnsn_astnode diff = dmnsn_new_astnode2(DMNSN_AST_SUB, @$, $1, $3);
+ $$ = dmnsn_eval_scalar(diff);
+ dmnsn_delete_astnode(diff);
+ }
;
-VECTOR_LITERAL: "<" FLOAT "," FLOAT "," FLOAT ">"
+FLOAT_TERM: FLOAT_FACTOR
+ | FLOAT_TERM "*" FLOAT_FACTOR
{
- $$ = dmnsn_new_astnode(DMNSN_AST_VECTOR, @$);
- dmnsn_array_push($$.children, &$2);
- dmnsn_array_push($$.children, &$4);
- dmnsn_array_push($$.children, &$6);
+ $$ = dmnsn_new_astnode2(DMNSN_AST_MUL, @$, $1, $3);
+ }
+ | FLOAT_TERM "/" FLOAT_FACTOR
+ {
+ $$ = dmnsn_new_astnode2(DMNSN_AST_DIV, @$, $1, $3);
}
-;
-FLOAT: FLOAT_LITERAL
-;
+FLOAT_FACTOR: FLOAT_LITERAL
+ | "+" FLOAT_FACTOR { $$ = $2; }
+ | "-" FLOAT_FACTOR
+ {
+ $$ = dmnsn_new_astnode1(DMNSN_AST_NEGATE, @$, $2);
+ }
+ | "(" FLOAT ")" { $$ = $2; }
FLOAT_LITERAL: "integer"
{
$$ = dmnsn_new_astnode(DMNSN_AST_INTEGER, @$);
$$.ptr = malloc(sizeof(long));
+ if (!$$.ptr)
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Failed to allocate room for integer.");
+
*(long *)$$.ptr = strtol($1, NULL, 0);
}
| "float"
{
$$ = dmnsn_new_astnode(DMNSN_AST_FLOAT, @$);
$$.ptr = malloc(sizeof(double));
+ if (!$$.ptr)
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Failed to allocate room for float.");
+
*(double *)$$.ptr = strtod($1, NULL);
}
;
+VECTOR: VECTOR_LITERAL
+;
+
+VECTOR_LITERAL: "<" FLOAT "," FLOAT "," FLOAT ">"
+ {
+ $$ = dmnsn_new_astnode3(DMNSN_AST_VECTOR, @$, $2, $4, $6);
+ }
+;
+
%%
dmnsn_array *
@@ -731,6 +815,189 @@ dmnsn_delete_astree(dmnsn_array *astree)
}
}
+static dmnsn_astnode
+dmnsn_eval_scalar_unary(dmnsn_astnode astnode)
+{
+ dmnsn_astnode ret = dmnsn_copy_astnode(astnode), rhs;
+ dmnsn_array_get(astnode.children, 0, &rhs);
+ rhs = dmnsn_eval_scalar(rhs);
+
+ if (rhs.type == DMNSN_AST_INTEGER) {
+ long n = *(long *)rhs.ptr;
+ long *res = malloc(sizeof(long));
+ if (!res)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for integer.");
+
+ switch(astnode.type) {
+ case DMNSN_AST_NEGATE:
+ *res = -n;
+ break;
+
+ default:
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Attempt to evaluate wrong unary operator.");
+ }
+
+ ret.type = DMNSN_AST_INTEGER;
+ ret.ptr = res;
+ } else if (rhs.type == DMNSN_AST_FLOAT) {
+ double n = *(double *)rhs.ptr;
+ double *res = malloc(sizeof(double));
+ if (!res)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for float.");
+
+ switch(astnode.type) {
+ case DMNSN_AST_NEGATE:
+ *res = -n;
+ break;
+
+ default:
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Attempt to evaluate wrong unary operator.");
+ }
+
+ ret.type = DMNSN_AST_FLOAT;
+ ret.ptr = res;
+ } else {
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Invalid right hand side to unary operator.");
+ }
+
+ dmnsn_delete_astnode(rhs);
+ return ret;
+}
+
+static dmnsn_astnode
+dmnsn_eval_scalar_binary(dmnsn_astnode astnode)
+{
+ dmnsn_astnode ret = dmnsn_copy_astnode(astnode), lhs, rhs;
+ dmnsn_array_get(astnode.children, 0, &lhs);
+ dmnsn_array_get(astnode.children, 1, &rhs);
+ lhs = dmnsn_eval_scalar(lhs);
+ rhs = dmnsn_eval_scalar(rhs);
+
+ if (lhs.type == DMNSN_AST_INTEGER && rhs.type == DMNSN_AST_INTEGER
+ && astnode.type != DMNSN_AST_DIV) {
+ long l, r;
+ l = *(long *)lhs.ptr;
+ r = *(long *)rhs.ptr;
+
+ long *res = malloc(sizeof(long));
+ if (!res)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for integer.");
+
+ switch (astnode.type) {
+ case DMNSN_AST_ADD:
+ *res = l + r;
+ break;
+ case DMNSN_AST_SUB:
+ *res = l - r;
+ break;
+ case DMNSN_AST_MUL:
+ *res = l*r;
+ break;
+
+ default:
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Attempt to evaluate wrong binary operator.");
+ }
+
+ ret.type = DMNSN_AST_INTEGER;
+ ret.ptr = res;
+ } else {
+ double l = 0.0, r = 0.0;
+
+ if (lhs.type == DMNSN_AST_INTEGER)
+ l = *(long *)lhs.ptr;
+ else if (lhs.type == DMNSN_AST_FLOAT)
+ l = *(double *)lhs.ptr;
+ else
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Invalid left hand side to binary operator.");
+
+ if (rhs.type == DMNSN_AST_INTEGER)
+ r = *(long *)rhs.ptr;
+ else if (rhs.type == DMNSN_AST_FLOAT)
+ r = *(double *)rhs.ptr;
+ else
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Invalid right hand side to binary operator.");
+
+ double *res = malloc(sizeof(double));
+ if (!res)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for float.");
+
+ switch (astnode.type) {
+ case DMNSN_AST_ADD:
+ *res = l + r;
+ break;
+ case DMNSN_AST_SUB:
+ *res = l - r;
+ break;
+ case DMNSN_AST_MUL:
+ *res = l*r;
+ break;
+ case DMNSN_AST_DIV:
+ *res = l/r;
+ break;
+
+ default:
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Attempt to evaluate wrong binary operator.");
+ }
+
+ ret.type = DMNSN_AST_FLOAT;
+ ret.ptr = res;
+ }
+
+ dmnsn_delete_astnode(lhs);
+ dmnsn_delete_astnode(rhs);
+ return ret;
+}
+
+dmnsn_astnode
+dmnsn_eval_scalar(dmnsn_astnode astnode)
+{
+ dmnsn_astnode ret;
+
+ switch (astnode.type) {
+ case DMNSN_AST_INTEGER:
+ ret = dmnsn_copy_astnode(astnode);
+ ret.ptr = malloc(sizeof(long));
+ if (!ret.ptr)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for integer.");
+
+ memcpy(ret.ptr, astnode.ptr, sizeof(long));
+ return ret;
+
+ case DMNSN_AST_FLOAT:
+ ret = dmnsn_copy_astnode(astnode);
+ ret.ptr = malloc(sizeof(double));
+ if (!ret.ptr)
+ dmnsn_error(DMNSN_SEVERITY_HIGH, "Failed to allocate room for float.");
+
+ memcpy(ret.ptr, astnode.ptr, sizeof(double));
+ return ret;
+
+ case DMNSN_AST_NEGATE:
+ return dmnsn_eval_scalar_unary(astnode);
+
+ case DMNSN_AST_ADD:
+ case DMNSN_AST_SUB:
+ case DMNSN_AST_MUL:
+ case DMNSN_AST_DIV:
+ return dmnsn_eval_scalar_binary(astnode);
+
+ default:
+ dmnsn_error(DMNSN_SEVERITY_HIGH,
+ "Given non-arithmetic-expression to evaluate.");
+ return astnode; /* Silence warning */
+ }
+}
+
+/* TODO */
+dmnsn_astnode dmnsn_eval_vector(dmnsn_astnode astnode);
+
static void
dmnsn_print_astnode(FILE *file, dmnsn_astnode astnode)
{
diff --git a/dimension/parse.h b/dimension/parse.h
index 956c946..5801cdf 100644
--- a/dimension/parse.h
+++ b/dimension/parse.h
@@ -57,6 +57,10 @@ dmnsn_array *dmnsn_parse(const dmnsn_array *tokens);
/* Free an abstract syntax tree */
void dmnsn_delete_astree(dmnsn_array *astree);
+/* Evaluate an arithmetic expression */
+dmnsn_astnode dmnsn_eval_scalar(dmnsn_astnode astnode);
+dmnsn_astnode dmnsn_eval_vector(dmnsn_astnode astnode);
+
/* Print an S-expression of the abstract syntax tree to `file' */
void dmnsn_print_astree_sexpr(FILE *file, const dmnsn_array *astree);