From: Dale Weiler <killfieldengine@gmail.com>
Date: Sat, 14 Apr 2012 06:48:11 +0000 (-0400)
Subject: Indentation
X-Git-Tag: 0.1-rc1~672
X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=b9050b6637edc1133ff5326634d8df6a7e843083;p=xonotic%2Fgmqcc.git

Indentation
---

diff --git a/parse.c b/parse.c
index 9af6049..792495b 100644
--- a/parse.c
+++ b/parse.c
@@ -315,55 +315,55 @@ 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", 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))
 							
 							/*
 							 * Parse all elements using the macro above.