darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-01-18 14:21:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename

Browse source
This commit is contained in:
Dale Weiler 2013-01-30 05:35:07 +00:00
parent d201cfe6b4
commit 36c5722273
11 changed files with 100 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
ast.c
View file

@ -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;
}

4
code.c
View file

@ -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;

10
ftepp.c
View file

@ -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] = '"';

12
gmqcc.h
View file

@ -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

10
ir.c
View file

@ -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

2
lexer.c
View file

@ -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);

90
main.c
View file

@ -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);

8
opts.c
View file

@ -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) {

36
parser.c
View file

@ -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, "<vector.y>", TYPE_NOEXPR);
parser->const_vec[2] = ast_value_new(empty_ctx, "<vector.z>", 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);

4
test.c
View file

@ -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")) {

6
util.c
View file

@ -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);