darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-01-18 22:31: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; size_t len;
char *from; char *from;
if (!OPTION_VALUE_BOOL(OPTION_DUMP) && if (!OPTS_OPTION_BOOL(OPTION_DUMP) &&
!OPTION_VALUE_BOOL(OPTION_DUMPFIN) && !OPTS_OPTION_BOOL(OPTION_DUMPFIN) &&
!OPTION_VALUE_BOOL(OPTION_DEBUG)) !OPTS_OPTION_BOOL(OPTION_DEBUG))
{ {
return NULL; 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 */ /* 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); compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count);
elemtype = &array->expression.next->expression; 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; int vtype = elemtype->vtype;
/* same as with field arrays */ /* 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); compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count);
v = ir_builder_create_global(ir, self->name, vtype); 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 */ /* 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); 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) for (i = 0; i < vec_size(self->locals); ++i)
{ {
if (!ast_local_codegen(self->locals[i], func->ir_func, false)) { 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); compile_error(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name);
return false; 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.offset = code_header.globals.offset + (sizeof(int32_t) * vec_size(code_globals));
code_header.strings.length = vec_size(code_chars); code_header.strings.length = vec_size(code_chars);
code_header.version = 6; code_header.version = 6;
if (OPTION_VALUE_BOOL(OPTION_FORCECRC)) if (OPTS_OPTION_BOOL(OPTION_FORCECRC))
code_header.crc16 = OPTION_VALUE_U16(OPTION_FORCED_CRC); code_header.crc16 = OPTS_OPTION_U16(OPTION_FORCED_CRC);
else else
code_header.crc16 = code_crc; code_header.crc16 = code_crc;
code_header.entfield = code_entfields; 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: default:
ftepp_error(ftepp, "junk in #if: `%s` ...", ftepp_tokval(ftepp)); 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); ftepp_error(ftepp, "internal: token %i\n", ftepp->token);
return false; return false;
} }
@ -1670,7 +1670,7 @@ bool ftepp_init()
/* set the right macro based on the selected standard */ /* set the right macro based on the selected standard */
ftepp_add_define(NULL, "GMQCC"); 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__"); ftepp_add_define(NULL, "__STD_FTEQCC__");
/* 1.00 */ /* 1.00 */
major[0] = '"'; major[0] = '"';
@ -1680,15 +1680,15 @@ bool ftepp_init()
minor[0] = '"'; minor[0] = '"';
minor[1] = '0'; minor[1] = '0';
minor[2] = '"'; 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__"); ftepp_add_define(NULL, "__STD_GMQCC__");
sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR); sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR);
sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR); 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__"); ftepp_add_define(NULL, "__STD_QCCX__");
sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR); sprintf(major, "\"%d\"", GMQCC_VERSION_MAJOR);
sprintf(minor, "\"%d\"", GMQCC_VERSION_MINOR); 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__"); ftepp_add_define(NULL, "__STD_QCC__");
/* 1.0 */ /* 1.0 */
major[0] = '"'; major[0] = '"';

12
gmqcc.h
View file

