autocommit for files dated 2014-11-17 20:13:32

diff --git a/misc/argsgen.c b/misc/argsgen.c
new file mode 100644 (file)
index 0000000..48f676e
--- /dev/null
+++ b/misc/argsgen.c
@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "../util.h"
+#define EMAX       128 // maximum arguments
+#define SPLIT_CALL 8   // argument count to split by newline on function calls
+#define SPLIT_ARG  4   // argument count to split by newline in function decls
+
+int main() {
+    FILE *fp = fopen("tests/args.c", "w");
+    fprintf(fp, "// function arguments\n\n");
+
+    const char *types[] = {
+        "int", "short", "long",
+        "$"
+    };
+
+    table_t *table = table_create(NULL); // table for last thing
+
+    for (int e = 0; e < sizeof(types)/sizeof(types[0]); e++) {
+        if (types[e][0] != '$')
+            fprintf(fp, "void test_%s(", types[e]);
+        else
+            fprintf(fp, "void test_mix(");
+
+        for (int i = 1; i < EMAX; i++) {
+            if (types[e][0] != '$')
+                fprintf(fp, "%-6s value%-3d", types[e], i);
+            else {
+                string_t *string = string_create();
+                const char *type = types[rand() % (sizeof(types)/sizeof(types[0]) - 1)];
+                fprintf(fp, "%-6s value%-3d", type, i);
+                string_catf(string, "%d", i);
+                table_insert(table, string_buffer(string), (void*)type);
+            }
+            if (i != EMAX-1)
+                fprintf(fp, ", ");
+            if (i % SPLIT_ARG == 0) {
+                fprintf(fp, "\n");
+                if (types[e][0] != '$') {
+                    fprintf(fp, "           "); // void test_ whitespace
+                    for (int j = 0; j < strlen(types[e]); j++)
+                        fprintf(fp, " ");
+                } else {
+                    fprintf(fp, "              ");
+                }
+            }
+        }
+
+        fprintf(fp, ") {\n");
+        for (int i = 1; i < EMAX; i++) {
+            char t = types[e][0];
+            if (t == '$') {
+                string_t *key = string_create();
+                string_catf(key, "%d", i);
+                const char *type = table_find(table, string_buffer(key));
+                t = type[0];
+            }
+            if (types[e][0] == 'd')
+                fprintf(fp, "    expect%c(value%d, 0.%d);\n", t, i, i);
+            else if (types[e][0] == 'f')
+                fprintf(fp, "    expect%c(value%d, 0.%d);\n", t, i, i);
+            else
+                fprintf(fp, "    expect%c(value%d, %d);\n", t, i, i);
+        }
+        fprintf(fp, "}\n");
+    }
+
+    fprintf(fp, "int main() {\n");
+    for (int i = 0; i < sizeof(types)/sizeof(types[0]) - 1; i++) {
+        fprintf(fp, "    test_%s(", types[i]);
+        for (int j = 1; j < EMAX; j++) {
+            if (types[i][0] == 'f') {
+                string_t *len = string_create();
+                string_catf(len, "0.%df", j);
+                fprintf(fp, string_buffer(len), j);
+                for (int p = strlen(string_buffer(len)); p <= 5; p++)
+                    fprintf(fp, " ");
+            } else if (types[i][0] == 'd')
+                fprintf(fp, "0.%-3d", j);
+            else
+                fprintf(fp, "%-3d", j);
+
+            if (i != EMAX-1)
+                fprintf(fp, ", ");
+
+            if (j % SPLIT_CALL == 0) {
+                fprintf(fp, "\n    ");
+                fprintf(fp, "      "); // test_
+                for (int k = 0; k < strlen(types[i]); k++)
+                    fprintf(fp, " ");
+            }
+        }
+        fprintf(fp, "\n    );\n");
+    }
+    // mix is special since it needs to align everything
+    // at 0.ffff <-- six things
+    fprintf(fp, "    test_mix(");
+    for (int j = 1; j < EMAX; j++) {
+        string_t *key = string_create();
+        string_catf(key, "%d", j);
+        const char *type = table_find(table, string_buffer(key));
+
+        if (type[0] == 'f') {
+            string_t *len = string_create();
+            string_catf(len, "0.%df", j);
+            fprintf(fp, string_buffer(len), j);
+            for (int p = strlen(string_buffer(len)); p <= 5; p++)
+                fprintf(fp, " ");
+        } else if (type[0] == 'd')
+            fprintf(fp, "0.%-4d", j);
+        else
+            fprintf(fp, "%-6d", j);
+
+        if (j != EMAX-1)
+            fprintf(fp, ", ");
+
+        if (j % SPLIT_CALL == 0) {
+            fprintf(fp, "\n    ");
+            fprintf(fp, "         "); // test_mix
+        }
+    }
+    fprintf(fp, "\n    );\n");
+    fprintf(fp, "    return 0;\n}\n");
+    fclose(fp);
+}

diff --git a/tests/_Bool.c b/tests/_Bool.c
new file mode 100644 (file)
index 0000000..3747327
--- /dev/null
+++ b/tests/_Bool.c
@@ -0,0 +1,32 @@
+// bool
+
+#include <stdbool.h>
+
+int main(void) {
+    expecti(__bool_true_false_are_defined, 1);
+
+    _Bool a = 0;
+    _Bool b = 1;
+    _Bool c = 2;
+    _Bool d = 3;
+
+    expecti(a, 0);
+    expecti(b, 1);
+    expecti(c, 1);
+    expecti(d, 1);
+
+    a = 3;
+    b = 2;
+    c = 1;
+    d = 0;
+
+    expecti(a, 1);
+    expecti(b, 1);
+    expecti(c, 1);
+    expecti(d, 0);
+
+    bool a1 = false;
+    a1 = !a1;
+    a1 = (a1) ? true : false;
+    expecti(a1, true);
+}

