/* Project: Small Expression Evaluator for Q library

* Author: Richard James Howe

* License: The Unlicense

* See: <https://en.wikipedia.org/wiki/Shunting-yard_algorithm> */

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "q.h"

#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))

#define DEFAULT_STACK_SIZE (64)

enum { ASSOCIATE_NONE, ASSOCIATE_LEFT, ASSOCIATE_RIGHT, };

enum { LEX_NUMBER, LEX_OPERATOR, LEX_END, };

static void expr_delete(qexpr_t *e) {

if (!e)

return;

free(e->ops);

free(e->numbers);

for (size_t i = 0; i < e->vars_max; i++) {

free(e->vars[i]->name);

free(e->vars[i]);

}

free(e->vars);

free(e);

}

static qexpr_t *expr_new(size_t max) {

max = max ? max : 64;

qexpr_t *e = calloc(sizeof(*e), 1);

if (!e)

goto fail;

e->ops = calloc(sizeof(*e->ops), max);

e->numbers = calloc(sizeof(*(e->numbers)), max);

if (!(e->ops) || !(e->numbers))

goto fail;

e->ops_max = max;

e->numbers_max = max;

qexpr_init(e);

return e;

fail:

expr_delete(e);

return NULL;

}

static qvariable_t *variable_lookup(qexpr_t *e, const char *name) {

assert(e);

for (size_t i = 0; i < e->vars_max; i++) {

qvariable_t *v = e->vars[i];

if (!strcmp(v->name, name))

return v;

}

return NULL;

}

static char *estrdup(const char *s) {

assert(s);

const size_t l = strlen(s) + 1;

char *r = malloc(l);

return memcpy(r, s, l);

}

static int variable_name_is_valid(const char *n) {

assert(n);

if (!isalpha(*n) && !(*n == '_'))

return 0;

for (n++; *n; n++)

if (!isalnum(*n) && !(*n == '_'))

return 0;

return 1;

}

static qvariable_t *variable_add(qexpr_t *e, const char *name, q_t value) {

assert(e);

assert(name);

qvariable_t *v = variable_lookup(e, name), **vs = e->vars;

if (v) {

v->value = value;

return v;

}

if (!variable_name_is_valid(name))

return NULL;

char *s = estrdup(name);

vs = realloc(e->vars, (e->vars_max + 1) * sizeof(*vs));

v = calloc(1, sizeof(*v));

if (!vs || !v || !s)

goto fail;

v->name = s;

v->value = value;

vs[e->vars_max++] = v;

e->vars = vs;

return v;

fail:

free(v);

free(s);

free(vs);

if (vs != e->vars)

free(e->vars);

return NULL;

}

static inline int tests(FILE *out) {

assert(out);

int report = 0;

static const struct test {

int r;

q_t result;

const char *expr;

} tests[] = { // NB. Variables defined later.

{ -1, QINT( 0), "" },

{ -1, QINT( 0), "(" },

{ -1, QINT( 0), ")" },

{ -1, QINT( 0), "2**3" },

{ 0, QINT( 0), "0" },

{ 0, QINT( 2), "1+1" },

{ 0, -QINT( 1), "-1" },

{ 0, QINT( 1), "--1" },

{ 0, QINT(14), "2+(3*4)" },

{ 0, QINT(23), "a+(b*5)" },

{ -1, QINT(14), "(2+(3* 4)" },

{ -1, QINT(14), "2+(3*4)(" },

{ 0, QINT(14), "2+3*4" },

{ 0, QINT( 0), " 2==3 " },

{ 0, QINT( 1), "2 ==2" },

{ 0, QINT( 1), "2== (1+1)" },

//{ 0, QINT( 8), "2 pow 3" },

//{ -1, QINT( 0), "2pow3" },

{ 0, QINT(20), "(2+3)*4" },

{ 0, -QINT( 4), "(2+(-3))*4" },

{ -1, QINT( 0), "1/0" },

{ -1, QINT( 0), "1%0" },

{ 0, QINT(50), "100/2" },

{ 0, QINT( 2), "1--1", },

{ 0, QINT( 0), "1---1", },

};

if (fputs("Running Built In Self Tests:\n", out) < 0)

report = -1;

const size_t length = sizeof (tests) / sizeof (tests[0]);

for (size_t i = 0; i < length; i++) {

qexpr_t *e = expr_new(64);

const struct test *test = &tests[i];

if (!e) {

(void)fprintf(out, "test failed (unable to allocate)\n");

report = -1;

goto end;

}

qvariable_t *v1 = variable_add(e, "a", QINT(3));

qvariable_t *v2 = variable_add(e, "b", QINT(4));

qvariable_t *v3 = variable_add(e, "c", -QINT(5));

if (!v1 || !v2 || !v3) {

(void)fprintf(out, "test failed (unable to assign variable)\n");

report = -1;

goto end;

}

const int r = qexpr(e, test->expr);

const q_t tos = e->numbers[0];

const int pass = (r == test->r) && (r != 0 || tos == test->result);

if (fprintf(out, "%s: r(%2d), eval(\"%s\") = %lg \n",

pass ? " ok" : " FAIL", r, test->expr, (double)tos) < 0)

report = -1;

if (!pass) {

(void)fprintf(out, "\tExpected: r(%2d), %lg\n",

test->r, (double)(test->result));

report = -1;

}

expr_delete(e);

}

end:

if (fprintf(out, "Tests Complete: %s\n", report == 0 ? "pass" : "FAIL") < 0)

report = -1;

return report;

}

static qexpr_t *expr_new_with_vars(size_t max) {

qexpr_t *e = expr_new(max);

if (!e) return NULL;

if (!variable_add(e, "whole", qinfo.whole)) goto fail;

if (!variable_add(e, "fractional", qinfo.fractional)) goto fail;

if (!variable_add(e, "bit", qinfo.bit)) goto fail;

if (!variable_add(e, "smallest", qinfo.min)) goto fail;

if (!variable_add(e, "biggest", qinfo.max)) goto fail;

if (!variable_add(e, "pi", qinfo.pi)) goto fail;

if (!variable_add(e, "e", qinfo.e)) goto fail;

if (!variable_add(e, "sqrt2", qinfo.sqrt2)) goto fail;

if (!variable_add(e, "sqrt3", qinfo.sqrt3)) goto fail;

if (!variable_add(e, "ln2", qinfo.ln2)) goto fail;

if (!variable_add(e, "ln10", qinfo.ln10)) goto fail;

return e;

fail:

expr_delete(e);

return NULL;

}

static int usage(FILE *out, const char *arg0) {

assert(out);

assert(arg0);

return fprintf(out, "usage: %s expr\n", arg0);

}

int main(int argc, char *argv[]) {

if (argc == 1) {

if (usage(stderr, argv[0]) < 0) { return 1; }

return tests(stderr);

}

if (argc < 2) {

(void)fprintf(stderr, "usage: %s expr\n", argv[0]);

return 1;

}

int r = 0;

for (int i = 1; i < argc; i++) {

qexpr_t *e = expr_new_with_vars(0);

if (!e) {

(void)fprintf(stderr, "allocate failed\n");

r = 1;

break;

}

if (qexpr(e, argv[i]) == 0) {

char n[64 + 1] = { 0, };

qsprint(e->numbers[0], n, sizeof n);

if (printf("%s\n", n) < 0)

r = 1;

r = 0;

} else {

(void)fprintf(stderr, "error: %s\n", e->error_string);

r = 1;

}

expr_delete(e);

}

return r;

}