lexer.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5
   6 #include "gmqcc.h"
   7 #include "lexer.h"
   8
   9 char* *lex_filenames;
  10
  11 void lexerror(lex_file *lex, const char *fmt, ...)
  12 {
  13         va_list ap;
  14
  15         va_start(ap, fmt);
  16         if (lex)
  17         con_vprintmsg(LVL_ERROR, lex->name, lex->sline, "parse error", fmt, ap);
  18     else
  19         con_vprintmsg(LVL_ERROR, "", 0, "parse error", fmt, ap);
  20         va_end(ap);
  21 }
  22
  23 bool lexwarn(lex_file *lex, int warntype, const char *fmt, ...)
  24 {
  25         va_list ap;
  26         int lvl = LVL_WARNING;
  27
  28     if (!OPTS_WARN(warntype))
  29         return false;
  30
  31     if (opts_werror)
  32             lvl = LVL_ERROR;
  33
  34         va_start(ap, fmt);
  35     con_vprintmsg(lvl, lex->name, lex->sline, "warning", fmt, ap);
  36         va_end(ap);
  37
  38         return opts_werror;
  39 }
  40
  41
  42 #if 0
  43 token* token_new()
  44 {
  45     token *tok = (token*)mem_a(sizeof(token));
  46     if (!tok)
  47         return NULL;
  48     memset(tok, 0, sizeof(*tok));
  49     return tok;
  50 }
  51
  52 void token_delete(token *self)
  53 {
  54     if (self->next && self->next->prev == self)
  55         self->next->prev = self->prev;
  56     if (self->prev && self->prev->next == self)
  57         self->prev->next = self->next;
  58     MEM_VECTOR_CLEAR(self, value);
  59     mem_d(self);
  60 }
  61
  62 token* token_copy(const token *cp)
  63 {
  64     token* self = token_new();
  65     if (!self)
  66         return NULL;
  67     /* copy the value */
  68     self->value_alloc = cp->value_count + 1;
  69     self->value_count = cp->value_count;
  70     self->value = (char*)mem_a(self->value_alloc);
  71     if (!self->value) {
  72         mem_d(self);
  73         return NULL;
  74     }
  75     memcpy(self->value, cp->value, cp->value_count);
  76     self->value[self->value_alloc-1] = 0;
  77
  78     /* rest */
  79     self->ctx = cp->ctx;
  80     self->ttype = cp->ttype;
  81     memcpy(&self->constval, &cp->constval, sizeof(self->constval));
  82     return self;
  83 }
  84
  85 void token_delete_all(token *t)
  86 {
  87     token *n;
  88
  89     do {
  90         n = t->next;
  91         token_delete(t);
  92         t = n;
  93     } while(t);
  94 }
  95
  96 token* token_copy_all(const token *cp)
  97 {
  98     token *cur;
  99     token *out;
 100
 101     out = cur = token_copy(cp);
 102     if (!out)
 103         return NULL;
 104
 105     while (cp->next) {
 106         cp = cp->next;
 107         cur->next = token_copy(cp);
 108         if (!cur->next) {
 109             token_delete_all(out);
 110             return NULL;
 111         }
 112         cur->next->prev = cur;
 113         cur = cur->next;
 114     }
 115
 116     return out;
 117 }
 118 #else
 119 static void lex_token_new(lex_file *lex)
 120 {
 121 #if 0
 122     if (lex->tok)
 123         token_delete(lex->tok);
 124     lex->tok = token_new();
 125 #else
 126     if (lex->tok.value)
 127         vec_shrinkto(lex->tok.value, 0);
 128     lex->tok.constval.t  = 0;
 129     lex->tok.ctx.line = lex->sline;
 130     lex->tok.ctx.file = lex->name;
 131 #endif
 132 }
 133 #endif
 134
 135 lex_file* lex_open(const char *file)
 136 {
 137     lex_file *lex;
 138     FILE *in = util_fopen(file, "rb");
 139
 140     if (!in) {
 141         lexerror(NULL, "open failed: '%s'\n", file);
 142         return NULL;
 143     }
 144
 145     lex = (lex_file*)mem_a(sizeof(*lex));
 146     if (!lex) {
 147         fclose(in);
 148         lexerror(NULL, "out of memory\n");
 149         return NULL;
 150     }
 151
 152     memset(lex, 0, sizeof(*lex));
 153
 154     lex->file = in;
 155     lex->name = util_strdup(file);
 156     lex->line = 1; /* we start counting at 1 */
 157
 158     lex->peekpos = 0;
 159     lex->eof = false;
 160
 161     vec_push(lex_filenames, lex->name);
 162     return lex;
 163 }
 164
 165 lex_file* lex_open_string(const char *str, size_t len, const char *name)
 166 {
 167     lex_file *lex;
 168
 169     lex = (lex_file*)mem_a(sizeof(*lex));
 170     if (!lex) {
 171         lexerror(NULL, "out of memory\n");
 172         return NULL;
 173     }
 174
 175     memset(lex, 0, sizeof(*lex));
 176
 177     lex->file = NULL;
 178     lex->open_string        = str;
 179     lex->open_string_length = len;
 180     lex->open_string_pos    = 0;
 181
 182     lex->name = util_strdup(name ? name : "<string-source>");
 183     lex->line = 1; /* we start counting at 1 */
 184
 185     lex->peekpos = 0;
 186     lex->eof = false;
 187
 188     vec_push(lex_filenames, lex->name);
 189
 190     return lex;
 191 }
 192
 193 void lex_cleanup(void)
 194 {
 195     size_t i;
 196     for (i = 0; i < vec_size(lex_filenames); ++i)
 197         mem_d(lex_filenames[i]);
 198     vec_free(lex_filenames);
 199 }
 200
 201 void lex_close(lex_file *lex)
 202 {
 203     size_t i;
 204     for (i = 0; i < vec_size(lex->frames); ++i)
 205         mem_d(lex->frames[i].name);
 206     vec_free(lex->frames);
 207
 208     if (lex->modelname)
 209         vec_free(lex->modelname);
 210
 211     if (lex->file)
 212         fclose(lex->file);
 213 #if 0
 214     if (lex->tok)
 215         token_delete(lex->tok);
 216 #else
 217     vec_free(lex->tok.value);
 218 #endif
 219     /* mem_d(lex->name); collected in lex_filenames */
 220     mem_d(lex);
 221 }
 222
 223 static int lex_fgetc(lex_file *lex)
 224 {
 225     if (lex->file)
 226         return fgetc(lex->file);
 227     if (lex->open_string) {
 228         if (lex->open_string_pos >= lex->open_string_length)
 229             return EOF;
 230         return lex->open_string[lex->open_string_pos++];
 231     }
 232     return EOF;
 233 }
 234
 235 /* Get or put-back data
 236  * The following to functions do NOT understand what kind of data they
 237  * are working on.
 238  * The are merely wrapping get/put in order to count line numbers.
 239  */
 240 static void lex_ungetch(lex_file *lex, int ch);
 241 static int lex_try_trigraph(lex_file *lex, int old)
 242 {
 243     int c2, c3;
 244     c2 = lex_fgetc(lex);
 245     if (c2 != '?') {
 246         lex_ungetch(lex, c2);
 247         return old;
 248     }
 249
 250     c3 = lex_fgetc(lex);
 251     switch (c3) {
 252         case '=': return '#';
 253         case '/': return '\\';
 254         case '\'': return '^';
 255         case '(': return '[';
 256         case ')': return ']';
 257         case '!': return '|';
 258         case '<': return '{';
 259         case '>': return '}';
 260         case '-': return '~';
 261         default:
 262             lex_ungetch(lex, c3);
 263             lex_ungetch(lex, c2);
 264             return old;
 265     }
 266 }
 267
 268 static int lex_try_digraph(lex_file *lex, int ch)
 269 {
 270     int c2;
 271     c2 = lex_fgetc(lex);
 272     if      (ch == '<' && c2 == ':')
 273         return '[';
 274     else if (ch == ':' && c2 == '>')
 275         return ']';
 276     else if (ch == '<' && c2 == '%')
 277         return '{';
 278     else if (ch == '%' && c2 == '>')
 279         return '}';
 280     else if (ch == '%' && c2 == ':')
 281         return '#';
 282     lex_ungetch(lex, c2);
 283     return ch;
 284 }
 285
 286 static int lex_getch(lex_file *lex)
 287 {
 288     int ch;
 289
 290     if (lex->peekpos) {
 291         lex->peekpos--;
 292         if (lex->peek[lex->peekpos] == '\n')
 293             lex->line++;
 294         return lex->peek[lex->peekpos];
 295     }
 296
 297     ch = lex_fgetc(lex);
 298     if (ch == '\n')
 299         lex->line++;
 300     else if (ch == '?')
 301         return lex_try_trigraph(lex, ch);
 302     else if (!lex->flags.nodigraphs && (ch == '<' || ch == ':' || ch == '%'))
 303         return lex_try_digraph(lex, ch);
 304     return ch;
 305 }
 306
 307 static void lex_ungetch(lex_file *lex, int ch)
 308 {
 309     lex->peek[lex->peekpos++] = ch;
 310     if (ch == '\n')
 311         lex->line--;
 312 }
 313
 314 /* classify characters
 315  * some additions to the is*() functions of ctype.h
 316  */
 317
 318 /* Idents are alphanumberic, but they start with alpha or _ */
 319 static bool isident_start(int ch)
 320 {
 321     return isalpha(ch) || ch == '_';
 322 }
 323
 324 static bool isident(int ch)
 325 {
 326     return isident_start(ch) || isdigit(ch);
 327 }
 328
 329 /* isxdigit_only is used when we already know it's not a digit
 330  * and want to see if it's a hex digit anyway.
 331  */
 332 static bool isxdigit_only(int ch)
 333 {
 334     return (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
 335 }
 336
 337 /* Append a character to the token buffer */
 338 static void lex_tokench(lex_file *lex, int ch)
 339 {
 340     vec_push(lex->tok.value, ch);
 341 }
 342
 343 /* Append a trailing null-byte */
 344 static void lex_endtoken(lex_file *lex)
 345 {
 346     vec_push(lex->tok.value, 0);
 347     vec_shrinkby(lex->tok.value, 1);
 348 }
 349
 350 /* Skip whitespace and comments and return the first
 351  * non-white character.
 352  * As this makes use of the above getch() ungetch() functions,
 353  * we don't need to care at all about line numbering anymore.
 354  *
 355  * In theory, this function should only be used at the beginning
 356  * of lexing, or when we *know* the next character is part of the token.
 357  * Otherwise, if the parser throws an error, the linenumber may not be
 358  * the line of the error, but the line of the next token AFTER the error.
 359  *
 360  * This is currently only problematic when using c-like string-continuation,
 361  * since comments and whitespaces are allowed between 2 such strings.
 362  * Example:
 363 printf(   "line one\n"
 364 // A comment
 365           "A continuation of the previous string"
 366 // This line is skipped
 367       , foo);
 368
 369  * In this case, if the parse decides it didn't actually want a string,
 370  * and uses lex->line to print an error, it will show the ', foo);' line's
 371  * linenumber.
 372  *
 373  * On the other hand, the parser is supposed to remember the line of the next
 374  * token's beginning. In this case we would want skipwhite() to be called
 375  * AFTER reading a token, so that the parser, before reading the NEXT token,
 376  * doesn't store teh *comment's* linenumber, but the actual token's linenumber.
 377  *
 378  * THIS SOLUTION
 379  *    here is to store the line of the first character after skipping
 380  *    the initial whitespace in lex->sline, this happens in lex_do.
 381  */
 382 static int lex_skipwhite(lex_file *lex)
 383 {
 384     int ch = 0;
 385     bool haswhite = false;
 386
 387     do
 388     {
 389         ch = lex_getch(lex);
 390         while (ch != EOF && isspace(ch)) {
 391             if (lex->flags.preprocessing) {
 392                 if (ch == '\n') {
 393                     /* end-of-line */
 394                     /* see if there was whitespace first */
 395                     if (haswhite) { /* (vec_size(lex->tok.value)) { */
 396                         lex_ungetch(lex, ch);
 397                         lex_endtoken(lex);
 398                         return TOKEN_WHITE;
 399                     }
 400                     /* otherwise return EOL */
 401                     return TOKEN_EOL;
 402                 }
 403                 haswhite = true;
 404                 lex_tokench(lex, ch);
 405             }
 406             ch = lex_getch(lex);
 407         }
 408
 409         if (ch == '/') {
 410             ch = lex_getch(lex);
 411             if (ch == '/')
 412             {
 413                 /* one line comment */
 414                 ch = lex_getch(lex);
 415
 416                 if (lex->flags.preprocessing) {
 417                     haswhite = true;
 418                     lex_tokench(lex, '/');
 419                     lex_tokench(lex, '/');
 420                 }
 421
 422                 while (ch != EOF && ch != '\n') {
 423                     if (lex->flags.preprocessing)
 424                         lex_tokench(lex, ch);
 425                     ch = lex_getch(lex);
 426                 }
 427                 if (lex->flags.preprocessing) {
 428                     lex_ungetch(lex, '\n');
 429                     lex_endtoken(lex);
 430                     return TOKEN_WHITE;
 431                 }
 432                 continue;
 433             }
 434             if (ch == '*')
 435             {
 436                 /* multiline comment */
 437                 if (lex->flags.preprocessing) {
 438                     haswhite = true;
 439                     lex_tokench(lex, '/');
 440                     lex_tokench(lex, '*');
 441                 }
 442
 443                 while (ch != EOF)
 444                 {
 445                     ch = lex_getch(lex);
 446                     if (ch == '*') {
 447                         ch = lex_getch(lex);
 448                         if (ch == '/') {
 449                             if (lex->flags.preprocessing) {
 450                                 lex_tokench(lex, '*');
 451                                 lex_tokench(lex, '/');
 452                             }
 453                             break;
 454                         }
 455                     }
 456                     if (lex->flags.preprocessing) {
 457                         lex_tokench(lex, ch);
 458                     }
 459                 }
 460                 ch = ' '; /* cause TRUE in the isspace check */
 461                 continue;
 462             }
 463             /* Otherwise roll back to the slash and break out of the loop */
 464             lex_ungetch(lex, ch);
 465             ch = '/';
 466             break;
 467         }
 468     } while (ch != EOF && isspace(ch));
 469
 470     if (haswhite) {
 471         lex_endtoken(lex);
 472         lex_ungetch(lex, ch);
 473         return TOKEN_WHITE;
 474     }
 475     return ch;
 476 }
 477
 478 /* Get a token */
 479 static bool GMQCC_WARN lex_finish_ident(lex_file *lex)
 480 {
 481     int ch;
 482
 483     ch = lex_getch(lex);
 484     while (ch != EOF && isident(ch))
 485     {
 486         lex_tokench(lex, ch);
 487         ch = lex_getch(lex);
 488     }
 489
 490     /* last ch was not an ident ch: */
 491     lex_ungetch(lex, ch);
 492
 493     return true;
 494 }
 495
 496 /* read one ident for the frame list */
 497 static int lex_parse_frame(lex_file *lex)
 498 {
 499     int ch;
 500
 501     lex_token_new(lex);
 502
 503     ch = lex_getch(lex);
 504     while (ch != EOF && ch != '\n' && isspace(ch))
 505         ch = lex_getch(lex);
 506
 507     if (ch == '\n')
 508         return 1;
 509
 510     if (!isident_start(ch)) {
 511         lexerror(lex, "invalid framename, must start with one of a-z or _, got %c", ch);
 512         return -1;
 513     }
 514
 515     lex_tokench(lex, ch);
 516     if (!lex_finish_ident(lex))
 517         return -1;
 518     lex_endtoken(lex);
 519     return 0;
 520 }
 521
 522 /* read a list of $frames */
 523 static bool lex_finish_frames(lex_file *lex)
 524 {
 525     do {
 526         size_t i;
 527         int    rc;
 528         frame_macro m;
 529
 530         rc = lex_parse_frame(lex);
 531         if (rc > 0) /* end of line */
 532             return true;
 533         if (rc < 0) /* error */
 534             return false;
 535
 536         for (i = 0; i < vec_size(lex->frames); ++i) {
 537             if (!strcmp(lex->tok.value, lex->frames[i].name)) {
 538                 lex->frames[i].value = lex->framevalue++;
 539                 if (lexwarn(lex, WARN_FRAME_MACROS, "duplicate frame macro defined: `%s`", lex->tok.value))
 540                     return false;
 541                 break;
 542             }
 543         }
 544         if (i < vec_size(lex->frames))
 545             continue;
 546
 547         m.value = lex->framevalue++;
 548         m.name = util_strdup(lex->tok.value);
 549         vec_shrinkto(lex->tok.value, 0);
 550         vec_push(lex->frames, m);
 551     } while (true);
 552 }
 553
 554 static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
 555 {
 556     int ch = 0;
 557
 558     while (ch != EOF)
 559     {
 560         ch = lex_getch(lex);
 561         if (ch == quote)
 562             return TOKEN_STRINGCONST;
 563
 564         if (!lex->flags.preprocessing && ch == '\\') {
 565             ch = lex_getch(lex);
 566             if (ch == EOF) {
 567                 lexerror(lex, "unexpected end of file");
 568                 lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
 569                 return (lex->tok.ttype = TOKEN_ERROR);
 570             }
 571
 572             switch (ch) {
 573             case '\\': break;
 574             case 'a':  ch = '\a'; break;
 575             case 'b':  ch = '\b'; break;
 576             case 'r':  ch = '\r'; break;
 577             case 'n':  ch = '\n'; break;
 578             case 't':  ch = '\t'; break;
 579             case 'f':  ch = '\f'; break;
 580             case 'v':  ch = '\v'; break;
 581             default:
 582                 lexwarn(lex, WARN_UNKNOWN_CONTROL_SEQUENCE, "unrecognized control sequence: \\%c", ch);
 583                 /* so we just add the character plus backslash no matter what it actually is */
 584                 lex_tokench(lex, '\\');
 585             }
 586             /* add the character finally */
 587             lex_tokench(lex, ch);
 588         }
 589         else
 590             lex_tokench(lex, ch);
 591     }
 592     lexerror(lex, "unexpected end of file within string constant");
 593     lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
 594     return (lex->tok.ttype = TOKEN_ERROR);
 595 }
 596
 597 static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
 598 {
 599     bool ishex = false;
 600
 601     int  ch = lastch;
 602
 603     /* parse a number... */
 604     lex->tok.ttype = TOKEN_INTCONST;
 605
 606     lex_tokench(lex, ch);
 607
 608     ch = lex_getch(lex);
 609     if (ch != '.' && !isdigit(ch))
 610     {
 611         if (lastch != '0' || ch != 'x')
 612         {
 613             /* end of the number or EOF */
 614             lex_ungetch(lex, ch);
 615             lex_endtoken(lex);
 616
 617             lex->tok.constval.i = lastch - '0';
 618             return lex->tok.ttype;
 619         }
 620
 621         ishex = true;
 622     }
 623
 624     /* EOF would have been caught above */
 625
 626     if (ch != '.')
 627     {
 628         lex_tokench(lex, ch);
 629         ch = lex_getch(lex);
 630         while (isdigit(ch) || (ishex && isxdigit_only(ch)))
 631         {
 632             lex_tokench(lex, ch);
 633             ch = lex_getch(lex);
 634         }
 635     }
 636     /* NOT else, '.' can come from above as well */
 637     if (ch == '.' && !ishex)
 638     {
 639         /* Allow floating comma in non-hex mode */
 640         lex->tok.ttype = TOKEN_FLOATCONST;
 641         lex_tokench(lex, ch);
 642
 643         /* continue digits-only */
 644         ch = lex_getch(lex);
 645         while (isdigit(ch))
 646         {
 647             lex_tokench(lex, ch);
 648             ch = lex_getch(lex);
 649         }
 650     }
 651     /* put back the last character */
 652     /* but do not put back the trailing 'f' or a float */
 653     if (lex->tok.ttype == TOKEN_FLOATCONST && ch == 'f')
 654         ch = lex_getch(lex);
 655
 656     /* generally we don't want words to follow numbers: */
 657     if (isident(ch)) {
 658         lexerror(lex, "unexpected trailing characters after number");
 659         return (lex->tok.ttype = TOKEN_ERROR);
 660     }
 661     lex_ungetch(lex, ch);
 662
 663     lex_endtoken(lex);
 664     if (lex->tok.ttype == TOKEN_FLOATCONST)
 665         lex->tok.constval.f = strtod(lex->tok.value, NULL);
 666     else
 667         lex->tok.constval.i = strtol(lex->tok.value, NULL, 0);
 668     return lex->tok.ttype;
 669 }
 670
 671 int lex_do(lex_file *lex)
 672 {
 673     int ch, nextch;
 674
 675     lex_token_new(lex);
 676 #if 0
 677     if (!lex->tok)
 678         return TOKEN_FATAL;
 679 #endif
 680
 681     ch = lex_skipwhite(lex);
 682     lex->sline = lex->line;
 683     lex->tok.ctx.line = lex->sline;
 684     lex->tok.ctx.file = lex->name;
 685
 686     if (lex->flags.preprocessing && (ch == TOKEN_WHITE || ch == TOKEN_EOL || ch == TOKEN_FATAL)) {
 687         return (lex->tok.ttype = ch);
 688     }
 689
 690     if (lex->eof)
 691         return (lex->tok.ttype = TOKEN_FATAL);
 692
 693     if (ch == EOF) {
 694         lex->eof = true;
 695         return (lex->tok.ttype = TOKEN_EOF);
 696     }
 697
 698     /* modelgen / spiritgen commands */
 699     if (ch == '$') {
 700         const char *v;
 701         size_t frame;
 702
 703         ch = lex_getch(lex);
 704         if (!isident_start(ch)) {
 705             lexerror(lex, "hanging '$' modelgen/spritegen command line");
 706             return lex_do(lex);
 707         }
 708         lex_tokench(lex, ch);
 709         if (!lex_finish_ident(lex))
 710             return (lex->tok.ttype = TOKEN_ERROR);
 711         lex_endtoken(lex);
 712         /* skip the known commands */
 713         v = lex->tok.value;
 714
 715         if (!strcmp(v, "frame") || !strcmp(v, "framesave"))
 716         {
 717             /* frame/framesave command works like an enum
 718              * similar to fteqcc we handle this in the lexer.
 719              * The reason for this is that it is sensitive to newlines,
 720              * which the parser is unaware of
 721              */
 722             if (!lex_finish_frames(lex))
 723                  return (lex->tok.ttype = TOKEN_ERROR);
 724             return lex_do(lex);
 725         }
 726
 727         if (!strcmp(v, "framevalue"))
 728         {
 729             ch = lex_getch(lex);
 730             while (ch != EOF && isspace(ch) && ch != '\n')
 731                 ch = lex_getch(lex);
 732
 733             if (!isdigit(ch)) {
 734                 lexerror(lex, "$framevalue requires an integer parameter");
 735                 return lex_do(lex);
 736             }
 737
 738             lex_token_new(lex);
 739             lex->tok.ttype = lex_finish_digit(lex, ch);
 740             lex_endtoken(lex);
 741             if (lex->tok.ttype != TOKEN_INTCONST) {
 742                 lexerror(lex, "$framevalue requires an integer parameter");
 743                 return lex_do(lex);
 744             }
 745             lex->framevalue = lex->tok.constval.i;
 746             return lex_do(lex);
 747         }
 748
 749         if (!strcmp(v, "framerestore"))
 750         {
 751             int rc;
 752
 753             lex_token_new(lex);
 754
 755             rc = lex_parse_frame(lex);
 756
 757             if (rc > 0) {
 758                 lexerror(lex, "$framerestore requires a framename parameter");
 759                 return lex_do(lex);
 760             }
 761             if (rc < 0)
 762                 return (lex->tok.ttype = TOKEN_FATAL);
 763
 764             v = lex->tok.value;
 765             for (frame = 0; frame < vec_size(lex->frames); ++frame) {
 766                 if (!strcmp(v, lex->frames[frame].name)) {
 767                     lex->framevalue = lex->frames[frame].value;
 768                     return lex_do(lex);
 769                 }
 770             }
 771             lexerror(lex, "unknown framename `%s`", v);
 772             return lex_do(lex);
 773         }
 774
 775         if (!strcmp(v, "modelname"))
 776         {
 777             int rc;
 778
 779             lex_token_new(lex);
 780
 781             rc = lex_parse_frame(lex);
 782
 783             if (rc > 0) {
 784                 lexerror(lex, "$modelname requires a parameter");
 785                 return lex_do(lex);
 786             }
 787             if (rc < 0)
 788                 return (lex->tok.ttype = TOKEN_FATAL);
 789
 790             v = lex->tok.value;
 791             if (lex->modelname) {
 792                 frame_macro m;
 793                 m.value = lex->framevalue;
 794                 m.name = lex->modelname;
 795                 lex->modelname = NULL;
 796                 vec_push(lex->frames, m);
 797             }
 798             lex->modelname = lex->tok.value;
 799             lex->tok.value = NULL;
 800             return lex_do(lex);
 801         }
 802
 803         if (!strcmp(v, "flush"))
 804         {
 805             size_t frame;
 806             for (frame = 0; frame < vec_size(lex->frames); ++frame)
 807                 mem_d(lex->frames[frame].name);
 808             vec_free(lex->frames);
 809             /* skip line (fteqcc does it too) */
 810             ch = lex_getch(lex);
 811             while (ch != EOF && ch != '\n')
 812                 ch = lex_getch(lex);
 813             return lex_do(lex);
 814         }
 815
 816         if (!strcmp(v, "cd") ||
 817             !strcmp(v, "origin") ||
 818             !strcmp(v, "base") ||
 819             !strcmp(v, "flags") ||
 820             !strcmp(v, "scale") ||
 821             !strcmp(v, "skin"))
 822         {
 823             /* skip line */
 824             ch = lex_getch(lex);
 825             while (ch != EOF && ch != '\n')
 826                 ch = lex_getch(lex);
 827             return lex_do(lex);
 828         }
 829
 830         for (frame = 0; frame < vec_size(lex->frames); ++frame) {
 831             if (!strcmp(v, lex->frames[frame].name)) {
 832                 lex->tok.constval.i = lex->frames[frame].value;
 833                 return (lex->tok.ttype = TOKEN_INTCONST);
 834             }
 835         }
 836
 837         lexerror(lex, "invalid frame macro");
 838         return lex_do(lex);
 839     }
 840
 841     /* single-character tokens */
 842     switch (ch)
 843     {
 844         case '[':
 845         case '(':
 846             lex_tokench(lex, ch);
 847             lex_endtoken(lex);
 848             if (lex->flags.noops)
 849                 return (lex->tok.ttype = ch);
 850             else
 851                 return (lex->tok.ttype = TOKEN_OPERATOR);
 852         case ')':
 853         case ';':
 854         case '{':
 855         case '}':
 856         case ']':
 857
 858         case '#':
 859             lex_tokench(lex, ch);
 860             lex_endtoken(lex);
 861             return (lex->tok.ttype = ch);
 862         default:
 863             break;
 864     }
 865
 866     if (lex->flags.noops)
 867     {
 868         /* Detect characters early which are normally
 869          * operators OR PART of an operator.
 870          */
 871         switch (ch)
 872         {
 873             case '+':
 874             case '-':
 875             case '*':
 876             case '/':
 877             case '<':
 878             case '>':
 879             case '=':
 880             case '&':
 881             case '|':
 882             case '^':
 883             case '~':
 884             case ',':
 885             case '!':
 886                 lex_tokench(lex, ch);
 887                 lex_endtoken(lex);
 888                 return (lex->tok.ttype = ch);
 889             default:
 890                 break;
 891         }
 892
 893         if (ch == '.')
 894         {
 895             lex_tokench(lex, ch);
 896             /* peak ahead once */
 897             nextch = lex_getch(lex);
 898             if (nextch != '.') {
 899                 lex_ungetch(lex, nextch);
 900                 lex_endtoken(lex);
 901                 return (lex->tok.ttype = ch);
 902             }
 903             /* peak ahead again */
 904             nextch = lex_getch(lex);
 905             if (nextch != '.') {
 906                 lex_ungetch(lex, nextch);
 907                 lex_ungetch(lex, nextch);
 908                 lex_endtoken(lex);
 909                 return (lex->tok.ttype = ch);
 910             }
 911             /* fill the token to be "..." */
 912             lex_tokench(lex, ch);
 913             lex_tokench(lex, ch);
 914             lex_endtoken(lex);
 915             return (lex->tok.ttype = TOKEN_DOTS);
 916         }
 917     }
 918
 919     if (ch == ',' || ch == '.') {
 920         lex_tokench(lex, ch);
 921         lex_endtoken(lex);
 922         return (lex->tok.ttype = TOKEN_OPERATOR);
 923     }
 924
 925     if (ch == '+' || ch == '-' || /* ++, --, +=, -=  and -> as well! */
 926         ch == '>' || ch == '<' || /* <<, >>, <=, >= */
 927         ch == '=' || ch == '!' || /* ==, != */
 928         ch == '&' || ch == '|')   /* &&, ||, &=, |= */
 929     {
 930         lex_tokench(lex, ch);
 931
 932         nextch = lex_getch(lex);
 933         if (nextch == ch || nextch == '=') {
 934             lex_tokench(lex, nextch);
 935         } else if (ch == '-' && nextch == '>') {
 936             lex_tokench(lex, nextch);
 937         } else
 938             lex_ungetch(lex, nextch);
 939
 940         lex_endtoken(lex);
 941         return (lex->tok.ttype = TOKEN_OPERATOR);
 942     }
 943
 944     /*
 945     if (ch == '^' || ch == '~' || ch == '!')
 946     {
 947         lex_tokench(lex, ch);
 948         lex_endtoken(lex);
 949         return (lex->tok.ttype = TOKEN_OPERATOR);
 950     }
 951     */
 952
 953     if (ch == '*' || ch == '/') /* *=, /= */
 954     {
 955         lex_tokench(lex, ch);
 956
 957         nextch = lex_getch(lex);
 958         if (nextch == '=') {
 959             lex_tokench(lex, nextch);
 960         } else
 961             lex_ungetch(lex, nextch);
 962
 963         lex_endtoken(lex);
 964         return (lex->tok.ttype = TOKEN_OPERATOR);
 965     }
 966
 967     if (isident_start(ch))
 968     {
 969         const char *v;
 970
 971         lex_tokench(lex, ch);
 972         if (!lex_finish_ident(lex)) {
 973             /* error? */
 974             return (lex->tok.ttype = TOKEN_ERROR);
 975         }
 976         lex_endtoken(lex);
 977         lex->tok.ttype = TOKEN_IDENT;
 978
 979         v = lex->tok.value;
 980         if (!strcmp(v, "void")) {
 981             lex->tok.ttype = TOKEN_TYPENAME;
 982             lex->tok.constval.t = TYPE_VOID;
 983         } else if (!strcmp(v, "int")) {
 984             lex->tok.ttype = TOKEN_TYPENAME;
 985             lex->tok.constval.t = TYPE_INTEGER;
 986         } else if (!strcmp(v, "float")) {
 987             lex->tok.ttype = TOKEN_TYPENAME;
 988             lex->tok.constval.t = TYPE_FLOAT;
 989         } else if (!strcmp(v, "string")) {
 990             lex->tok.ttype = TOKEN_TYPENAME;
 991             lex->tok.constval.t = TYPE_STRING;
 992         } else if (!strcmp(v, "entity")) {
 993             lex->tok.ttype = TOKEN_TYPENAME;
 994             lex->tok.constval.t = TYPE_ENTITY;
 995         } else if (!strcmp(v, "vector")) {
 996             lex->tok.ttype = TOKEN_TYPENAME;
 997             lex->tok.constval.t = TYPE_VECTOR;
 998         } else if (!strcmp(v, "for")  ||
 999                  !strcmp(v, "while")  ||
1000                  !strcmp(v, "do")     ||
1001                  !strcmp(v, "if")     ||
1002                  !strcmp(v, "else")   ||
1003                  !strcmp(v, "local")  ||
1004                  !strcmp(v, "return") ||
1005                  !strcmp(v, "not")    ||
1006                  !strcmp(v, "const"))
1007         {
1008             lex->tok.ttype = TOKEN_KEYWORD;
1009         }
1010         else if (opts_standard != COMPILER_QCC)
1011         {
1012             /* other standards reserve these keywords */
1013             if (!strcmp(v, "switch") ||
1014                 !strcmp(v, "struct") ||
1015                 !strcmp(v, "union")  ||
1016                 !strcmp(v, "break")  ||
1017                 !strcmp(v, "continue") ||
1018                 !strcmp(v, "var"))
1019             {
1020                 lex->tok.ttype = TOKEN_KEYWORD;
1021             }
1022         }
1023
1024         return lex->tok.ttype;
1025     }
1026
1027     if (ch == '"')
1028     {
1029         lex->flags.nodigraphs = true;
1030         if (lex->flags.preprocessing)
1031             lex_tokench(lex, ch);
1032         lex->tok.ttype = lex_finish_string(lex, '"');
1033         if (lex->flags.preprocessing)
1034             lex_tokench(lex, ch);
1035         while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST)
1036         {
1037             /* Allow c style "string" "continuation" */
1038             ch = lex_skipwhite(lex);
1039             if (ch != '"') {
1040                 lex_ungetch(lex, ch);
1041                 break;
1042             }
1043
1044             lex->tok.ttype = lex_finish_string(lex, '"');
1045         }
1046         lex->flags.nodigraphs = false;
1047         lex_endtoken(lex);
1048         return lex->tok.ttype;
1049     }
1050
1051     if (ch == '\'')
1052     {
1053         /* we parse character constants like string,
1054          * but return TOKEN_CHARCONST, or a vector type if it fits...
1055          * Likewise actual unescaping has to be done by the parser.
1056          * The difference is we don't allow 'char' 'continuation'.
1057          */
1058         if (lex->flags.preprocessing)
1059             lex_tokench(lex, ch);
1060         lex->tok.ttype = lex_finish_string(lex, '\'');
1061         if (lex->flags.preprocessing)
1062             lex_tokench(lex, ch);
1063         lex_endtoken(lex);
1064
1065          /* It's a vector if we can successfully scan 3 floats */
1066 #ifdef WIN32
1067         if (sscanf_s(lex->tok.value, " %f %f %f ",
1068                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
1069 #else
1070         if (sscanf(lex->tok.value, " %f %f %f ",
1071                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
1072 #endif
1073
1074         {
1075              lex->tok.ttype = TOKEN_VECTORCONST;
1076         }
1077
1078         return lex->tok.ttype;
1079     }
1080
1081     if (isdigit(ch))
1082     {
1083         lex->tok.ttype = lex_finish_digit(lex, ch);
1084         lex_endtoken(lex);
1085         return lex->tok.ttype;
1086     }
1087
1088     lexerror(lex, "unknown token");
1089     return (lex->tok.ttype = TOKEN_ERROR);
1090 }