diff --git a/tests/alignof.c b/tests/alignof.c
new file mode 100644 (file)
index 0000000..f3a58a9
--- /dev/null
+++ b/tests/alignof.c
@@ -0,0 +1,43 @@
+// alignof
+
+#include <alignof.h>
+
+int main(void) {
+    expecti(__alignof_is_defined, 1);
+
+    expecti(alignof(char), 1);
+    expecti(alignof(int),  4);
+    expecti(alignof(long), 8);
+
+    struct test {
+        char a;
+        int  b;
+    };
+
+    expecti(alignof(struct test), 8);
+
+    expecti(_Alignof(char), 1);
+    expecti(__alignof__(char), 1);
+    expecti(_Alignof(struct test), 8);
+    expecti(__alignof__(struct test), 8);
+
+    struct complex {
+        struct {
+            char a;
+            short b;
+            int c;
+        } d;
+        char e;
+        union {
+            int f;
+            struct {
+                int g;
+                int h;
+            } i;
+        } j;
+    };
+
+    expecti(alignof(struct complex), 16);
+
+    return 0;
+}

diff --git a/tests/args.c b/tests/args.c
new file mode 100644 (file)
index 0000000..da09247
--- /dev/null
+++ b/tests/args.c
@@ -0,0 +1,713 @@
+// function arguments
+
+void test_int(int    value1  , int    value2  , int    value3  , int    value4  ,
+              int    value5  , int    value6  , int    value7  , int    value8  ,
+              int    value9  , int    value10 , int    value11 , int    value12 ,
+              int    value13 , int    value14 , int    value15 , int    value16 ,
+              int    value17 , int    value18 , int    value19 , int    value20 ,
+              int    value21 , int    value22 , int    value23 , int    value24 ,
+              int    value25 , int    value26 , int    value27 , int    value28 ,
+              int    value29 , int    value30 , int    value31 , int    value32 ,
+              int    value33 , int    value34 , int    value35 , int    value36 ,
+              int    value37 , int    value38 , int    value39 , int    value40 ,
+              int    value41 , int    value42 , int    value43 , int    value44 ,
+              int    value45 , int    value46 , int    value47 , int    value48 ,
+              int    value49 , int    value50 , int    value51 , int    value52 ,
+              int    value53 , int    value54 , int    value55 , int    value56 ,
+              int    value57 , int    value58 , int    value59 , int    value60 ,
+              int    value61 , int    value62 , int    value63 , int    value64 ,
+              int    value65 , int    value66 , int    value67 , int    value68 ,
+              int    value69 , int    value70 , int    value71 , int    value72 ,
+              int    value73 , int    value74 , int    value75 , int    value76 ,
+              int    value77 , int    value78 , int    value79 , int    value80 ,
+              int    value81 , int    value82 , int    value83 , int    value84 ,
+              int    value85 , int    value86 , int    value87 , int    value88 ,
+              int    value89 , int    value90 , int    value91 , int    value92 ,
+              int    value93 , int    value94 , int    value95 , int    value96 ,
+              int    value97 , int    value98 , int    value99 , int    value100,
+              int    value101, int    value102, int    value103, int    value104,
+              int    value105, int    value106, int    value107, int    value108,
+              int    value109, int    value110, int    value111, int    value112,
+              int    value113, int    value114, int    value115, int    value116,
+              int    value117, int    value118, int    value119, int    value120,
+              int    value121, int    value122, int    value123, int    value124,
+              int    value125, int    value126, int    value127) {
+    expecti(value1, 1);
+    expecti(value2, 2);
+    expecti(value3, 3);
+    expecti(value4, 4);
+    expecti(value5, 5);
+    expecti(value6, 6);
+    expecti(value7, 7);
+    expecti(value8, 8);
+    expecti(value9, 9);
+    expecti(value10, 10);
+    expecti(value11, 11);
+    expecti(value12, 12);
+    expecti(value13, 13);
+    expecti(value14, 14);
+    expecti(value15, 15);
+    expecti(value16, 16);
+    expecti(value17, 17);
+    expecti(value18, 18);
+    expecti(value19, 19);
+    expecti(value20, 20);
+    expecti(value21, 21);
+    expecti(value22, 22);
+    expecti(value23, 23);
+    expecti(value24, 24);
+    expecti(value25, 25);
+    expecti(value26, 26);
+    expecti(value27, 27);
+    expecti(value28, 28);
+    expecti(value29, 29);
+    expecti(value30, 30);
+    expecti(value31, 31);
+    expecti(value32, 32);
+    expecti(value33, 33);
+    expecti(value34, 34);
+    expecti(value35, 35);
+    expecti(value36, 36);
+    expecti(value37, 37);
+    expecti(value38, 38);
+    expecti(value39, 39);
+    expecti(value40, 40);
+    expecti(value41, 41);
+    expecti(value42, 42);
+    expecti(value43, 43);
+    expecti(value44, 44);
+    expecti(value45, 45);
+    expecti(value46, 46);
+    expecti(value47, 47);
+    expecti(value48, 48);
+    expecti(value49, 49);
+    expecti(value50, 50);
+    expecti(value51, 51);
+    expecti(value52, 52);
+    expecti(value53, 53);
+    expecti(value54, 54);
+    expecti(value55, 55);
+    expecti(value56, 56);
+    expecti(value57, 57);
+    expecti(value58, 58);
+    expecti(value59, 59);
+    expecti(value60, 60);
+    expecti(value61, 61);
+    expecti(value62, 62);
+    expecti(value63, 63);
+    expecti(value64, 64);
+    expecti(value65, 65);
+    expecti(value66, 66);
+    expecti(value67, 67);
+    expecti(value68, 68);
+    expecti(value69, 69);
+    expecti(value70, 70);
+    expecti(value71, 71);
+    expecti(value72, 72);
+    expecti(value73, 73);
+    expecti(value74, 74);
+    expecti(value75, 75);
+    expecti(value76, 76);
+    expecti(value77, 77);
+    expecti(value78, 78);
+    expecti(value79, 79);
+    expecti(value80, 80);
+    expecti(value81, 81);
+    expecti(value82, 82);
+    expecti(value83, 83);
+    expecti(value84, 84);
+    expecti(value85, 85);
+    expecti(value86, 86);
+    expecti(value87, 87);
+    expecti(value88, 88);
+    expecti(value89, 89);
+    expecti(value90, 90);
+    expecti(value91, 91);
+    expecti(value92, 92);
+    expecti(value93, 93);
+    expecti(value94, 94);
+    expecti(value95, 95);
+    expecti(value96, 96);
+    expecti(value97, 97);
+    expecti(value98, 98);
+    expecti(value99, 99);
+    expecti(value100, 100);
+    expecti(value101, 101);
+    expecti(value102, 102);
+    expecti(value103, 103);
+    expecti(value104, 104);
+    expecti(value105, 105);
+    expecti(value106, 106);
+    expecti(value107, 107);
+    expecti(value108, 108);
+    expecti(value109, 109);
+    expecti(value110, 110);
+    expecti(value111, 111);
+    expecti(value112, 112);
+    expecti(value113, 113);
+    expecti(value114, 114);
+    expecti(value115, 115);
+    expecti(value116, 116);
+    expecti(value117, 117);
+    expecti(value118, 118);
+    expecti(value119, 119);
+    expecti(value120, 120);
+    expecti(value121, 121);
+    expecti(value122, 122);
+    expecti(value123, 123);
+    expecti(value124, 124);
+    expecti(value125, 125);
+    expecti(value126, 126);
+    expecti(value127, 127);
+}
+void test_short(short  value1  , short  value2  , short  value3  , short  value4  ,
+                short  value5  , short  value6  , short  value7  , short  value8  ,
+                short  value9  , short  value10 , short  value11 , short  value12 ,
+                short  value13 , short  value14 , short  value15 , short  value16 ,
+                short  value17 , short  value18 , short  value19 , short  value20 ,
+                short  value21 , short  value22 , short  value23 , short  value24 ,
+                short  value25 , short  value26 , short  value27 , short  value28 ,
+                short  value29 , short  value30 , short  value31 , short  value32 ,
+                short  value33 , short  value34 , short  value35 , short  value36 ,
+                short  value37 , short  value38 , short  value39 , short  value40 ,
+                short  value41 , short  value42 , short  value43 , short  value44 ,
+                short  value45 , short  value46 , short  value47 , short  value48 ,
+                short  value49 , short  value50 , short  value51 , short  value52 ,
+                short  value53 , short  value54 , short  value55 , short  value56 ,
+                short  value57 , short  value58 , short  value59 , short  value60 ,
+                short  value61 , short  value62 , short  value63 , short  value64 ,
+                short  value65 , short  value66 , short  value67 , short  value68 ,
+                short  value69 , short  value70 , short  value71 , short  value72 ,
+                short  value73 , short  value74 , short  value75 , short  value76 ,
+                short  value77 , short  value78 , short  value79 , short  value80 ,
+                short  value81 , short  value82 , short  value83 , short  value84 ,
+                short  value85 , short  value86 , short  value87 , short  value88 ,
+                short  value89 , short  value90 , short  value91 , short  value92 ,
+                short  value93 , short  value94 , short  value95 , short  value96 ,
+                short  value97 , short  value98 , short  value99 , short  value100,
+                short  value101, short  value102, short  value103, short  value104,
+                short  value105, short  value106, short  value107, short  value108,
+                short  value109, short  value110, short  value111, short  value112,
+                short  value113, short  value114, short  value115, short  value116,
+                short  value117, short  value118, short  value119, short  value120,
+                short  value121, short  value122, short  value123, short  value124,
+                short  value125, short  value126, short  value127) {
+    expects(value1, 1);
+    expects(value2, 2);
+    expects(value3, 3);
+    expects(value4, 4);
+    expects(value5, 5);
+    expects(value6, 6);
+    expects(value7, 7);
+    expects(value8, 8);
+    expects(value9, 9);
+    expects(value10, 10);
+    expects(value11, 11);
+    expects(value12, 12);
+    expects(value13, 13);
+    expects(value14, 14);
+    expects(value15, 15);
+    expects(value16, 16);
+    expects(value17, 17);
+    expects(value18, 18);
+    expects(value19, 19);
+    expects(value20, 20);
+    expects(value21, 21);
+    expects(value22, 22);
+    expects(value23, 23);
+    expects(value24, 24);
+    expects(value25, 25);
+    expects(value26, 26);
+    expects(value27, 27);
+    expects(value28, 28);
+    expects(value29, 29);
+    expects(value30, 30);
+    expects(value31, 31);
+    expects(value32, 32);
+    expects(value33, 33);
+    expects(value34, 34);
+    expects(value35, 35);
+    expects(value36, 36);
+    expects(value37, 37);
+    expects(value38, 38);
+    expects(value39, 39);
+    expects(value40, 40);
+    expects(value41, 41);
+    expects(value42, 42);
+    expects(value43, 43);
+    expects(value44, 44);
+    expects(value45, 45);
+    expects(value46, 46);
+    expects(value47, 47);
+    expects(value48, 48);
+    expects(value49, 49);
+    expects(value50, 50);
+    expects(value51, 51);
+    expects(value52, 52);
+    expects(value53, 53);
+    expects(value54, 54);
+    expects(value55, 55);
+    expects(value56, 56);
+    expects(value57, 57);
+    expects(value58, 58);
+    expects(value59, 59);
+    expects(value60, 60);
+    expects(value61, 61);
+    expects(value62, 62);
+    expects(value63, 63);
+    expects(value64, 64);
+    expects(value65, 65);
+    expects(value66, 66);
+    expects(value67, 67);
+    expects(value68, 68);
+    expects(value69, 69);
+    expects(value70, 70);
+    expects(value71, 71);
+    expects(value72, 72);
+    expects(value73, 73);
+    expects(value74, 74);
+    expects(value75, 75);
+    expects(value76, 76);
+    expects(value77, 77);
+    expects(value78, 78);
+    expects(value79, 79);
+    expects(value80, 80);
+    expects(value81, 81);
+    expects(value82, 82);
+    expects(value83, 83);
+    expects(value84, 84);
+    expects(value85, 85);
+    expects(value86, 86);
+    expects(value87, 87);
+    expects(value88, 88);
+    expects(value89, 89);
+    expects(value90, 90);
+    expects(value91, 91);
+    expects(value92, 92);
+    expects(value93, 93);
+    expects(value94, 94);
+    expects(value95, 95);
+    expects(value96, 96);
+    expects(value97, 97);
+    expects(value98, 98);
+    expects(value99, 99);
+    expects(value100, 100);
+    expects(value101, 101);
+    expects(value102, 102);
+    expects(value103, 103);
+    expects(value104, 104);
+    expects(value105, 105);
+    expects(value106, 106);
+    expects(value107, 107);
+    expects(value108, 108);
+    expects(value109, 109);
+    expects(value110, 110);
+    expects(value111, 111);
+    expects(value112, 112);
+    expects(value113, 113);
+    expects(value114, 114);
+    expects(value115, 115);
+    expects(value116, 116);
+    expects(value117, 117);
+    expects(value118, 118);
+    expects(value119, 119);
+    expects(value120, 120);
+    expects(value121, 121);
+    expects(value122, 122);
+    expects(value123, 123);
+    expects(value124, 124);
+    expects(value125, 125);
+    expects(value126, 126);
+    expects(value127, 127);
+}
+void test_long(long   value1  , long   value2  , long   value3  , long   value4  ,
+               long   value5  , long   value6  , long   value7  , long   value8  ,
+               long   value9  , long   value10 , long   value11 , long   value12 ,
+               long   value13 , long   value14 , long   value15 , long   value16 ,
+               long   value17 , long   value18 , long   value19 , long   value20 ,
+               long   value21 , long   value22 , long   value23 , long   value24 ,
+               long   value25 , long   value26 , long   value27 , long   value28 ,
+               long   value29 , long   value30 , long   value31 , long   value32 ,
+               long   value33 , long   value34 , long   value35 , long   value36 ,
+               long   value37 , long   value38 , long   value39 , long   value40 ,
+               long   value41 , long   value42 , long   value43 , long   value44 ,
+               long   value45 , long   value46 , long   value47 , long   value48 ,
+               long   value49 , long   value50 , long   value51 , long   value52 ,
+               long   value53 , long   value54 , long   value55 , long   value56 ,
+               long   value57 , long   value58 , long   value59 , long   value60 ,
+               long   value61 , long   value62 , long   value63 , long   value64 ,
+               long   value65 , long   value66 , long   value67 , long   value68 ,
+               long   value69 , long   value70 , long   value71 , long   value72 ,
+               long   value73 , long   value74 , long   value75 , long   value76 ,
+               long   value77 , long   value78 , long   value79 , long   value80 ,
+               long   value81 , long   value82 , long   value83 , long   value84 ,
+               long   value85 , long   value86 , long   value87 , long   value88 ,
+               long   value89 , long   value90 , long   value91 , long   value92 ,
+               long   value93 , long   value94 , long   value95 , long   value96 ,
+               long   value97 , long   value98 , long   value99 , long   value100,
+               long   value101, long   value102, long   value103, long   value104,
+               long   value105, long   value106, long   value107, long   value108,
+               long   value109, long   value110, long   value111, long   value112,
+               long   value113, long   value114, long   value115, long   value116,
+               long   value117, long   value118, long   value119, long   value120,
+               long   value121, long   value122, long   value123, long   value124,
+               long   value125, long   value126, long   value127) {
+    expectl(value1, 1);
+    expectl(value2, 2);
+    expectl(value3, 3);
+    expectl(value4, 4);
+    expectl(value5, 5);
+    expectl(value6, 6);
+    expectl(value7, 7);
+    expectl(value8, 8);
+    expectl(value9, 9);
+    expectl(value10, 10);
+    expectl(value11, 11);
+    expectl(value12, 12);
+    expectl(value13, 13);
+    expectl(value14, 14);
+    expectl(value15, 15);
+    expectl(value16, 16);
+    expectl(value17, 17);
+    expectl(value18, 18);
+    expectl(value19, 19);
+    expectl(value20, 20);
+    expectl(value21, 21);
+    expectl(value22, 22);
+    expectl(value23, 23);
+    expectl(value24, 24);
+    expectl(value25, 25);
+    expectl(value26, 26);
+    expectl(value27, 27);
+    expectl(value28, 28);
+    expectl(value29, 29);
+    expectl(value30, 30);
+    expectl(value31, 31);
+    expectl(value32, 32);
+    expectl(value33, 33);
+    expectl(value34, 34);
+    expectl(value35, 35);
+    expectl(value36, 36);
+    expectl(value37, 37);
+    expectl(value38, 38);
+    expectl(value39, 39);
+    expectl(value40, 40);
+    expectl(value41, 41);
+    expectl(value42, 42);
+    expectl(value43, 43);
+    expectl(value44, 44);
+    expectl(value45, 45);
+    expectl(value46, 46);
+    expectl(value47, 47);
+    expectl(value48, 48);
+    expectl(value49, 49);
+    expectl(value50, 50);
+    expectl(value51, 51);
+    expectl(value52, 52);
+    expectl(value53, 53);
+    expectl(value54, 54);
+    expectl(value55, 55);
+    expectl(value56, 56);
+    expectl(value57, 57);
+    expectl(value58, 58);
+    expectl(value59, 59);
+    expectl(value60, 60);
+    expectl(value61, 61);
+    expectl(value62, 62);
+    expectl(value63, 63);
+    expectl(value64, 64);
+    expectl(value65, 65);
+    expectl(value66, 66);
+    expectl(value67, 67);
+    expectl(value68, 68);
+    expectl(value69, 69);
+    expectl(value70, 70);
+    expectl(value71, 71);
+    expectl(value72, 72);
+    expectl(value73, 73);
+    expectl(value74, 74);
+    expectl(value75, 75);
+    expectl(value76, 76);
+    expectl(value77, 77);
+    expectl(value78, 78);
+    expectl(value79, 79);
+    expectl(value80, 80);
+    expectl(value81, 81);
+    expectl(value82, 82);
+    expectl(value83, 83);
+    expectl(value84, 84);
+    expectl(value85, 85);
+    expectl(value86, 86);
+    expectl(value87, 87);
+    expectl(value88, 88);
+    expectl(value89, 89);
+    expectl(value90, 90);
+    expectl(value91, 91);
+    expectl(value92, 92);
+    expectl(value93, 93);
+    expectl(value94, 94);
+    expectl(value95, 95);
+    expectl(value96, 96);
+    expectl(value97, 97);
+    expectl(value98, 98);
+    expectl(value99, 99);
+    expectl(value100, 100);
+    expectl(value101, 101);
+    expectl(value102, 102);
+    expectl(value103, 103);
+    expectl(value104, 104);
+    expectl(value105, 105);
+    expectl(value106, 106);
+    expectl(value107, 107);
+    expectl(value108, 108);
+    expectl(value109, 109);
+    expectl(value110, 110);
+    expectl(value111, 111);
+    expectl(value112, 112);
+    expectl(value113, 113);
+    expectl(value114, 114);
+    expectl(value115, 115);
+    expectl(value116, 116);
+    expectl(value117, 117);
+    expectl(value118, 118);
+    expectl(value119, 119);
+    expectl(value120, 120);
+    expectl(value121, 121);
+    expectl(value122, 122);
+    expectl(value123, 123);
+    expectl(value124, 124);
+    expectl(value125, 125);
+    expectl(value126, 126);
+    expectl(value127, 127);
+}
+void test_mix(short  value1  , short  value2  , int    value3  , short  value4  ,
+              long   value5  , short  value6  , short  value7  , int    value8  ,
+              int    value9  , short  value10 , long   value11 , short  value12 ,
+              long   value13 , short  value14 , long   value15 , short  value16 ,
+              int    value17 , int    value18 , short  value19 , short  value20 ,
+              long   value21 , long   value22 , int    value23 , int    value24 ,
+              long   value25 , long   value26 , long   value27 , short  value28 ,
+              short  value29 , short  value30 , long   value31 , int    value32 ,
+              int    value33 , int    value34 , long   value35 , int    value36 ,
+              short  value37 , short  value38 , short  value39 , short  value40 ,
+              int    value41 , int    value42 , int    value43 , long   value44 ,
+              long   value45 , short  value46 , long   value47 , long   value48 ,
+              long   value49 , int    value50 , long   value51 , short  value52 ,
+              short  value53 , long   value54 , long   value55 , int    value56 ,
+              long   value57 , long   value58 , short  value59 , short  value60 ,
+              int    value61 , int    value62 , long   value63 , int    value64 ,
+              long   value65 , long   value66 , short  value67 , int    value68 ,
+              short  value69 , long   value70 , int    value71 , int    value72 ,
+              int    value73 , int    value74 , long   value75 , int    value76 ,
+              long   value77 , long   value78 , int    value79 , long   value80 ,
+              short  value81 , int    value82 , int    value83 , long   value84 ,
+              long   value85 , int    value86 , int    value87 , long   value88 ,
+              long   value89 , short  value90 , int    value91 , int    value92 ,
+              long   value93 , int    value94 , short  value95 , short  value96 ,
+              short  value97 , int    value98 , int    value99 , long   value100,
+              int    value101, short  value102, long   value103, short  value104,
+              long   value105, int    value106, long   value107, long   value108,
+              int    value109, int    value110, short  value111, long   value112,
+              short  value113, long   value114, long   value115, short  value116,
+              int    value117, long   value118, short  value119, long   value120,
+              short  value121, int    value122, int    value123, short  value124,
+              int    value125, long   value126, int    value127) {
+    expects(value1, 1);
+    expects(value2, 2);
+    expecti(value3, 3);
+    expects(value4, 4);
+    expectl(value5, 5);
+    expects(value6, 6);
+    expects(value7, 7);
+    expecti(value8, 8);
+    expecti(value9, 9);
+    expects(value10, 10);
+    expectl(value11, 11);
+    expects(value12, 12);
+    expectl(value13, 13);
+    expects(value14, 14);
+    expectl(value15, 15);
+    expects(value16, 16);
+    expecti(value17, 17);
+    expecti(value18, 18);
+    expects(value19, 19);
+    expects(value20, 20);
+    expectl(value21, 21);
+    expectl(value22, 22);
+    expecti(value23, 23);
+    expecti(value24, 24);
+    expectl(value25, 25);
+    expectl(value26, 26);
+    expectl(value27, 27);
+    expects(value28, 28);
+    expects(value29, 29);
+    expects(value30, 30);
+    expectl(value31, 31);
+    expecti(value32, 32);
+    expecti(value33, 33);
+    expecti(value34, 34);
+    expectl(value35, 35);
+    expecti(value36, 36);
+    expects(value37, 37);
+    expects(value38, 38);
+    expects(value39, 39);
+    expects(value40, 40);
+    expecti(value41, 41);
+    expecti(value42, 42);
+    expecti(value43, 43);
+    expectl(value44, 44);
+    expectl(value45, 45);
+    expects(value46, 46);
+    expectl(value47, 47);
+    expectl(value48, 48);
+    expectl(value49, 49);
+    expecti(value50, 50);
+    expectl(value51, 51);
+    expects(value52, 52);
+    expects(value53, 53);
+    expectl(value54, 54);
+    expectl(value55, 55);
+    expecti(value56, 56);
+    expectl(value57, 57);
+    expectl(value58, 58);
+    expects(value59, 59);
+    expects(value60, 60);
+    expecti(value61, 61);
+    expecti(value62, 62);
+    expectl(value63, 63);
+    expecti(value64, 64);
+    expectl(value65, 65);
+    expectl(value66, 66);
+    expects(value67, 67);
+    expecti(value68, 68);
+    expects(value69, 69);
+    expectl(value70, 70);
+    expecti(value71, 71);
+    expecti(value72, 72);
+    expecti(value73, 73);
+    expecti(value74, 74);
+    expectl(value75, 75);
+    expecti(value76, 76);
+    expectl(value77, 77);
+    expectl(value78, 78);
+    expecti(value79, 79);
+    expectl(value80, 80);
+    expects(value81, 81);
+    expecti(value82, 82);
+    expecti(value83, 83);
+    expectl(value84, 84);
+    expectl(value85, 85);
+    expecti(value86, 86);
+    expecti(value87, 87);
+    expectl(value88, 88);
+    expectl(value89, 89);
+    expects(value90, 90);
+    expecti(value91, 91);
+    expecti(value92, 92);
+    expectl(value93, 93);
+    expecti(value94, 94);
+    expects(value95, 95);
+    expects(value96, 96);
+    expects(value97, 97);
+    expecti(value98, 98);
+    expecti(value99, 99);
+    expectl(value100, 100);
+    expecti(value101, 101);
+    expects(value102, 102);
+    expectl(value103, 103);
+    expects(value104, 104);
+    expectl(value105, 105);
+    expecti(value106, 106);
+    expectl(value107, 107);
+    expectl(value108, 108);
+    expecti(value109, 109);
+    expecti(value110, 110);
+    expects(value111, 111);
+    expectl(value112, 112);
+    expects(value113, 113);
+    expectl(value114, 114);
+    expectl(value115, 115);
+    expects(value116, 116);
+    expecti(value117, 117);
+    expectl(value118, 118);
+    expects(value119, 119);
+    expectl(value120, 120);
+    expects(value121, 121);
+    expecti(value122, 122);
+    expecti(value123, 123);
+    expects(value124, 124);
+    expecti(value125, 125);
+    expectl(value126, 126);
+    expecti(value127, 127);
+}
+int main(void) {
+    test_int(1  , 2  , 3  , 4  , 5  , 6  , 7  , 8  ,
+             9  , 10 , 11 , 12 , 13 , 14 , 15 , 16 ,
+             17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 ,
+             25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 ,
+             33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 ,
+             41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 ,
+             49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 ,
+             57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 ,
+             65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 ,
+             73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 ,
+             81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 ,
+             89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 ,
+             97 , 98 , 99 , 100, 101, 102, 103, 104,
+             105, 106, 107, 108, 109, 110, 111, 112,
+             113, 114, 115, 116, 117, 118, 119, 120,
+             121, 122, 123, 124, 125, 126, 127,
+    );
+    test_short(1  , 2  , 3  , 4  , 5  , 6  , 7  , 8  ,
+               9  , 10 , 11 , 12 , 13 , 14 , 15 , 16 ,
+               17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 ,
+               25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 ,
+               33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 ,
+               41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 ,
+               49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 ,
+               57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 ,
+               65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 ,
+               73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 ,
+               81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 ,
+               89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 ,
+               97 , 98 , 99 , 100, 101, 102, 103, 104,
+               105, 106, 107, 108, 109, 110, 111, 112,
+               113, 114, 115, 116, 117, 118, 119, 120,
+               121, 122, 123, 124, 125, 126, 127,
+    );
+    test_long(1  , 2  , 3  , 4  , 5  , 6  , 7  , 8  ,
+              9  , 10 , 11 , 12 , 13 , 14 , 15 , 16 ,
+              17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 ,
+              25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 ,
+              33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 ,
+              41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 ,
+              49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 ,
+              57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 ,
+              65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 ,
+              73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 ,
+              81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 ,
+              89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 ,
+              97 , 98 , 99 , 100, 101, 102, 103, 104,
+              105, 106, 107, 108, 109, 110, 111, 112,
+              113, 114, 115, 116, 117, 118, 119, 120,
+              121, 122, 123, 124, 125, 126, 127,
+    );
+    test_mix(1     , 2     , 3     , 4     , 5     , 6     , 7     , 8     ,
+             9     , 10    , 11    , 12    , 13    , 14    , 15    , 16    ,
+             17    , 18    , 19    , 20    , 21    , 22    , 23    , 24    ,
+             25    , 26    , 27    , 28    , 29    , 30    , 31    , 32    ,
+             33    , 34    , 35    , 36    , 37    , 38    , 39    , 40    ,
+             41    , 42    , 43    , 44    , 45    , 46    , 47    , 48    ,
+             49    , 50    , 51    , 52    , 53    , 54    , 55    , 56    ,
+             57    , 58    , 59    , 60    , 61    , 62    , 63    , 64    ,
+             65    , 66    , 67    , 68    , 69    , 70    , 71    , 72    ,
+             73    , 74    , 75    , 76    , 77    , 78    , 79    , 80    ,
+             81    , 82    , 83    , 84    , 85    , 86    , 87    , 88    ,
+             89    , 90    , 91    , 92    , 93    , 94    , 95    , 96    ,
+             97    , 98    , 99    , 100   , 101   , 102   , 103   , 104   ,
+             105   , 106   , 107   , 108   , 109   , 110   , 111   , 112   ,
+             113   , 114   , 115   , 116   , 117   , 118   , 119   , 120   ,
+             121   , 122   , 123   , 124   , 125   , 126   , 127
+    );
+    return 0;
+}

