Vector test

[xonotic/gmqcc.git] / parse.c

diff --git a/parse.c b/parse.c
index 0dfe3e9441a5387b932cd6964de22516b26947d4..d2c90630b098ab34aac042bbf503394ecda550d8 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -315,55 +315,56 @@ int parse_tree(struct lex_file *file) {
                                                         * complicated mechanics of a vector, and can be extended as well.  This
                                                         * is a rather large macro, and is #undef after it's use below.
                                                         */
-                                               #define PARSE_VEC_ELEMENT(NAME, BIT)                                                                                                                               \
-                                                   token = lex_token(file);                                                                                                                                           \
-                                                   if (token == ' ') {                                                                                                                                                \
-                                                       token = lex_token(file);                                                                                                                                       \
-                                                   }                                                                                                                                                                  \
-                                                   if (token == '.') {                                                                                                                                                \
-                                                       compile_calc_d = 1;                                                                                                                                            \
-                                                   }                                                                                                                                                                  \
-                                                   if (!isdigit(token) && !compile_calc_d && token != '+' && token != '-')                                                                                            \
-                                                       error(ERROR_PARSE,"%s:%d Invalid constant initializer element %c for vector, must be numeric\n", file->name, file->line, NAME);                                \
-                                                   if (token == '+') {                                                                                                                                                \
-                                                       compile_calc_s = '+';                                                                                                                                          \
-                                                   }                                                                                                                                                                  \
-                                                   if (token == '-' && !compile_calc_s) {                                                                                                                             \
-                                                       compile_calc_s = '-';                                                                                                                                          \
-                                                   }                                                                                                                                                                  \
-                                                   while (isdigit(token) || token == '.' || token == '+' || token == '-') {                                                                                           \
-                                                           *compile_eval++ = token;                                                                                                                                       \
-                                                           token           = lex_token(file);                                                                                                                             \
-                                                           if (token == '.' && compile_calc_d) {                                                                                                                          \
-                                                               error(ERROR_PARSE, "%s:%d Invalid constant initializer element %c for vector, must be numeric.\n", file->name, file->line, NAME);                          \
-                                                           token = lex_token(file);                                                                                                                                   \
-                                                           }                                                                                                                                                              \
-                                                           if ((token == '-' || token == '+') && compile_calc_s) {                                                                                                        \
-                                                               error(ERROR_PARSE, "%s:%d Invalid constant initializer sign for vector element %c\n", file->name, file->line, NAME);                                       \
-                                                           token = lex_token(file);                                                                                                                                   \
-                                                       } else if (token == '.' && !compile_calc_d) {                                                                                                                  \
-                                                           compile_calc_d = 1;                                                                                                                                        \
-                                                       } else if (token == '-' && !compile_calc_s) {                                                                                                                  \
-                                                           compile_calc_s = '-';                                                                                                                                      \
-                                                       } else if (token == '+' && !compile_calc_s) {                                                                                                                  \
-                                                           compile_calc_s = '+';                                                                                                                                      \
-                                                       }                                                                                                                                                              \
-                                                   }                                                                                                                                                                  \
-                                                   if (token == ' ') {                                                                                                                                                \
-                                                       token = lex_token(file);                                                                                                                                       \
-                                                   }                                                                                                                                                                  \
-                                                   if (NAME != 'z') {                                                                                                                                                 \
-                                                       if (token != ',' && token != ' ')  {                                                                                                                           \
-                                                           error(ERROR_PARSE, "%s:%d invalid constant initializer element %c for vector (missing spaces, or comma delimited list?)\n", NAME, file->name, file->line); \
-                                                       }                                                                                                                                                              \
-                                                   } else if (token != '}') {                                                                                                                                         \
-                                                       error(ERROR_PARSE, "%s:%d Expected `}` on end of constant initialization for vector\n", file->name, file->line);                                               \
-                                                   }                                                                                                                                                                  \
-                                                   compile_calc_##BIT = atof(compile_data);                                                                                                                           \
-                                                   compile_calc_d = 0;                                                                                                                                                \
-                                                   compile_calc_s = 0;                                                                                                                                                \
-                                                   compile_eval   = &compile_data[0];                                                                                                                                 \
-                                                   memset(compile_data, 0, sizeof(compile_data))
+                                                       #define PARSE_VEC_ELEMENT(NAME, BIT)                                                                                                                                   \
+                                                           token = lex_token(file);                                                                                                                                           \
+                                                           if (token == ' ') {                                                                                                                                                \
+                                                               token = lex_token(file);                                                                                                                                       \
+                                                           }                                                                                                                                                                  \
+                                                           if (token == '.') {                                                                                                                                                \
+                                                               compile_calc_d = 1;                                                                                                                                            \
+                                                           }                                                                                                                                                                  \
+                                                           if (!isdigit(token) && !compile_calc_d && token != '+' && token != '-')  {                                                                                         \
+                                                               error(ERROR_PARSE,"%s:%d Invalid constant initializer element %c for vector, must be numeric\n", file->name, file->line, NAME);                                \
+                                                           }                                                                                                                                                                  \
+                                                           if (token == '+') {                                                                                                                                                \
+                                                               compile_calc_s = '+';                                                                                                                                          \
+                                                           }                                                                                                                                                                  \
+                                                           if (token == '-' && !compile_calc_s) {                                                                                                                             \
+                                                               compile_calc_s = '-';                                                                                                                                          \
+                                                           }                                                                                                                                                                  \
+                                                           while (isdigit(token) || token == '.' || token == '+' || token == '-') {                                                                                           \
+                                                               *compile_eval++ = token;                                                                                                                                       \
+                                                               token           = lex_token(file);                                                                                                                             \
+                                                               if (token == '.' && compile_calc_d) {                                                                                                                          \
+                                                                   error(ERROR_PARSE, "%s:%d Invalid constant initializer element %c for vector, must be numeric.\n", file->name, file->line, NAME);                          \
+                                                                   token = lex_token(file);                                                                                                                                   \
+                                                               }                                                                                                                                                              \
+                                                               if ((token == '-' || token == '+') && compile_calc_s) {                                                                                                        \
+                                                                   error(ERROR_PARSE, "%s:%d Invalid constant initializer sign for vector element %c\n", file->name, file->line, NAME);                                       \
+                                                                   token = lex_token(file);                                                                                                                                   \
+                                                               } else if (token == '.' && !compile_calc_d) {                                                                                                                  \
+                                                                   compile_calc_d = 1;                                                                                                                                        \
+                                                               } else if (token == '-' && !compile_calc_s) {                                                                                                                  \
+                                                                   compile_calc_s = '-';                                                                                                                                      \
+                                                               } else if (token == '+' && !compile_calc_s) {                                                                                                                  \
+                                                                   compile_calc_s = '+';                                                                                                                                      \
+                                                               }                                                                                                                                                              \
+                                                           }                                                                                                                                                                  \
+                                                           if (token == ' ') {                                                                                                                                                \
+                                                               token = lex_token(file);                                                                                                                                       \
+                                                           }                                                                                                                                                                  \
+                                                           if (NAME != 'z') {                                                                                                                                                 \
+                                                               if (token != ',' && token != ' ')  {                                                                                                                           \
+                                                                   error(ERROR_PARSE, "%s:%d invalid constant initializer element %c for vector (missing spaces, or comma delimited list?)\n", file->name, file->line, NAME); \
+                                                               }                                                                                                                                                              \
+                                                           } else if (token != '}') {                                                                                                                                         \
+                                                               error(ERROR_PARSE, "%s:%d Expected `}` on end of constant initialization for vector\n", file->name, file->line);                                               \
+                                                           }                                                                                                                                                                  \
+                                                           compile_calc_##BIT = atof(compile_data);                                                                                                                           \
+                                                           compile_calc_d = 0;                                                                                                                                                \
+                                                           compile_calc_s = 0;                                                                                                                                                \
+                                                           compile_eval   = &compile_data[0];                                                                                                                                 \
+                                                           memset(compile_data, 0, sizeof(compile_data))
                                                        
                                                        /*
                                                         * Parse all elements using the macro above.
@@ -392,7 +393,6 @@ int parse_tree(struct lex_file *file) {
                                                        
                                                case TOKEN_ENTITY:
                                                case TOKEN_FLOAT:
-                                                       
                                                        if (!isdigit(token))
                                                                error(ERROR_PARSE, "%s:%d Expected numeric constant for float constant\n");
                                                        break;