ast_value *imm_float_zero;
ast_value *imm_float_one;
+ ast_value *imm_float_neg_one;
+
ast_value *imm_vector_zero;
+
ast_value *nil;
ast_value *reserved_version;
return r;
}
-static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
-{
- bool r;
- va_list ap;
- va_start(ap, fmt);
- r = vcompile_warning(ctx, warntype, fmt, ap);
- va_end(ap);
- return r;
-}
-
/**********************************************************************
* some maths used for constant folding
*/
return parser->imm_float_zero;
}
+static ast_value* parser_const_float_neg1(parser_t *parser) {
+ if (!parser->imm_float_neg_one)
+ parser->imm_float_neg_one = parser_const_float(parser, -1);
+ return parser->imm_float_neg_one;
+}
+
static ast_value* parser_const_float_1(parser_t *parser)
{
if (!parser->imm_float_one)
*/
static bool rotate_entfield_array_index_nodes(ast_expression **out)
{
- ast_array_index *index;
+ ast_array_index *index, *oldindex;
ast_entfield *entfield;
ast_value *field;
sub = index->index;
entity = entfield->entity;
- ast_delete(index);
+ oldindex = index;
index = ast_array_index_new(ctx, (ast_expression*)field, sub);
entfield = ast_entfield_new(ctx, entity, (ast_expression*)index);
*out = (ast_expression*)entfield;
+ oldindex->array = NULL;
+ oldindex->index = NULL;
+ ast_delete(oldindex);
+
return true;
}
{
#if 0
/* This is not broken in fteqcc anymore */
- if (opts.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"
}
else
assignop = type_storep_instr[exprs[0]->expression.vtype];
- if (assignop == AINSTR_END || !ast_compare_type(field->expression.next, exprs[1]))
+ if (assignop == VINSTR_END || !ast_compare_type(field->expression.next, exprs[1]))
{
ast_type_to_string(field->expression.next, ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2));
assignop = type_store_instr[exprs[0]->expression.vtype];
}
- if (assignop == AINSTR_END) {
+ if (assignop == VINSTR_END) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2));
compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
asbinstore->keep_dest = true;
out = (ast_expression*)asbinstore;
break;
+
+ case opid2('~', 'P'):
+ if (exprs[0]->expression.vtype != TYPE_FLOAT) {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ compile_error(ast_ctx(exprs[0]), "invalid type for bit not: %s", ty1);
+ return false;
+ }
+
+ if(CanConstFold1(exprs[0]))
+ out = (ast_expression*)parser_const_float(parser, ~(qcint)ConstF(0));
+ else
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser_const_float_neg1(parser), exprs[0]);
+ break;
+
}
#undef NotSameType
* We should also consider adding correction tables for
* other things as well.
*/
- if (opts.correction) {
+ if (OPTS_OPTION_BOOL(OPTION_CORRECTION)) {
correction_t corr;
correct_init(&corr);
}
}
else if (parser->tok == ')') {
+ while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
+ if (!parser_sy_apply_operator(parser, &sy))
+ goto onerr;
+ }
+ if (!vec_size(sy.paren))
+ break;
if (wantop) {
- if (!vec_size(sy.paren))
- break;
if (vec_last(sy.paren) == PAREN_TERNARY1) {
parseerror(parser, "mismatched parentheses (closing paren in ternary expression?)");
goto onerr;
goto onerr;
} else {
/* must be a function call without parameters */
- if (!vec_size(sy.paren))
- break;
if (vec_last(sy.paren) != PAREN_FUNC) {
parseerror(parser, "closing paren in invalid position");
goto onerr;
goto onerr;
}
else if (parser->tok == ']') {
+ while (vec_size(sy.paren) && vec_last(sy.paren) == PAREN_TERNARY2) {
+ if (!parser_sy_apply_operator(parser, &sy))
+ goto onerr;
+ }
if (!vec_size(sy.paren))
break;
- if (!vec_size(sy.paren) || vec_last(sy.paren) != PAREN_INDEX) {
+ if (vec_last(sy.paren) != PAREN_INDEX) {
parseerror(parser, "mismatched parentheses, unexpected ']'");
goto onerr;
}
if (!parser_close_paren(parser, &sy))
goto onerr;
+ wantop = true;
}
else if (!wantop) {
if (!parse_sya_operand(parser, &sy, with_labels))
ast_unary *unary;
ast_expression *prev;
+ if (cond->expression.vtype == TYPE_VOID || cond->expression.vtype >= TYPE_VARIANT) {
+ char ty[1024];
+ ast_type_to_string(cond, ty, sizeof(ty));
+ compile_error(ast_ctx(cond), "invalid type for if() condition: %s", ty);
+ }
+
if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING)
{
prev = cond;
if (typevar || parser->tok == TOKEN_TYPENAME) {
#if 0
- if (opts.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;
/* parse the incrementor */
if (parser->tok != ')') {
+ lex_ctx condctx = parser_ctx(parser);
increment = parse_expression_leave(parser, false, false, false);
if (!increment)
goto onerr;
if (!ast_side_effects(increment)) {
- if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
+ if (compile_warning(condctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
goto onerr;
}
}
parseerror(parser, "cannot declare a variable from here");
return false;
}
- if (opts.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;
}
}
else if (!strcmp(parser_tokval(parser), "for"))
{
- if (opts.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;
}
}
else
{
+ lex_ctx ctx = parser_ctx(parser);
ast_expression *exp = parse_expression(parser, false, false);
if (!exp)
return false;
*out = exp;
if (!ast_side_effects(exp)) {
- if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
+ if (compile_warning(ctx, WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
return false;
}
return true;
}
}
+ if (var->hasvalue) {
+ parseerror(parser, "function `%s` declared with multiple bodies", var->name);
+ ast_block_delete(block);
+ goto enderr;
+ }
+
func = ast_function_new(ast_ctx(var), var->name, var);
if (!func) {
parseerror(parser, "failed to allocate function for `%s`", var->name);
if (parser->tok == ';')
return parser_next(parser);
- else if (opts.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;
vec_free(params);
/* sanity check */
- if (vec_size(params) > 8 && opts.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 */
}
/* now there may be function parens again */
- if (parser->tok == '(' && opts.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");
/* Part 0: finish the type */
if (parser->tok == '(') {
- if (opts.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) {
}
/* for functions returning functions */
while (parser->tok == '(') {
- if (opts.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) {
goto cleanup;
*/
}
- if ((opts.standard == COMPILER_QCC || opts.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");
ast_delete(var);
var = proto;
}
- if (opts.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");
retval = false;
goto cleanup;
}
- if (opts.standard != COMPILER_GMQCC) {
+ if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
ast_delete(var);
var = NULL;
goto skipvar;
break;
}
- if (localblock && opts.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) )
break;
}
}
- else if (opts.standard == COMPILER_QCC) {
+ else if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_QCC) {
parseerror(parser, "expected '=' before function body in this standard");
}
}
else
{
- parseerror(parser, "unexpected token: %s", parser->lex->tok.value);
+ parseerror(parser, "unexpected token: `%s`", parser->lex->tok.value);
return false;
}
return true;
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 (opts.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;
continue;
asvalue = (ast_value*)(parser->globals[i]);
if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
- retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
- "unused global: `%s`", asvalue->name);
+ retval = retval && !compile_warning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
+ "unused global: `%s`", asvalue->name);
}
if (!ast_global_codegen(asvalue, ir, false)) {
con_out("failed to generate global %s\n", asvalue->name);
return false;
}
}
- if (opts.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)) {
}
if (retval) {
- if (opts.dumpfin)
+ if (OPTS_OPTION_BOOL(OPTION_DUMPFIN))
ir_builder_dump(ir, con_out);
generate_checksum(parser);