lex.c

   1 /*
   2  * Copyright (C) 2012
   3  *     Dale Weiler
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is furnished to do
  10  * so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23 #include "gmqcc.h"
  24
  25 /*
  26  * Keywords are multichar, punctuation lexing is a bit more complicated
  27  * than keyword lexing.
  28  */
  29 static const char *const lex_keywords[] = {
  30     "do",    "else",     "if",     "while",
  31     "break", "continue", "return", "goto",
  32     "for",   "typedef"
  33 };
  34
  35 struct lex_file *lex_open(FILE *fp) {
  36     struct lex_file *lex = mem_a(sizeof(struct lex_file));
  37     if (!lex || !fp)
  38         return NULL;
  39
  40     lex->file = fp;
  41     fseek(lex->file, 0, SEEK_END);
  42     lex->length = ftell(lex->file);
  43     lex->size   = lex->length; /* copy, this is never changed */
  44     fseek(lex->file, 0, SEEK_SET);
  45     lex->last = 0;
  46     lex->line = 0;
  47
  48     memset(lex->peek, 0, sizeof(lex->peek));
  49     return lex;
  50 }
  51
  52 void lex_close(struct lex_file *file) {
  53     if (!file) return;
  54
  55     fclose(file->file); /* may already be closed */
  56     mem_d (file);
  57 }
  58
  59 static void lex_addch(int ch, struct lex_file *file) {
  60     if (file->current <  sizeof(file->lastok)-1)
  61         file->lastok[file->current++] = (char)ch;
  62     if (file->current == sizeof(file->lastok)-1)
  63         file->lastok[file->current]   = (char)'\0';
  64 }
  65 static inline void lex_clear(struct lex_file *file) {
  66     file->current = 0;
  67 }
  68
  69 /*
  70  * read in inget/unget character from a lexer stream.
  71  * This doesn't play with file streams, the lexer has
  72  * it's own internal state for this.
  73  */
  74 static int lex_inget(struct lex_file *file) {
  75     file->length --;
  76     if (file->last > 0)
  77         return file->peek[--file->last];
  78     return fgetc(file->file);
  79 }
  80 static void lex_unget(int ch, struct lex_file *file) {
  81     if (file->last < sizeof(file->peek))
  82         file->peek[file->last++] = ch;
  83     file->length ++;
  84 }
  85
  86 /*
  87  * This is trigraph and digraph support, a feature not qc compiler
  88  * supports.  Moving up in this world!
  89  */
  90 static int lex_trigraph(struct lex_file *file) {
  91     int  ch;
  92     if ((ch = lex_inget(file)) != '?') {
  93         lex_unget(ch, file);
  94         return '?';
  95     }
  96
  97     ch = lex_inget(file);
  98     switch (ch) {
  99         case '(' : return '[' ;
 100         case ')' : return ']' ;
 101         case '/' : return '\\';
 102         case '\'': return '^' ;
 103         case '<' : return '{' ;
 104         case '>' : return '}' ;
 105         case '!' : return '|' ;
 106         case '-' : return '~' ;
 107         case '=' : return '#' ;
 108         default:
 109             lex_unget('?', file);
 110             lex_unget(ch , file);
 111             return '?';
 112     }
 113     return '?';
 114 }
 115 static int lex_digraph(struct lex_file *file, int first) {
 116     int ch = lex_inget(file);
 117     switch (first) {
 118         case '<':
 119             if (ch == '%') return '{';
 120             if (ch == ':') return '[';
 121             break;
 122         case '%':
 123             if (ch == '>') return '}';
 124             if (ch == ':') return '#';
 125             break;
 126         case ':':
 127             if (ch == '>') return ']';
 128             break;
 129     }
 130
 131     lex_unget(ch, file);
 132     return first;
 133 }
 134
 135 static int lex_getch(struct lex_file *file) {
 136     int ch = lex_inget(file);
 137
 138     static int str = 0;
 139     switch (ch) {
 140         case '?' :
 141             return lex_trigraph(file);
 142         case '<' :
 143         case ':' :
 144         case '%' :
 145         case '"' : str = !str; if (str) { file->line ++; }
 146             return lex_digraph(file, ch);
 147
 148         case '\n':
 149             if (!str)
 150                 file->line++;
 151     }
 152
 153     return ch;
 154 }
 155
 156 static int lex_get(struct lex_file *file) {
 157     int ch;
 158     if (!isspace(ch = lex_getch(file)))
 159         return ch;
 160
 161     /* skip over all spaces */
 162     while (isspace(ch) && ch != '\n')
 163         ch = lex_getch(file);
 164
 165     if (ch == '\n')
 166         return ch;
 167     lex_unget(ch, file);
 168     return ' ';
 169 }
 170
 171 static int lex_skipchr(struct lex_file *file) {
 172     int ch;
 173     int it;
 174
 175     lex_clear(file);
 176     lex_addch('\'', file);
 177
 178     for (it = 0; it < 2 && ((ch = lex_inget(file)) != '\''); it++) {
 179         lex_addch(ch, file);
 180
 181         if (ch == '\n')
 182             return ERROR_LEX;
 183         if (ch == '\\')
 184             lex_addch(lex_getch(file), file);
 185     }
 186     lex_addch('\'', file);
 187     lex_addch('\0', file);
 188
 189     if (it > 2)
 190         return ERROR_LEX;
 191
 192     return LEX_CHRLIT;
 193 }
 194
 195 static int lex_skipstr(struct lex_file *file) {
 196     int ch;
 197     lex_clear(file);
 198     lex_addch('"', file);
 199
 200     while ((ch = lex_getch(file)) != '"') {
 201         if (ch == '\n' || ch == EOF)
 202             return ERROR_LEX;
 203
 204         lex_addch(ch, file);
 205         if (ch == '\\')
 206             lex_addch(lex_inget(file), file);
 207     }
 208
 209     lex_addch('"', file);
 210     lex_addch('\0', file);
 211
 212     return LEX_STRLIT;
 213 }
 214 static int lex_skipcmt(struct lex_file *file) {
 215     int ch;
 216     lex_clear(file);
 217     ch = lex_getch(file);
 218
 219     if (ch == '/') {
 220         lex_addch('/', file);
 221         lex_addch('/', file);
 222
 223         while ((ch = lex_getch(file)) != '\n') {
 224             if (ch == '\\') {
 225                 lex_addch(ch, file);
 226                 lex_addch(lex_getch(file), file);
 227             } else {
 228                 lex_addch(ch, file);
 229             }
 230         }
 231         lex_addch('\0', file);
 232         return LEX_COMMENT;
 233     }
 234
 235     if (ch != '*') {
 236         lex_unget(ch, file);
 237         return '/';
 238     }
 239
 240     lex_addch('/', file);
 241
 242     /* hate this */
 243     do {
 244         lex_addch(ch, file);
 245         while ((ch = lex_getch(file)) != '*') {
 246             if (ch == EOF)
 247                 return error(file, ERROR_LEX, "malformatted comment");
 248             else
 249                 lex_addch(ch, file);
 250         }
 251         lex_addch(ch, file);
 252     } while ((ch = lex_getch(file)) != '/');
 253
 254     lex_addch('/',  file);
 255     lex_addch('\0', file);
 256
 257     return LEX_COMMENT;
 258 }
 259
 260 static int lex_getsource(struct lex_file *file) {
 261     int ch = lex_get(file);
 262
 263     /* skip char/string/comment */
 264     switch (ch) {
 265         case '\'': return lex_skipchr(file);
 266         case '"':  return lex_skipstr(file);
 267         case '/':  return lex_skipcmt(file);
 268         default:
 269             return ch;
 270     }
 271 }
 272
 273 int lex_token(struct lex_file *file) {
 274     int ch = lex_getsource(file);
 275     int it;
 276
 277     /* valid identifier */
 278     if (ch > 0 && (ch == '_' || isalpha(ch))) {
 279         lex_clear(file);
 280
 281         /*
 282          * Yes this is dirty, but there is no other _sane_ easy
 283          * way to do it, this is what I call defensive programming
 284          * if something breaks, add more defense :-)
 285          */
 286         while (ch >   0   && ch != ' ' && ch != '(' &&
 287                ch != '\n' && ch != ';' && ch != ')') {
 288             lex_addch(ch, file);
 289             ch = lex_getsource(file);
 290         }
 291         lex_unget(ch,   file);
 292         lex_addch('\0', file);
 293
 294         /* look inside the table for a keyword .. */
 295         for (it = 0; it < sizeof(lex_keywords)/sizeof(*lex_keywords); it++)
 296             if (!strncmp(file->lastok, lex_keywords[it], strlen(lex_keywords[it])))
 297                 return it;
 298
 299         /* try a type? */
 300         #define TEST_TYPE(X)                                 \
 301             do {                                             \
 302                 if (!strncmp(X, "float",  sizeof("float")))  \
 303                     return TOKEN_FLOAT;                      \
 304                 if (!strncmp(X, "vector", sizeof("vector"))) \
 305                     return TOKEN_VECTOR;                     \
 306                 if (!strncmp(X, "string", sizeof("string"))) \
 307                     return TOKEN_STRING;                     \
 308                 if (!strncmp(X, "entity", sizeof("entity"))) \
 309                     return TOKEN_ENTITY;                     \
 310                 if (!strncmp(X, "void"  , sizeof("void")))   \
 311                     return TOKEN_VOID;                       \
 312             } while(0)
 313
 314         TEST_TYPE(file->lastok);
 315
 316         /* try the hashtable for typedefs? */
 317         if (typedef_find(file->lastok))
 318             TEST_TYPE(typedef_find(file->lastok)->name);
 319
 320         #undef TEST_TYPE
 321         return LEX_IDENT;
 322     }
 323     return ch;
 324 }
 325
 326 void lex_reset(struct lex_file *file) {
 327     file->current = 0;
 328     file->last    = 0;
 329     file->length  = file->size;
 330     fseek(file->file, 0, SEEK_SET);
 331
 332     memset(file->peek,   0, sizeof(file->peek  ));
 333     memset(file->lastok, 0, sizeof(file->lastok));
 334 }
 335
 336 /*
 337  * Include a file into the lexer / parsing process:  This really
 338  * should check if names are the same to prevent endless include
 339  * recrusion.
 340  */
 341 struct lex_file *lex_include(struct lex_file *lex, char *file) {
 342     util_strrq(file);
 343     if (strncmp(lex->name, file, strlen(lex->name)) == 0) {
 344         error(lex, ERROR_LEX, "Source file cannot include itself\n");
 345         exit (-1);
 346     }
 347
 348     FILE *fp = fopen(file, "r");
 349     if  (!fp) {
 350         error(lex, ERROR_LEX, "Include file `%s` doesn't exist\n", file);
 351         exit (-1);
 352     }
 353
 354     return lex_open(fp);
 355 }