Merge branch 'master' into cooking
[xonotic/gmqcc.git] / lexer.c
1 /*
2  * Copyright (C) 2012, 2013
3  *     Wolfgang Bumiller
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 <string.h>
24 #include <stdlib.h>
25
26 #include "gmqcc.h"
27 #include "lexer.h"
28 /*
29  * List of Keywords
30  */
31
32 /* original */
33 static const char *keywords_qc[] = {
34     "for", "do", "while",
35     "if", "else",
36     "local",
37     "return",
38     "const"
39 };
40 /* For fte/gmgqcc */
41 static const char *keywords_fg[] = {
42     "switch", "case", "default",
43     "struct", "union",
44     "break", "continue",
45     "typedef",
46     "goto",
47
48     "__builtin_debug_printtype"
49 };
50
51 /*
52  * Lexer code
53  */
54 static char* *lex_filenames;
55
56 static void lexerror(lex_file *lex, const char *fmt, ...)
57 {
58     va_list ap;
59
60     va_start(ap, fmt);
61     if (lex)
62         con_vprintmsg(LVL_ERROR, lex->name, lex->sline, lex->column, "parse error", fmt, ap);
63     else
64         con_vprintmsg(LVL_ERROR, "", 0, 0, "parse error", fmt, ap);
65     va_end(ap);
66 }
67
68 static bool lexwarn(lex_file *lex, int warntype, const char *fmt, ...)
69 {
70     bool      r;
71     lex_ctx_t ctx;
72     va_list   ap;
73
74     ctx.file   = lex->name;
75     ctx.line   = lex->sline;
76     ctx.column = lex->column;
77
78     va_start(ap, fmt);
79     r = vcompile_warning(ctx, warntype, fmt, ap);
80     va_end(ap);
81     return r;
82 }
83
84
85 #if 0
86 token* token_new()
87 {
88     token *tok = (token*)mem_a(sizeof(token));
89     if (!tok)
90         return NULL;
91     memset(tok, 0, sizeof(*tok));
92     return tok;
93 }
94
95 void token_delete(token *self)
96 {
97     if (self->next && self->next->prev == self)
98         self->next->prev = self->prev;
99     if (self->prev && self->prev->next == self)
100         self->prev->next = self->next;
101     MEM_VECTOR_CLEAR(self, value);
102     mem_d(self);
103 }
104
105 token* token_copy(const token *cp)
106 {
107     token* self = token_new();
108     if (!self)
109         return NULL;
110     /* copy the value */
111     self->value_alloc = cp->value_count + 1;
112     self->value_count = cp->value_count;
113     self->value = (char*)mem_a(self->value_alloc);
114     if (!self->value) {
115         mem_d(self);
116         return NULL;
117     }
118     memcpy(self->value, cp->value, cp->value_count);
119     self->value[self->value_alloc-1] = 0;
120
121     /* rest */
122     self->ctx = cp->ctx;
123     self->ttype = cp->ttype;
124     memcpy(&self->constval, &cp->constval, sizeof(self->constval));
125     return self;
126 }
127
128 void token_delete_all(token *t)
129 {
130     token *n;
131
132     do {
133         n = t->next;
134         token_delete(t);
135         t = n;
136     } while(t);
137 }
138
139 token* token_copy_all(const token *cp)
140 {
141     token *cur;
142     token *out;
143
144     out = cur = token_copy(cp);
145     if (!out)
146         return NULL;
147
148     while (cp->next) {
149         cp = cp->next;
150         cur->next = token_copy(cp);
151         if (!cur->next) {
152             token_delete_all(out);
153             return NULL;
154         }
155         cur->next->prev = cur;
156         cur = cur->next;
157     }
158
159     return out;
160 }
161 #else
162 static void lex_token_new(lex_file *lex)
163 {
164 #if 0
165     if (lex->tok)
166         token_delete(lex->tok);
167     lex->tok = token_new();
168 #else
169     if (lex->tok.value)
170         vec_shrinkto(lex->tok.value, 0);
171
172     lex->tok.constval.t  = 0;
173     lex->tok.ctx.line    = lex->sline;
174     lex->tok.ctx.file    = lex->name;
175     lex->tok.ctx.column  = lex->column;
176 #endif
177 }
178 #endif
179
180 lex_file* lex_open(const char *file)
181 {
182     lex_file *lex;
183     FILE *in = fs_file_open(file, "rb");
184
185     if (!in) {
186         lexerror(NULL, "open failed: '%s'\n", file);
187         return NULL;
188     }
189
190     lex = (lex_file*)mem_a(sizeof(*lex));
191     if (!lex) {
192         fs_file_close(in);
193         lexerror(NULL, "out of memory\n");
194         return NULL;
195     }
196
197     memset(lex, 0, sizeof(*lex));
198
199     lex->file    = in;
200     lex->name    = util_strdup(file);
201     lex->line    = 1; /* we start counting at 1 */
202     lex->column  = 0;
203     lex->peekpos = 0;
204     lex->eof     = false;
205
206     vec_push(lex_filenames, lex->name);
207     return lex;
208 }
209
210 lex_file* lex_open_string(const char *str, size_t len, const char *name)
211 {
212     lex_file *lex;
213
214     lex = (lex_file*)mem_a(sizeof(*lex));
215     if (!lex) {
216         lexerror(NULL, "out of memory\n");
217         return NULL;
218     }
219
220     memset(lex, 0, sizeof(*lex));
221
222     lex->file = NULL;
223     lex->open_string        = str;
224     lex->open_string_length = len;
225     lex->open_string_pos    = 0;
226
227     lex->name    = util_strdup(name ? name : "<string-source>");
228     lex->line    = 1; /* we start counting at 1 */
229     lex->peekpos = 0;
230     lex->eof     = false;
231     lex->column  = 0;
232
233     vec_push(lex_filenames, lex->name);
234
235     return lex;
236 }
237
238 void lex_cleanup(void)
239 {
240     size_t i;
241     for (i = 0; i < vec_size(lex_filenames); ++i)
242         mem_d(lex_filenames[i]);
243     vec_free(lex_filenames);
244 }
245
246 void lex_close(lex_file *lex)
247 {
248     size_t i;
249     for (i = 0; i < vec_size(lex->frames); ++i)
250         mem_d(lex->frames[i].name);
251     vec_free(lex->frames);
252
253     if (lex->modelname)
254         vec_free(lex->modelname);
255
256     if (lex->file)
257         fs_file_close(lex->file);
258 #if 0
259     if (lex->tok)
260         token_delete(lex->tok);
261 #else
262     vec_free(lex->tok.value);
263 #endif
264     /* mem_d(lex->name); collected in lex_filenames */
265     mem_d(lex);
266 }
267
268 static int lex_fgetc(lex_file *lex)
269 {
270     if (lex->file) {
271         lex->column++;
272         return fs_file_getc(lex->file);
273     }
274     if (lex->open_string) {
275         if (lex->open_string_pos >= lex->open_string_length)
276             return EOF;
277         lex->column++;
278         return lex->open_string[lex->open_string_pos++];
279     }
280     return EOF;
281 }
282
283 /* Get or put-back data
284  * The following to functions do NOT understand what kind of data they
285  * are working on.
286  * The are merely wrapping get/put in order to count line numbers.
287  */
288 static void lex_ungetch(lex_file *lex, int ch);
289 static int lex_try_trigraph(lex_file *lex, int old)
290 {
291     int c2, c3;
292     c2 = lex_fgetc(lex);
293     if (!lex->push_line && c2 == '\n') {
294         lex->line++;
295         lex->column = 0;
296     }
297
298     if (c2 != '?') {
299         lex_ungetch(lex, c2);
300         return old;
301     }
302
303     c3 = lex_fgetc(lex);
304     if (!lex->push_line && c3 == '\n') {
305         lex->line++;
306         lex->column = 0;
307     }
308
309     switch (c3) {
310         case '=': return '#';
311         case '/': return '\\';
312         case '\'': return '^';
313         case '(': return '[';
314         case ')': return ']';
315         case '!': return '|';
316         case '<': return '{';
317         case '>': return '}';
318         case '-': return '~';
319         default:
320             lex_ungetch(lex, c3);
321             lex_ungetch(lex, c2);
322             return old;
323     }
324 }
325
326 static int lex_try_digraph(lex_file *lex, int ch)
327 {
328     int c2;
329     c2 = lex_fgetc(lex);
330     /* we just used fgetc() so count lines
331      * need to offset a \n the ungetch would recognize
332      */
333     if (!lex->push_line && c2 == '\n')
334         lex->line++;
335     if      (ch == '<' && c2 == ':')
336         return '[';
337     else if (ch == ':' && c2 == '>')
338         return ']';
339     else if (ch == '<' && c2 == '%')
340         return '{';
341     else if (ch == '%' && c2 == '>')
342         return '}';
343     else if (ch == '%' && c2 == ':')
344         return '#';
345     lex_ungetch(lex, c2);
346     return ch;
347 }
348
349 static int lex_getch(lex_file *lex)
350 {
351     int ch;
352
353     if (lex->peekpos) {
354         lex->peekpos--;
355         if (!lex->push_line && lex->peek[lex->peekpos] == '\n') {
356             lex->line++;
357             lex->column = 0;
358         }
359         return lex->peek[lex->peekpos];
360     }
361
362     ch = lex_fgetc(lex);
363     if (!lex->push_line && ch == '\n') {
364         lex->line++;
365         lex->column = 0;
366     }
367     else if (ch == '?')
368         return lex_try_trigraph(lex, ch);
369     else if (!lex->flags.nodigraphs && (ch == '<' || ch == ':' || ch == '%'))
370         return lex_try_digraph(lex, ch);
371     return ch;
372 }
373
374 static void lex_ungetch(lex_file *lex, int ch)
375 {
376     lex->peek[lex->peekpos++] = ch;
377     lex->column--;
378     if (!lex->push_line && ch == '\n') {
379         lex->line--;
380         lex->column = 0;
381     }
382 }
383
384 /* classify characters
385  * some additions to the is*() functions of ctype.h
386  */
387
388 /* Idents are alphanumberic, but they start with alpha or _ */
389 static bool isident_start(int ch)
390 {
391     return util_isalpha(ch) || ch == '_';
392 }
393
394 static bool isident(int ch)
395 {
396     return isident_start(ch) || util_isdigit(ch);
397 }
398
399 /* isxdigit_only is used when we already know it's not a digit
400  * and want to see if it's a hex digit anyway.
401  */
402 static bool isxdigit_only(int ch)
403 {
404     return (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
405 }
406
407 /* Append a character to the token buffer */
408 static void lex_tokench(lex_file *lex, int ch)
409 {
410     vec_push(lex->tok.value, ch);
411 }
412
413 /* Append a trailing null-byte */
414 static void lex_endtoken(lex_file *lex)
415 {
416     vec_push(lex->tok.value, 0);
417     vec_shrinkby(lex->tok.value, 1);
418 }
419
420 static bool lex_try_pragma(lex_file *lex)
421 {
422     int ch;
423     char *pragma  = NULL;
424     char *command = NULL;
425     char *param   = NULL;
426     size_t line;
427
428     if (lex->flags.preprocessing)
429         return false;
430
431     line = lex->line;
432
433     ch = lex_getch(lex);
434     if (ch != '#') {
435         lex_ungetch(lex, ch);
436         return false;
437     }
438
439     for (ch = lex_getch(lex); vec_size(pragma) < 8 && ch >= 'a' && ch <= 'z'; ch = lex_getch(lex))
440         vec_push(pragma, ch);
441     vec_push(pragma, 0);
442
443     if (ch != ' ' || strcmp(pragma, "pragma")) {
444         lex_ungetch(lex, ch);
445         goto unroll;
446     }
447
448     for (ch = lex_getch(lex); vec_size(command) < 32 && ch >= 'a' && ch <= 'z'; ch = lex_getch(lex))
449         vec_push(command, ch);
450     vec_push(command, 0);
451
452     if (ch != '(') {
453         lex_ungetch(lex, ch);
454         goto unroll;
455     }
456
457     for (ch = lex_getch(lex); vec_size(param) < 1024 && ch != ')' && ch != '\n'; ch = lex_getch(lex))
458         vec_push(param, ch);
459     vec_push(param, 0);
460
461     if (ch != ')') {
462         lex_ungetch(lex, ch);
463         goto unroll;
464     }
465
466     if (!strcmp(command, "push")) {
467         if (!strcmp(param, "line")) {
468             lex->push_line++;
469             if (lex->push_line == 1)
470                 --line;
471         }
472         else
473             goto unroll;
474     }
475     else if (!strcmp(command, "pop")) {
476         if (!strcmp(param, "line")) {
477             if (lex->push_line)
478                 lex->push_line--;
479             if (lex->push_line == 0)
480                 --line;
481         }
482         else
483             goto unroll;
484     }
485     else if (!strcmp(command, "file")) {
486         lex->name = util_strdup(param);
487         vec_push(lex_filenames, lex->name);
488     }
489     else if (!strcmp(command, "line")) {
490         line = strtol(param, NULL, 0)-1;
491     }
492     else
493         goto unroll;
494
495     lex->line = line;
496     while (ch != '\n' && ch != EOF)
497         ch = lex_getch(lex);
498     vec_free(command);
499     vec_free(param);
500     vec_free(pragma);
501     return true;
502
503 unroll:
504     if (command) {
505         vec_pop(command);
506         while (vec_size(command)) {
507             lex_ungetch(lex, (unsigned char)vec_last(command));
508             vec_pop(command);
509         }
510         vec_free(command);
511         lex_ungetch(lex, ' ');
512     }
513     if (param) {
514         vec_pop(param);
515         while (vec_size(param)) {
516             lex_ungetch(lex, (unsigned char)vec_last(param));
517             vec_pop(param);
518         }
519         vec_free(param);
520         lex_ungetch(lex, ' ');
521     }
522     if (pragma) {
523         vec_pop(pragma);
524         while (vec_size(pragma)) {
525             lex_ungetch(lex, (unsigned char)vec_last(pragma));
526             vec_pop(pragma);
527         }
528         vec_free(pragma);
529     }
530     lex_ungetch(lex, '#');
531
532     lex->line = line;
533     return false;
534 }
535
536 /* Skip whitespace and comments and return the first
537  * non-white character.
538  * As this makes use of the above getch() ungetch() functions,
539  * we don't need to care at all about line numbering anymore.
540  *
541  * In theory, this function should only be used at the beginning
542  * of lexing, or when we *know* the next character is part of the token.
543  * Otherwise, if the parser throws an error, the linenumber may not be
544  * the line of the error, but the line of the next token AFTER the error.
545  *
546  * This is currently only problematic when using c-like string-continuation,
547  * since comments and whitespaces are allowed between 2 such strings.
548  * Example:
549 printf(   "line one\n"
550 // A comment
551           "A continuation of the previous string"
552 // This line is skipped
553       , foo);
554
555  * In this case, if the parse decides it didn't actually want a string,
556  * and uses lex->line to print an error, it will show the ', foo);' line's
557  * linenumber.
558  *
559  * On the other hand, the parser is supposed to remember the line of the next
560  * token's beginning. In this case we would want skipwhite() to be called
561  * AFTER reading a token, so that the parser, before reading the NEXT token,
562  * doesn't store teh *comment's* linenumber, but the actual token's linenumber.
563  *
564  * THIS SOLUTION
565  *    here is to store the line of the first character after skipping
566  *    the initial whitespace in lex->sline, this happens in lex_do.
567  */
568 static int lex_skipwhite(lex_file *lex, bool hadwhite)
569 {
570     int ch = 0;
571     bool haswhite = hadwhite;
572
573     do
574     {
575         ch = lex_getch(lex);
576         while (ch != EOF && util_isspace(ch)) {
577             if (ch == '\n') {
578                 if (lex_try_pragma(lex))
579                     continue;
580             }
581             if (lex->flags.preprocessing) {
582                 if (ch == '\n') {
583                     /* end-of-line */
584                     /* see if there was whitespace first */
585                     if (haswhite) { /* (vec_size(lex->tok.value)) { */
586                         lex_ungetch(lex, ch);
587                         lex_endtoken(lex);
588                         return TOKEN_WHITE;
589                     }
590                     /* otherwise return EOL */
591                     return TOKEN_EOL;
592                 }
593                 haswhite = true;
594                 lex_tokench(lex, ch);
595             }
596             ch = lex_getch(lex);
597         }
598
599         if (ch == '/') {
600             ch = lex_getch(lex);
601             if (ch == '/')
602             {
603                 /* one line comment */
604                 ch = lex_getch(lex);
605
606                 if (lex->flags.preprocessing) {
607                     haswhite = true;
608                     /*
609                     lex_tokench(lex, '/');
610                     lex_tokench(lex, '/');
611                     */
612                     lex_tokench(lex, ' ');
613                     lex_tokench(lex, ' ');
614                 }
615
616                 while (ch != EOF && ch != '\n') {
617                     if (lex->flags.preprocessing)
618                         lex_tokench(lex, ' '); /* ch); */
619                     ch = lex_getch(lex);
620                 }
621                 if (lex->flags.preprocessing) {
622                     lex_ungetch(lex, '\n');
623                     lex_endtoken(lex);
624                     return TOKEN_WHITE;
625                 }
626                 continue;
627             }
628             if (ch == '*')
629             {
630                 /* multiline comment */
631                 if (lex->flags.preprocessing) {
632                     haswhite = true;
633                     /*
634                     lex_tokench(lex, '/');
635                     lex_tokench(lex, '*');
636                     */
637                     lex_tokench(lex, ' ');
638                     lex_tokench(lex, ' ');
639                 }
640
641                 while (ch != EOF)
642                 {
643                     ch = lex_getch(lex);
644                     if (ch == '*') {
645                         ch = lex_getch(lex);
646                         if (ch == '/') {
647                             if (lex->flags.preprocessing) {
648                                 /*
649                                 lex_tokench(lex, '*');
650                                 lex_tokench(lex, '/');
651                                 */
652                                 lex_tokench(lex, ' ');
653                                 lex_tokench(lex, ' ');
654                             }
655                             break;
656                         }
657                         lex_ungetch(lex, ch);
658                     }
659                     if (lex->flags.preprocessing) {
660                         if (ch == '\n')
661                             lex_tokench(lex, '\n');
662                         else
663                             lex_tokench(lex, ' '); /* ch); */
664                     }
665                 }
666                 ch = ' '; /* cause TRUE in the isspace check */
667                 continue;
668             }
669             /* Otherwise roll back to the slash and break out of the loop */
670             lex_ungetch(lex, ch);
671             ch = '/';
672             break;
673         }
674     } while (ch != EOF && util_isspace(ch));
675
676     if (haswhite) {
677         lex_endtoken(lex);
678         lex_ungetch(lex, ch);
679         return TOKEN_WHITE;
680     }
681     return ch;
682 }
683
684 /* Get a token */
685 static bool GMQCC_WARN lex_finish_ident(lex_file *lex)
686 {
687     int ch;
688
689     ch = lex_getch(lex);
690     while (ch != EOF && isident(ch))
691     {
692         lex_tokench(lex, ch);
693         ch = lex_getch(lex);
694     }
695
696     /* last ch was not an ident ch: */
697     lex_ungetch(lex, ch);
698
699     return true;
700 }
701
702 /* read one ident for the frame list */
703 static int lex_parse_frame(lex_file *lex)
704 {
705     int ch;
706
707     lex_token_new(lex);
708
709     ch = lex_getch(lex);
710     while (ch != EOF && ch != '\n' && util_isspace(ch))
711         ch = lex_getch(lex);
712
713     if (ch == '\n')
714         return 1;
715
716     if (!isident_start(ch)) {
717         lexerror(lex, "invalid framename, must start with one of a-z or _, got %c", ch);
718         return -1;
719     }
720
721     lex_tokench(lex, ch);
722     if (!lex_finish_ident(lex))
723         return -1;
724     lex_endtoken(lex);
725     return 0;
726 }
727
728 /* read a list of $frames */
729 static bool lex_finish_frames(lex_file *lex)
730 {
731     do {
732         size_t i;
733         int    rc;
734         frame_macro m;
735
736         rc = lex_parse_frame(lex);
737         if (rc > 0) /* end of line */
738             return true;
739         if (rc < 0) /* error */
740             return false;
741
742         for (i = 0; i < vec_size(lex->frames); ++i) {
743             if (!strcmp(lex->tok.value, lex->frames[i].name)) {
744                 lex->frames[i].value = lex->framevalue++;
745                 if (lexwarn(lex, WARN_FRAME_MACROS, "duplicate frame macro defined: `%s`", lex->tok.value))
746                     return false;
747                 break;
748             }
749         }
750         if (i < vec_size(lex->frames))
751             continue;
752
753         m.value = lex->framevalue++;
754         m.name = util_strdup(lex->tok.value);
755         vec_shrinkto(lex->tok.value, 0);
756         vec_push(lex->frames, m);
757     } while (true);
758
759     return false;
760 }
761
762 static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
763 {
764     uchar_t chr;
765     int ch = 0;
766     int nextch;
767     bool hex;
768     char u8buf[8]; /* way more than enough */
769     int  u8len, uc;
770
771     while (ch != EOF)
772     {
773         ch = lex_getch(lex);
774         if (ch == quote)
775             return TOKEN_STRINGCONST;
776
777         if (lex->flags.preprocessing && ch == '\\') {
778             lex_tokench(lex, ch);
779             ch = lex_getch(lex);
780             if (ch == EOF) {
781                 lexerror(lex, "unexpected end of file");
782                 lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
783                 return (lex->tok.ttype = TOKEN_ERROR);
784             }
785             lex_tokench(lex, ch);
786         }
787         else if (ch == '\\') {
788             ch = lex_getch(lex);
789             if (ch == EOF) {
790                 lexerror(lex, "unexpected end of file");
791                 lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
792                 return (lex->tok.ttype = TOKEN_ERROR);
793             }
794
795             switch (ch) {
796             case '\\': break;
797             case '\'': break;
798             case '"':  break;
799             case 'a':  ch = '\a'; break;
800             case 'b':  ch = '\b'; break;
801             case 'r':  ch = '\r'; break;
802             case 'n':  ch = '\n'; break;
803             case 't':  ch = '\t'; break;
804             case 'f':  ch = '\f'; break;
805             case 'v':  ch = '\v'; break;
806             case 'x':
807             case 'X':
808                 /* same procedure as in fteqcc */
809                 ch = 0;
810                 nextch = lex_getch(lex);
811                 if      (nextch >= '0' && nextch <= '9')
812                     ch += nextch - '0';
813                 else if (nextch >= 'a' && nextch <= 'f')
814                     ch += nextch - 'a' + 10;
815                 else if (nextch >= 'A' && nextch <= 'F')
816                     ch += nextch - 'A' + 10;
817                 else {
818                     lexerror(lex, "bad character code");
819                     lex_ungetch(lex, nextch);
820                     return (lex->tok.ttype = TOKEN_ERROR);
821                 }
822
823                 ch *= 0x10;
824                 nextch = lex_getch(lex);
825                 if      (nextch >= '0' && nextch <= '9')
826                     ch += nextch - '0';
827                 else if (nextch >= 'a' && nextch <= 'f')
828                     ch += nextch - 'a' + 10;
829                 else if (nextch >= 'A' && nextch <= 'F')
830                     ch += nextch - 'A' + 10;
831                 else {
832                     lexerror(lex, "bad character code");
833                     lex_ungetch(lex, nextch);
834                     return (lex->tok.ttype = TOKEN_ERROR);
835                 }
836                 break;
837
838             /* fteqcc support */
839             case '0': case '1': case '2': case '3':
840             case '4': case '5': case '6': case '7':
841             case '8': case '9':
842                 ch = 18 + ch - '0';
843                 break;
844             case '<':  ch = 29; break;
845             case '-':  ch = 30; break;
846             case '>':  ch = 31; break;
847             case '[':  ch = 16; break;
848             case ']':  ch = 17; break;
849             case '{':
850                 chr = 0;
851                 nextch = lex_getch(lex);
852                 hex = (nextch == 'x');
853                 if (!hex)
854                     lex_ungetch(lex, nextch);
855                 for (nextch = lex_getch(lex); nextch != '}'; nextch = lex_getch(lex)) {
856                     if (!hex) {
857                         if (nextch >= '0' && nextch <= '9')
858                             chr = chr * 10 + nextch - '0';
859                         else {
860                             lexerror(lex, "bad character code");
861                             return (lex->tok.ttype = TOKEN_ERROR);
862                         }
863                     } else {
864                         if (nextch >= '0' && nextch <= '9')
865                             chr = chr * 0x10 + nextch - '0';
866                         else if (nextch >= 'a' && nextch <= 'f')
867                             chr = chr * 0x10 + nextch - 'a' + 10;
868                         else if (nextch >= 'A' && nextch <= 'F')
869                             chr = chr * 0x10 + nextch - 'A' + 10;
870                         else {
871                             lexerror(lex, "bad character code");
872                             return (lex->tok.ttype = TOKEN_ERROR);
873                         }
874                     }
875                     if (chr > 0x10FFFF || (!OPTS_FLAG(UTF8) && chr > 255))
876                     {
877                         lexerror(lex, "character code out of range");
878                         return (lex->tok.ttype = TOKEN_ERROR);
879                     }
880                 }
881                 if (OPTS_FLAG(UTF8) && chr >= 128) {
882                     u8len = u8_fromchar(chr, u8buf, sizeof(u8buf));
883                     if (!u8len)
884                         ch = 0;
885                     else {
886                         --u8len;
887                         lex->column += u8len;
888                         for (uc = 0; uc < u8len; ++uc)
889                             lex_tokench(lex, u8buf[uc]);
890                         /* the last character will be inserted with the tokench() call
891                          * below the switch
892                          */
893                         ch = u8buf[uc];
894                     }
895                 }
896                 else
897                     ch = chr;
898                 break;
899             case '\n':  ch = '\n'; break;
900
901             default:
902                 lexwarn(lex, WARN_UNKNOWN_CONTROL_SEQUENCE, "unrecognized control sequence: \\%c", ch);
903                 /* so we just add the character plus backslash no matter what it actually is */
904                 lex_tokench(lex, '\\');
905             }
906             /* add the character finally */
907             lex_tokench(lex, ch);
908         }
909         else
910             lex_tokench(lex, ch);
911     }
912     lexerror(lex, "unexpected end of file within string constant");
913     lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
914     return (lex->tok.ttype = TOKEN_ERROR);
915 }
916
917 static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
918 {
919     bool ishex = false;
920
921     int  ch = lastch;
922
923     /* parse a number... */
924     if (ch == '.')
925         lex->tok.ttype = TOKEN_FLOATCONST;
926     else
927         lex->tok.ttype = TOKEN_INTCONST;
928
929     lex_tokench(lex, ch);
930
931     ch = lex_getch(lex);
932     if (ch != '.' && !util_isdigit(ch))
933     {
934         if (lastch != '0' || ch != 'x')
935         {
936             /* end of the number or EOF */
937             lex_ungetch(lex, ch);
938             lex_endtoken(lex);
939
940             lex->tok.constval.i = lastch - '0';
941             return lex->tok.ttype;
942         }
943
944         ishex = true;
945     }
946
947     /* EOF would have been caught above */
948
949     if (ch != '.')
950     {
951         lex_tokench(lex, ch);
952         ch = lex_getch(lex);
953         while (util_isdigit(ch) || (ishex && isxdigit_only(ch)))
954         {
955             lex_tokench(lex, ch);
956             ch = lex_getch(lex);
957         }
958     }
959     /* NOT else, '.' can come from above as well */
960     if (lex->tok.ttype != TOKEN_FLOATCONST && ch == '.' && !ishex)
961     {
962         /* Allow floating comma in non-hex mode */
963         lex->tok.ttype = TOKEN_FLOATCONST;
964         lex_tokench(lex, ch);
965
966         /* continue digits-only */
967         ch = lex_getch(lex);
968         while (util_isdigit(ch))
969         {
970             lex_tokench(lex, ch);
971             ch = lex_getch(lex);
972         }
973     }
974     /* put back the last character */
975     /* but do not put back the trailing 'f' or a float */
976     if (lex->tok.ttype == TOKEN_FLOATCONST && ch == 'f')
977         ch = lex_getch(lex);
978
979     /* generally we don't want words to follow numbers: */
980     if (isident(ch)) {
981         lexerror(lex, "unexpected trailing characters after number");
982         return (lex->tok.ttype = TOKEN_ERROR);
983     }
984     lex_ungetch(lex, ch);
985
986     lex_endtoken(lex);
987     if (lex->tok.ttype == TOKEN_FLOATCONST)
988         lex->tok.constval.f = strtod(lex->tok.value, NULL);
989     else
990         lex->tok.constval.i = strtol(lex->tok.value, NULL, 0);
991     return lex->tok.ttype;
992 }
993
994 int lex_do(lex_file *lex)
995 {
996     int ch, nextch, thirdch;
997     bool hadwhite = false;
998
999     lex_token_new(lex);
1000 #if 0
1001     if (!lex->tok)
1002         return TOKEN_FATAL;
1003 #endif
1004
1005     while (true) {
1006         ch = lex_skipwhite(lex, hadwhite);
1007         hadwhite = true;
1008         if (!lex->flags.mergelines || ch != '\\')
1009             break;
1010         ch = lex_getch(lex);
1011         if (ch == '\r')
1012             ch = lex_getch(lex);
1013         if (ch != '\n') {
1014             lex_ungetch(lex, ch);
1015             ch = '\\';
1016             break;
1017         }
1018         /* we reached a linemerge */
1019         lex_tokench(lex, '\n');
1020         continue;
1021     }
1022
1023     if (lex->flags.preprocessing && (ch == TOKEN_WHITE || ch == TOKEN_EOL || ch == TOKEN_FATAL)) {
1024         return (lex->tok.ttype = ch);
1025     }
1026
1027     lex->sline = lex->line;
1028     lex->tok.ctx.line = lex->sline;
1029     lex->tok.ctx.file = lex->name;
1030
1031     if (lex->eof)
1032         return (lex->tok.ttype = TOKEN_FATAL);
1033
1034     if (ch == EOF) {
1035         lex->eof = true;
1036         return (lex->tok.ttype = TOKEN_EOF);
1037     }
1038
1039     /* modelgen / spiritgen commands */
1040     if (ch == '$' && !lex->flags.preprocessing) {
1041         const char *v;
1042         size_t frame;
1043
1044         ch = lex_getch(lex);
1045         if (!isident_start(ch)) {
1046             lexerror(lex, "hanging '$' modelgen/spritegen command line");
1047             return lex_do(lex);
1048         }
1049         lex_tokench(lex, ch);
1050         if (!lex_finish_ident(lex))
1051             return (lex->tok.ttype = TOKEN_ERROR);
1052         lex_endtoken(lex);
1053         /* skip the known commands */
1054         v = lex->tok.value;
1055
1056         if (!strcmp(v, "frame") || !strcmp(v, "framesave"))
1057         {
1058             /* frame/framesave command works like an enum
1059              * similar to fteqcc we handle this in the lexer.
1060              * The reason for this is that it is sensitive to newlines,
1061              * which the parser is unaware of
1062              */
1063             if (!lex_finish_frames(lex))
1064                  return (lex->tok.ttype = TOKEN_ERROR);
1065             return lex_do(lex);
1066         }
1067
1068         if (!strcmp(v, "framevalue"))
1069         {
1070             ch = lex_getch(lex);
1071             while (ch != EOF && util_isspace(ch) && ch != '\n')
1072                 ch = lex_getch(lex);
1073
1074             if (!util_isdigit(ch)) {
1075                 lexerror(lex, "$framevalue requires an integer parameter");
1076                 return lex_do(lex);
1077             }
1078
1079             lex_token_new(lex);
1080             lex->tok.ttype = lex_finish_digit(lex, ch);
1081             lex_endtoken(lex);
1082             if (lex->tok.ttype != TOKEN_INTCONST) {
1083                 lexerror(lex, "$framevalue requires an integer parameter");
1084                 return lex_do(lex);
1085             }
1086             lex->framevalue = lex->tok.constval.i;
1087             return lex_do(lex);
1088         }
1089
1090         if (!strcmp(v, "framerestore"))
1091         {
1092             int rc;
1093
1094             lex_token_new(lex);
1095
1096             rc = lex_parse_frame(lex);
1097
1098             if (rc > 0) {
1099                 lexerror(lex, "$framerestore requires a framename parameter");
1100                 return lex_do(lex);
1101             }
1102             if (rc < 0)
1103                 return (lex->tok.ttype = TOKEN_FATAL);
1104
1105             v = lex->tok.value;
1106             for (frame = 0; frame < vec_size(lex->frames); ++frame) {
1107                 if (!strcmp(v, lex->frames[frame].name)) {
1108                     lex->framevalue = lex->frames[frame].value;
1109                     return lex_do(lex);
1110                 }
1111             }
1112             lexerror(lex, "unknown framename `%s`", v);
1113             return lex_do(lex);
1114         }
1115
1116         if (!strcmp(v, "modelname"))
1117         {
1118             int rc;
1119
1120             lex_token_new(lex);
1121
1122             rc = lex_parse_frame(lex);
1123
1124             if (rc > 0) {
1125                 lexerror(lex, "$modelname requires a parameter");
1126                 return lex_do(lex);
1127             }
1128             if (rc < 0)
1129                 return (lex->tok.ttype = TOKEN_FATAL);
1130
1131             if (lex->modelname) {
1132                 frame_macro m;
1133                 m.value = lex->framevalue;
1134                 m.name = lex->modelname;
1135                 lex->modelname = NULL;
1136                 vec_push(lex->frames, m);
1137             }
1138             lex->modelname = lex->tok.value;
1139             lex->tok.value = NULL;
1140             return lex_do(lex);
1141         }
1142
1143         if (!strcmp(v, "flush"))
1144         {
1145             size_t fi;
1146             for (fi = 0; fi < vec_size(lex->frames); ++fi)
1147                 mem_d(lex->frames[fi].name);
1148             vec_free(lex->frames);
1149             /* skip line (fteqcc does it too) */
1150             ch = lex_getch(lex);
1151             while (ch != EOF && ch != '\n')
1152                 ch = lex_getch(lex);
1153             return lex_do(lex);
1154         }
1155
1156         if (!strcmp(v, "cd") ||
1157             !strcmp(v, "origin") ||
1158             !strcmp(v, "base") ||
1159             !strcmp(v, "flags") ||
1160             !strcmp(v, "scale") ||
1161             !strcmp(v, "skin"))
1162         {
1163             /* skip line */
1164             ch = lex_getch(lex);
1165             while (ch != EOF && ch != '\n')
1166                 ch = lex_getch(lex);
1167             return lex_do(lex);
1168         }
1169
1170         for (frame = 0; frame < vec_size(lex->frames); ++frame) {
1171             if (!strcmp(v, lex->frames[frame].name)) {
1172                 lex->tok.constval.i = lex->frames[frame].value;
1173                 return (lex->tok.ttype = TOKEN_INTCONST);
1174             }
1175         }
1176
1177         lexerror(lex, "invalid frame macro");
1178         return lex_do(lex);
1179     }
1180
1181     /* single-character tokens */
1182     switch (ch)
1183     {
1184         case '[':
1185             nextch = lex_getch(lex);
1186             if (nextch == '[') {
1187                 lex_tokench(lex, ch);
1188                 lex_tokench(lex, nextch);
1189                 lex_endtoken(lex);
1190                 return (lex->tok.ttype = TOKEN_ATTRIBUTE_OPEN);
1191             }
1192             lex_ungetch(lex, nextch);
1193             /* FALL THROUGH */
1194         case '(':
1195         case ':':
1196         case '?':
1197             lex_tokench(lex, ch);
1198             lex_endtoken(lex);
1199             if (lex->flags.noops)
1200                 return (lex->tok.ttype = ch);
1201             else
1202                 return (lex->tok.ttype = TOKEN_OPERATOR);
1203
1204         case ']':
1205             if (lex->flags.noops) {
1206                 nextch = lex_getch(lex);
1207                 if (nextch == ']') {
1208                     lex_tokench(lex, ch);
1209                     lex_tokench(lex, nextch);
1210                     lex_endtoken(lex);
1211                     return (lex->tok.ttype = TOKEN_ATTRIBUTE_CLOSE);
1212                 }
1213                 lex_ungetch(lex, nextch);
1214             }
1215             /* FALL THROUGH */
1216         case ')':
1217         case ';':
1218         case '{':
1219         case '}':
1220
1221         case '#':
1222             lex_tokench(lex, ch);
1223             lex_endtoken(lex);
1224             return (lex->tok.ttype = ch);
1225         default:
1226             break;
1227     }
1228
1229     if (ch == '.') {
1230         nextch = lex_getch(lex);
1231         /* digits starting with a dot */
1232         if (util_isdigit(nextch)) {
1233             lex_ungetch(lex, nextch);
1234             lex->tok.ttype = lex_finish_digit(lex, ch);
1235             lex_endtoken(lex);
1236             return lex->tok.ttype;
1237         }
1238         lex_ungetch(lex, nextch);
1239     }
1240
1241     if (lex->flags.noops)
1242     {
1243         /* Detect characters early which are normally
1244          * operators OR PART of an operator.
1245          */
1246         switch (ch)
1247         {
1248             /*
1249             case '+':
1250             case '-':
1251             */
1252             case '*':
1253             case '/':
1254             case '<':
1255             case '>':
1256             case '=':
1257             case '&':
1258             case '|':
1259             case '^':
1260             case '~':
1261             case ',':
1262             case '!':
1263                 lex_tokench(lex, ch);
1264                 lex_endtoken(lex);
1265                 return (lex->tok.ttype = ch);
1266             default:
1267                 break;
1268         }
1269     }
1270
1271     if (ch == '.')
1272     {
1273         lex_tokench(lex, ch);
1274         /* peak ahead once */
1275         nextch = lex_getch(lex);
1276         if (nextch != '.') {
1277             lex_ungetch(lex, nextch);
1278             lex_endtoken(lex);
1279             if (lex->flags.noops)
1280                 return (lex->tok.ttype = ch);
1281             else
1282                 return (lex->tok.ttype = TOKEN_OPERATOR);
1283         }
1284         /* peak ahead again */
1285         nextch = lex_getch(lex);
1286         if (nextch != '.') {
1287             lex_ungetch(lex, nextch);
1288             lex_ungetch(lex, '.');
1289             lex_endtoken(lex);
1290             if (lex->flags.noops)
1291                 return (lex->tok.ttype = ch);
1292             else
1293                 return (lex->tok.ttype = TOKEN_OPERATOR);
1294         }
1295         /* fill the token to be "..." */
1296         lex_tokench(lex, ch);
1297         lex_tokench(lex, ch);
1298         lex_endtoken(lex);
1299         return (lex->tok.ttype = TOKEN_DOTS);
1300     }
1301
1302     if (ch == ',' || ch == '.') {
1303         lex_tokench(lex, ch);
1304         lex_endtoken(lex);
1305         return (lex->tok.ttype = TOKEN_OPERATOR);
1306     }
1307
1308     if (ch == '+' || ch == '-' || /* ++, --, +=, -=  and -> as well! */
1309         ch == '>' || ch == '<' || /* <<, >>, <=, >=  and >< as well! */
1310         ch == '=' || ch == '!' || /* <=>, ==, !=                     */
1311         ch == '&' || ch == '|' || /* &&, ||, &=, |=                  */
1312         ch == '~' || ch == '^'    /* ~=, ~, ^                        */
1313     )  {
1314         lex_tokench(lex, ch);
1315
1316         nextch = lex_getch(lex);
1317         if ((nextch == '=' && ch != '<') ||
1318             (nextch == ch  && ch != '!') ||
1319             (nextch == '<' && ch == '>')) {
1320             lex_tokench(lex, nextch);
1321         } else if (ch == '<' && nextch == '=') {
1322             lex_tokench(lex, nextch);
1323             if ((thirdch = lex_getch(lex)) == '>')
1324                 lex_tokench(lex, thirdch);
1325             else
1326                 lex_ungetch(lex, thirdch);
1327
1328         } else if (ch == '-' && nextch == '>') {
1329             lex_tokench(lex, nextch);
1330         } else if (ch == '&' && nextch == '~') {
1331             thirdch = lex_getch(lex);
1332             if (thirdch != '=') {
1333                 lex_ungetch(lex, thirdch);
1334                 lex_ungetch(lex, nextch);
1335             }
1336             else {
1337                 lex_tokench(lex, nextch);
1338                 lex_tokench(lex, thirdch);
1339             }
1340         }
1341         else if (lex->flags.preprocessing &&
1342                  ch == '-' && util_isdigit(nextch))
1343         {
1344             lex->tok.ttype = lex_finish_digit(lex, nextch);
1345             if (lex->tok.ttype == TOKEN_INTCONST)
1346                 lex->tok.constval.i = -lex->tok.constval.i;
1347             else
1348                 lex->tok.constval.f = -lex->tok.constval.f;
1349             lex_endtoken(lex);
1350             return lex->tok.ttype;
1351         } else {
1352             lex_ungetch(lex, nextch);
1353         }
1354
1355         lex_endtoken(lex);
1356         return (lex->tok.ttype = TOKEN_OPERATOR);
1357     }
1358
1359     /*
1360     if (ch == '^' || ch == '~' || ch == '!')
1361     {
1362         lex_tokench(lex, ch);
1363         lex_endtoken(lex);
1364         return (lex->tok.ttype = TOKEN_OPERATOR);
1365     }
1366     */
1367
1368     if (ch == '*' || ch == '/') /* *=, /= */
1369     {
1370         lex_tokench(lex, ch);
1371
1372         nextch = lex_getch(lex);
1373         if (nextch == '=' || nextch == '*') {
1374             lex_tokench(lex, nextch);
1375         } else
1376             lex_ungetch(lex, nextch);
1377
1378         lex_endtoken(lex);
1379         return (lex->tok.ttype = TOKEN_OPERATOR);
1380     }
1381
1382     if (ch == '%') {
1383         lex_tokench(lex, ch);
1384         lex_endtoken(lex);
1385         return (lex->tok.ttype = TOKEN_OPERATOR);
1386     }
1387
1388     if (isident_start(ch))
1389     {
1390         const char *v;
1391
1392         lex_tokench(lex, ch);
1393         if (!lex_finish_ident(lex)) {
1394             /* error? */
1395             return (lex->tok.ttype = TOKEN_ERROR);
1396         }
1397         lex_endtoken(lex);
1398         lex->tok.ttype = TOKEN_IDENT;
1399
1400         v = lex->tok.value;
1401         if (!strcmp(v, "void")) {
1402             lex->tok.ttype = TOKEN_TYPENAME;
1403             lex->tok.constval.t = TYPE_VOID;
1404         } else if (!strcmp(v, "int")) {
1405             lex->tok.ttype = TOKEN_TYPENAME;
1406             lex->tok.constval.t = TYPE_INTEGER;
1407         } else if (!strcmp(v, "float")) {
1408             lex->tok.ttype = TOKEN_TYPENAME;
1409             lex->tok.constval.t = TYPE_FLOAT;
1410         } else if (!strcmp(v, "string")) {
1411             lex->tok.ttype = TOKEN_TYPENAME;
1412             lex->tok.constval.t = TYPE_STRING;
1413         } else if (!strcmp(v, "entity")) {
1414             lex->tok.ttype = TOKEN_TYPENAME;
1415             lex->tok.constval.t = TYPE_ENTITY;
1416         } else if (!strcmp(v, "vector")) {
1417             lex->tok.ttype = TOKEN_TYPENAME;
1418             lex->tok.constval.t = TYPE_VECTOR;
1419         } else {
1420             size_t kw;
1421             for (kw = 0; kw < GMQCC_ARRAY_COUNT(keywords_qc); ++kw) {
1422                 if (!strcmp(v, keywords_qc[kw]))
1423                     return (lex->tok.ttype = TOKEN_KEYWORD);
1424             }
1425             if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_QCC) {
1426                 for (kw = 0; kw < GMQCC_ARRAY_COUNT(keywords_fg); ++kw) {
1427                     if (!strcmp(v, keywords_fg[kw]))
1428                         return (lex->tok.ttype = TOKEN_KEYWORD);
1429                 }
1430             }
1431         }
1432
1433         return lex->tok.ttype;
1434     }
1435
1436     if (ch == '"')
1437     {
1438         lex->flags.nodigraphs = true;
1439         if (lex->flags.preprocessing)
1440             lex_tokench(lex, ch);
1441         lex->tok.ttype = lex_finish_string(lex, '"');
1442         if (lex->flags.preprocessing)
1443             lex_tokench(lex, ch);
1444         while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST)
1445         {
1446             /* Allow c style "string" "continuation" */
1447             ch = lex_skipwhite(lex, false);
1448             if (ch != '"') {
1449                 lex_ungetch(lex, ch);
1450                 break;
1451             }
1452
1453             lex->tok.ttype = lex_finish_string(lex, '"');
1454         }
1455         lex->flags.nodigraphs = false;
1456         lex_endtoken(lex);
1457         return lex->tok.ttype;
1458     }
1459
1460     if (ch == '\'')
1461     {
1462         /* we parse character constants like string,
1463          * but return TOKEN_CHARCONST, or a vector type if it fits...
1464          * Likewise actual unescaping has to be done by the parser.
1465          * The difference is we don't allow 'char' 'continuation'.
1466          */
1467         if (lex->flags.preprocessing)
1468             lex_tokench(lex, ch);
1469         lex->tok.ttype = lex_finish_string(lex, '\'');
1470         if (lex->flags.preprocessing)
1471             lex_tokench(lex, ch);
1472         lex_endtoken(lex);
1473
1474         lex->tok.ttype = TOKEN_CHARCONST;
1475          /* It's a vector if we can successfully scan 3 floats */
1476 #ifdef _MSC_VER
1477         if (sscanf_s(lex->tok.value, " %f %f %f ",
1478                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
1479 #else
1480         if (sscanf(lex->tok.value, " %f %f %f ",
1481                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
1482 #endif
1483
1484         {
1485              lex->tok.ttype = TOKEN_VECTORCONST;
1486         }
1487         else
1488         {
1489             if (!lex->flags.preprocessing && strlen(lex->tok.value) > 1) {
1490                 uchar_t u8char;
1491                 /* check for a valid utf8 character */
1492                 if (!OPTS_FLAG(UTF8) || !u8_analyze(lex->tok.value, NULL, NULL, &u8char, 8)) {
1493                     if (lexwarn(lex, WARN_MULTIBYTE_CHARACTER,
1494                                 ( OPTS_FLAG(UTF8) ? "invalid multibyte character sequence `%s`"
1495                                                   : "multibyte character: `%s`" ),
1496                                 lex->tok.value))
1497                         return (lex->tok.ttype = TOKEN_ERROR);
1498                 }
1499                 else
1500                     lex->tok.constval.i = u8char;
1501             }
1502             else
1503                 lex->tok.constval.i = lex->tok.value[0];
1504         }
1505
1506         return lex->tok.ttype;
1507     }
1508
1509     if (util_isdigit(ch))
1510     {
1511         lex->tok.ttype = lex_finish_digit(lex, ch);
1512         lex_endtoken(lex);
1513         return lex->tok.ttype;
1514     }
1515
1516     if (lex->flags.preprocessing) {
1517         lex_tokench(lex, ch);
1518         lex_endtoken(lex);
1519         return (lex->tok.ttype = ch);
1520     }
1521
1522     lexerror(lex, "unknown token: `%c`", ch);
1523     return (lex->tok.ttype = TOKEN_ERROR);
1524 }