FTEPP_PREDEFS = false
+ #Enable math constant definitions. This only works in combination
+ #with '-fftepp' and is currently not included by '-std=fteqcc'.
+ #The following macros will be added:
+ #
+ # M_E
+ # M_LOG2E
+ # M_LOG10E
+ # M_LN2
+ # M_LN10
+ # M_PI
+ # M_PI_2
+ # M_PI_4
+ # M_1_PI
+ # M_2_PI
+ # M_2_SQRTPI
+ # M_SQRT2
+ # M_SQRT1_2
+ # M_TAU
+
+ FTEPP_MATHDEFS = false
+
+
+ #Enable indirect macro expansion. This only works in combination
+ #with '-fftepp' and is currently not included by '-std=fteqcc'.
+ #Enabling this behavior will allow the preprocessor to operate more
+ #like the standard C preprocessor in that it will allow arguments
+ #of macros which are macro-expanded to be substituted into the
+ #definition of the macro. As an example:
+ #
+ # #define STR1(x) #x
+ # #define STR2(x) STR1(x)
+ # #define THE_ANSWER 42
+ # #define THE_ANSWER_STR STR2(THE_ANSWER) /* "42" */
+ #
+ #With this enabled, an expansion of THE_ANSWER_STR will yield
+ #the string "42". With this disabled an expansion of THE_ANSWER_STR
+ #will yield "THE_ANSWER"
+
+ FTEPP_INDIRECT_EXPANSION = false
+
+
#Allow switch cases to use non constant variables.
RELAXED_SWITCH = true
SORT_OPERANDS = false
+ #Emulate OP_STATE operations in code rather than using the instruction.
+ #The desired fps can be set via -state-fps=NUM, defaults to 10.
+
+ EMULATE_STATE = false
+
+
+ #Turn on arithmetic exception tests in the compiler. In constant expressions
+ #which trigger exceptions like division by zero, overflow, underflow, etc,
+ #the following flag will produce diagnostics for what triggered that
+ #exception.
+ ARITHMETIC_EXCEPTIONS = false
+
+ #Split vector-literals which are only used dirctly as function parameters
+ #into 3 floats stored separately to reduce the number of globals at the
+ #expense of additional instructions.
+ SPLIT_VECTOR_PARAMETERS = false
+
+ #Force all expressions to be "eraseable" which permits the compiler
+ #to remove unused functions, variables and statements. This is
+ #equivlant to putting [[eraseable]] on all definitions. This is
+ #dangerous as it breaks auto cvars, definitions for functions the
+ #engine may be looking for and translatable strings. Instead, you
+ #can mark a definition with [[noerase]] to prevent this from happening.
+ DEFAULT_ERASEABLE = false
[warnings]
#Generate a warning about variables which are declared but never
- #used. This can be avoided by adding the ‘noref’ keyword in front
+ #used. This can be avoided by adding the ‘noref’ keyword in front
#of the variable declaration. Additionally a complete section of
#unreferenced variables can be opened using ‘#pragma noref 1’ and
#closed via ‘#pragma noref 0’.
UNUSED_VARIABLE = false
+ #Generate a warning about vector variables which are declared but
+ #components of it are never used.
+
+ UNUSED_COMPONENT = false
+
#Generate a warning if it is possible that a variable can be used
#without prior initialization. Note that this warning is not nec‐
#essarily reliable if the initialization happens only under cer‐
CONST_OVERWRITE = true
+
+ #Warn about the use of preprocessor directives inside macros.
+
+ DIRECTIVE_INMACRO = true
+
+
+ #When using a function that is not explicitly defined, the compiler
+ #will search its intrinsics table for something that matches that
+ #function name by appending "__builtin_" to it. This behaviour may
+ #be unexpected, so enabling this will produce a diagnostic when
+ #such a function is resolved to a builtin.
+
+ BUILTINS = true
+
+
+ #When comparing an inexact value such as `1.0/3.0' the result is
+ #pathologically wrong. Enabling this will trigger a compiler warning
+ #on such expressions.
+ INEXACT_COMPARES = true
+
+
[optimizations]
#Some general peephole optimizations. For instance the code `a = b
#+ c` typically generates 2 instructions, an ADD and a STORE. This
OVERLAP_LOCALS = true
-
#This promotes locally declared variables to "temps". Meaning when
#a temporary result of an operation has to be stored somewhere, a
#local variable which is not 'alive' at that point can be used to
CONST_FOLD_DCE = true
+
#For constant expressions we can fold them to immediate values.
#this option cannot be disabled or enabled, the compiler forces
#it to stay enabled by ignoring the value entierly. There are