return parser->imm_float[i];
}
out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
- out->isconst = true;
+ out->hasvalue = true;
out->constval.vfloat = d;
vec_push(parser->imm_float, out);
return out;
out = ast_value_new(parser_ctx(parser), name, TYPE_STRING);
} else
out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
- out->isconst = true;
+ out->hasvalue = true;
out->constval.vstring = parser_strdup(str);
vec_push(parser->imm_string, out);
return out;
return parser->imm_vector[i];
}
out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
- out->isconst = true;
+ out->hasvalue = true;
out->constval.vvec = v;
vec_push(parser->imm_vector, out);
return out;
(exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
exprs[0]->expression.vtype != T)
#define CanConstFold1(A) \
- (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
+ (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue)
#define CanConstFold(A, B) \
(CanConstFold1(A) && CanConstFold1(B))
#define ConstV(i) (asvalue[(i)]->constval.vvec)
case opid1(','):
if (blocks[0]) {
- vec_push(blocks[0]->exprs, exprs[1]);
+ ast_block_add_expr(blocks[0], exprs[1]);
} else {
blocks[0] = ast_block_new(ctx);
- vec_push(blocks[0]->exprs, exprs[0]);
- vec_push(blocks[0]->exprs, exprs[1]);
+ ast_block_add_expr(blocks[0], exprs[0]);
+ ast_block_add_expr(blocks[0], exprs[1]);
}
if (!ast_block_set_type(blocks[0], exprs[1]))
return false;
generated_op += 1; /* INSTR_OR */
case opid2('&','&'):
generated_op += INSTR_AND;
+#if 0
if (NotSameType(TYPE_FLOAT)) {
parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
type_name[exprs[0]->expression.vtype],
parseerror(parser, "TODO: optional early out");
return false;
}
+#endif
if (opts_standard == COMPILER_GMQCC)
con_out("TODO: early out logic\n");
if (CanConstFold(exprs[0], exprs[1]))
parseerror(parser, "expected condition or 'not'");
return false;
}
- if (parser->tok == TOKEN_KEYWORD && !strcmp(parser_tokval(parser), "not")) {
+ if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "not")) {
ifnot = true;
if (!parser_next(parser)) {
parseerror(parser, "expected condition in parenthesis");
increment = parse_expression_leave(parser, false);
if (!increment)
goto onerr;
- if (!ast_istype(increment, ast_store) &&
- !ast_istype(increment, ast_call) &&
- !ast_istype(increment, ast_binstore))
- {
+ if (!ast_side_effects(increment)) {
if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
goto onerr;
}
if (!OPTS_FLAG(RELAXED_SWITCH)) {
opval = (ast_value*)operand;
- if (!ast_istype(operand, ast_value) || !opval->isconst) {
+ if (!ast_istype(operand, ast_value) || !opval->hasvalue) {
parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
ast_unref(operand);
return false;
}
if (!expr)
continue;
- vec_push(caseblock->exprs, expr);
+ ast_block_add_expr(caseblock, expr);
}
}
if (!exp)
return false;
*out = exp;
- if (!ast_istype(exp, ast_store) &&
- !ast_istype(exp, ast_call) &&
- !ast_istype(exp, ast_binstore))
- {
+ if (!ast_side_effects(exp)) {
if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
return false;
}
}
if (!expr)
continue;
- vec_push(block->exprs, expr);
+ ast_block_add_expr(block, expr);
}
if (parser->tok != '}') {
parseerror(parser, "expected a framenumber constant in[frame,think] notation");
return false;
}
- if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->isconst) {
+ if (!ast_istype(framenum, ast_value) || !( (ast_value*)framenum )->hasvalue) {
ast_unref(framenum);
parseerror(parser, "framenumber in [frame,think] notation must be a constant");
return false;
if (store_think) ast_delete(store_think);
retval = false;
}
- vec_push(block->exprs, (ast_expression*)store_frame);
- vec_push(block->exprs, (ast_expression*)store_nextthink);
- vec_push(block->exprs, (ast_expression*)store_think);
+ ast_block_add_expr(block, (ast_expression*)store_frame);
+ ast_block_add_expr(block, (ast_expression*)store_nextthink);
+ ast_block_add_expr(block, (ast_expression*)store_think);
}
if (!retval) {
return NULL;
}
- vec_push(block->exprs, (ast_expression*)st);
+ ast_block_add_expr(block, (ast_expression*)st);
ret = ast_return_new(ctx, NULL);
if (!ret) {
return NULL;
}
- vec_push(block->exprs, (ast_expression*)ret);
+ ast_block_add_expr(block, (ast_expression*)ret);
return (ast_expression*)block;
} else {
return NULL;
}
- vec_push(block->exprs, (ast_expression*)st);
+ ast_block_add_expr(block, (ast_expression*)st);
ret = ast_return_new(ctx, NULL);
if (!ret) {
return NULL;
}
- vec_push(block->exprs, (ast_expression*)ret);
+ ast_block_add_expr(block, (ast_expression*)ret);
return (ast_expression*)block;
} else {
goto cleanup;
}
- vec_push(func->blocks[0]->exprs, root);
+ ast_block_add_expr(func->blocks[0], root);
array->setter = fval;
return true;
cleanup:
goto cleanup;
}
- vec_push(func->blocks[0]->exprs, root);
+ ast_block_add_expr(func->blocks[0], root);
array->setter = fval;
return true;
cleanup:
goto cleanup;
}
- vec_push(func->blocks[0]->exprs, root);
+ ast_block_add_expr(func->blocks[0], root);
array->getter = fval;
return true;
cleanup:
}
}
- if (is_const)
- var->isconst = true;
-
/* Part 2:
* Create the global/local, and deal with vector types.
*/
break;
}
- if (var->isconst) {
+ if (var->hasvalue) {
(void)!parsewarning(parser, WARN_DOUBLE_DECLARATION,
"builtin `%s` has already been defined\n"
" -> previous declaration here: %s:%i",
if (!localblock) {
cval = (ast_value*)cexp;
- if (!ast_istype(cval, ast_value) || !cval->isconst)
+ if (!ast_istype(cval, ast_value) || !cval->hasvalue)
parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
else
{
- var->isconst = true;
+ var->hasvalue = true;
if (cval->expression.vtype == TYPE_STRING)
var->constval.vstring = parser_strdup(cval->constval.vstring);
else
else {
if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0)
parseerror(parser, "internal error: leaked operands");
- vec_push(localblock->exprs, (ast_expression*)sy.out[0].out);
+ ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out);
}
vec_free(sy.out);
vec_free(sy.ops);
for (i = 0; i < vec_size(parser->fields); ++i) {
ast_value *field;
- bool isconst;
+ bool hasvalue;
if (!ast_istype(parser->fields[i], ast_value))
continue;
field = (ast_value*)parser->fields[i];
- isconst = field->isconst;
- field->isconst = false;
+ hasvalue = field->hasvalue;
+ field->hasvalue = false;
if (!ast_global_codegen((ast_value*)field, ir, true)) {
con_out("failed to generate field %s\n", field->name);
ir_builder_delete(ir);
return false;
}
- if (isconst) {
+ if (hasvalue) {
ir_value *ifld;
ast_expression *subtype;
- field->isconst = true;
+ field->hasvalue = true;
subtype = field->expression.next;
ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
if (subtype->expression.vtype == TYPE_FIELD)
if (!ast_istype(parser->globals[i], ast_value))
continue;
asvalue = (ast_value*)(parser->globals[i]);
- if (!asvalue->uses && !asvalue->isconst && asvalue->expression.vtype != TYPE_FUNCTION) {
+ if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
if (strcmp(asvalue->name, "end_sys_globals") &&
strcmp(asvalue->name, "end_sys_fields"))
{
projects / xonotic / gmqcc.git / blobdiff