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 } parser_t;
  13
  14 MEM_VEC_FUNCTIONS(parser_t, ast_value*, globals)
  15
  16 void parseerror(parser_t *parser, const char *fmt, ...)
  17 {
  18         va_list ap;
  19
  20     if (parser)
  21             printf("error %s:%lu: ", parser->lex->tok->ctx.file, (unsigned long)parser->lex->tok->ctx.line);
  22         else
  23             printf("error: ");
  24
  25         va_start(ap, fmt);
  26         vprintf(fmt, ap);
  27         va_end(ap);
  28
  29         printf("\n");
  30 }
  31
  32 bool parser_next(parser_t *parser)
  33 {
  34     /* lex_do kills the previous token */
  35     parser->tok = lex_do(parser->lex);
  36     if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
  37         return false;
  38     return true;
  39 }
  40
  41 /* lift a token out of the parser so it's not destroyed by parser_next */
  42 token *parser_lift(parser_t *parser)
  43 {
  44     token *tok = parser->lex->tok;
  45     parser->lex->tok = NULL;
  46     return tok;
  47 }
  48
  49 #define parser_tokval(p) (p->lex->tok->value)
  50 #define parser_token(p)  (p->lex->tok)
  51 #define parser_ctx(p)    (p->lex->tok->ctx)
  52
  53 ast_value* parser_find_global(parser_t *parser, const char *name)
  54 {
  55     size_t i;
  56     for (i = 0; i < parser->globals_count; ++i) {
  57         if (!strcmp(parser->globals[i]->name, name))
  58             return parser->globals[i];
  59     }
  60     return NULL;
  61 }
  62
  63 bool parser_do(parser_t *parser)
  64 {
  65     if (parser->tok == TOKEN_TYPENAME)
  66     {
  67         ast_value *var;
  68         int       vtype = parser->lex->tok->constval.t;
  69
  70         /* Declaring a variable */
  71         if (!parser_next(parser))
  72             return false;
  73
  74         if (parser->tok != TOKEN_IDENT) {
  75             parseerror(parser, "expected variable name\n");
  76             return false;
  77         }
  78
  79         var = parser_find_global(parser, parser_tokval(parser));
  80
  81         if (var) {
  82             parseerror(parser, "global already exists: %s\n", parser_tokval(parser));
  83             return false;
  84         }
  85
  86         var = ast_value_new(parser_ctx(parser), parser_tokval(parser), vtype);
  87         if (!parser_t_globals_add(parser, var))
  88             return false;
  89
  90         /* Constant assignment */
  91         if (!parser_next(parser))
  92             return false;
  93
  94         if (parser->tok == ';')
  95             return parser_next(parser);
  96
  97         if (parser->tok != '=') {
  98             parseerror(parser, "expected '=' or ';'");
  99             return false;
 100         }
 101
 102         /* '=' found, assign... */
 103         parseerror(parser, "TODO, const assignment");
 104         return false;
 105     }
 106     else if (parser->tok == TOKEN_KEYWORD)
 107     {
 108         /* handle 'var' and 'const' */
 109         return false;
 110     }
 111     else if (parser->tok == '.')
 112     {
 113         /* entity-member declaration */
 114         return false;
 115     }
 116     else
 117     {
 118         parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
 119         return false;
 120     }
 121     return true;
 122 }
 123
 124 bool parser_compile(const char *filename)
 125 {
 126     size_t i;
 127     parser_t *parser;
 128     ir_builder *ir;
 129
 130     parser = (parser_t*)mem_a(sizeof(parser_t));
 131     if (!parser)
 132         return false;
 133
 134     MEM_VECTOR_INIT(parser, globals);
 135     parser->lex = lex_open(filename);
 136
 137     if (!parser->lex) {
 138         printf("failed to open file \"%s\"\n", filename);
 139         return false;
 140     }
 141
 142     /* initial lexer/parser state */
 143     parser->lex->flags.noops = true;
 144
 145     if (parser_next(parser))
 146     {
 147         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
 148         {
 149             if (!parser_do(parser)) {
 150                 if (parser->tok == TOKEN_EOF)
 151                     break;
 152                 printf("parse error\n");
 153                 lex_close(parser->lex);
 154                 mem_d(parser);
 155                 return false;
 156             }
 157         }
 158     }
 159
 160     lex_close(parser->lex);
 161
 162     ir = ir_builder_new("gmqcc_out");
 163     if (!ir) {
 164         printf("failed to allocate builder\n");
 165         goto cleanup;
 166     }
 167
 168     for (i = 0; i < parser->globals_count; ++i) {
 169         if (!ast_global_codegen(parser->globals[i], ir)) {
 170             printf("failed to generate global %s\n", parser->globals[i]->name);
 171         }
 172     }
 173
 174     ir_builder_dump(ir, printf);
 175
 176 cleanup:
 177     for (i = 0; i < parser->globals_count; ++i) {
 178         ast_value_delete(parser->globals[i]);
 179     }
 180     MEM_VECTOR_CLEAR(parser, globals);
 181
 182     mem_d(parser);
 183     return true;
 184 }