#include "lexer.h"
uint32_t opts_flags[1 + (COUNT_FLAGS / 32)];
+uint32_t opts_optimization[1 + (COUNT_OPTIMIZATIONS / 32)];
+
+/* counter increased in ir.c */
+unsigned int optimization_count[COUNT_OPTIMIZATIONS];
uint32_t opts_O = 1;
const char *opts_output = "progs.dat";
bool opts_dump = false;
bool opts_forcecrc = false;
bool opts_pp_only = false;
-size_t opts_max_array_size = 1024;
+size_t opts_max_array_size = (1024 << 3);
uint16_t opts_forced_crc;
static bool options_setwarn(const char *name, bool on) {
return options_setflag_all(name, on, opts_warn, opts_warn_list, COUNT_WARNINGS);
}
+static bool options_setoptim(const char *name, bool on) {
+ return options_setflag_all(name, on, opts_optimization, opts_opt_list, COUNT_OPTIMIZATIONS);
+}
static bool options_witharg(int *argc_, char ***argv_, char **out) {
int argc = *argc_;
#endif
}
+static void set_optimizations(unsigned int level)
+{
+ size_t i;
+ for (i = 0; i < COUNT_OPTIMIZATIONS; ++i)
+ options_set(opts_optimization, i, level >= opts_opt_oflag[i]);
+}
+
static bool options_parse(int argc, char **argv) {
bool argend = false;
size_t itr;
options_set(opts_flags, TRANSLATABLE_STRINGS, true);
options_set(opts_flags, ADJUST_VECTOR_FIELDS, false);
options_set(opts_flags, ASSIGN_FUNCTION_TYPES, true);
+ options_set(opts_warn, WARN_TERNARY_PRECEDENCE, true);
+ options_set(opts_flags, CORRECT_TERNARY, false);
opts_standard = COMPILER_FTEQCC;
} else if (!strcmp(argarg, "qccx")) {
options_set(opts_flags, ADJUST_VECTOR_FIELDS, false);
case 'O':
if (!options_witharg(&argc, &argv, &argarg)) {
- con_out("option -O requires a numerical argument\n");
+ con_out("option -O requires a numerical argument, or optimization name with an optional 'no-' prefix\n");
return false;
}
- opts_O = atoi(argarg);
+ if (isdigit(argarg[0])) {
+ opts_O = atoi(argarg);
+ set_optimizations(opts_O);
+ } else {
+ util_strtocmd(argarg, argarg, strlen(argarg)+1);
+ if (!strcmp(argarg, "HELP")) {
+ con_out("Possible optimizations:\n");
+ for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) {
+ util_strtononcmd(opts_opt_list[itr].name, buffer, sizeof(buffer));
+ con_out(" -O%-20s (-O%u)\n", buffer, opts_opt_oflag[itr]);
+ }
+ exit(0);
+ }
+ else if (!strcmp(argarg, "ALL"))
+ set_optimizations(opts_O = 9999);
+ else if (!strncmp(argarg, "NO_", 3)) {
+ if (!options_setoptim(argarg+3, false)) {
+ con_out("unknown optimization: %s\n", argarg+3);
+ return false;
+ }
+ }
+ else {
+ if (!options_setoptim(argarg, true)) {
+ con_out("unknown optimization: %s\n", argarg);
+ return false;
+ }
+ }
+ }
break;
case 'o':
size_t itr;
int retval = 0;
bool opts_output_free = false;
+ bool operators_free = false;
bool progs_src = false;
FILE *outfile = NULL;
options_set(opts_flags, ADJUST_VECTOR_FIELDS, true);
options_set(opts_flags, FTEPP, false);
+ options_set(opts_flags, CORRECT_TERNARY, true);
if (!options_parse(argc, argv)) {
return usage();
operator_count = qcc_operator_count;
}
+ if (operators == fte_operators) {
+ /* fix ternary? */
+ if (OPTS_FLAG(CORRECT_TERNARY)) {
+ oper_info *newops;
+ if (operators[operator_count-2].id != opid1(',') ||
+ operators[operator_count-1].id != opid2(':','?'))
+ {
+ con_err("internal error: operator precedence table wasn't updated correctly!\n");
+ exit(1);
+ }
+ operators_free = true;
+ newops = mem_a(sizeof(operators[0]) * operator_count);
+ memcpy(newops, operators, sizeof(operators[0]) * operator_count);
+ memcpy(&newops[operator_count-2], &operators[operator_count-1], sizeof(newops[0]));
+ memcpy(&newops[operator_count-1], &operators[operator_count-2], sizeof(newops[0]));
+ newops[operator_count-2].prec = newops[operator_count-1].prec+1;
+ operators = newops;
+ }
+ }
+
if (opts_dump) {
for (itr = 0; itr < COUNT_FLAGS; ++itr) {
con_out("Flag %s = %i\n", opts_flag_list[itr].name, OPTS_FLAG(itr));
goto cleanup;
}
data = ftepp_get();
- if (!parser_compile_string_len(items[itr].filename, data, vec_size(data)-1)) {
- retval = 1;
- goto cleanup;
+ if (vec_size(data)) {
+ if (!parser_compile_string_len(items[itr].filename, data, vec_size(data))) {
+ retval = 1;
+ goto cleanup;
+ }
}
ftepp_flush();
}
/* stuff */
+ if (!opts_pp_only) {
+ for (itr = 0; itr < COUNT_OPTIMIZATIONS; ++itr) {
+ if (optimization_count[itr]) {
+ con_out("%s: %u\n", opts_opt_list[itr].name, (unsigned int)optimization_count[itr]);
+ }
+ }
+ }
+
cleanup:
util_debug("COM", "cleaning ...\n");
ftepp_finish();
parser_cleanup();
if (opts_output_free)
mem_d((char*)opts_output);
+ if (operators_free)
+ mem_d((void*)operators);
lex_cleanup();
util_meminfo();