ast_value **accessors;
ast_value *imm_float_zero;
+ ast_value *imm_float_one;
ast_value *imm_vector_zero;
size_t crc_globals;
static bool GMQCC_WARN parser_pop_local(parser_t *parser);
-static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields);
+static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, bool is_const);
static ast_block* parse_block(parser_t *parser, bool warnreturn);
static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn);
static ast_expression* parse_statement_or_block(parser_t *parser);
return parser->imm_float_zero;
}
+static ast_value* parser_const_float_1(parser_t *parser)
+{
+ if (!parser->imm_float_one)
+ parser->imm_float_one = parser_const_float(parser, 1);
+ return parser->imm_float_one;
+}
+
static char *parser_strdup(const char *str)
{
if (str && !*str) {
ast_expression *exprs[3];
ast_block *blocks[3];
ast_value *asvalue[3];
- size_t i, assignop, addop;
+ size_t i, assignop, addop, subop;
qcint generated_op = 0;
char ty1[1024];
if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
exprs[0],
- (ast_expression*)parser_const_float(parser, 1));
+ (ast_expression*)parser_const_float_1(parser));
} else {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
exprs[0],
- (ast_expression*)parser_const_float(parser, 1));
+ (ast_expression*)parser_const_float_1(parser));
}
break;
case opid3('S','+','+'):
/* prefix ++ */
if (exprs[0]->expression.vtype != TYPE_FLOAT) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1));
- parseerror(parser, "invalid type for prefix increment: %s", ty1);
+ parseerror(parser, "invalid type for suffix increment: %s", ty1);
return false;
}
- if (op->id == opid3('+','+','P'))
+ if (op->id == opid3('S','+','+')) {
addop = INSTR_ADD_F;
- else
+ subop = INSTR_SUB_F;
+ } else {
addop = INSTR_SUB_F;
+ subop = INSTR_ADD_F;
+ }
if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
exprs[0],
- (ast_expression*)parser_const_float(parser, 1));
+ (ast_expression*)parser_const_float_1(parser));
} else {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
exprs[0],
- (ast_expression*)parser_const_float(parser, 1));
+ (ast_expression*)parser_const_float_1(parser));
}
+ if (!out)
+ return false;
+ out = (ast_expression*)ast_binary_new(ctx, subop,
+ out,
+ (ast_expression*)parser_const_float_1(parser));
break;
case opid2('+','='):
case opid2('-','='):
return false;
};
break;
+ case opid2('*','='):
+ case opid2('/','='):
+ if (exprs[1]->expression.vtype != TYPE_FLOAT ||
+ !(exprs[0]->expression.vtype == TYPE_FLOAT ||
+ exprs[0]->expression.vtype == TYPE_VECTOR))
+ {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+ parseerror(parser, "invalid types used in expression: %s and %s",
+ ty1, ty2);
+ return false;
+ }
+ if (ast_istype(exprs[0], ast_entfield))
+ assignop = type_storep_instr[exprs[0]->expression.vtype];
+ else
+ assignop = type_store_instr[exprs[0]->expression.vtype];
+ switch (exprs[0]->expression.vtype) {
+ case TYPE_FLOAT:
+ out = (ast_expression*)ast_binstore_new(ctx, assignop,
+ (op->id == opid2('*','=') ? INSTR_MUL_F : INSTR_DIV_F),
+ exprs[0], exprs[1]);
+ break;
+ case TYPE_VECTOR:
+ if (op->id == opid2('*','=')) {
+ out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
+ exprs[0], exprs[1]);
+ } else {
+ /* there's no DIV_VF */
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F,
+ (ast_expression*)parser_const_float_1(parser),
+ exprs[1]);
+ if (!out)
+ return false;
+ out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_MUL_VF,
+ exprs[0], out);
+ }
+ break;
+ default:
+ parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
+ type_name[exprs[0]->expression.vtype],
+ type_name[exprs[1]->expression.vtype]);
+ return false;
+ };
+ break;
+ case opid2('&','='):
+ case opid2('|','='):
+ if (NotSameType(TYPE_FLOAT)) {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+ parseerror(parser, "invalid types used in expression: %s and %s",
+ ty1, ty2);
+ return false;
+ }
+ if (ast_istype(exprs[0], ast_entfield))
+ assignop = type_storep_instr[exprs[0]->expression.vtype];
+ else
+ assignop = type_store_instr[exprs[0]->expression.vtype];
+ out = (ast_expression*)ast_binstore_new(ctx, assignop,
+ (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
+ exprs[0], exprs[1]);
+ break;
+ case opid3('&','~','='):
+ /* This is like: a &= ~(b);
+ * But QC has no bitwise-not, so we implement it as
+ * a -= a & (b);
+ */
+ if (NotSameType(TYPE_FLOAT)) {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+ parseerror(parser, "invalid types used in expression: %s and %s",
+ ty1, ty2);
+ return false;
+ }
+ if (ast_istype(exprs[0], ast_entfield))
+ assignop = type_storep_instr[exprs[0]->expression.vtype];
+ else
+ assignop = type_store_instr[exprs[0]->expression.vtype];
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
+ if (!out)
+ return false;
+ out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
+ break;
}
#undef NotSameType
parseerror(parser, "TODO: assignment of new variables to be non-const");
goto onerr;
- if (!parse_variable(parser, block, true))
+ if (!parse_variable(parser, block, true, false))
goto onerr;
}
else if (parser->tok != ';')
if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
return false;
}
- if (!parse_variable(parser, block, false))
+ if (!parse_variable(parser, block, false, false))
return false;
*out = NULL;
return true;
parseerror(parser, "expected variable declaration");
return false;
}
- if (!parse_variable(parser, block, true))
+ if (!parse_variable(parser, block, true, false))
return false;
*out = NULL;
return true;
return var;
}
-static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields)
+static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, bool is_const)
{
ast_value *var;
ast_value *proto;
}
}
+ if (is_const)
+ var->isconst = true;
+
/* Part 2:
* Create the global/local, and deal with vector types.
*/
{
if (parser->tok == TOKEN_TYPENAME || parser->tok == '.')
{
- return parse_variable(parser, NULL, false);
+ return parse_variable(parser, NULL, false, false);
}
- else if (parser->tok == TOKEN_KEYWORD)
+ else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var"))
{
- /* handle 'var' and 'const' */
if (!strcmp(parser_tokval(parser), "var")) {
if (!parser_next(parser)) {
parseerror(parser, "expected variable declaration after 'var'");
return false;
}
- return parse_variable(parser, NULL, true);
+ return parse_variable(parser, NULL, true, false);
+ }
+ }
+ else if (parser->tok == TOKEN_KEYWORD)
+ {
+ if (!strcmp(parser_tokval(parser), "const")) {
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected variable declaration after 'const'");
+ return false;
+ }
+ return parse_variable(parser, NULL, true, true);
}
+ parseerror(parser, "unrecognized keyword `%s`", parser_tokval(parser));
return false;
}
else if (parser->tok == '$')