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