From bb650f4a52a456c1aa0a34508d6f3dcce58291b6 Mon Sep 17 00:00:00 2001 From: unknown <> Date: Mon, 17 Nov 2014 20:13:32 +0000 Subject: [PATCH] autocommit for files dated 2014-11-17 20:13:32 --- misc/argsgen.c | 127 ++++++++ tests/_Bool.c | 32 ++ tests/alignof.c | 43 +++ tests/args.c | 713 +++++++++++++++++++++++++++++++++++++++++++++ tests/arithmetic.c | 55 ++++ tests/array.c | 48 +++ util.c | 239 +++++++++++++++ 7 files changed, 1257 insertions(+) create mode 100644 misc/argsgen.c create mode 100644 tests/_Bool.c create mode 100644 tests/alignof.c create mode 100644 tests/args.c create mode 100644 tests/arithmetic.c create mode 100644 tests/array.c create mode 100644 util.c diff --git a/misc/argsgen.c b/misc/argsgen.c new file mode 100644 index 0000000..48f676e --- /dev/null +++ b/misc/argsgen.c @@ -0,0 +1,127 @@ +#include +#include +#include + +#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 index 0000000..3747327 --- /dev/null +++ b/tests/_Bool.c @@ -0,0 +1,32 @@ +// bool + +#include + +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 index 0000000..f3a58a9 --- /dev/null +++ b/tests/alignof.c @@ -0,0 +1,43 @@ +// alignof + +#include + +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 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 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 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 index 0000000..5aa9f82 --- /dev/null +++ b/util.c @@ -0,0 +1,239 @@ +#include +#include +#include +#include +#include + +#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; +} -- 2.40.0