test/ast-test.c

   1 #include "gmqcc.h"
   2 #include "ast.h"
   3
   4 /* NOTE: it's a test - I'll abort() on epic-failure */
   5
   6 #ifdef assert
   7 #   undef assert
   8 #endif
   9 /* (note: 'do {} while(0)' forces the need for a semicolon after assert() */
  10 #define assert(x) do { if ( !(x) ) { printf("Assertion failed: %s\n", #x); abort(); } } while(0)
  11
  12 VECTOR_MAKE(ast_value*, globals);
  13 VECTOR_MAKE(ast_value*, fields);
  14 VECTOR_MAKE(ast_function*, functions);
  15
  16 uint32_t    opts_flags[1 + (COUNT_FLAGS / 32)];
  17 uint32_t    opts_warn [1 + (COUNT_WARNINGS / 32)];
  18
  19 uint32_t    opts_O        = 1;
  20 const char *opts_output   = "progs.dat";
  21 int         opts_standard = COMPILER_GMQCC;
  22 bool        opts_debug    = false;
  23 bool        opts_memchk   = false;
  24 bool        opts_werror   = false;
  25
  26 #include "ast-macros.h"
  27
  28 int main()
  29 {
  30     size_t i;
  31
  32     ir_builder     *ir;
  33
  34     TESTVARS();
  35
  36     DEFVAR(vi);
  37     DEFVAR(vx);
  38     DEFVAR(f0);
  39     DEFVAR(f1);
  40     DEFVAR(f5);
  41     DEFVAR(cv3x4x5);
  42     DEFVAR(cv1x1x1);
  43     DEFVAR(sHello);
  44     DEFVAR(sNL);
  45     DEFVAR(print);
  46     DEFVAR(ftos);
  47     DEFVAR(spawn);
  48
  49     DEFVAR(mema);
  50     DEFVAR(memb);
  51     DEFVAR(memv);
  52     DEFVAR(pawn);
  53
  54     /* opts_debug = true; */
  55
  56 BUILTIN(print, TYPE_VOID, -1);
  57 PARAM(TYPE_STRING, text);
  58 ENDBUILTIN();
  59
  60 BUILTIN(ftos, TYPE_STRING, -2);
  61 PARAM(TYPE_FLOAT, value);
  62 ENDBUILTIN();
  63
  64 BUILTIN(spawn, TYPE_ENTITY, -3);
  65 ENDBUILTIN();
  66
  67     TESTINIT();
  68 VAR(TYPE_FLOAT, f0);
  69 VAR(TYPE_FLOAT, f1);
  70 VAR(TYPE_FLOAT, f5);
  71 VAR(TYPE_STRING, sHello);
  72 VAR(TYPE_STRING, sNL);
  73 VAR(TYPE_VECTOR, cv3x4x5);
  74 VAR(TYPE_VECTOR, cv1x1x1);
  75
  76 FIELD(TYPE_FLOAT, mema);
  77 FIELD(TYPE_FLOAT, memb);
  78 FIELD(TYPE_VECTOR, memv);
  79
  80 MKCONSTFLOAT(f0, 0.0);
  81 MKCONSTFLOAT(f1, 1.0);
  82 MKCONSTFLOAT(f5, 5.0);
  83 MKCONSTSTRING(sHello, "Hello, World\n");
  84 MKCONSTSTRING(sNL, "\n");
  85 MKCONSTVECTOR(cv3x4x5, 3, 4, 5);
  86 MKCONSTVECTOR(cv1x1x1, 1, 1, 1);
  87
  88 FUNCTION(foo, TYPE_VOID);
  89 ENDFUNCTION(foo);
  90
  91 #define PRINTNL() do { CALL(print) CALLPARAM(sNL) ENDCALL(); } while(0)
  92
  93 FUNCTION(main, TYPE_VOID);
  94
  95     VAR(TYPE_FLOAT, vi);
  96     VAR(TYPE_FLOAT, vx);
  97     VAR(TYPE_ENTITY, pawn);
  98
  99     MKLOCAL(vi);
 100     MKLOCAL(vx);
 101     MKLOCAL(pawn);
 102
 103     STATE(ASSIGN(STORE_F, vi, f0));
 104     WHILE(BIN(LT, vi, f5));
 105         STATE(ASSIGN(STORE_F, vx, BIN(MUL_F, vi, f5)));
 106         STATE(ASSIGN(STORE_F, vi, BIN(ADD_F, vi, f1)));
 107     ENDWHILE();
 108
 109     CALL(print)
 110     CALLPARAM(sHello)
 111     ENDCALL();
 112
 113     CALL(spawn)
 114     ENDCALLWITH(newent, STATE(ASSIGN(STORE_ENT, pawn, newent)));
 115
 116     STATE(ASSIGN(STOREP_F, ENTFIELD(pawn, mema), f5));
 117     STATE(ASSIGN(STOREP_F, ENTFIELD(pawn, memb), f1));
 118     STATE(ASSIGN(STOREP_V, ENTFIELD(pawn, memv), cv3x4x5));
 119     CALL(ftos)
 120     CALLPARAM(ENTFIELD(pawn, mema))
 121     ENDCALLWITH(output,
 122         CALL(print)
 123         CALLPARAM(output)
 124         CALLPARAM(sNL)
 125         ENDCALL();
 126     );
 127     CALL(ftos)
 128     CALLPARAM(ENTFIELD(pawn, memb))
 129     ENDCALLWITH(output,
 130         CALL(print)
 131         CALLPARAM(output)
 132         CALLPARAM(sNL)
 133         ENDCALL();
 134     );
 135     CALL(ftos)
 136     CALLPARAM(ENTFIELD(pawn, VECMEM(memv, 2)))
 137     ENDCALLWITH(output,
 138         CALL(print)
 139         CALLPARAM(output)
 140         CALLPARAM(sNL)
 141         ENDCALL();
 142     );
 143
 144 ENDFUNCTION(main);
 145
 146     ir = ir_builder_new("ast_test");
 147     assert(ir);
 148
 149     /* gen fields */
 150     for (i = 0; i < fields_elements; ++i) {
 151         if (!ast_global_codegen(fields_data[i], ir)) {
 152             assert(!"failed to generate field");
 153         }
 154     }
 155     /* gen globals */
 156     for (i = 0; i < globals_elements; ++i) {
 157         if (!ast_global_codegen(globals_data[i], ir)) {
 158             assert(!"failed to generate global");
 159         }
 160     }
 161
 162     /* gen functions */
 163     for (i = 0; i < functions_elements; ++i) {
 164         if (!ast_function_codegen(functions_data[i], ir)) {
 165             assert(!"failed to generate function");
 166         }
 167         if (!ir_function_finalize(functions_data[i]->ir_func))
 168             assert(!"finalize on function failed...");
 169     }
 170
 171
 172     /* dump */
 173     ir_builder_dump(ir, printf);
 174
 175     /* Now create a file */
 176     if (!ir_builder_generate(ir, "test_ast.dat"))
 177         printf("*** failed to generate code\n");
 178
 179     /* ir cleanup */
 180     ir_builder_delete(ir);
 181
 182     /* cleanup */
 183     /* Functions must be deleted FIRST since their expressions
 184      * reference global variables.
 185      */
 186     for (i = 0; i < functions_elements; ++i) {
 187         ast_function_delete(functions_data[i]);
 188     }
 189     if (functions_data)
 190         mem_d(functions_data);
 191
 192     /* We must delete not only globals, but also the functions'
 193      * ast_values (their type and name), that's why we added them to the globals vector.
 194      */
 195     for (i = 0; i < globals_elements; ++i) {
 196         ast_value_delete(globals_data[i]);
 197     }
 198     if (globals_data)
 199         mem_d(globals_data);
 200     return 0;
 201 }