From 36c5722273f1ea87603621c6ee20b7178a7a641b Mon Sep 17 00:00:00 2001 From: Dale Weiler Date: Wed, 30 Jan 2013 05:35:07 +0000 Subject: [PATCH] Rename --- ast.c | 14 ++++----- code.c | 4 +-- ftepp.c | 10 +++---- gmqcc.h | 12 +++++--- ir.c | 10 +++---- lexer.c | 2 +- main.c | 90 ++++++++++++++++++++++++++++---------------------------- opts.c | 8 ++--- parser.c | 36 +++++++++++------------ test.c | 4 +-- util.c | 6 ++-- 11 files changed, 100 insertions(+), 96 deletions(-) diff --git a/ast.c b/ast.c index 41eadfa..3a4f1d7 100644 --- a/ast.c +++ b/ast.c @@ -1124,9 +1124,9 @@ const char* ast_function_label(ast_function *self, const char *prefix) size_t len; char *from; - if (!OPTION_VALUE_BOOL(OPTION_DUMP) && - !OPTION_VALUE_BOOL(OPTION_DUMPFIN) && - !OPTION_VALUE_BOOL(OPTION_DEBUG)) + if (!OPTS_OPTION_BOOL(OPTION_DUMP) && + !OPTS_OPTION_BOOL(OPTION_DUMPFIN) && + !OPTS_OPTION_BOOL(OPTION_DEBUG)) { return NULL; } @@ -1235,7 +1235,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */ - if (!array->expression.count || array->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) + if (!array->expression.count || array->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count); elemtype = &array->expression.next->expression; @@ -1297,7 +1297,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) int vtype = elemtype->vtype; /* same as with field arrays */ - if (!self->expression.count || self->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) + if (!self->expression.count || self->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); v = ir_builder_create_global(ir, self->name, vtype); @@ -1434,7 +1434,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) } /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */ - if (!self->expression.count || self->expression.count > OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE)) { + if (!self->expression.count || self->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) { compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); } @@ -1706,7 +1706,7 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu for (i = 0; i < vec_size(self->locals); ++i) { if (!ast_local_codegen(self->locals[i], func->ir_func, false)) { - if (OPTION_VALUE_BOOL(OPTION_DEBUG)) + if (OPTS_OPTION_BOOL(OPTION_DEBUG)) compile_error(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name); return false; } diff --git a/code.c b/code.c index e480ed2..43a34c9 100644 --- a/code.c +++ b/code.c @@ -137,8 +137,8 @@ bool code_write(const char *filename, const char *lnofile) { code_header.strings.offset = code_header.globals.offset + (sizeof(int32_t) * vec_size(code_globals)); code_header.strings.length = vec_size(code_chars); code_header.version = 6; - if (OPTION_VALUE_BOOL(OPTION_FORCECRC)) - code_header.crc16 = OPTION_VALUE_U16(OPTION_FORCED_CRC); + if (OPTS_OPTION_BOOL(OPTION_FORCECRC)) + code_header.crc16 = OPTS_OPTION_U16(OPTION_FORCED_CRC); else code_header.crc16 = code_crc; code_header.entfield = code_entfields; diff --git a/ftepp.c b/ftepp.c index 04d64e7..34eec59 100644 --- a/ftepp.c +++ b/ftepp.c @@ -1011,7 +1011,7 @@ static bool ftepp_if_value(ftepp_t *ftepp, bool *out, double *value_out) default: ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp)); - if (OPTION_VALUE_BOOL(OPTION_DEBUG)) + if (OPTS_OPTION_BOOL(OPTION_DEBUG)) ftepp_error(ftepp, "internal: token %i\n", ftepp->token); return false; } @@ -1670,7 +1670,7 @@ bool ftepp_init() /* set the right macro based on the selected standard */ ftepp_add_define(NULL, "GMQCC"); - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_FTEQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) { ftepp_add_define(NULL, "__STD_FTEQCC__"); /* 1.00 */ major[0] = '"'; @@ -1680,15 +1680,15 @@ bool ftepp_init() minor[0] = '"'; minor[1] = '0'; minor[2] = '"'; - } else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_GMQCC) { + } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) { ftepp_add_define(NULL, "__STD_GMQCC__"); sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR); sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR); - } else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCCX) { + } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCCX) { ftepp_add_define(NULL, "__STD_QCCX__"); sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR); sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR); - } else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) { + } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { ftepp_add_define(NULL, "__STD_QCC__"); /* 1.0 */ major[0] = '"'; diff --git a/gmqcc.h b/gmqcc.h index fed9b31..0b97e2f 100644 --- a/gmqcc.h +++ b/gmqcc.h @@ -1131,12 +1131,16 @@ enum { # include "opts.def" OPTION_COUNT }; + +/* disabled for now */ +#if 0 static const char *opts_options_descriptions[OPTION_COUNT + 1] = { # define GMQCC_TYPE_OPTIONS # define GMQCC_DEFINE_FLAG(X, Y) Y, # include "opts.def" "" }; +#endif extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS]; @@ -1163,10 +1167,6 @@ typedef union { } opt_value_t; -#define OPTION_VALUE_BOOL(X) (opts.options[X].B) -#define OPTION_VALUE_U16(X) (opts.options[X].U16) -#define OPTION_VALUE_U32(X) (opts.options[X].U32) -#define OPTION_VALUE_STR(X) (opts.options[X].STR) typedef struct { opt_value_t options [OPTION_COUNT]; uint32_t flags [1 + (COUNT_FLAGS / 32)]; @@ -1184,5 +1184,9 @@ extern opts_cmd_t opts; #define OPTS_WARN(i) OPTS_GENERIC(opts.warn, (i)) #define OPTS_WERROR(i) OPTS_GENERIC(opts.werror, (i)) #define OPTS_OPTIMIZATION(i) OPTS_GENERIC(opts.optimization, (i)) +#define OPTS_OPTION_BOOL(X) (opts.options[X].B) +#define OPTS_OPTION_U16(X) (opts.options[X].U16) +#define OPTS_OPTION_U32(X) (opts.options[X].U32) +#define OPTS_OPTION_STR(X) (opts.options[X].STR) #endif diff --git a/ir.c b/ir.c index 0f437aa..0d7d90e 100644 --- a/ir.c +++ b/ir.c @@ -3228,7 +3228,7 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global) irfun = global->constval.vfunc; def = code_functions + irfun->code_function_def; - if (OPTION_VALUE_BOOL(OPTION_G) || + if (OPTS_OPTION_BOOL(OPTION_G) || !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) || (irfun->flags & IR_FLAG_MASK_NO_OVERLAP)) { @@ -3379,7 +3379,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc def.type = global->vtype; def.offset = vec_size(code_globals); def.name = 0; - if (OPTION_VALUE_BOOL(OPTION_G) || !islocal) + if (OPTS_OPTION_BOOL(OPTION_G) || !islocal) { pushdef = true; @@ -3555,7 +3555,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field) def.offset = (uint16_t)vec_size(code_globals); /* create a global named the same as the field */ - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) { /* in our standard, the global gets a dot prefix */ size_t len = strlen(field->name); char name[1024]; @@ -3693,7 +3693,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename) code_push_statement(&stmt, vec_last(code_linenums)); } - if (OPTION_VALUE_BOOL(OPTION_PP_ONLY)) + if (OPTS_OPTION_BOOL(OPTION_PP_ONLY)) return true; if (vec_size(code_statements) != vec_size(code_linenums)) { @@ -3714,7 +3714,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename) memcpy(vec_add(lnofile, 5), ".lno", 5); } - if (!OPTION_VALUE_BOOL(OPTION_QUIET)) { + if (!OPTS_OPTION_BOOL(OPTION_QUIET)) { if (lnofile) con_out("writing '%s' and '%s'...\n", filename, lnofile); else diff --git a/lexer.c b/lexer.c index c8001d6..f345e47 100644 --- a/lexer.c +++ b/lexer.c @@ -1387,7 +1387,7 @@ int lex_do(lex_file *lex) if (!strcmp(v, keywords_qc[kw])) return (lex->tok.ttype = TOKEN_KEYWORD); } - if (OPTION_VALUE_U32(OPTION_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); diff --git a/main.c b/main.c index 5849b53..dee9a32 100644 --- a/main.c +++ b/main.c @@ -174,14 +174,14 @@ static bool options_parse(int argc, char **argv) { opts_set(opts.werror, WARN_MISSING_RETURN_VALUES, true); - OPTION_VALUE_U32(OPTION_STANDARD) = COMPILER_GMQCC; + OPTS_OPTION_U32(OPTION_STANDARD) = COMPILER_GMQCC; } else if (!strcmp(argarg, "qcc")) { opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false); opts_set(opts.flags, ASSIGN_FUNCTION_TYPES, true); - OPTION_VALUE_U32(OPTION_STANDARD) = COMPILER_QCC; + OPTS_OPTION_U32(OPTION_STANDARD) = COMPILER_QCC; } else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc")) { @@ -192,12 +192,12 @@ static bool options_parse(int argc, char **argv) { opts_set(opts.flags, CORRECT_TERNARY, false); opts_set(opts.warn, WARN_TERNARY_PRECEDENCE, true); - OPTION_VALUE_U32(OPTION_STANDARD) = COMPILER_FTEQCC; + OPTS_OPTION_U32(OPTION_STANDARD) = COMPILER_FTEQCC; } else if (!strcmp(argarg, "qccx")) { opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false); - OPTION_VALUE_U32(OPTION_STANDARD) = COMPILER_QCCX; + OPTS_OPTION_U32(OPTION_STANDARD) = COMPILER_QCCX; } else { con_out("Unknown standard: %s\n", argarg); @@ -207,8 +207,8 @@ static bool options_parse(int argc, char **argv) { } if (options_long_gcc("force-crc", &argc, &argv, &argarg)) { - OPTION_VALUE_BOOL(OPTION_FORCECRC) = true; - OPTION_VALUE_U16 (OPTION_FORCED_CRC) = strtol(argarg, NULL, 0); + OPTS_OPTION_BOOL(OPTION_FORCECRC) = true; + OPTS_OPTION_U16 (OPTION_FORCED_CRC) = strtol(argarg, NULL, 0); continue; } if (options_long_gcc("redirout", &argc, &argv, &redirout)) { @@ -248,19 +248,19 @@ static bool options_parse(int argc, char **argv) { } if (!strcmp(argv[0]+1, "debug")) { - OPTION_VALUE_BOOL(OPTION_DEBUG) = true; + OPTS_OPTION_BOOL(OPTION_DEBUG) = true; continue; } if (!strcmp(argv[0]+1, "dump")) { - OPTION_VALUE_BOOL(OPTION_DUMP) = true; + OPTS_OPTION_BOOL(OPTION_DUMP) = true; continue; } if (!strcmp(argv[0]+1, "dumpfin")) { - OPTION_VALUE_BOOL(OPTION_DUMPFIN) = true; + OPTS_OPTION_BOOL(OPTION_DUMPFIN) = true; continue; } if (!strcmp(argv[0]+1, "memchk")) { - OPTION_VALUE_BOOL(OPTION_MEMCHK) = true; + OPTS_OPTION_BOOL(OPTION_MEMCHK) = true; continue; } if (!strcmp(argv[0]+1, "nocolor")) { @@ -280,18 +280,18 @@ static bool options_parse(int argc, char **argv) { exit(0); case 'E': - OPTION_VALUE_BOOL(OPTION_PP_ONLY) = true; + OPTS_OPTION_BOOL(OPTION_PP_ONLY) = true; opts_set(opts.flags, FTEPP_PREDEFS, true); /* predefs on for -E */ break; /* debug turns on -flno */ case 'g': opts_setflag("LNO", true); - OPTION_VALUE_BOOL(OPTION_G) = true; + OPTS_OPTION_BOOL(OPTION_G) = true; break; case 'q': - OPTION_VALUE_BOOL(OPTION_QUIET) = true; + OPTS_OPTION_BOOL(OPTION_QUIET) = true; break; case 'D': @@ -402,7 +402,7 @@ static bool options_parse(int argc, char **argv) { } if (isdigit(argarg[0])) { uint32_t val = atoi(argarg); - OPTION_VALUE_U32(OPTION_O) = val; + OPTS_OPTION_U32(OPTION_O) = val; opts_setoptimlevel(val); } else { util_strtocmd(argarg, argarg, strlen(argarg)+1); @@ -415,7 +415,7 @@ static bool options_parse(int argc, char **argv) { exit(0); } else if (!strcmp(argarg, "ALL")) - opts_setoptimlevel(OPTION_VALUE_U32(OPTION_O) = 9999); + opts_setoptimlevel(OPTS_OPTION_U32(OPTION_O) = 9999); else if (!strncmp(argarg, "NO_", 3)) { if (!opts_setoptim(argarg+3, false)) { con_out("unknown optimization: %s\n", argarg+3); @@ -436,7 +436,7 @@ static bool options_parse(int argc, char **argv) { con_out("option -o requires an argument: the output file name\n"); return false; } - OPTION_VALUE_STR(OPTION_OUTPUT) = argarg; + OPTS_OPTION_STR(OPTION_OUTPUT) = argarg; opts_output_wasset = true; break; @@ -468,25 +468,25 @@ static bool options_parse(int argc, char **argv) { exit(0); } else if (!strcmp(argv[0]+2, "quiet")) { - OPTION_VALUE_BOOL(OPTION_QUIET) = true; + OPTS_OPTION_BOOL(OPTION_QUIET) = true; break; } else if (!strcmp(argv[0]+2, "correct")) { - OPTION_VALUE_BOOL(OPTION_CORRECTION) = true; + OPTS_OPTION_BOOL(OPTION_CORRECTION) = true; break; } else if (!strcmp(argv[0]+2, "no-correct")) { - OPTION_VALUE_BOOL(OPTION_CORRECTION) = false; + OPTS_OPTION_BOOL(OPTION_CORRECTION) = false; break; } else if (!strcmp(argv[0]+2, "add-info")) { - OPTION_VALUE_BOOL(OPTION_ADD_INFO) = true; + OPTS_OPTION_BOOL(OPTION_ADD_INFO) = true; break; } else { /* All long options with arguments */ if (options_long_witharg("output", &argc, &argv, &argarg)) { - OPTION_VALUE_STR(OPTION_OUTPUT) = argarg; + OPTS_OPTION_STR(OPTION_OUTPUT) = argarg; opts_output_wasset = true; } else { con_out("Unknown parameter: %s\n", argv[0]); @@ -562,10 +562,10 @@ int main(int argc, char **argv) { } /* the standard decides which set of operators to use */ - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) { operators = c_operators; operator_count = c_operator_count; - } else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_FTEQCC) { + } else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) { operators = fte_operators; operator_count = fte_operator_count; } else { @@ -593,22 +593,22 @@ int main(int argc, char **argv) { } } - if (OPTION_VALUE_BOOL(OPTION_DUMP)) { + if (OPTS_OPTION_BOOL(OPTION_DUMP)) { for (itr = 0; itr < COUNT_FLAGS; ++itr) con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr)); for (itr = 0; itr < COUNT_WARNINGS; ++itr) con_out("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(itr)); - con_out("output = %s\n", OPTION_VALUE_STR(OPTION_OUTPUT)); - con_out("optimization level = %u\n", OPTION_VALUE_U32(OPTION_O)); - con_out("standard = %u\n", OPTION_VALUE_U32(OPTION_STANDARD)); + con_out("output = %s\n", OPTS_OPTION_STR(OPTION_OUTPUT)); + con_out("optimization level = %u\n", OPTS_OPTION_U32(OPTION_O)); + con_out("standard = %u\n", OPTS_OPTION_U32(OPTION_STANDARD)); } - if (OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { + if (OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { if (opts_output_wasset) { - outfile = file_open(OPTION_VALUE_STR(OPTION_OUTPUT), "wb"); + outfile = file_open(OPTS_OPTION_STR(OPTION_OUTPUT), "wb"); if (!outfile) { - con_err("failed to open `%s` for writing\n", OPTION_VALUE_STR(OPTION_OUTPUT)); + con_err("failed to open `%s` for writing\n", OPTS_OPTION_STR(OPTION_OUTPUT)); retval = 1; goto cleanup; } @@ -618,7 +618,7 @@ int main(int argc, char **argv) { } } - if (!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { + if (!OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { if (!parser_init()) { con_err("failed to initialize parser\n"); retval = 1; @@ -626,7 +626,7 @@ int main(int argc, char **argv) { } } - if (OPTION_VALUE_BOOL(OPTION_PP_ONLY) || OPTS_FLAG(FTEPP)) { + if (OPTS_OPTION_BOOL(OPTION_PP_ONLY) || OPTS_FLAG(FTEPP)) { if (!ftepp_init()) { con_err("failed to initialize parser\n"); retval = 1; @@ -640,7 +640,7 @@ int main(int argc, char **argv) { util_debug("COM", "starting ...\n"); /* add macros */ - if (OPTION_VALUE_BOOL(OPTION_PP_ONLY) || OPTS_FLAG(FTEPP)) { + if (OPTS_OPTION_BOOL(OPTION_PP_ONLY) || OPTS_FLAG(FTEPP)) { for (itr = 0; itr < vec_size(ppems); itr++) { ftepp_add_macro(ppems[itr].name, ppems[itr].value); mem_d(ppems[itr].name); @@ -673,7 +673,7 @@ int main(int argc, char **argv) { } if (!opts_output_wasset) { - OPTION_VALUE_STR(OPTION_OUTPUT) = util_strdup(line); + OPTS_OPTION_STR(OPTION_OUTPUT) = util_strdup(line); opts_output_free = true; } @@ -695,15 +695,15 @@ srcdone: goto cleanup; if (vec_size(items)) { - if (!OPTION_VALUE_BOOL(OPTION_QUIET) && - !OPTION_VALUE_BOOL(OPTION_PP_ONLY)) + if (!OPTS_OPTION_BOOL(OPTION_QUIET) && + !OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { con_out("Mode: %s\n", (progs_src ? "progs.src" : "manual")); con_out("There are %lu items to compile:\n", (unsigned long)vec_size(items)); } for (itr = 0; itr < vec_size(items); ++itr) { - if (!OPTION_VALUE_BOOL(OPTION_QUIET) && - !OPTION_VALUE_BOOL(OPTION_PP_ONLY)) + if (!OPTS_OPTION_BOOL(OPTION_QUIET) && + !OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { con_out(" item: %s (%s)\n", items[itr].filename, @@ -713,7 +713,7 @@ srcdone: ("unknown")))))); } - if (OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { + if (OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { const char *out; if (!ftepp_preprocess_file(items[itr].filename)) { retval = 1; @@ -755,8 +755,8 @@ srcdone: } ftepp_finish(); - if (!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { - if (!parser_finish(OPTION_VALUE_STR(OPTION_OUTPUT))) { + if (!OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { + if (!parser_finish(OPTS_OPTION_STR(OPTION_OUTPUT))) { retval = 1; goto cleanup; } @@ -764,8 +764,8 @@ srcdone: } /* stuff */ - if (!OPTION_VALUE_BOOL(OPTION_QUIET) && - !OPTION_VALUE_BOOL(OPTION_PP_ONLY)) + if (!OPTS_OPTION_BOOL(OPTION_QUIET) && + !OPTS_OPTION_BOOL(OPTION_PP_ONLY)) { for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) { if (opts_optimizationcount[itr]) { @@ -781,10 +781,10 @@ cleanup: vec_free(items); vec_free(ppems); - if (!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) + if (!OPTS_OPTION_BOOL(OPTION_PP_ONLY)) parser_cleanup(); if (opts_output_free) - mem_d(OPTION_VALUE_STR(OPTION_OUTPUT)); + mem_d(OPTS_OPTION_STR(OPTION_OUTPUT)); if (operators_free) mem_d((void*)operators); diff --git a/opts.c b/opts.c index 5ea4f6e..c0be2dd 100644 --- a/opts.c +++ b/opts.c @@ -27,7 +27,7 @@ opts_cmd_t opts; /* command lien options */ static void opts_setdefault() { memset(&opts, 0, sizeof(opts_cmd_t)); - OPTION_VALUE_BOOL(OPTION_CORRECTION) = true; + OPTS_OPTION_BOOL(OPTION_CORRECTION) = true; /* warnings */ opts_set(opts.warn, WARN_UNUSED_VARIABLE, true); @@ -92,9 +92,9 @@ void opts_restore_non_Werror_all() { void opts_init(const char *output, int standard, size_t arraysize) { opts_setdefault(); - OPTION_VALUE_STR(OPTION_OUTPUT) = (char*)output; - OPTION_VALUE_U32(OPTION_STANDARD) = standard; - OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE) = arraysize; + OPTS_OPTION_STR(OPTION_OUTPUT) = (char*)output; + OPTS_OPTION_U32(OPTION_STANDARD) = standard; + OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE) = arraysize; } static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) { diff --git a/parser.c b/parser.c index f407690..a54094a 100644 --- a/parser.c +++ b/parser.c @@ -630,7 +630,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { #if 0 /* This is not broken in fteqcc anymore */ - if (OPTION_VALUE_U32(OPTION_STANDARD) != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { /* this error doesn't need to make us bail out */ (void)!parsewarning(parser, WARN_EXTENSIONS, "accessing array-field members of an entity without parenthesis\n" @@ -1784,7 +1784,7 @@ static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels) * We should also consider adding correction tables for * other things as well. */ - if (OPTION_VALUE_BOOL(OPTION_CORRECTION)) { + if (OPTS_OPTION_BOOL(OPTION_CORRECTION)) { correction_t corr; correct_init(&corr); @@ -2635,7 +2635,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou if (typevar || parser->tok == TOKEN_TYPENAME) { #if 0 - if (OPTION_VALUE_U32(OPTION_STANDARD) != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { if (parsewarning(parser, WARN_EXTENSIONS, "current standard does not allow variable declarations in for-loop initializers")) goto onerr; @@ -3440,7 +3440,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "cannot declare a variable from here"); return false; } - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } @@ -3507,7 +3507,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else if (!strcmp(parser_tokval(parser), "for")) { - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?")) return false; } @@ -4109,7 +4109,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) if (parser->tok == ';') return parser_next(parser); - else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) + else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)"); return retval; @@ -4625,7 +4625,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) vec_free(params); /* sanity check */ - if (vec_size(params) > 8 && OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) + if (vec_size(params) > 8 && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard"); /* parse-out */ @@ -4839,7 +4839,7 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va } /* now there may be function parens again */ - if (parser->tok == '(' && OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) + if (parser->tok == '(' && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); if (parser->tok == '(' && wasarray) parseerror(parser, "arrays as part of a return type is not supported"); @@ -4978,7 +4978,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield /* Part 0: finish the type */ if (parser->tok == '(') { - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); var = parse_parameter_list(parser, var); if (!var) { @@ -5001,7 +5001,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } /* for functions returning functions */ while (parser->tok == '(') { - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); var = parse_parameter_list(parser, var); if (!var) { @@ -5071,7 +5071,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; */ } - if ((OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC || OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_FTEQCC) && + if ((OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC || OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_FTEQCC) && (old = parser_find_global(parser, var->name))) { parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); @@ -5143,7 +5143,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield ast_delete(var); var = proto; } - if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC && + if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC && (old = parser_find_field(parser, var->name))) { parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); @@ -5174,7 +5174,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield retval = false; goto cleanup; } - if (OPTION_VALUE_U32(OPTION_STANDARD) != COMPILER_GMQCC) { + if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) { ast_delete(var); var = NULL; goto skipvar; @@ -5354,7 +5354,7 @@ skipvar: break; } - if (localblock && OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) { + if (localblock && OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { if (parsewarning(parser, WARN_LOCAL_CONSTANTS, "initializing expression turns variable `%s` into a constant in this standard", var->name) ) @@ -5374,7 +5374,7 @@ skipvar: break; } } - else if (OPTION_VALUE_U32(OPTION_STANDARD) == COMPILER_QCC) { + else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) { parseerror(parser, "expected '=' before function body in this standard"); } @@ -5735,7 +5735,7 @@ bool parser_init() parser->const_vec[1] = ast_value_new(empty_ctx, "", TYPE_NOEXPR); parser->const_vec[2] = ast_value_new(empty_ctx, "", TYPE_NOEXPR); - if (OPTION_VALUE_BOOL(OPTION_ADD_INFO)) { + if (OPTS_OPTION_BOOL(OPTION_ADD_INFO)) { parser->reserved_version = ast_value_new(empty_ctx, "reserved:version", TYPE_STRING); parser->reserved_version->cvq = CV_CONST; parser->reserved_version->hasvalue = true; @@ -6024,7 +6024,7 @@ bool parser_finish(const char *output) return false; } } - if (OPTION_VALUE_BOOL(OPTION_DUMP)) + if (OPTS_OPTION_BOOL(OPTION_DUMP)) ir_builder_dump(ir, con_out); for (i = 0; i < vec_size(parser->functions); ++i) { if (!ir_function_finalize(parser->functions[i]->ir_func)) { @@ -6041,7 +6041,7 @@ bool parser_finish(const char *output) } if (retval) { - if (OPTION_VALUE_BOOL(OPTION_DUMPFIN)) + if (OPTS_OPTION_BOOL(OPTION_DUMPFIN)) ir_builder_dump(ir, con_out); generate_checksum(parser); diff --git a/test.c b/test.c index c33b4ac..a7b02c7 100644 --- a/test.c +++ b/test.c @@ -1242,11 +1242,11 @@ int main(int argc, char **argv) { con_change(redirout, redirerr); if (!strcmp(argv[0]+1, "debug")) { - OPTION_VALUE_BOOL(OPTION_DEBUG) = true; + OPTS_OPTION_BOOL(OPTION_DEBUG) = true; continue; } if (!strcmp(argv[0]+1, "memchk")) { - OPTION_VALUE_BOOL(OPTION_MEMCHK) = true; + OPTS_OPTION_BOOL(OPTION_MEMCHK) = true; continue; } if (!strcmp(argv[0]+1, "nocolor")) { diff --git a/util.c b/util.c index 0ac4df3..1810adf 100644 --- a/util.c +++ b/util.c @@ -132,7 +132,7 @@ void *util_memory_r(void *ptrn, size_t byte, unsigned int line, const char *file void util_meminfo() { struct memblock_t *info; - if (!OPTION_VALUE_BOOL(OPTION_MEMCHK)) + if (!OPTS_OPTION_BOOL(OPTION_MEMCHK)) return; for (info = mem_start; info; info = info->next) { @@ -175,10 +175,10 @@ char *util_strdup(const char *s) { void util_debug(const char *area, const char *ms, ...) { va_list va; - if (!OPTION_VALUE_BOOL(OPTION_DEBUG)) + if (!OPTS_OPTION_BOOL(OPTION_DEBUG)) return; - if (!strcmp(area, "MEM") && !OPTION_VALUE_BOOL(OPTION_MEMCHK)) + if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK)) return; va_start(va, ms); -- 2.39.2