diff --git a/tests/arithmetic.c b/tests/arithmetic.c
new file mode 100644 (file)
index 0000000..0fd5a23
--- /dev/null
+++ b/tests/arithmetic.c
@@ -0,0 +1,55 @@
+// arithmetic
+
+int main(void) {
+    int i = 0 - 1;
+
+    expecti(0, 0);
+    expecti(1, 1);
+
+    expecti(1 + 2, 3);
+    expecti(2 - 1, 1);
+
+    expecti(1 + 2 + 3 + 4, 10);
+    expecti(1 + 2 * 3 + 4, 11);
+    expecti(1 * 2 + 3 * 4, 14);
+
+    expecti(4 / 2 + 6 / 3, 4);
+    expecti(24 / 2 / 3 ,   4);
+
+    expecti(24 % 7, 3);
+    expecti(24 % 3, 0);
+
+    expecti('a' + 1, 98);
+    expecti('b' + 1, 99);
+    expecti('a' + 2, 'b' + 1);
+    expecti('b' + 1, 'c');
+
+    expecti(i,   0 - 1);
+    expecti(i,  -1);
+    expecti(i+1, 0);
+
+    expecti(1, +1);
+
+    i = 16;
+    expecti(i++, 16);
+    expecti(i,   17);
+    expecti(i--, 17);
+    expecti(i,   16);
+    expecti(++i, 17);
+    expecti(i,   17);
+    expecti(--i, 16);
+    expecti(i,   16);
+
+    expecti(!1, 0);
+    expecti(!0, 1);
+
+    expecti((1 + 2) ? 128 : 256,   128);
+    expecti((1 - 1) ? 128 : 256,   256);
+    expecti((1 - 1) ? 64  : 256/2, 128);
+    expecti((1 - 0) ? 256 : 64/2,  256);
+
+
+    expecti((1 + 2) ?: 1024,       3);
+
+    return 0;
+}

