X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=lexer.c;h=db0a8f4d9bf541bdd25597c5047e040d7dc36fc5;hp=55557daddad9115bdd1186c1574199a5a75886f2;hb=160e7cf7eebd7fa173fb739aca00143097a3518b;hpb=2164afb8cf8de2d23da61d53019db0dda21d2e00

diff --git a/lexer.c b/lexer.c
index 55557da..db0a8f4 100644
--- a/lexer.c
+++ b/lexer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
  *     Wolfgang Bumiller
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -184,7 +184,7 @@ static void lex_token_new(lex_file *lex)
 lex_file* lex_open(const char *file)
 {
     lex_file *lex;
-    FILE *in = file_open(file, "rb");
+    FILE *in = fs_file_open(file, "rb");
 
     if (!in) {
         lexerror(NULL, "open failed: '%s'\n", file);
@@ -193,7 +193,7 @@ lex_file* lex_open(const char *file)
 
     lex = (lex_file*)mem_a(sizeof(*lex));
     if (!lex) {
-        file_close(in);
+        fs_file_close(in);
         lexerror(NULL, "out of memory\n");
         return NULL;
     }
@@ -258,7 +258,7 @@ void lex_close(lex_file *lex)
         vec_free(lex->modelname);
 
     if (lex->file)
-        file_close(lex->file);
+        fs_file_close(lex->file);
 #if 0
     if (lex->tok)
         token_delete(lex->tok);
@@ -272,7 +272,7 @@ void lex_close(lex_file *lex)
 static int lex_fgetc(lex_file *lex)
 {
     if (lex->file)
-        return fgetc(lex->file);
+        return fs_file_getc(lex->file);
     if (lex->open_string) {
         if (lex->open_string_pos >= lex->open_string_length)
             return EOF;
@@ -291,12 +291,16 @@ 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++;
     if (c2 != '?') {
         lex_ungetch(lex, c2);
         return old;
     }
 
     c3 = lex_fgetc(lex);
+    if (!lex->push_line && c3 == '\n')
+        lex->line++;
     switch (c3) {
         case '=': return '#';
         case '/': return '\\';
@@ -479,31 +483,34 @@ static bool lex_try_pragma(lex_file *lex)
     lex->line = line;
     while (ch != '\n' && ch != EOF)
         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)) {
-            lex_ungetch(lex, vec_last(command));
+            lex_ungetch(lex, (unsigned char)vec_last(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)) {
-            lex_ungetch(lex, vec_last(pragma));
+            lex_ungetch(lex, (unsigned char)vec_last(pragma));
             vec_pop(pragma);
         }
         vec_free(pragma);
@@ -736,10 +743,13 @@ static bool lex_finish_frames(lex_file *lex)
         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)
 {
+    uchar_t chr;
     int ch = 0;
     int nextch;
     bool hex;
@@ -825,7 +835,7 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
             case '[':  ch = 16; break;
             case ']':  ch = 17; break;
             case '{':
-                ch = 0;
+                chr = 0;
                 nextch = lex_getch(lex);
                 hex = (nextch == 'x');
                 if (!hex)
@@ -833,32 +843,31 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
                 for (nextch = lex_getch(lex); nextch != '}'; nextch = lex_getch(lex)) {
                     if (!hex) {
                         if (nextch >= '0' && nextch <= '9')
-                            ch = ch * 10 + nextch - '0';
+                            chr = chr * 10 + nextch - '0';
                         else {
                             lexerror(lex, "bad character code");
                             return (lex->tok.ttype = TOKEN_ERROR);
                         }
                     } else {
-                        if (nextch >= '0' || nextch <= '9')
-                            ch = ch * 16 + nextch - '0';
+                        if (nextch >= '0' && nextch <= '9')
+                            chr = chr * 0x10 + nextch - '0';
                         else if (nextch >= 'a' && nextch <= 'f')
-                            ch = ch * 16 + nextch - 'a' + 10;
+                            chr = chr * 0x10 + nextch - 'a' + 10;
                         else if (nextch >= 'A' && nextch <= 'F')
-                            ch = ch * 16 + nextch - 'A' + 10;
+                            chr = chr * 0x10 + nextch - 'A' + 10;
                         else {
                             lexerror(lex, "bad character code");
                             return (lex->tok.ttype = TOKEN_ERROR);
                         }
                     }
-                    if ( (!OPTS_FLAG(UTF8) && ch > 255) ||
-                         ( OPTS_FLAG(UTF8) && ch > 0x10FFFF) )
+                    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) && ch >= 128) {
-                    u8len = u8_fromchar((Uchar)ch, u8buf, sizeof(u8buf));
+                if (OPTS_FLAG(UTF8) && chr >= 128) {
+                    u8len = u8_fromchar(chr, u8buf, sizeof(u8buf));
                     if (!u8len)
                         ch = 0;
                     else {
@@ -871,6 +880,8 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
                         ch = u8buf[uc];
                     }
                 }
+                else
+                    ch = chr;
                 break;
             case '\n':  ch = '\n'; break;
 
@@ -984,6 +995,8 @@ int lex_do(lex_file *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 = '\\';
@@ -1240,31 +1253,37 @@ int lex_do(lex_file *lex)
             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);
-            }
-            /* 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);
-            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 == '.') {
@@ -1274,15 +1293,23 @@ int lex_do(lex_file *lex)
     }
 
     if (ch == '+' || ch == '-' || /* ++, --, +=, -=  and -> as well! */
-        ch == '>' || ch == '<' || /* <<, >>, <=, >= */
-        ch == '=' || ch == '!' || /* ==, != */
-        ch == '&' || ch == '|')   /* &&, ||, &=, |= */
-    {
+        ch == '>' || ch == '<' || /* <<, >>, <=, >=                  */
+        ch == '=' || ch == '!' || /* <=>, ==, !=                     */
+        ch == '&' || ch == '|' || /* &&, ||, &=, |=                  */
+        ch == '~'                 /* ~=, ~                           */
+    )  {
         lex_tokench(lex, ch);
 
         nextch = lex_getch(lex);
-        if (nextch == '=' || (nextch == ch && ch != '!')) {
+        if ((nextch == '=' && ch != '<') || (nextch == ch && ch != '!')) {
             lex_tokench(lex, nextch);
+        } 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 == '~') {
@@ -1295,8 +1322,20 @@ int lex_do(lex_file *lex)
                 lex_tokench(lex, nextch);
                 lex_tokench(lex, thirdch);
             }
-        } else
+        }
+        else if (lex->flags.preprocessing &&
+                 ch == '-' && 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_endtoken(lex);
         return (lex->tok.ttype = TOKEN_OPERATOR);
@@ -1316,7 +1355,7 @@ int lex_do(lex_file *lex)
         lex_tokench(lex, ch);
 
         nextch = lex_getch(lex);
-        if (nextch == '=') {
+        if (nextch == '=' || nextch == '*') {
             lex_tokench(lex, nextch);
         } else
             lex_ungetch(lex, nextch);
@@ -1325,6 +1364,12 @@ int lex_do(lex_file *lex)
         return (lex->tok.ttype = TOKEN_OPERATOR);
     }
 
+    if (ch == '%') {
+        lex_tokench(lex, ch);
+        lex_endtoken(lex);
+        return (lex->tok.ttype = TOKEN_OPERATOR);
+    }
+
     if (isident_start(ch))
     {
         const char *v;
@@ -1362,7 +1407,7 @@ int lex_do(lex_file *lex)
                 if (!strcmp(v, keywords_qc[kw]))
                     return (lex->tok.ttype = TOKEN_KEYWORD);
             }
-            if (opts.standard != COMPILER_QCC) {
+            if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_QCC) {
                 for (kw = 0; kw < num_keywords_fg; ++kw) {
                     if (!strcmp(v, keywords_fg[kw]))
                         return (lex->tok.ttype = TOKEN_KEYWORD);
@@ -1427,7 +1472,7 @@ int lex_do(lex_file *lex)
         else
         {
             if (!lex->flags.preprocessing && strlen(lex->tok.value) > 1) {
-                Uchar u8char;
+                uchar_t u8char;
                 /* check for a valid utf8 character */
                 if (!OPTS_FLAG(UTF8) || !u8_analyze(lex->tok.value, NULL, NULL, &u8char, 8)) {
                     if (lexwarn(lex, WARN_MULTIBYTE_CHARACTER,
@@ -1459,6 +1504,6 @@ int lex_do(lex_file *lex)
         return (lex->tok.ttype = ch);
     }
 
-    lexerror(lex, "unknown token");
+    lexerror(lex, "unknown token: `%s`", lex->tok.value);
     return (lex->tok.ttype = TOKEN_ERROR);
 }