Make it a function

[xonotic/gmqcc.git] / lexer.c

diff --git a/lexer.c b/lexer.c
index e2cf8039fd628245a15d4ac0738775500f6cf4e1..1a8c17a1f3e414928737277fb7a5a59b76e1e8da 100644 (file)
--- a/lexer.c
+++ b/lexer.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013, 2014

  *     Wolfgang Bumiller
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  *     Wolfgang Bumiller
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of


@@ -20,10 +20,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */

-#include <stdio.h>
-#include <stdlib.h>

 #include <string.h>
 #include <string.h>

-#include <stdarg.h>
+#include <stdlib.h>

 
 #include "gmqcc.h"
 #include "lexer.h"
 
 #include "gmqcc.h"
 #include "lexer.h"


@@ -40,8 +38,6 @@ static const char *keywords_qc[] = {
     "return",
     "const"
 };
     "return",
     "const"
 };

-static size_t num_keywords_qc = sizeof(keywords_qc) / sizeof(keywords_qc[0]);
-

 /* For fte/gmgqcc */
 static const char *keywords_fg[] = {
     "switch", "case", "default",
 /* For fte/gmgqcc */
 static const char *keywords_fg[] = {
     "switch", "case", "default",


@@ -52,142 +48,59 @@ static const char *keywords_fg[] = {
 
     "__builtin_debug_printtype"
 };
 
     "__builtin_debug_printtype"
 };

-static size_t num_keywords_fg = sizeof(keywords_fg) / sizeof(keywords_fg[0]);

 
 /*
  * Lexer code
  */
 
 /*
  * Lexer code
  */

+static char* *lex_filenames;

 
 

-char* *lex_filenames;
-
-void lexerror(lex_file *lex, const char *fmt, ...)
+static void lexerror(lex_file *lex, const char *fmt, ...)

 {
     va_list ap;
 
     va_start(ap, fmt);
     if (lex)
 {
     va_list ap;
 
     va_start(ap, fmt);
     if (lex)

-        con_vprintmsg(LVL_ERROR, lex->name, lex->sline, "parse error", fmt, ap);
+        con_vprintmsg(LVL_ERROR, lex->name, lex->sline, lex->column, "parse error", fmt, ap);

     else
     else

-        con_vprintmsg(LVL_ERROR, "", 0, "parse error", fmt, ap);
+        con_vprintmsg(LVL_ERROR, "", 0, 0, "parse error", fmt, ap);

     va_end(ap);
 }
 
     va_end(ap);
 }
 

-bool lexwarn(lex_file *lex, int warntype, const char *fmt, ...)
+static bool lexwarn(lex_file *lex, int warntype, const char *fmt, ...)

 {
 {

-    va_list ap;
-    int lvl = LVL_WARNING;
+    bool      r;
+    lex_ctx_t ctx;
+    va_list   ap;

 
 

-    if (!OPTS_WARN(warntype))
-        return false;
-
-    if (opts_werror)
-        lvl = LVL_ERROR;
+    ctx.file   = lex->name;
+    ctx.line   = lex->sline;
+    ctx.column = lex->column;

 
     va_start(ap, fmt);
 
     va_start(ap, fmt);

-    con_vprintmsg(lvl, lex->name, lex->sline, "warning", fmt, ap);
+    r = vcompile_warning(ctx, warntype, fmt, ap);

     va_end(ap);
     va_end(ap);

-
-    return opts_werror;
-}
-
-
-#if 0
-token* token_new()
-{
-    token *tok = (token*)mem_a(sizeof(token));
-    if (!tok)
-        return NULL;
-    memset(tok, 0, sizeof(*tok));
-    return tok;
-}
-
-void token_delete(token *self)
-{
-    if (self->next && self->next->prev == self)
-        self->next->prev = self->prev;
-    if (self->prev && self->prev->next == self)
-        self->prev->next = self->next;
-    MEM_VECTOR_CLEAR(self, value);
-    mem_d(self);
-}
-
-token* token_copy(const token *cp)
-{
-    token* self = token_new();
-    if (!self)
-        return NULL;
-    /* copy the value */
-    self->value_alloc = cp->value_count + 1;
-    self->value_count = cp->value_count;
-    self->value = (char*)mem_a(self->value_alloc);
-    if (!self->value) {
-        mem_d(self);
-        return NULL;
-    }
-    memcpy(self->value, cp->value, cp->value_count);
-    self->value[self->value_alloc-1] = 0;
-
-    /* rest */
-    self->ctx = cp->ctx;
-    self->ttype = cp->ttype;
-    memcpy(&self->constval, &cp->constval, sizeof(self->constval));
-    return self;
+    return r;

 }
 
 }
 

-void token_delete_all(token *t)
-{
-    token *n;
-
-    do {
-        n = t->next;
-        token_delete(t);
-        t = n;
-    } while(t);
-}
-
-token* token_copy_all(const token *cp)
-{
-    token *cur;
-    token *out;
-
-    out = cur = token_copy(cp);
-    if (!out)
-        return NULL;
-
-    while (cp->next) {
-        cp = cp->next;
-        cur->next = token_copy(cp);
-        if (!cur->next) {
-            token_delete_all(out);
-            return NULL;
-        }
-        cur->next->prev = cur;
-        cur = cur->next;
-    }
-
-    return out;
-}
-#else

 static void lex_token_new(lex_file *lex)
 {
 static void lex_token_new(lex_file *lex)
 {

-#if 0
-    if (lex->tok)
-        token_delete(lex->tok);
-    lex->tok = token_new();
-#else

     if (lex->tok.value)
         vec_shrinkto(lex->tok.value, 0);
     if (lex->tok.value)
         vec_shrinkto(lex->tok.value, 0);

+

     lex->tok.constval.t  = 0;
     lex->tok.constval.t  = 0;

-    lex->tok.ctx.line = lex->sline;
-    lex->tok.ctx.file = lex->name;
-#endif
+    lex->tok.ctx.line    = lex->sline;
+    lex->tok.ctx.file    = lex->name;
+    lex->tok.ctx.column  = lex->column;

 }
 }

-#endif
+
+static void lex_ungetch(lex_file *lex, int ch);
+static int lex_getch(lex_file *lex);

 
 lex_file* lex_open(const char *file)
 {
 
 lex_file* lex_open(const char *file)
 {

-    lex_file *lex;
-    FILE *in = util_fopen(file, "rb");
+    lex_file  *lex;
+    fs_file_t *in = fs_file_open(file, "rb");
+    uint32_t   read;

 
     if (!in) {
         lexerror(NULL, "open failed: '%s'\n", file);
 
     if (!in) {
         lexerror(NULL, "open failed: '%s'\n", file);


@@ -196,19 +109,32 @@ lex_file* lex_open(const char *file)
 
     lex = (lex_file*)mem_a(sizeof(*lex));
     if (!lex) {
 
     lex = (lex_file*)mem_a(sizeof(*lex));
     if (!lex) {

-        fclose(in);
+        fs_file_close(in);

         lexerror(NULL, "out of memory\n");
         return NULL;
     }
 
     memset(lex, 0, sizeof(*lex));
 
         lexerror(NULL, "out of memory\n");
         return NULL;
     }
 
     memset(lex, 0, sizeof(*lex));
 

-    lex->file = in;
-    lex->name = util_strdup(file);
-    lex->line = 1; /* we start counting at 1 */
-
+    lex->file    = in;
+    lex->name    = util_strdup(file);
+    lex->line    = 1; /* we start counting at 1 */
+    lex->column  = 0;

     lex->peekpos = 0;
     lex->peekpos = 0;

-    lex->eof = false;
+    lex->eof     = false;
+
+    /* handle BOM */
+    if ((read = (lex_getch(lex) << 16) | (lex_getch(lex) << 8) | lex_getch(lex)) != 0xEFBBBF) {
+        lex_ungetch(lex, (read & 0x0000FF));
+        lex_ungetch(lex, (read & 0x00FF00) >> 8);
+        lex_ungetch(lex, (read & 0xFF0000) >> 16);
+    } else {
+        /*
+         * otherwise the lexer has advanced 3 bytes for the BOM, we need
+         * to set the column back to 0
+         */
+        lex->column = 0;
+    }

 
     vec_push(lex_filenames, lex->name);
     return lex;
 
     vec_push(lex_filenames, lex->name);
     return lex;


@@ -231,11 +157,11 @@ lex_file* lex_open_string(const char *str, size_t len, const char *name)
     lex->open_string_length = len;
     lex->open_string_pos    = 0;
 
     lex->open_string_length = len;
     lex->open_string_pos    = 0;
 

-    lex->name = util_strdup(name ? name : "<string-source>");
-    lex->line = 1; /* we start counting at 1 */
-
+    lex->name    = util_strdup(name ? name : "<string-source>");
+    lex->line    = 1; /* we start counting at 1 */

     lex->peekpos = 0;
     lex->peekpos = 0;

-    lex->eof = false;
+    lex->eof     = false;
+    lex->column  = 0;

 
     vec_push(lex_filenames, lex->name);
 
 
     vec_push(lex_filenames, lex->name);
 


@@ -261,27 +187,29 @@ void lex_close(lex_file *lex)
         vec_free(lex->modelname);
 
     if (lex->file)
         vec_free(lex->modelname);
 
     if (lex->file)

-        fclose(lex->file);
-#if 0
-    if (lex->tok)
-        token_delete(lex->tok);
-#else
+        fs_file_close(lex->file);
+

     vec_free(lex->tok.value);
     vec_free(lex->tok.value);

-#endif
+

     /* mem_d(lex->name); collected in lex_filenames */
     mem_d(lex);
 }
 
     /* mem_d(lex->name); collected in lex_filenames */
     mem_d(lex);
 }
 

+
+

 static int lex_fgetc(lex_file *lex)
 {
 static int lex_fgetc(lex_file *lex)
 {

-    if (lex->file)
-        return fgetc(lex->file);
+    if (lex->file) {
+        lex->column++;
+        return fs_file_getc(lex->file);
+    }

     if (lex->open_string) {
         if (lex->open_string_pos >= lex->open_string_length)
     if (lex->open_string) {
         if (lex->open_string_pos >= lex->open_string_length)

-            return EOF;
+            return FS_FILE_EOF;
+        lex->column++;

         return lex->open_string[lex->open_string_pos++];
     }
         return lex->open_string[lex->open_string_pos++];
     }

-    return EOF;
+    return FS_FILE_EOF;

 }
 
 /* Get or put-back data
 }
 
 /* Get or put-back data


@@ -289,17 +217,26 @@ static int lex_fgetc(lex_file *lex)
  * are working on.
  * The are merely wrapping get/put in order to count line numbers.
  */
  * are working on.
  * The are merely wrapping get/put in order to count line numbers.
  */

-static void lex_ungetch(lex_file *lex, int ch);

 static int lex_try_trigraph(lex_file *lex, int old)
 {
     int c2, c3;
     c2 = lex_fgetc(lex);
 static int lex_try_trigraph(lex_file *lex, int old)
 {
     int c2, c3;
     c2 = lex_fgetc(lex);

+    if (!lex->push_line && c2 == '\n') {
+        lex->line++;
+        lex->column = 0;
+    }
+

     if (c2 != '?') {
         lex_ungetch(lex, c2);
         return old;
     }
 
     c3 = lex_fgetc(lex);
     if (c2 != '?') {
         lex_ungetch(lex, c2);
         return old;
     }
 
     c3 = lex_fgetc(lex);

+    if (!lex->push_line && c3 == '\n') {
+        lex->line++;
+        lex->column = 0;
+    }
+

     switch (c3) {
         case '=': return '#';
         case '/': return '\\';
     switch (c3) {
         case '=': return '#';
         case '/': return '\\';


@@ -346,14 +283,18 @@ static int lex_getch(lex_file *lex)
 
     if (lex->peekpos) {
         lex->peekpos--;
 
     if (lex->peekpos) {
         lex->peekpos--;

-        if (!lex->push_line && lex->peek[lex->peekpos] == '\n')
+        if (!lex->push_line && lex->peek[lex->peekpos] == '\n') {

             lex->line++;
             lex->line++;

+            lex->column = 0;
+        }

         return lex->peek[lex->peekpos];
     }
 
     ch = lex_fgetc(lex);
         return lex->peek[lex->peekpos];
     }
 
     ch = lex_fgetc(lex);

-    if (!lex->push_line && ch == '\n')
+    if (!lex->push_line && ch == '\n') {

         lex->line++;
         lex->line++;

+        lex->column = 0;
+    }

     else if (ch == '?')
         return lex_try_trigraph(lex, ch);
     else if (!lex->flags.nodigraphs && (ch == '<' || ch == ':' || ch == '%'))
     else if (ch == '?')
         return lex_try_trigraph(lex, ch);
     else if (!lex->flags.nodigraphs && (ch == '<' || ch == ':' || ch == '%'))


@@ -364,8 +305,11 @@ static int lex_getch(lex_file *lex)
 static void lex_ungetch(lex_file *lex, int ch)
 {
     lex->peek[lex->peekpos++] = ch;
 static void lex_ungetch(lex_file *lex, int ch)
 {
     lex->peek[lex->peekpos++] = ch;

-    if (!lex->push_line && ch == '\n')
+    lex->column--;
+    if (!lex->push_line && ch == '\n') {

         lex->line--;
         lex->line--;

+        lex->column = 0;
+    }

 }
 
 /* classify characters
 }
 
 /* classify characters


@@ -375,12 +319,12 @@ static void lex_ungetch(lex_file *lex, int ch)
 /* Idents are alphanumberic, but they start with alpha or _ */
 static bool isident_start(int ch)
 {
 /* Idents are alphanumberic, but they start with alpha or _ */
 static bool isident_start(int ch)
 {

-    return isalpha(ch) || ch == '_';
+    return util_isalpha(ch) || ch == '_';

 }
 
 static bool isident(int ch)
 {
 }
 
 static bool isident(int ch)
 {

-    return isident_start(ch) || isdigit(ch);
+    return isident_start(ch) || util_isdigit(ch);

 }
 
 /* isxdigit_only is used when we already know it's not a digit
 }
 
 /* isxdigit_only is used when we already know it's not a digit


@@ -441,7 +385,7 @@ static bool lex_try_pragma(lex_file *lex)
         goto unroll;
     }
 
         goto unroll;
     }
 

-    for (ch = lex_getch(lex); vec_size(param) < 32 && ch != ')' && ch != '\n'; ch = lex_getch(lex))
+    for (ch = lex_getch(lex); vec_size(param) < 1024 && ch != ')' && ch != '\n'; ch = lex_getch(lex))

         vec_push(param, ch);
     vec_push(param, 0);
 
         vec_push(param, ch);
     vec_push(param, 0);
 


@@ -480,31 +424,36 @@ static bool lex_try_pragma(lex_file *lex)
         goto unroll;
 
     lex->line = line;
         goto unroll;
 
     lex->line = line;

-    while (ch != '\n' && ch != EOF)
+    while (ch != '\n' && ch != FS_FILE_EOF)

         ch = lex_getch(lex);
         ch = lex_getch(lex);

+    vec_free(command);
+    vec_free(param);
+    vec_free(pragma);

     return true;
 
 unroll:
     if (command) {
         vec_pop(command);
         while (vec_size(command)) {
     return true;
 
 unroll:
     if (command) {
         vec_pop(command);
         while (vec_size(command)) {

-            lex_ungetch(lex, vec_last(command));
+            lex_ungetch(lex, (unsigned char)vec_last(command));

             vec_pop(command);
         }
         vec_free(command);
             vec_pop(command);
         }
         vec_free(command);

+        lex_ungetch(lex, ' ');

     }
     }

-    if (command) {
-        vec_pop(command);
-        while (vec_size(command)) {
-            lex_ungetch(lex, vec_last(command));
-            vec_pop(command);
+    if (param) {
+        vec_pop(param);
+        while (vec_size(param)) {
+            lex_ungetch(lex, (unsigned char)vec_last(param));
+            vec_pop(param);

         }
         }

-        vec_free(command);
+        vec_free(param);
+        lex_ungetch(lex, ' ');

     }
     if (pragma) {
         vec_pop(pragma);
         while (vec_size(pragma)) {
     }
     if (pragma) {
         vec_pop(pragma);
         while (vec_size(pragma)) {

-            lex_ungetch(lex, vec_last(pragma));
+            lex_ungetch(lex, (unsigned char)vec_last(pragma));

             vec_pop(pragma);
         }
         vec_free(pragma);
             vec_pop(pragma);
         }
         vec_free(pragma);


@@ -547,15 +496,15 @@ printf(   "line one\n"
  *    here is to store the line of the first character after skipping
  *    the initial whitespace in lex->sline, this happens in lex_do.
  */
  *    here is to store the line of the first character after skipping
  *    the initial whitespace in lex->sline, this happens in lex_do.
  */

-static int lex_skipwhite(lex_file *lex)
+static int lex_skipwhite(lex_file *lex, bool hadwhite)

 {
     int ch = 0;
 {
     int ch = 0;

-    bool haswhite = false;
+    bool haswhite = hadwhite;

 
     do
     {
         ch = lex_getch(lex);
 
     do
     {
         ch = lex_getch(lex);

-        while (ch != EOF && isspace(ch)) {
+        while (ch != FS_FILE_EOF && util_isspace(ch)) {

             if (ch == '\n') {
                 if (lex_try_pragma(lex))
                     continue;
             if (ch == '\n') {
                 if (lex_try_pragma(lex))
                     continue;


@@ -587,15 +536,11 @@ static int lex_skipwhite(lex_file *lex)
 
                 if (lex->flags.preprocessing) {
                     haswhite = true;
 
                 if (lex->flags.preprocessing) {
                     haswhite = true;

-                    /*
-                    lex_tokench(lex, '/');
-                    lex_tokench(lex, '/');
-                    */

                     lex_tokench(lex, ' ');
                     lex_tokench(lex, ' ');
                 }
 
                     lex_tokench(lex, ' ');
                     lex_tokench(lex, ' ');
                 }
 

-                while (ch != EOF && ch != '\n') {
+                while (ch != FS_FILE_EOF && ch != '\n') {

                     if (lex->flags.preprocessing)
                         lex_tokench(lex, ' '); /* ch); */
                     ch = lex_getch(lex);
                     if (lex->flags.preprocessing)
                         lex_tokench(lex, ' '); /* ch); */
                     ch = lex_getch(lex);


@@ -612,25 +557,17 @@ static int lex_skipwhite(lex_file *lex)
                 /* multiline comment */
                 if (lex->flags.preprocessing) {
                     haswhite = true;
                 /* multiline comment */
                 if (lex->flags.preprocessing) {
                     haswhite = true;

-                    /*
-                    lex_tokench(lex, '/');
-                    lex_tokench(lex, '*');
-                    */

                     lex_tokench(lex, ' ');
                     lex_tokench(lex, ' ');
                 }
 
                     lex_tokench(lex, ' ');
                     lex_tokench(lex, ' ');
                 }
 

-                while (ch != EOF)
+                while (ch != FS_FILE_EOF)

                 {
                     ch = lex_getch(lex);
                     if (ch == '*') {
                         ch = lex_getch(lex);
                         if (ch == '/') {
                             if (lex->flags.preprocessing) {
                 {
                     ch = lex_getch(lex);
                     if (ch == '*') {
                         ch = lex_getch(lex);
                         if (ch == '/') {
                             if (lex->flags.preprocessing) {

-                                /*
-                                lex_tokench(lex, '*');
-                                lex_tokench(lex, '/');
-                                */

                                 lex_tokench(lex, ' ');
                                 lex_tokench(lex, ' ');
                             }
                                 lex_tokench(lex, ' ');
                                 lex_tokench(lex, ' ');
                             }


@@ -642,7 +579,7 @@ static int lex_skipwhite(lex_file *lex)
                         if (ch == '\n')
                             lex_tokench(lex, '\n');
                         else
                         if (ch == '\n')
                             lex_tokench(lex, '\n');
                         else

-                            lex_tokench(lex, ' '); /* ch); */
+                            lex_tokench(lex, ' ');

                     }
                 }
                 ch = ' '; /* cause TRUE in the isspace check */
                     }
                 }
                 ch = ' '; /* cause TRUE in the isspace check */


@@ -653,7 +590,7 @@ static int lex_skipwhite(lex_file *lex)
             ch = '/';
             break;
         }
             ch = '/';
             break;
         }

-    } while (ch != EOF && isspace(ch));
+    } while (ch != FS_FILE_EOF && util_isspace(ch));

 
     if (haswhite) {
         lex_endtoken(lex);
 
     if (haswhite) {
         lex_endtoken(lex);


@@ -669,7 +606,7 @@ static bool GMQCC_WARN lex_finish_ident(lex_file *lex)
     int ch;
 
     ch = lex_getch(lex);
     int ch;
 
     ch = lex_getch(lex);

-    while (ch != EOF && isident(ch))
+    while (ch != FS_FILE_EOF && isident(ch))

     {
         lex_tokench(lex, ch);
         ch = lex_getch(lex);
     {
         lex_tokench(lex, ch);
         ch = lex_getch(lex);


@@ -689,7 +626,7 @@ static int lex_parse_frame(lex_file *lex)
     lex_token_new(lex);
 
     ch = lex_getch(lex);
     lex_token_new(lex);
 
     ch = lex_getch(lex);

-    while (ch != EOF && ch != '\n' && isspace(ch))
+    while (ch != FS_FILE_EOF && ch != '\n' && util_isspace(ch))

         ch = lex_getch(lex);
 
     if (ch == '\n')
         ch = lex_getch(lex);
 
     if (ch == '\n')


@@ -737,14 +674,21 @@ static bool lex_finish_frames(lex_file *lex)
         vec_shrinkto(lex->tok.value, 0);
         vec_push(lex->frames, m);
     } while (true);
         vec_shrinkto(lex->tok.value, 0);
         vec_push(lex->frames, m);
     } while (true);

+
+    return false;

 }
 
 static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
 {
 }
 
 static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
 {

+    utf8ch_t chr = 0;

     int ch = 0;
     int nextch;
     int ch = 0;
     int nextch;

+    bool hex;
+    bool oct;
+    char u8buf[8]; /* way more than enough */
+    int  u8len, uc;

 
 

-    while (ch != EOF)
+    while (ch != FS_FILE_EOF)

     {
         ch = lex_getch(lex);
         if (ch == quote)
     {
         ch = lex_getch(lex);
         if (ch == quote)


@@ -753,18 +697,18 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
         if (lex->flags.preprocessing && ch == '\\') {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);
         if (lex->flags.preprocessing && ch == '\\') {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);

-            if (ch == EOF) {
+            if (ch == FS_FILE_EOF) {

                 lexerror(lex, "unexpected end of file");
                 lexerror(lex, "unexpected end of file");

-                lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
+                lex_ungetch(lex, FS_FILE_EOF); /* next token to be TOKEN_EOF */

                 return (lex->tok.ttype = TOKEN_ERROR);
             }
             lex_tokench(lex, ch);
         }
         else if (ch == '\\') {
             ch = lex_getch(lex);
                 return (lex->tok.ttype = TOKEN_ERROR);
             }
             lex_tokench(lex, ch);
         }
         else if (ch == '\\') {
             ch = lex_getch(lex);

-            if (ch == EOF) {
+            if (ch == FS_FILE_EOF) {

                 lexerror(lex, "unexpected end of file");
                 lexerror(lex, "unexpected end of file");

-                lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
+                lex_ungetch(lex, FS_FILE_EOF); /* next token to be TOKEN_EOF */

                 return (lex->tok.ttype = TOKEN_ERROR);
             }
 
                 return (lex->tok.ttype = TOKEN_ERROR);
             }
 


@@ -820,6 +764,67 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
             case '<':  ch = 29; break;
             case '-':  ch = 30; break;
             case '>':  ch = 31; break;
             case '<':  ch = 29; break;
             case '-':  ch = 30; break;
             case '>':  ch = 31; break;

+            case '[':  ch = 16; break;
+            case ']':  ch = 17; break;
+            case '{':
+                chr = 0;
+                nextch = lex_getch(lex);
+                hex = (nextch == 'x');
+                oct = (nextch == '0');
+                if (!hex && !oct)
+                    lex_ungetch(lex, nextch);
+                for (nextch = lex_getch(lex); nextch != '}'; nextch = lex_getch(lex)) {
+                    if (!hex && !oct) {
+                        if (nextch >= '0' && nextch <= '9')
+                            chr = chr * 10 + nextch - '0';
+                        else {
+                            lexerror(lex, "bad character code");
+                            return (lex->tok.ttype = TOKEN_ERROR);
+                        }
+                    } else if (!oct) {
+                        if (nextch >= '0' && nextch <= '9')
+                            chr = chr * 0x10 + nextch - '0';
+                        else if (nextch >= 'a' && nextch <= 'f')
+                            chr = chr * 0x10 + nextch - 'a' + 10;
+                        else if (nextch >= 'A' && nextch <= 'F')
+                            chr = chr * 0x10 + nextch - 'A' + 10;
+                        else {
+                            lexerror(lex, "bad character code");
+                            return (lex->tok.ttype = TOKEN_ERROR);
+                        }
+                    } else {
+                        if (nextch >= '0' && nextch <= '9')
+                            chr = chr * 8 + chr - '0';
+                        else {
+                            lexerror(lex, "bad character code");
+                            return (lex->tok.ttype = TOKEN_ERROR);
+                        }
+                    }
+                    if (chr > 0x10FFFF || (!OPTS_FLAG(UTF8) && chr > 255))
+                    {
+                        lexerror(lex, "character code out of range");
+                        return (lex->tok.ttype = TOKEN_ERROR);
+                    }
+                }
+                if (OPTS_FLAG(UTF8) && chr >= 128) {
+                    u8len = utf8_from(u8buf, chr);
+                    if (!u8len)
+                        ch = 0;
+                    else {
+                        --u8len;
+                        lex->column += u8len;
+                        for (uc = 0; uc < u8len; ++uc)
+                            lex_tokench(lex, u8buf[uc]);
+                        /*
+                         * the last character will be inserted with the tokench() call
+                         * below the switch
+                         */
+                        ch = u8buf[uc];
+                    }
+                }
+                else
+                    ch = chr;
+                break;

             case '\n':  ch = '\n'; break;
 
             default:
             case '\n':  ch = '\n'; break;
 
             default:


@@ -834,7 +839,7 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
             lex_tokench(lex, ch);
     }
     lexerror(lex, "unexpected end of file within string constant");
             lex_tokench(lex, ch);
     }
     lexerror(lex, "unexpected end of file within string constant");

-    lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
+    lex_ungetch(lex, FS_FILE_EOF); /* next token to be TOKEN_EOF */

     return (lex->tok.ttype = TOKEN_ERROR);
 }
 
     return (lex->tok.ttype = TOKEN_ERROR);
 }
 


@@ -853,7 +858,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
     lex_tokench(lex, ch);
 
     ch = lex_getch(lex);
     lex_tokench(lex, ch);
 
     ch = lex_getch(lex);

-    if (ch != '.' && !isdigit(ch))
+    if (ch != '.' && !util_isdigit(ch))

     {
         if (lastch != '0' || ch != 'x')
         {
     {
         if (lastch != '0' || ch != 'x')
         {


@@ -874,7 +879,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
     {
         lex_tokench(lex, ch);
         ch = lex_getch(lex);
     {
         lex_tokench(lex, ch);
         ch = lex_getch(lex);

-        while (isdigit(ch) || (ishex && isxdigit_only(ch)))
+        while (util_isdigit(ch) || (ishex && isxdigit_only(ch)))

         {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);
         {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);


@@ -889,7 +894,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
 
         /* continue digits-only */
         ch = lex_getch(lex);
 
         /* continue digits-only */
         ch = lex_getch(lex);

-        while (isdigit(ch))
+        while (util_isdigit(ch))

         {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);
         {
             lex_tokench(lex, ch);
             ch = lex_getch(lex);


@@ -918,18 +923,18 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
 int lex_do(lex_file *lex)
 {
     int ch, nextch, thirdch;
 int lex_do(lex_file *lex)
 {
     int ch, nextch, thirdch;

+    bool hadwhite = false;

 
     lex_token_new(lex);
 
     lex_token_new(lex);

-#if 0
-    if (!lex->tok)
-        return TOKEN_FATAL;
-#endif

 
     while (true) {
 
     while (true) {

-        ch = lex_skipwhite(lex);
+        ch = lex_skipwhite(lex, hadwhite);
+        hadwhite = true;

         if (!lex->flags.mergelines || ch != '\\')
             break;
         ch = lex_getch(lex);
         if (!lex->flags.mergelines || ch != '\\')
             break;
         ch = lex_getch(lex);

+        if (ch == '\r')
+            ch = lex_getch(lex);

         if (ch != '\n') {
             lex_ungetch(lex, ch);
             ch = '\\';
         if (ch != '\n') {
             lex_ungetch(lex, ch);
             ch = '\\';


@@ -951,13 +956,13 @@ int lex_do(lex_file *lex)
     if (lex->eof)
         return (lex->tok.ttype = TOKEN_FATAL);
 
     if (lex->eof)
         return (lex->tok.ttype = TOKEN_FATAL);
 

-    if (ch == EOF) {
+    if (ch == FS_FILE_EOF) {

         lex->eof = true;
         return (lex->tok.ttype = TOKEN_EOF);
     }
 
     /* modelgen / spiritgen commands */
         lex->eof = true;
         return (lex->tok.ttype = TOKEN_EOF);
     }
 
     /* modelgen / spiritgen commands */

-    if (ch == '$') {
+    if (ch == '$' && !lex->flags.preprocessing) {

         const char *v;
         size_t frame;
 
         const char *v;
         size_t frame;
 


@@ -988,10 +993,10 @@ int lex_do(lex_file *lex)
         if (!strcmp(v, "framevalue"))
         {
             ch = lex_getch(lex);
         if (!strcmp(v, "framevalue"))
         {
             ch = lex_getch(lex);

-            while (ch != EOF && isspace(ch) && ch != '\n')
+            while (ch != FS_FILE_EOF && util_isspace(ch) && ch != '\n')

                 ch = lex_getch(lex);
 
                 ch = lex_getch(lex);
 

-            if (!isdigit(ch)) {
+            if (!util_isdigit(ch)) {

                 lexerror(lex, "$framevalue requires an integer parameter");
                 return lex_do(lex);
             }
                 lexerror(lex, "$framevalue requires an integer parameter");
                 return lex_do(lex);
             }


@@ -1048,7 +1053,6 @@ int lex_do(lex_file *lex)
             if (rc < 0)
                 return (lex->tok.ttype = TOKEN_FATAL);
 
             if (rc < 0)
                 return (lex->tok.ttype = TOKEN_FATAL);
 

-            v = lex->tok.value;

             if (lex->modelname) {
                 frame_macro m;
                 m.value = lex->framevalue;
             if (lex->modelname) {
                 frame_macro m;
                 m.value = lex->framevalue;


@@ -1069,7 +1073,7 @@ int lex_do(lex_file *lex)
             vec_free(lex->frames);
             /* skip line (fteqcc does it too) */
             ch = lex_getch(lex);
             vec_free(lex->frames);
             /* skip line (fteqcc does it too) */
             ch = lex_getch(lex);

-            while (ch != EOF && ch != '\n')
+            while (ch != FS_FILE_EOF && ch != '\n')

                 ch = lex_getch(lex);
             return lex_do(lex);
         }
                 ch = lex_getch(lex);
             return lex_do(lex);
         }


@@ -1083,7 +1087,7 @@ int lex_do(lex_file *lex)
         {
             /* skip line */
             ch = lex_getch(lex);
         {
             /* skip line */
             ch = lex_getch(lex);

-            while (ch != EOF && ch != '\n')
+            while (ch != FS_FILE_EOF && ch != '\n')

                 ch = lex_getch(lex);
             return lex_do(lex);
         }
                 ch = lex_getch(lex);
             return lex_do(lex);
         }


@@ -1103,6 +1107,15 @@ int lex_do(lex_file *lex)
     switch (ch)
     {
         case '[':
     switch (ch)
     {
         case '[':

+            nextch = lex_getch(lex);
+            if (nextch == '[') {
+                lex_tokench(lex, ch);
+                lex_tokench(lex, nextch);
+                lex_endtoken(lex);
+                return (lex->tok.ttype = TOKEN_ATTRIBUTE_OPEN);
+            }
+            lex_ungetch(lex, nextch);
+            /* FALL THROUGH */

         case '(':
         case ':':
         case '?':
         case '(':
         case ':':
         case '?':


@@ -1112,11 +1125,23 @@ int lex_do(lex_file *lex)
                 return (lex->tok.ttype = ch);
             else
                 return (lex->tok.ttype = TOKEN_OPERATOR);
                 return (lex->tok.ttype = ch);
             else
                 return (lex->tok.ttype = TOKEN_OPERATOR);

+
+        case ']':
+            if (lex->flags.noops) {
+                nextch = lex_getch(lex);
+                if (nextch == ']') {
+                    lex_tokench(lex, ch);
+                    lex_tokench(lex, nextch);
+                    lex_endtoken(lex);
+                    return (lex->tok.ttype = TOKEN_ATTRIBUTE_CLOSE);
+                }
+                lex_ungetch(lex, nextch);
+            }
+            /* FALL THROUGH */

         case ')':
         case ';':
         case '{':
         case '}':
         case ')':
         case ';':
         case '{':
         case '}':

-        case ']':

 
         case '#':
             lex_tokench(lex, ch);
 
         case '#':
             lex_tokench(lex, ch);


@@ -1129,7 +1154,7 @@ int lex_do(lex_file *lex)
     if (ch == '.') {
         nextch = lex_getch(lex);
         /* digits starting with a dot */
     if (ch == '.') {
         nextch = lex_getch(lex);
         /* digits starting with a dot */

-        if (isdigit(nextch)) {
+        if (util_isdigit(nextch)) {

             lex_ungetch(lex, nextch);
             lex->tok.ttype = lex_finish_digit(lex, ch);
             lex_endtoken(lex);
             lex_ungetch(lex, nextch);
             lex->tok.ttype = lex_finish_digit(lex, ch);
             lex_endtoken(lex);


@@ -1145,10 +1170,6 @@ int lex_do(lex_file *lex)
          */
         switch (ch)
         {
          */
         switch (ch)
         {

-            /*
-            case '+':
-            case '-':
-            */

             case '*':
             case '/':
             case '<':
             case '*':
             case '/':
             case '<':


@@ -1166,31 +1187,37 @@ int lex_do(lex_file *lex)
             default:
                 break;
         }
             default:
                 break;
         }

+    }

 
 

-        if (ch == '.')
-        {
-            lex_tokench(lex, ch);
-            /* peak ahead once */
-            nextch = lex_getch(lex);
-            if (nextch != '.') {
-                lex_ungetch(lex, nextch);
-                lex_endtoken(lex);
-                return (lex->tok.ttype = ch);
-            }
-            /* peak ahead again */
-            nextch = lex_getch(lex);
-            if (nextch != '.') {
-                lex_ungetch(lex, nextch);
-                lex_ungetch(lex, '.');
-                lex_endtoken(lex);
+    if (ch == '.')
+    {
+        lex_tokench(lex, ch);
+        /* peak ahead once */
+        nextch = lex_getch(lex);
+        if (nextch != '.') {
+            lex_ungetch(lex, nextch);
+            lex_endtoken(lex);
+            if (lex->flags.noops)

                 return (lex->tok.ttype = ch);
                 return (lex->tok.ttype = ch);

-            }
-            /* fill the token to be "..." */
-            lex_tokench(lex, ch);
-            lex_tokench(lex, ch);
+            else
+                return (lex->tok.ttype = TOKEN_OPERATOR);
+        }
+        /* peak ahead again */
+        nextch = lex_getch(lex);
+        if (nextch != '.') {
+            lex_ungetch(lex, nextch);
+            lex_ungetch(lex, '.');

             lex_endtoken(lex);
             lex_endtoken(lex);

-            return (lex->tok.ttype = TOKEN_DOTS);
+            if (lex->flags.noops)
+                return (lex->tok.ttype = ch);
+            else
+                return (lex->tok.ttype = TOKEN_OPERATOR);

         }
         }

+        /* fill the token to be "..." */
+        lex_tokench(lex, ch);
+        lex_tokench(lex, ch);
+        lex_endtoken(lex);
+        return (lex->tok.ttype = TOKEN_DOTS);

     }
 
     if (ch == ',' || ch == '.') {
     }
 
     if (ch == ',' || ch == '.') {


@@ -1200,15 +1227,29 @@ int lex_do(lex_file *lex)
     }
 
     if (ch == '+' || ch == '-' || /* ++, --, +=, -=  and -> as well! */
     }
 
     if (ch == '+' || ch == '-' || /* ++, --, +=, -=  and -> as well! */

-        ch == '>' || ch == '<' || /* <<, >>, <=, >= */
-        ch == '=' || ch == '!' || /* ==, != */
-        ch == '&' || ch == '|')   /* &&, ||, &=, |= */
-    {
+        ch == '>' || ch == '<' || /* <<, >>, <=, >=  and >< as well! */
+        ch == '=' || ch == '!' || /* <=>, ==, !=                     */
+        ch == '&' || ch == '|' || /* &&, ||, &=, |=                  */
+        ch == '~' || ch == '^'    /* ~=, ~, ^                        */
+    )  {

         lex_tokench(lex, ch);
         lex_tokench(lex, ch);

-

         nextch = lex_getch(lex);
         nextch = lex_getch(lex);

-        if (nextch == '=' || (nextch == ch && ch != '!')) {
+
+        if ((nextch == '=' && ch != '<') || (nextch == '<' && ch == '>'))
+            lex_tokench(lex, nextch);
+        else if (nextch == ch && ch != '!') {

             lex_tokench(lex, nextch);
             lex_tokench(lex, nextch);

+            if ((thirdch = lex_getch(lex)) == '=')
+                lex_tokench(lex, thirdch);
+            else
+                lex_ungetch(lex, thirdch);
+        } else if (ch == '<' && nextch == '=') {
+            lex_tokench(lex, nextch);
+            if ((thirdch = lex_getch(lex)) == '>')
+                lex_tokench(lex, thirdch);
+            else
+                lex_ungetch(lex, thirdch);
+

         } else if (ch == '-' && nextch == '>') {
             lex_tokench(lex, nextch);
         } else if (ch == '&' && nextch == '~') {
         } else if (ch == '-' && nextch == '>') {
             lex_tokench(lex, nextch);
         } else if (ch == '&' && nextch == '~') {


@@ -1221,28 +1262,31 @@ int lex_do(lex_file *lex)
                 lex_tokench(lex, nextch);
                 lex_tokench(lex, thirdch);
             }
                 lex_tokench(lex, nextch);
                 lex_tokench(lex, thirdch);
             }

-        } else
+        }
+        else if (lex->flags.preprocessing &&
+                 ch == '-' && util_isdigit(nextch))
+        {
+            lex->tok.ttype = lex_finish_digit(lex, nextch);
+            if (lex->tok.ttype == TOKEN_INTCONST)
+                lex->tok.constval.i = -lex->tok.constval.i;
+            else
+                lex->tok.constval.f = -lex->tok.constval.f;
+            lex_endtoken(lex);
+            return lex->tok.ttype;
+        } else {

             lex_ungetch(lex, nextch);
             lex_ungetch(lex, nextch);

+        }

 
         lex_endtoken(lex);
         return (lex->tok.ttype = TOKEN_OPERATOR);
     }
 
 
         lex_endtoken(lex);
         return (lex->tok.ttype = TOKEN_OPERATOR);
     }
 

-    /*
-    if (ch == '^' || ch == '~' || ch == '!')
-    {
-        lex_tokench(lex, ch);
-        lex_endtoken(lex);
-        return (lex->tok.ttype = TOKEN_OPERATOR);
-    }
-    */
-

     if (ch == '*' || ch == '/') /* *=, /= */
     {
         lex_tokench(lex, ch);
 
         nextch = lex_getch(lex);
     if (ch == '*' || ch == '/') /* *=, /= */
     {
         lex_tokench(lex, ch);
 
         nextch = lex_getch(lex);

-        if (nextch == '=') {
+        if (nextch == '=' || nextch == '*') {

             lex_tokench(lex, nextch);
         } else
             lex_ungetch(lex, nextch);
             lex_tokench(lex, nextch);
         } else
             lex_ungetch(lex, nextch);


@@ -1251,6 +1295,34 @@ int lex_do(lex_file *lex)
         return (lex->tok.ttype = TOKEN_OPERATOR);
     }
 
         return (lex->tok.ttype = TOKEN_OPERATOR);
     }
 

+    if (ch == '%') {
+        lex_tokench(lex, ch);
+        lex_endtoken(lex);
+        return (lex->tok.ttype = TOKEN_OPERATOR);
+    }
+
+    /* length operator */
+    if (ch == 'l') {
+        if ((nextch = lex_getch(lex)) == 'e') {
+        if ((nextch = lex_getch(lex)) == 'n') {
+        if ((nextch = lex_getch(lex)) == 'g') {
+        if ((nextch = lex_getch(lex)) == 't') {
+        if ((nextch = lex_getch(lex)) == 'h') {
+            lex_tokench(lex, 'l');
+            lex_tokench(lex, 'e');
+            lex_tokench(lex, 'n');
+            lex_tokench(lex, 'g');
+            lex_tokench(lex, 't');
+            lex_tokench(lex, 'h');
+            lex_endtoken(lex);
+            return (lex->tok.ttype = TOKEN_OPERATOR);
+        } else lex_ungetch(lex, nextch);
+        } else lex_ungetch(lex, nextch);
+        } else lex_ungetch(lex, nextch);
+        } else lex_ungetch(lex, nextch);
+        } else lex_ungetch(lex, nextch);
+    }
+

     if (isident_start(ch))
     {
         const char *v;
     if (isident_start(ch))
     {
         const char *v;


@@ -1284,12 +1356,12 @@ int lex_do(lex_file *lex)
             lex->tok.constval.t = TYPE_VECTOR;
         } else {
             size_t kw;
             lex->tok.constval.t = TYPE_VECTOR;
         } else {
             size_t kw;

-            for (kw = 0; kw < num_keywords_qc; ++kw) {
+            for (kw = 0; kw < GMQCC_ARRAY_COUNT(keywords_qc); ++kw) {

                 if (!strcmp(v, keywords_qc[kw]))
                     return (lex->tok.ttype = TOKEN_KEYWORD);
             }
                 if (!strcmp(v, keywords_qc[kw]))
                     return (lex->tok.ttype = TOKEN_KEYWORD);
             }

-            if (opts_standard != COMPILER_QCC) {
-                for (kw = 0; kw < num_keywords_fg; ++kw) {
+            if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_QCC) {
+                for (kw = 0; kw < GMQCC_ARRAY_COUNT(keywords_fg); ++kw) {

                     if (!strcmp(v, keywords_fg[kw]))
                         return (lex->tok.ttype = TOKEN_KEYWORD);
                 }
                     if (!strcmp(v, keywords_fg[kw]))
                         return (lex->tok.ttype = TOKEN_KEYWORD);
                 }


@@ -1310,7 +1382,7 @@ int lex_do(lex_file *lex)
         while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST)
         {
             /* Allow c style "string" "continuation" */
         while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST)
         {
             /* Allow c style "string" "continuation" */

-            ch = lex_skipwhite(lex);
+            ch = lex_skipwhite(lex, false);

             if (ch != '"') {
                 lex_ungetch(lex, ch);
                 break;
             if (ch != '"') {
                 lex_ungetch(lex, ch);
                 break;


@@ -1338,14 +1410,10 @@ int lex_do(lex_file *lex)
         lex_endtoken(lex);
 
         lex->tok.ttype = TOKEN_CHARCONST;
         lex_endtoken(lex);
 
         lex->tok.ttype = TOKEN_CHARCONST;

-         /* It's a vector if we can successfully scan 3 floats */
-#ifdef WIN32
-        if (sscanf_s(lex->tok.value, " %f %f %f ",
-                   &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
-#else
-        if (sscanf(lex->tok.value, " %f %f %f ",
+
+        /* It's a vector if we can successfully scan 3 floats */
+        if (util_sscanf(lex->tok.value, " %f %f %f ",

                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)
                    &lex->tok.constval.v.x, &lex->tok.constval.v.y, &lex->tok.constval.v.z) == 3)

-#endif

 
         {
              lex->tok.ttype = TOKEN_VECTORCONST;
 
         {
              lex->tok.ttype = TOKEN_VECTORCONST;


@@ -1353,22 +1421,38 @@ int lex_do(lex_file *lex)
         else
         {
             if (!lex->flags.preprocessing && strlen(lex->tok.value) > 1) {
         else
         {
             if (!lex->flags.preprocessing && strlen(lex->tok.value) > 1) {

-                if (lexwarn(lex, WARN_MULTIBYTE_CHARACTER, "multibyte character: `%s`", lex->tok.value))
-                    return (lex->tok.ttype = TOKEN_ERROR);
+                utf8ch_t u8char;
+                /* check for a valid utf8 character */
+                if (!OPTS_FLAG(UTF8) || !utf8_to(&u8char, (const unsigned char *)lex->tok.value, 8)) {
+                    if (lexwarn(lex, WARN_MULTIBYTE_CHARACTER,
+                                ( OPTS_FLAG(UTF8) ? "invalid multibyte character sequence `%s`"
+                                                  : "multibyte character: `%s`" ),
+                                lex->tok.value))
+                        return (lex->tok.ttype = TOKEN_ERROR);
+                }
+                else
+                    lex->tok.constval.i = u8char;

             }
             }

-            lex->tok.constval.i = lex->tok.value[0];
+            else
+                lex->tok.constval.i = lex->tok.value[0];

         }
 
         return lex->tok.ttype;
     }
 
         }
 
         return lex->tok.ttype;
     }
 

-    if (isdigit(ch))
+    if (util_isdigit(ch))

     {
         lex->tok.ttype = lex_finish_digit(lex, ch);
         lex_endtoken(lex);
         return lex->tok.ttype;
     }
 
     {
         lex->tok.ttype = lex_finish_digit(lex, ch);
         lex_endtoken(lex);
         return lex->tok.ttype;
     }
 

-    lexerror(lex, "unknown token");
+    if (lex->flags.preprocessing) {
+        lex_tokench(lex, ch);
+        lex_endtoken(lex);
+        return (lex->tok.ttype = ch);
+    }
+
+    lexerror(lex, "unknown token: `%c`", ch);

     return (lex->tok.ttype = TOKEN_ERROR);
 }
     return (lex->tok.ttype = TOKEN_ERROR);
 }