diff --git a/tests/array.c b/tests/array.c
new file mode 100644 (file)
index 0000000..f82d2fd
--- /dev/null
+++ b/tests/array.c
@@ -0,0 +1,48 @@
+// arrays
+
+void pass(int x[][3], int want) {
+    expecti(*(*(x + 1) + 1), want);
+}
+
+int main(void) {
+    int  a[2][2];
+    int *b = a;
+
+    *b = 1024;
+    expecti(*b, 1024);
+
+    int d[2][3];
+    int *e = d + 1;
+    *e = 1;
+    int *f = d;
+    *e = 64;
+    expecti(*(f + 3), 64);
+
+    int g[4][5];
+    int *h = g;
+    *(*(g + 1) + 2) = 1024;
+    expecti(*(h + 7), 1024);
+
+    int i[] = { 1, 2, 3 };
+    expecti(i[0], 1);
+    expecti(i[1], 2);
+    expecti(i[2], 3);
+
+    int j[2][3];
+    j[0][1] = 100;
+    j[1][1] = 200;
+    int *k = j;
+    expecti(k[1], 100);
+    expecti(k[4], 200);
+
+    int l[2][3];
+    int *m = l;
+    *(m + 4) = 4096;
+    pass(l, 4096);
+
+    int n[5*5];
+    n[10] = 25;
+    expecti(n[10], 25);
+
+    return 0;
+}

