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