parser.c

   1 #include <stdio.h>
   2 #include <stdarg.h>
   3
   4 #include "gmqcc.h"
   5 #include "lexer.h"
   6
   7 typedef struct {
   8     lex_file *lex;
   9     int      tok;
  10
  11     MEM_VECTOR_MAKE(ast_value*, globals);
  12     MEM_VECTOR_MAKE(ast_function*, functions);
  13
  14     ast_function *function;
  15 } parser_t;
  16
  17 MEM_VEC_FUNCTIONS(parser_t, ast_value*, globals)
  18 MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions)
  19
  20 void parseerror(parser_t *parser, const char *fmt, ...)
  21 {
  22         va_list ap;
  23
  24     if (parser)
  25             printf("error %s:%lu: ", parser->lex->tok->ctx.file, (unsigned long)parser->lex->tok->ctx.line);
  26         else
  27             printf("error: ");
  28
  29         va_start(ap, fmt);
  30         vprintf(fmt, ap);
  31         va_end(ap);
  32
  33         printf("\n");
  34 }
  35
  36 bool parser_next(parser_t *parser)
  37 {
  38     /* lex_do kills the previous token */
  39     parser->tok = lex_do(parser->lex);
  40     if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
  41         return false;
  42     return true;
  43 }
  44
  45 /* lift a token out of the parser so it's not destroyed by parser_next */
  46 token *parser_lift(parser_t *parser)
  47 {
  48     token *tok = parser->lex->tok;
  49     parser->lex->tok = NULL;
  50     return tok;
  51 }
  52
  53 #define parser_tokval(p) (p->lex->tok->value)
  54 #define parser_token(p)  (p->lex->tok)
  55 #define parser_ctx(p)    (p->lex->tok->ctx)
  56
  57 ast_value* parser_find_global(parser_t *parser, const char *name)
  58 {
  59     size_t i;
  60     for (i = 0; i < parser->globals_count; ++i) {
  61         if (!strcmp(parser->globals[i]->name, name))
  62             return parser->globals[i];
  63     }
  64     return NULL;
  65 }
  66
  67 typedef struct {
  68     MEM_VECTOR_MAKE(ast_value*, p);
  69 } paramlist_t;
  70 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
  71
  72 ast_value *parser_parse_type(parser_t *parser, bool *isfunc)
  73 {
  74     paramlist_t params;
  75     ast_value *var;
  76     lex_ctx   ctx = parser_ctx(parser);
  77     int vtype = parser_token(parser)->constval.t;
  78
  79     MEM_VECTOR_INIT(&params, p);
  80
  81     *isfunc = false;
  82
  83     if (!parser_next(parser))
  84         return NULL;
  85
  86     if (parser->tok == '(') {
  87         *isfunc = true;
  88         while (true) {
  89             ast_value *param;
  90             bool dummy;
  91
  92             if (!parser_next(parser)) {
  93                 MEM_VECTOR_CLEAR(&params, p);
  94                 return NULL;
  95             }
  96
  97             if (parser->tok == ')')
  98                 break;
  99
 100             param = parser_parse_type(parser, &dummy);
 101             (void)dummy;
 102
 103             if (!param) {
 104                 MEM_VECTOR_CLEAR(&params, p);
 105                 return NULL;
 106             }
 107
 108             if (!paramlist_t_p_add(&params, param)) {
 109                 MEM_VECTOR_CLEAR(&params, p);
 110                 parseerror(parser, "Out of memory while parsing typename");
 111                 return NULL;
 112             }
 113
 114             if (parser->tok == ',')
 115                 continue;
 116             if (parser->tok == ')')
 117                 break;
 118             MEM_VECTOR_CLEAR(&params, p);
 119             parseerror(parser, "Unexpected token");
 120             return NULL;
 121         }
 122         if (!parser_next(parser)) {
 123             MEM_VECTOR_CLEAR(&params, p);
 124             return NULL;
 125         }
 126     }
 127
 128     var = ast_value_new(ctx, "<unnamed>", vtype);
 129     if (!var) {
 130         MEM_VECTOR_CLEAR(&params, p);
 131         return NULL;
 132     }
 133     MEM_VECTOR_MOVE(&params, p, var, params);
 134     return var;
 135 }
 136
 137 bool parser_do(parser_t *parser)
 138 {
 139     if (parser->tok == TOKEN_TYPENAME)
 140     {
 141         bool isfunc = false;
 142         ast_function *func = NULL;
 143         lex_ctx ctx = parser_ctx(parser);
 144         ast_value *var = parser_parse_type(parser, &isfunc);
 145         if (!var)
 146             return false;
 147
 148         if (parser->tok != TOKEN_IDENT) {
 149             parseerror(parser, "expected variable name\n");
 150             return false;
 151         }
 152
 153         if (parser_find_global(parser, parser_tokval(parser))) {
 154             ast_value_delete(var);
 155             parseerror(parser, "global already exists: %s\n", parser_tokval(parser));
 156             return false;
 157         }
 158
 159         if (!ast_value_set_name(var, parser_tokval(parser))) {
 160             parseerror(parser, "failed to set variable name\n");
 161             ast_value_delete(var);
 162             return false;
 163         }
 164
 165         if (isfunc) {
 166             /* a function was defined */
 167             ast_value *fval;
 168
 169             /* turn var into a value of TYPE_FUNCTION, with the old var
 170              * as return type
 171              */
 172             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
 173             func = ast_function_new(ctx, var->name, fval);
 174             if (!fval || !func) {
 175                 ast_value_delete(var);
 176                 if (fval) ast_value_delete(fval);
 177                 if (func) ast_function_delete(func);
 178                 return false;
 179             }
 180
 181             fval->expression.next = (ast_expression*)var;
 182             MEM_VECTOR_MOVE(var, params, fval, params);
 183
 184             if (!parser_t_functions_add(parser, func)) {
 185                 ast_value_delete(var);
 186                 if (fval) ast_value_delete(fval);
 187                 if (func) ast_function_delete(func);
 188                 return false;
 189             }
 190
 191             var = fval;
 192         }
 193
 194         if (!parser_t_globals_add(parser, var) ||
 195             !parser_next(parser))
 196         {
 197             ast_value_delete(var);
 198             return false;
 199         }
 200
 201         if (parser->tok == ';') {
 202             if (!parser_next(parser))
 203                 return parser->tok == TOKEN_EOF;
 204             return true;
 205         }
 206
 207         if (parser->tok != '=') {
 208             parseerror(parser, "expected '=' or ';'");
 209             return false;
 210         }
 211
 212         if (!parser_next(parser))
 213             return false;
 214
 215         if (parser->tok == '#') {
 216             if (!isfunc || !func) {
 217                 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
 218                 return false;
 219             }
 220             if (!parser_next(parser)) {
 221                 parseerror(parser, "expected builtin number");
 222                 return false;
 223             }
 224             if (parser->tok != TOKEN_INTCONST) {
 225                 parseerror(parser, "builtin number must be an integer constant");
 226                 return false;
 227             }
 228             if (parser_token(parser)->constval.i <= 0) {
 229                 parseerror(parser, "builtin number must be positive integer greater than zero");
 230                 return false;
 231             }
 232
 233             func->builtin = -parser_token(parser)->constval.i;
 234         } else if (parser->tok == '{') {
 235             /* function body */
 236         } else {
 237             parseerror(parser, "TODO, const assignment");
 238         }
 239
 240         if (!parser_next(parser))
 241             return false;
 242
 243         if (parser->tok != ';') {
 244             parseerror(parser, "expected semicolon");
 245             return false;
 246         }
 247
 248         (void)parser_next(parser);
 249
 250         return true;
 251     }
 252     else if (parser->tok == TOKEN_KEYWORD)
 253     {
 254         /* handle 'var' and 'const' */
 255         return false;
 256     }
 257     else if (parser->tok == '.')
 258     {
 259         /* entity-member declaration */
 260         return false;
 261     }
 262     else
 263     {
 264         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
 265         return false;
 266     }
 267     return true;
 268 }
 269
 270 bool parser_compile(const char *filename)
 271 {
 272     size_t i;
 273     parser_t *parser;
 274     ir_builder *ir;
 275
 276     parser = (parser_t*)mem_a(sizeof(parser_t));
 277     if (!parser)
 278         return false;
 279
 280     memset(&parser, 0, sizeof(parser));
 281
 282     MEM_VECTOR_INIT(parser, globals);
 283     parser->lex = lex_open(filename);
 284
 285     if (!parser->lex) {
 286         printf("failed to open file \"%s\"\n", filename);
 287         return false;
 288     }
 289
 290     /* initial lexer/parser state */
 291     parser->lex->flags.noops = true;
 292
 293     if (parser_next(parser))
 294     {
 295         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
 296         {
 297             if (!parser_do(parser)) {
 298                 if (parser->tok == TOKEN_EOF)
 299                     parseerror(parser, "unexpected eof");
 300                 else
 301                     parseerror(parser, "parse error\n");
 302                 lex_close(parser->lex);
 303                 mem_d(parser);
 304                 return false;
 305             }
 306         }
 307     }
 308
 309     lex_close(parser->lex);
 310
 311     ir = ir_builder_new("gmqcc_out");
 312     if (!ir) {
 313         printf("failed to allocate builder\n");
 314         goto cleanup;
 315     }
 316
 317     for (i = 0; i < parser->globals_count; ++i) {
 318         if (!ast_global_codegen(parser->globals[i], ir)) {
 319             printf("failed to generate global %s\n", parser->globals[i]->name);
 320         }
 321     }
 322     for (i = 0; i < parser->functions_count; ++i) {
 323         if (!ast_function_codegen(parser->functions[i], ir)) {
 324             printf("failed to generate function %s\n", parser->functions[i]->name);
 325         }
 326         if (!ir_function_finalize(parser->functions[i]->ir_func)) {
 327             printf("failed to finalize function %s\n", parser->functions[i]->name);
 328         }
 329     }
 330
 331     ir_builder_dump(ir, printf);
 332
 333 cleanup:
 334     for (i = 0; i < parser->globals_count; ++i) {
 335         ast_value_delete(parser->globals[i]);
 336     }
 337     MEM_VECTOR_CLEAR(parser, globals);
 338
 339     mem_d(parser);
 340     return true;
 341 }