diff --git a/util.c b/util.c
new file mode 100644 (file)
index 0000000..5aa9f82
--- /dev/null
+++ b/util.c
@@ -0,0 +1,239 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "util.h"
+
+#define MEMORY 0x8000000
+
+static unsigned char *memory_pool = NULL;
+static size_t         memory_next = 0;
+
+static void memory_cleanup(void) {
+    free(memory_pool);
+}
+
+void *memory_allocate(size_t bytes) {
+    void *value;
+
+    if (!memory_pool) {
+        memory_pool = malloc(MEMORY);
+        atexit(memory_cleanup);
+    }
+
+    if (memory_next > MEMORY)
+        goto bail;
+
+    value = &memory_pool[memory_next];
+    memory_next += bytes;
+
+    if (memory_next > MEMORY) {
+bail:
+        fprintf(stderr, "[lice] out of memory");
+        exit(EXIT_FAILURE);
+    }
+
+    return value;
+}
+
+struct string_s {
+    char *buffer;
+    int   allocated;
+    int   length;
+};
+
+static void string_reallocate(string_t *string) {
+    int   size   = string->allocated * 2;
+    char *buffer = memory_allocate(size);
+
+    strcpy(buffer, string->buffer);
+    string->buffer    = buffer;
+    string->allocated = size;
+}
+
+void string_catf(string_t *string, const char *fmt, ...) {
+    va_list  va;
+    for (;;) {
+        int left  = string->allocated - string->length;
+        int write;
+
+        va_start(va, fmt);
+        write = vsnprintf(string->buffer + string->length, left, fmt, va);
+        va_end(va);
+
+        if (left <= write) {
+            string_reallocate(string);
+            continue;
+        }
+        string->length += write;
+        return;
+    }
+}
+
+string_t *string_create(void) {
+    string_t *string  = memory_allocate(sizeof(string_t));
+    string->buffer    = memory_allocate(8);
+    string->allocated = 8;
+    string->length    = 0;
+    string->buffer[0] = '\0';
+    return string;
+}
+
+char *string_buffer(string_t *string) {
+    return string->buffer;
+}
+
+void string_cat(string_t *string, char ch) {
+    if (string->allocated == (string->length + 1))
+        string_reallocate(string);
+    string->buffer[string->length++] = ch;
+    string->buffer[string->length]   = '\0';
+}
+
+char *string_quote(char *p) {
+    string_t *string = string_create();
+    while (*p) {
+        if (*p == '\"' || *p == '\\')
+            string_catf(string, "\\%c", *p);
+        else if (*p == '\n')
+            string_catf(string, "\\n");
+        else
+            string_cat(string, *p);
+        p++;
+    }
+    return string->buffer;
+}
+
+size_t string_length(string_t *string) {
+    return (string) ? string->length : 0;
+}
+
+typedef struct {
+    char *key;
+    void *value;
+} table_entry_t;
+
+void *table_create(void *parent) {
+    table_t *table = memory_allocate(sizeof(table_t));
+    table->list    = list_create();
+    table->parent  = parent;
+
+    return table;
+}
+
+void *table_find(table_t *table, const char *key) {
+    for (; table; table = table->parent) {
+        for (list_iterator_t *it = list_iterator(table->list); !list_iterator_end(it); ) {
+            table_entry_t *entry = list_iterator_next(it);
+            if (!strcmp(key, entry->key))
+                return entry->value;
+        }
+    }
+    return NULL;
+}
+
+void table_insert(table_t *table, char *key, void *value) {
+    table_entry_t *entry = memory_allocate(sizeof(table_entry_t));
+    entry->key           = key;
+    entry->value         = value;
+
+    list_push(table->list, entry);
+}
+
+void *table_parent(table_t *table) {
+    return table->parent;
+}
+
+list_t *table_values(table_t *table) {
+    list_t *list = list_create();
+    for (; table; table = table->parent)
+        for (list_iterator_t *it = list_iterator(table->list); !list_iterator_end(it); )
+            list_push(list, ((table_entry_t*)list_iterator_next(it))->value);
+    return list;
+}
+
+list_t *table_keys(table_t *table) {
+    list_t *list = list_create();
+    for (; table; table = table->parent)
+        for (list_iterator_t *it = list_iterator(table->list); !list_iterator_end(it); )
+            list_push(list, ((table_entry_t*)list_iterator_next(it))->key);
+    return list;
+}
+
+pair_t *pair_create(void *first, void *second) {
+    pair_t *pair = memory_allocate(sizeof(pair_t));
+    pair->first  = first;
+    pair->second = second;
+    return pair;
+}
+
+int strcasecmp(const char *s1, const char *s2) {
+    const unsigned char *u1 = (const unsigned char *)s1;
+    const unsigned char *u2 = (const unsigned char *)s2;
+
+    while (tolower(*u1) == tolower(*u2++))
+        if(*u1++ == '\0')
+            return 0;
+    return tolower(*u1) - tolower(*--u2);
+}
+
+int strncasecmp(const char *s1, const char *s2, size_t n) {
+    const unsigned char *u1 = (const unsigned char *)s1;
+    const unsigned char *u2 = (const unsigned char *)s2;
+
+    if (!n)
+        return 0;
+
+    do {
+        if (tolower(*u1) != tolower(*u2++))
+            return tolower(*u1) - tolower(*--u2);
+        if (*u1++ == '\0')
+            break;
+    } while (--n != 0);
+
+    return 0;
+}
+
+size_t getline(char **line, size_t *n, FILE *stream) {
+    char *buf = NULL;
+    char *p   = buf;
+
+    int   size;
+    int   c;
+
+    if (!line)
+        return -1;
+    if (!stream)
+        return -1;
+    if (!n)
+        return -1;
+
+    buf  = *line;
+    size = *n;
+
+    if ((c = fgetc(stream)) == EOF)
+        return -1;
+    if (!buf) {
+        buf  = malloc(128);
+        size = 128;
+    }
+    p = buf;
+    while(c != EOF) {
+        if ((p - buf) > (size - 1)) {
+            size = size + 128;
+            buf  = realloc(buf, size);
+        }
+        *p++ = c;
+        if (c == '\n')
+            break;
+        c = fgetc(stream);
+    }
+
+    *p++  = '\0';
+    *line = buf;
+    *n    = size;
+
+    return p - buf - 1;
+}