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
 129     parser = (parser_t*)mem_a(sizeof(parser_t));
 130     if (!parser)
 131         return false;
 132
 133     MEM_VECTOR_INIT(parser, globals);
 134     parser->lex = lex_open(filename);
 135
 136     if (!parser->lex) {
 137         printf("failed to open file \"%s\"\n", filename);
 138         return false;
 139     }
 140
 141     /* initial lexer/parser state */
 142     parser->lex->flags.noops = true;
 143
 144     if (parser_next(parser))
 145     {
 146         while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
 147         {
 148             if (!parser_do(parser)) {
 149                 printf("parse error\n");
 150                 lex_close(parser->lex);
 151                 mem_d(parser);
 152                 return false;
 153             }
 154         }
 155     }
 156
 157     lex_close(parser->lex);
 158     for (i = 0; i < parser->globals_count; ++i) {
 159         ast_value_delete(parser->globals[i]);
 160     }
 161     MEM_VECTOR_CLEAR(parser, globals);
 162
 163     mem_d(parser);
 164     return true;
 165 }