Add a new test: fcalc

fcalc is a basic, fully self-contained one-function calculator.
Source: https://github.com/tomolt/fcalc

Author: jserv

Makefile

@@ -169,6 +169,7 @@ include mk/tests.mk
 CHECK_ELF_FILES := \
 	hello \
 	puzzle \
+	fcalc
 
 ifeq ($(call has, EXT_M), 1)
 CHECK_ELF_FILES += \
@@ -177,6 +178,7 @@ endif
 
 EXPECTED_hello = Hello World!
 EXPECTED_puzzle = success in 2005 trials
+EXPECTED_fcalc = Performed 12 tests, 0 failures, 100% success rate.
 EXPECTED_pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086
 
 check: $(BIN)

README.md

@@ -244,6 +244,7 @@ In `rv32emu` repository, there are some prebuilt ELF files for testing purpose.
 * `dhrystone.elf` : See [rv8-bench](https://github.com/michaeljclark/rv8-bench)
 * `donut.elf` : See [donut](tests/donut.c)
 * `doom.elf` : See [sysprog21/doom_riscv](https://github.com/sysprog21/doom_riscv) [RV32M]
+* `fcalc.elf` : See [fcalc](tests/fcalc.c)
 * `ieee754.elf` : See [tests/ieee754.c](tests/ieee754.c) [RV32F]
 * `jit-bf.elf` : See [ezaki-k/xkon_beta](https://github.com/ezaki-k/xkon_beta)
 * `lena.elf`: See [tests/lena.c](tests/lena.c)

build/fcalc.elf

@@ -0,0 +1,148 @@
+/* fcalc - a basic, fully self-contained one-function calculator,
+ * released into the public domain. written by Thomas Oltmann.
+ *
+ * Supported operations:
+ *   addition (+)
+ *   subtraction (-)
+ *   multiplication (*)
+ *   division (/)
+ *   negation (-)
+ * Has a builtin 'pi' constant
+ *
+ * Source: https://github.com/tomolt/fcalc
+ */
+double fcalc(const char **str, int *err, int _)
+{
+    switch (_) {
+    case 0:; /* Parse full expression */
+        const char *str1 = *str;
+        int err1 = 0;
+        double ret = fcalc(&str1, &err1, 1);
+        while (*str1 != 0) {
+            if (*str1 != ' ' && *str1 != '\n')
+                err1 = 1;
+            str1++;
+        }
+        if (err)
+            *err = err1;
+        return ret;
+    case -1: /* Parse primitive */
+        while (**str == ' ')
+            (*str)++; /* Skip whitespace */
+        switch (**str) {
+        case '-': /* Parse unary minus (negation) */
+            (*str)++;
+            return -fcalc(str, err, -1);
+        case '(': /* Parse subexpression in parentheses */
+            (*str)++;
+            double ret = fcalc(str, err, 1);
+            if (**str != ')') {
+                *err = -1;
+                return 0.0;
+            }
+            (*str)++;
+            return ret;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4': /* Parse number */
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '.':
+            _ = 0;
+            double dig = 0.0, bak = 1.0;
+            for (;;) {
+                if (**str == '.') {
+                    _ = 1;
+                    (*str)++;
+                }
+                if (!(**str >= '0' && **str <= '9'))
+                    break;
+                if (_ == 1)
+                    bak /= 10.0;
+                dig = dig * 10.0 + (**str - '0');
+                (*str)++;
+            }
+            return dig * bak;
+        case 'p':
+        case 'P': /* Parse 'pi' */
+            (*str)++;
+            if (**str != 'i' && **str != 'I') {
+                *err = -1;
+                return 0.0;
+            }
+            (*str)++;
+            return 3.14159265358979;
+        default:
+            *err = -1;
+            return 0.0;
+        }
+    default:; /* Parse binary operation */
+        double lhs = fcalc(str, err, -1);
+        if (*err)
+            return 0.0;
+        for (;;) {
+            while (**str == ' ')
+                (*str)++; /* Skip whitespace */
+#define BINOP(sym, prec, op)                      \
+    if (prec >= _ && **str == sym) {              \
+        (*str)++;                                 \
+        double rhs = fcalc(str, err, (prec + 1)); \
+        if (*err)                                 \
+            return 0.0;                           \
+        op;                                       \
+    }
+            /* clang-format off */
+                 BINOP('+', 1, lhs += rhs)
+            else BINOP('-', 1, lhs -= rhs)
+            else BINOP('*', 2, lhs *= rhs)
+            else BINOP('/', 2, lhs /= rhs)
+            else return lhs;
+            /* clang-format on */
+#undef BINOP
+        }
+    }
+}
+
+#include <stdio.h>
+
+static const double EPSILON = 0.00001;
+
+static unsigned int fails, total;
+
+static void test(const char *name, const char *str, double er, int ee)
+{
+    total++;
+    int e;
+    double r = fcalc(&str, &e, 0);
+    double dr = r - er;
+    if ((dr > 0.0 ? dr : -dr) > EPSILON || e != ee) {
+        printf("Test '%s' failed; Expected %f/%d, got %f/%d\n", name, er, ee, r,
+               e);
+        fails++;
+    }
+}
+
+int main()
+{
+    test("Integer", "11", 11, 0);
+    test("Real number", "11.32", 11.32, 0);
+    test("Sub-0-Real", ".32", 0.32, 0);
+    test("Negation", "-42", -42, 0);
+    test("Addition", "1.2 + 5", 6.2, 0);
+    test("Subtraction", "3 - 1.4", 1.6, 0);
+    test("Multiplication", "10 * 5", 50, 0);
+    test("Division", "50 / 10", 5, 0);
+    test("Precedence", "3 - 2 * 5", -7, 0);
+    test("Pi", "pi", 3.14159265358979, 0);
+    test("Parentheses", "3 * (1 + 2)", 9, 0);
+    test("Unmatched (", "(1 + 2", 0.0, -1);
+    printf("Performed %d tests, %d failures, %d%% success rate.\n", total,
+           fails, 100 - fails * 100 / total);
+
+    return fails == 0 ? 0 : -1;
+}