@ -1131,12 +1131,16 @@ enum {
# include "opts.def" # include "opts.def"
OPTION_COUNT OPTION_COUNT
}; };
/* disabled for now */
#if 0
static const char *opts_options_descriptions[OPTION_COUNT + 1] = { static const char *opts_options_descriptions[OPTION_COUNT + 1] = {
# define GMQCC_TYPE_OPTIONS # define GMQCC_TYPE_OPTIONS
# define GMQCC_DEFINE_FLAG(X, Y) Y, # define GMQCC_DEFINE_FLAG(X, Y) Y,
# include "opts.def" # include "opts.def"
"" ""
}; };
#endif
extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS]; extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS];
@ -1163,10 +1167,6 @@ typedef union {
} opt_value_t; } 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 { typedef struct {
opt_value_t options [OPTION_COUNT]; opt_value_t options [OPTION_COUNT];
uint32_t flags [1 + (COUNT_FLAGS / 32)]; 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_WARN(i) OPTS_GENERIC(opts.warn, (i))
#define OPTS_WERROR(i) OPTS_GENERIC(opts.werror, (i)) #define OPTS_WERROR(i) OPTS_GENERIC(opts.werror, (i))
#define OPTS_OPTIMIZATION(i) OPTS_GENERIC(opts.optimization, (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 #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; irfun = global->constval.vfunc;
def = code_functions + irfun->code_function_def; def = code_functions + irfun->code_function_def;
if (OPTION_VALUE_BOOL(OPTION_G) || if (OPTS_OPTION_BOOL(OPTION_G) ||
!OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) || !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) ||
(irfun->flags & IR_FLAG_MASK_NO_OVERLAP)) (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.type = global->vtype;
def.offset = vec_size(code_globals); def.offset = vec_size(code_globals);
def.name = 0; def.name = 0;
if (OPTION_VALUE_BOOL(OPTION_G) || !islocal) if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{ {
pushdef = true; 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); def.offset = (uint16_t)vec_size(code_globals);
/* create a global named the same as the field */ /* 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 */ /* in our standard, the global gets a dot prefix */
size_t len = strlen(field->name); size_t len = strlen(field->name);
char name[1024]; 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)); code_push_statement(&stmt, vec_last(code_linenums));
} }
if (OPTION_VALUE_BOOL(OPTION_PP_ONLY)) if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
return true; return true;
if (vec_size(code_statements) != vec_size(code_linenums)) { 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); memcpy(vec_add(lnofile, 5), ".lno", 5);
} }
if (!OPTION_VALUE_BOOL(OPTION_QUIET)) { if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
if (lnofile) if (lnofile)
con_out("writing '%s' and '%s'...\n", filename, lnofile); con_out("writing '%s' and '%s'...\n", filename, lnofile);
else else

2
lexer.c
View file

@ -1387,7 +1387,7 @@ int lex_do(lex_file *lex)
if (!strcmp(v, keywords_qc[kw])) if (!strcmp(v, keywords_qc[kw]))
return (lex->tok.ttype = TOKEN_KEYWORD); 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) { for (kw = 0; kw < num_keywords_fg; ++kw) {
if (!strcmp(v, keywords_fg[kw])) if (!strcmp(v, keywords_fg[kw]))
return (lex->tok.ttype = TOKEN_KEYWORD); 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); 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")) { } else if (!strcmp(argarg, "qcc")) {
opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false); opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false);
opts_set(opts.flags, ASSIGN_FUNCTION_TYPES, true); 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")) { } 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.flags, CORRECT_TERNARY, false);
opts_set(opts.warn, WARN_TERNARY_PRECEDENCE, true); 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")) { } else if (!strcmp(argarg, "qccx")) {
opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false); opts_set(opts.flags, ADJUST_VECTOR_FIELDS, false);
OPTION_VALUE_U32(OPTION_STANDARD) = COMPILER_QCCX; OPTS_OPTION_U32(OPTION_STANDARD) = COMPILER_QCCX;
} else { } else {
con_out("Unknown standard: %s\n", argarg); 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)) { if (options_long_gcc("force-crc", &argc, &argv, &argarg)) {
OPTION_VALUE_BOOL(OPTION_FORCECRC) = true; OPTS_OPTION_BOOL(OPTION_FORCECRC) = true;
OPTION_VALUE_U16 (OPTION_FORCED_CRC) = strtol(argarg, NULL, 0); OPTS_OPTION_U16 (OPTION_FORCED_CRC) = strtol(argarg, NULL, 0);
continue; continue;
} }
if (options_long_gcc("redirout", &argc, &argv, &redirout)) { 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")) { if (!strcmp(argv[0]+1, "debug")) {
OPTION_VALUE_BOOL(OPTION_DEBUG) = true; OPTS_OPTION_BOOL(OPTION_DEBUG) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "dump")) { if (!strcmp(argv[0]+1, "dump")) {
OPTION_VALUE_BOOL(OPTION_DUMP) = true; OPTS_OPTION_BOOL(OPTION_DUMP) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "dumpfin")) { if (!strcmp(argv[0]+1, "dumpfin")) {
OPTION_VALUE_BOOL(OPTION_DUMPFIN) = true; OPTS_OPTION_BOOL(OPTION_DUMPFIN) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "memchk")) { if (!strcmp(argv[0]+1, "memchk")) {
OPTION_VALUE_BOOL(OPTION_MEMCHK) = true; OPTS_OPTION_BOOL(OPTION_MEMCHK) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "nocolor")) { if (!strcmp(argv[0]+1, "nocolor")) {
@ -280,18 +280,18 @@ static bool options_parse(int argc, char **argv) {
exit(0); exit(0);
case 'E': 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 */ opts_set(opts.flags, FTEPP_PREDEFS, true); /* predefs on for -E */
break; break;
/* debug turns on -flno */ /* debug turns on -flno */
case 'g': case 'g':
opts_setflag("LNO", true); opts_setflag("LNO", true);
OPTION_VALUE_BOOL(OPTION_G) = true; OPTS_OPTION_BOOL(OPTION_G) = true;
break; break;
case 'q': case 'q':
OPTION_VALUE_BOOL(OPTION_QUIET) = true; OPTS_OPTION_BOOL(OPTION_QUIET) = true;
break; break;
case 'D': case 'D':
@ -402,7 +402,7 @@ static bool options_parse(int argc, char **argv) {
} }
if (isdigit(argarg[0])) { if (isdigit(argarg[0])) {
uint32_t val = atoi(argarg); uint32_t val = atoi(argarg);
OPTION_VALUE_U32(OPTION_O) = val; OPTS_OPTION_U32(OPTION_O) = val;
opts_setoptimlevel(val); opts_setoptimlevel(val);
} else { } else {
util_strtocmd(argarg, argarg, strlen(argarg)+1); util_strtocmd(argarg, argarg, strlen(argarg)+1);
@ -415,7 +415,7 @@ static bool options_parse(int argc, char **argv) {
exit(0); exit(0);
} }
else if (!strcmp(argarg, "ALL")) 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)) { else if (!strncmp(argarg, "NO_", 3)) {
if (!opts_setoptim(argarg+3, false)) { if (!opts_setoptim(argarg+3, false)) {
con_out("unknown optimization: %s\n", argarg+3); 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"); con_out("option -o requires an argument: the output file name\n");
return false; return false;
} }
OPTION_VALUE_STR(OPTION_OUTPUT) = argarg; OPTS_OPTION_STR(OPTION_OUTPUT) = argarg;
opts_output_wasset = true; opts_output_wasset = true;
break; break;
@ -468,25 +468,25 @@ static bool options_parse(int argc, char **argv) {
exit(0); exit(0);
} }
else if (!strcmp(argv[0]+2, "quiet")) { else if (!strcmp(argv[0]+2, "quiet")) {
OPTION_VALUE_BOOL(OPTION_QUIET) = true; OPTS_OPTION_BOOL(OPTION_QUIET) = true;
break; break;
} }
else if (!strcmp(argv[0]+2, "correct")) { else if (!strcmp(argv[0]+2, "correct")) {
OPTION_VALUE_BOOL(OPTION_CORRECTION) = true; OPTS_OPTION_BOOL(OPTION_CORRECTION) = true;
break; break;
} }
else if (!strcmp(argv[0]+2, "no-correct")) { else if (!strcmp(argv[0]+2, "no-correct")) {
OPTION_VALUE_BOOL(OPTION_CORRECTION) = false; OPTS_OPTION_BOOL(OPTION_CORRECTION) = false;
break; break;
} }
else if (!strcmp(argv[0]+2, "add-info")) { else if (!strcmp(argv[0]+2, "add-info")) {
OPTION_VALUE_BOOL(OPTION_ADD_INFO) = true; OPTS_OPTION_BOOL(OPTION_ADD_INFO) = true;
break; break;
} }
else { else {
/* All long options with arguments */ /* All long options with arguments */
if (options_long_witharg("output", &argc, &argv, &argarg)) { if (options_long_witharg("output", &argc, &argv, &argarg)) {
OPTION_VALUE_STR(OPTION_OUTPUT) = argarg; OPTS_OPTION_STR(OPTION_OUTPUT) = argarg;
opts_output_wasset = true; opts_output_wasset = true;
} else { } else {
con_out("Unknown parameter: %s\n", argv[0]); 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 */ /* 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; operators = c_operators;
operator_count = c_operator_count; 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; operators = fte_operators;
operator_count = fte_operator_count; operator_count = fte_operator_count;
} else { } 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) for (itr = 0; itr < COUNT_FLAGS; ++itr)
con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr)); con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
for (itr = 0; itr < COUNT_WARNINGS; ++itr) for (itr = 0; itr < COUNT_WARNINGS; ++itr)
con_out("Warning %s = %i\n", opts_warn_list[itr].name, OPTS_WARN(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("output = %s\n", OPTS_OPTION_STR(OPTION_OUTPUT));
con_out("optimization level = %u\n", OPTION_VALUE_U32(OPTION_O)); con_out("optimization level = %u\n", OPTS_OPTION_U32(OPTION_O));
con_out("standard = %u\n", OPTION_VALUE_U32(OPTION_STANDARD)); 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) { if (opts_output_wasset) {
outfile = file_open(OPTION_VALUE_STR(OPTION_OUTPUT), "wb"); outfile = file_open(OPTS_OPTION_STR(OPTION_OUTPUT), "wb");
if (!outfile) { 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; retval = 1;
goto cleanup; 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()) { if (!parser_init()) {
con_err("failed to initialize parser\n"); con_err("failed to initialize parser\n");
retval = 1; 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()) { if (!ftepp_init()) {
con_err("failed to initialize parser\n"); con_err("failed to initialize parser\n");
retval = 1; retval = 1;
@ -640,7 +640,7 @@ int main(int argc, char **argv) {
util_debug("COM", "starting ...\n"); util_debug("COM", "starting ...\n");
/* add macros */ /* 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++) { for (itr = 0; itr < vec_size(ppems); itr++) {
ftepp_add_macro(ppems[itr].name, ppems[itr].value); ftepp_add_macro(ppems[itr].name, ppems[itr].value);
mem_d(ppems[itr].name); mem_d(ppems[itr].name);
@ -673,7 +673,7 @@ int main(int argc, char **argv) {
} }
if (!opts_output_wasset) { if (!opts_output_wasset) {
OPTION_VALUE_STR(OPTION_OUTPUT) = util_strdup(line); OPTS_OPTION_STR(OPTION_OUTPUT) = util_strdup(line);
opts_output_free = true; opts_output_free = true;
} }
@ -695,15 +695,15 @@ srcdone:
goto cleanup; goto cleanup;
if (vec_size(items)) { if (vec_size(items)) {
if (!OPTION_VALUE_BOOL(OPTION_QUIET) && if (!OPTS_OPTION_BOOL(OPTION_QUIET) &&
!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) !OPTS_OPTION_BOOL(OPTION_PP_ONLY))
{ {
con_out("Mode: %s\n", (progs_src ? "progs.src" : "manual")); con_out("Mode: %s\n", (progs_src ? "progs.src" : "manual"));
con_out("There are %lu items to compile:\n", (unsigned long)vec_size(items)); con_out("There are %lu items to compile:\n", (unsigned long)vec_size(items));
} }
for (itr = 0; itr < vec_size(items); ++itr) { for (itr = 0; itr < vec_size(items); ++itr) {
if (!OPTION_VALUE_BOOL(OPTION_QUIET) && if (!OPTS_OPTION_BOOL(OPTION_QUIET) &&
!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) !OPTS_OPTION_BOOL(OPTION_PP_ONLY))
{ {
con_out(" item: %s (%s)\n", con_out(" item: %s (%s)\n",
items[itr].filename, items[itr].filename,
@ -713,7 +713,7 @@ srcdone:
("unknown")))))); ("unknown"))))));
} }
if (OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { if (OPTS_OPTION_BOOL(OPTION_PP_ONLY)) {
const char *out; const char *out;
if (!ftepp_preprocess_file(items[itr].filename)) { if (!ftepp_preprocess_file(items[itr].filename)) {
retval = 1; retval = 1;
@ -755,8 +755,8 @@ srcdone:
} }
ftepp_finish(); ftepp_finish();
if (!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) { if (!OPTS_OPTION_BOOL(OPTION_PP_ONLY)) {
if (!parser_finish(OPTION_VALUE_STR(OPTION_OUTPUT))) { if (!parser_finish(OPTS_OPTION_STR(OPTION_OUTPUT))) {
retval = 1; retval = 1;
goto cleanup; goto cleanup;
} }
@ -764,8 +764,8 @@ srcdone:
} }
/* stuff */ /* stuff */
if (!OPTION_VALUE_BOOL(OPTION_QUIET) && if (!OPTS_OPTION_BOOL(OPTION_QUIET) &&
!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) !OPTS_OPTION_BOOL(OPTION_PP_ONLY))
{ {
for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) { for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) {
if (opts_optimizationcount[itr]) { if (opts_optimizationcount[itr]) {
@ -781,10 +781,10 @@ cleanup:
vec_free(items); vec_free(items);
vec_free(ppems); vec_free(ppems);
if (!OPTION_VALUE_BOOL(OPTION_PP_ONLY)) if (!OPTS_OPTION_BOOL(OPTION_PP_ONLY))
parser_cleanup(); parser_cleanup();
if (opts_output_free) if (opts_output_free)
mem_d(OPTION_VALUE_STR(OPTION_OUTPUT)); mem_d(OPTS_OPTION_STR(OPTION_OUTPUT));
if (operators_free) if (operators_free)
mem_d((void*)operators); mem_d((void*)operators);

8
opts.c
View file

@ -27,7 +27,7 @@ opts_cmd_t opts; /* command lien options */
static void opts_setdefault() { static void opts_setdefault() {
memset(&opts, 0, sizeof(opts_cmd_t)); memset(&opts, 0, sizeof(opts_cmd_t));
OPTION_VALUE_BOOL(OPTION_CORRECTION) = true; OPTS_OPTION_BOOL(OPTION_CORRECTION) = true;
/* warnings */ /* warnings */
opts_set(opts.warn, WARN_UNUSED_VARIABLE, true); 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) { void opts_init(const char *output, int standard, size_t arraysize) {
opts_setdefault(); opts_setdefault();
OPTION_VALUE_STR(OPTION_OUTPUT) = (char*)output; OPTS_OPTION_STR(OPTION_OUTPUT) = (char*)output;
OPTION_VALUE_U32(OPTION_STANDARD) = standard; OPTS_OPTION_U32(OPTION_STANDARD) = standard;
OPTION_VALUE_U32(OPTION_MAX_ARRAY_SIZE) = arraysize; 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) { 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 #if 0
/* This is not broken in fteqcc anymore */ /* 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 */ /* this error doesn't need to make us bail out */
(void)!parsewarning(parser, WARN_EXTENSIONS, (void)!parsewarning(parser, WARN_EXTENSIONS,
"accessing array-field members of an entity without parenthesis\n" "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 * We should also consider adding correction tables for
* other things as well. * other things as well.
*/ */
if (OPTION_VALUE_BOOL(OPTION_CORRECTION)) { if (OPTS_OPTION_BOOL(OPTION_CORRECTION)) {
correction_t corr; correction_t corr;
correct_init(&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 (typevar || parser->tok == TOKEN_TYPENAME) {
#if 0 #if 0
if (OPTION_VALUE_U32(OPTION_STANDARD) != COMPILER_GMQCC) { if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
if (parsewarning(parser, WARN_EXTENSIONS, if (parsewarning(parser, WARN_EXTENSIONS,
"current standard does not allow variable declarations in for-loop initializers")) "current standard does not allow variable declarations in for-loop initializers"))
goto onerr; 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"); parseerror(parser, "cannot declare a variable from here");
return false; 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")) if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
return false; 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")) 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=?")) 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; return false;
} }
@ -4109,7 +4109,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
if (parser->tok == ';') if (parser->tok == ';')
return parser_next(parser); 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)"); parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
return retval; return retval;
@ -4625,7 +4625,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var)
vec_free(params); vec_free(params);
/* sanity check */ /* 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"); (void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard");
/* parse-out */ /* 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 */ /* 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"); parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
if (parser->tok == '(' && wasarray) if (parser->tok == '(' && wasarray)
parseerror(parser, "arrays as part of a return type is not supported"); 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 */ /* Part 0: finish the type */
if (parser->tok == '(') { 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"); parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
var = parse_parameter_list(parser, var); var = parse_parameter_list(parser, var);
if (!var) { if (!var) {
@ -5001,7 +5001,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
} }
/* for functions returning functions */ /* for functions returning functions */
while (parser->tok == '(') { 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"); parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
var = parse_parameter_list(parser, var); var = parse_parameter_list(parser, var);
if (!var) { if (!var) {
@ -5071,7 +5071,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
goto cleanup; 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))) (old = parser_find_global(parser, var->name)))
{ {
parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); 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); ast_delete(var);
var = proto; 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))) (old = parser_find_field(parser, var->name)))
{ {
parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); 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; retval = false;
goto cleanup; goto cleanup;
} }
if (OPTION_VALUE_U32(OPTION_STANDARD) != COMPILER_GMQCC) { if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
ast_delete(var); ast_delete(var);
var = NULL; var = NULL;
goto skipvar; goto skipvar;
@ -5354,7 +5354,7 @@ skipvar:
break; 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, if (parsewarning(parser, WARN_LOCAL_CONSTANTS,
"initializing expression turns variable `%s` into a constant in this standard", "initializing expression turns variable `%s` into a constant in this standard",
var->name) ) var->name) )
@ -5374,7 +5374,7 @@ skipvar:
break; 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"); 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[1] = ast_value_new(empty_ctx, "<vector.y>", TYPE_NOEXPR);
parser->const_vec[2] = ast_value_new(empty_ctx, "<vector.z>", 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 = ast_value_new(empty_ctx, "reserved:version", TYPE_STRING);
parser->reserved_version->cvq = CV_CONST; parser->reserved_version->cvq = CV_CONST;
parser->reserved_version->hasvalue = true; parser->reserved_version->hasvalue = true;
@ -6024,7 +6024,7 @@ bool parser_finish(const char *output)
return false; return false;
} }
} }
if (OPTION_VALUE_BOOL(OPTION_DUMP)) if (OPTS_OPTION_BOOL(OPTION_DUMP))
ir_builder_dump(ir, con_out); ir_builder_dump(ir, con_out);
for (i = 0; i < vec_size(parser->functions); ++i) { for (i = 0; i < vec_size(parser->functions); ++i) {
if (!ir_function_finalize(parser->functions[i]->ir_func)) { if (!ir_function_finalize(parser->functions[i]->ir_func)) {
@ -6041,7 +6041,7 @@ bool parser_finish(const char *output)
} }
if (retval) { if (retval) {
if (OPTION_VALUE_BOOL(OPTION_DUMPFIN)) if (OPTS_OPTION_BOOL(OPTION_DUMPFIN))
ir_builder_dump(ir, con_out); ir_builder_dump(ir, con_out);
generate_checksum(parser); generate_checksum(parser);

4
test.c
View file

@ -1242,11 +1242,11 @@ int main(int argc, char **argv) {
con_change(redirout, redirerr); con_change(redirout, redirerr);
if (!strcmp(argv[0]+1, "debug")) { if (!strcmp(argv[0]+1, "debug")) {
OPTION_VALUE_BOOL(OPTION_DEBUG) = true; OPTS_OPTION_BOOL(OPTION_DEBUG) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "memchk")) { if (!strcmp(argv[0]+1, "memchk")) {
OPTION_VALUE_BOOL(OPTION_MEMCHK) = true; OPTS_OPTION_BOOL(OPTION_MEMCHK) = true;
continue; continue;
} }
if (!strcmp(argv[0]+1, "nocolor")) { 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() { void util_meminfo() {
struct memblock_t *info; struct memblock_t *info;
if (!OPTION_VALUE_BOOL(OPTION_MEMCHK)) if (!OPTS_OPTION_BOOL(OPTION_MEMCHK))
return; return;
for (info = mem_start; info; info = info->next) { 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, ...) { void util_debug(const char *area, const char *ms, ...) {
va_list va; va_list va;
if (!OPTION_VALUE_BOOL(OPTION_DEBUG)) if (!OPTS_OPTION_BOOL(OPTION_DEBUG))
return; return;
if (!strcmp(area, "MEM") && !OPTION_VALUE_BOOL(OPTION_MEMCHK)) if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK))
return; return;
va_start(va, ms); va_start(va, ms);