darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-02-21 10:51:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Replacing lots of parseerror calls with compile_error calls and a more correct context information

Browse source
This commit is contained in:
Wolfgang Bumiller 2013-01-13 17:31:31 +01:00
parent 1d05cd28ee
commit 8d4e395092
1 changed files with 78 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

166
parser.c
View file

@ -548,8 +548,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
DEBUGSHUNTDO(con_out("apply %s\n", op->op)); DEBUGSHUNTDO(con_out("apply %s\n", op->op));
if (vec_size(sy->out) < op->operands) { if (vec_size(sy->out) < op->operands) {
parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out), compile_error(ctx, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
op->op, (int)op->id); op->op, (int)op->id);
return false; return false;
} }
@ -578,7 +578,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
} }
if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) { if (blocks[0] && !vec_size(blocks[0]->exprs) && op->id != opid1(',')) {
parseerror(parser, "internal error: operator cannot be applied on empty blocks"); compile_error(ctx, "internal error: operator cannot be applied on empty blocks");
return false; return false;
} }
@ -596,7 +596,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
switch (op->id) switch (op->id)
{ {
default: default:
parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id); compile_error(ctx, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
return false; return false;
case opid1('.'): case opid1('.'):
@ -610,23 +610,23 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
else if (exprs[1] == (ast_expression*)parser->const_vec[2]) else if (exprs[1] == (ast_expression*)parser->const_vec[2])
out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL); out = (ast_expression*)ast_member_new(ctx, exprs[0], 2, NULL);
else { else {
parseerror(parser, "access to invalid vector component"); compile_error(ctx, "access to invalid vector component");
return false; return false;
} }
} }
else if (exprs[0]->expression.vtype == TYPE_ENTITY) { else if (exprs[0]->expression.vtype == TYPE_ENTITY) {
if (exprs[1]->expression.vtype != TYPE_FIELD) { if (exprs[1]->expression.vtype != TYPE_FIELD) {
parseerror(parser, "type error: right hand of member-operand should be an entity-field"); compile_error(ast_ctx(exprs[1]), "type error: right hand of member-operand should be an entity-field");
return false; return false;
} }
out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]); out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
} }
else if (exprs[0]->expression.vtype == TYPE_VECTOR) { else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
parseerror(parser, "vectors cannot be accessed this way"); compile_error(ast_ctx(exprs[1]), "vectors cannot be accessed this way");
return false; return false;
} }
else { else {
parseerror(parser, "type error: member-of operator on something that is not an entity or vector"); compile_error(ast_ctx(exprs[1]), "type error: member-of operator on something that is not an entity or vector");
return false; return false;
} }
break; break;
@ -637,12 +637,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
exprs[0]->expression.next->expression.vtype == TYPE_ARRAY)) exprs[0]->expression.next->expression.vtype == TYPE_ARRAY))
{ {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
parseerror(parser, "cannot index value of type %s", ty1); compile_error(ast_ctx(exprs[0]), "cannot index value of type %s", ty1);
return false; return false;
} }
if (exprs[1]->expression.vtype != TYPE_FLOAT) { if (exprs[1]->expression.vtype != TYPE_FLOAT) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
parseerror(parser, "index must be of type float, not %s", ty1); compile_error(ast_ctx(exprs[1]), "index must be of type float, not %s", ty1);
return false; return false;
} }
out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]); out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
@ -701,8 +701,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
exprs[0]); exprs[0]);
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot negate type %s", compile_error(ctx, "invalid types used in expression: cannot negate type %s",
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
} }
break; break;
@ -743,8 +743,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]); out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot logically negate type %s", compile_error(ctx, "invalid types used in expression: cannot logically negate type %s",
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
} }
break; break;
@ -753,9 +753,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype || if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
(exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) ) (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
{ {
parseerror(parser, "invalid types used in expression: cannot add type %s and %s", compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
switch (exprs[0]->expression.vtype) { switch (exprs[0]->expression.vtype) {
@ -774,9 +774,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot add type %s and %s", compile_error(ctx, "invalid types used in expression: cannot add type %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
}; };
break; break;
@ -784,9 +784,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype || if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
(exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) ) (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
{ {
parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s", compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
type_name[exprs[1]->expression.vtype], type_name[exprs[1]->expression.vtype],
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
} }
switch (exprs[0]->expression.vtype) { switch (exprs[0]->expression.vtype) {
@ -803,9 +803,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s", compile_error(ctx, "invalid types used in expression: cannot subtract type %s from %s",
type_name[exprs[1]->expression.vtype], type_name[exprs[1]->expression.vtype],
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
}; };
break; break;
@ -817,9 +817,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
exprs[0]->expression.vtype == TYPE_FLOAT) exprs[0]->expression.vtype == TYPE_FLOAT)
) )
{ {
parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
type_name[exprs[1]->expression.vtype], type_name[exprs[1]->expression.vtype],
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
} }
switch (exprs[0]->expression.vtype) { switch (exprs[0]->expression.vtype) {
@ -914,17 +914,17 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
} }
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s", compile_error(ctx, "invalid types used in expression: cannot multiply types %s and %s",
type_name[exprs[1]->expression.vtype], type_name[exprs[1]->expression.vtype],
type_name[exprs[0]->expression.vtype]); type_name[exprs[0]->expression.vtype]);
return false; return false;
}; };
break; break;
case opid1('/'): case opid1('/'):
if (NotSameType(TYPE_FLOAT)) { if (NotSameType(TYPE_FLOAT)) {
parseerror(parser, "invalid types used in expression: cannot divide types %s and %s", compile_error(ctx, "invalid types used in expression: cannot divide types %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
if (CanConstFold(exprs[0], exprs[1])) if (CanConstFold(exprs[0], exprs[1]))
@ -934,14 +934,14 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
break; break;
case opid1('%'): case opid1('%'):
case opid2('%','='): case opid2('%','='):
parseerror(parser, "qc does not have a modulo operator"); compile_error(ctx, "qc does not have a modulo operator");
return false; return false;
case opid1('|'): case opid1('|'):
case opid1('&'): case opid1('&'):
if (NotSameType(TYPE_FLOAT)) { if (NotSameType(TYPE_FLOAT)) {
parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s", compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
if (CanConstFold(exprs[0], exprs[1])) if (CanConstFold(exprs[0], exprs[1]))
@ -975,16 +975,6 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
generated_op += 1; /* INSTR_OR */ generated_op += 1; /* INSTR_OR */
case opid2('&','&'): case opid2('&','&'):
generated_op += INSTR_AND; 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],
type_name[exprs[1]->expression.vtype]);
parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
parseerror(parser, "TODO: optional early out");
return false;
}
#endif
if (CanConstFold(exprs[0], exprs[1])) if (CanConstFold(exprs[0], exprs[1]))
{ {
if (OPTS_FLAG(PERL_LOGIC)) { if (OPTS_FLAG(PERL_LOGIC)) {
@ -1003,7 +993,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) { if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); compile_error(ctx, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
return false; return false;
} }
for (i = 0; i < 2; ++i) { for (i = 0; i < 2; ++i) {
@ -1036,14 +1026,14 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
case opid2('?',':'): case opid2('?',':'):
if (vec_last(parser->pot) != POT_TERNARY2) { if (vec_last(parser->pot) != POT_TERNARY2) {
parseerror(parser, "mismatched parenthesis/ternary"); compile_error(ctx, "mismatched parenthesis/ternary");
return false; return false;
} }
vec_pop(parser->pot); vec_pop(parser->pot);
if (!ast_compare_type(exprs[1], exprs[2])) { if (!ast_compare_type(exprs[1], exprs[2])) {
ast_type_to_string(exprs[1], ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty1, sizeof(ty1));
ast_type_to_string(exprs[2], ty2, sizeof(ty2)); ast_type_to_string(exprs[2], ty2, sizeof(ty2));
parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); compile_error(ctx, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2);
return false; return false;
} }
if (CanConstFold1(exprs[0])) if (CanConstFold1(exprs[0]))
@ -1061,27 +1051,27 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
case opid2('<', '='): case opid2('<', '='):
generated_op += INSTR_LE; generated_op += INSTR_LE;
if (NotSameType(TYPE_FLOAT)) { if (NotSameType(TYPE_FLOAT)) {
parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
break; break;
case opid2('!', '='): case opid2('!', '='):
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) { if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
break; break;
case opid2('=', '='): case opid2('=', '='):
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) { if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s", compile_error(ctx, "invalid types used in expression: cannot perform comparison between types %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
} }
out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
@ -1110,7 +1100,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
"invalid types in assignment: cannot assign %s to %s", ty2, ty1); "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
} }
else else
parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
} }
} }
else else
@ -1128,7 +1118,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (assignop == AINSTR_END) { if (assignop == AINSTR_END) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
} }
else if (!ast_compare_type(exprs[0], exprs[1])) else if (!ast_compare_type(exprs[0], exprs[1]))
{ {
@ -1142,11 +1132,11 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
"invalid types in assignment: cannot assign %s to %s", ty2, ty1); "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
} }
else else
parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); compile_error(ctx, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
} }
} }
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
} }
out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
break; break;
@ -1155,7 +1145,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
/* prefix ++ */ /* prefix ++ */
if (exprs[0]->expression.vtype != TYPE_FLOAT) { if (exprs[0]->expression.vtype != TYPE_FLOAT) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
parseerror(parser, "invalid type for prefix increment: %s", ty1); compile_error(ast_ctx(exprs[0]), "invalid type for prefix increment: %s", ty1);
return false; return false;
} }
if (op->id == opid3('+','+','P')) if (op->id == opid3('+','+','P'))
@ -1163,7 +1153,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
else else
addop = INSTR_SUB_F; addop = INSTR_SUB_F;
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
} }
if (ast_istype(exprs[0], ast_entfield)) { if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
@ -1180,7 +1170,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
/* prefix ++ */ /* prefix ++ */
if (exprs[0]->expression.vtype != TYPE_FLOAT) { if (exprs[0]->expression.vtype != TYPE_FLOAT) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
parseerror(parser, "invalid type for suffix increment: %s", ty1); compile_error(ast_ctx(exprs[0]), "invalid type for suffix increment: %s", ty1);
return false; return false;
} }
if (op->id == opid3('S','+','+')) { if (op->id == opid3('S','+','+')) {
@ -1191,7 +1181,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
subop = INSTR_ADD_F; subop = INSTR_ADD_F;
} }
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
} }
if (ast_istype(exprs[0], ast_entfield)) { if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop, out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
@ -1215,12 +1205,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
{ {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s", compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
ty1, ty2); ty1, ty2);
return false; return false;
} }
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
} }
if (ast_istype(exprs[0], ast_entfield)) if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->expression.vtype]; assignop = type_storep_instr[exprs[0]->expression.vtype];
@ -1238,9 +1228,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
exprs[0], exprs[1]); exprs[0], exprs[1]);
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s", compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
}; };
break; break;
@ -1252,12 +1242,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
{ {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types used in expression: %s and %s", compile_error(ctx, "invalid types used in expression: %s and %s",
ty1, ty2); ty1, ty2);
return false; return false;
} }
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
} }
if (ast_istype(exprs[0], ast_entfield)) if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->expression.vtype]; assignop = type_storep_instr[exprs[0]->expression.vtype];
@ -1285,9 +1275,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
} }
break; break;
default: default:
parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s", compile_error(ctx, "invalid types used in expression: cannot add or subtract type %s and %s",
type_name[exprs[0]->expression.vtype], type_name[exprs[0]->expression.vtype],
type_name[exprs[1]->expression.vtype]); type_name[exprs[1]->expression.vtype]);
return false; return false;
}; };
break; break;
@ -1296,12 +1286,12 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (NotSameType(TYPE_FLOAT)) { if (NotSameType(TYPE_FLOAT)) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types used in expression: %s and %s", compile_error(ctx, "invalid types used in expression: %s and %s",
ty1, ty2); ty1, ty2);
return false; return false;
} }
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
} }
if (ast_istype(exprs[0], ast_entfield)) if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->expression.vtype]; assignop = type_storep_instr[exprs[0]->expression.vtype];
@ -1319,8 +1309,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (NotSameType(TYPE_FLOAT)) { if (NotSameType(TYPE_FLOAT)) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2)); ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types used in expression: %s and %s", compile_error(ctx, "invalid types used in expression: %s and %s",
ty1, ty2); ty1, ty2);
return false; return false;
} }
if (ast_istype(exprs[0], ast_entfield)) if (ast_istype(exprs[0], ast_entfield))
@ -1331,7 +1321,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
if (!out) if (!out)
return false; return false;
if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
} }
asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
asbinstore->keep_dest = true; asbinstore->keep_dest = true;
@ -1341,7 +1331,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
#undef NotSameType #undef NotSameType
if (!out) { if (!out) {
parseerror(parser, "failed to apply operand %s", op->op); compile_error(ctx, "failed to apply operand %s", op->op);
return false; return false;
} }