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);
size_t i;
ast_value *out;
for (i = 0; i < vec_size(parser->imm_float); ++i) {
- if (parser->imm_float[i]->constval.vfloat == d)
+ const double compare = parser->imm_float[i]->constval.vfloat;
+ if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0)
return parser->imm_float[i];
}
out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
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;
+ size_t i, assignop, addop, subop;
qcint generated_op = 0;
char ty1[1024];
(ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
#define CanConstFold(A, B) \
(CanConstFold1(A) && CanConstFold1(B))
-#define CanConstFold3(A, B, C) \
- (CanConstFold1(A) && CanConstFold1(B) && CanConstFold1(C))
#define ConstV(i) (asvalue[(i)]->constval.vvec)
#define ConstF(i) (asvalue[(i)]->constval.vfloat)
#define ConstS(i) (asvalue[(i)]->constval.vstring)
}
out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
break;
+ case opid3('+','+','P'):
+ case opid3('-','-','P'):
+ /* 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);
+ return false;
+ }
+ if (op->id == opid3('+','+','P'))
+ addop = INSTR_ADD_F;
+ else
+ addop = INSTR_SUB_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_1(parser));
+ } else {
+ out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
+ exprs[0],
+ (ast_expression*)parser_const_float_1(parser));
+ }
+ break;
+ case opid3('S','+','+'):
+ 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 suffix increment: %s", ty1);
+ return false;
+ }
+ if (op->id == opid3('S','+','+')) {
+ addop = INSTR_ADD_F;
+ 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_1(parser));
+ } else {
+ out = (ast_expression*)ast_binstore_new(ctx, INSTR_STORE_F, addop,
+ exprs[0],
+ (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('-','='):
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
(exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != 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: cannot add or subtract type %s and %s",
- type_name[exprs[0]->expression.vtype],
- type_name[exprs[1]->expression.vtype]);
+ ty1, ty2);
return false;
}
if (ast_istype(exprs[0], ast_entfield))
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
else
{
/* classify the operator */
- /* TODO: suffix operators */
const oper_info *op;
const oper_info *olast = NULL;
size_t o;
for (o = 0; o < operator_count; ++o) {
if ((!(operators[o].flags & OP_PREFIX) == wantop) &&
- !(operators[o].flags & OP_SUFFIX) && /* remove this */
+ /* !(operators[o].flags & OP_SUFFIX) && / * remove this */
!strcmp(parser_tokval(parser), operators[o].op))
{
break;
} else {
DEBUGSHUNTDO(con_out("push operator %s\n", op->op));
vec_push(sy.ops, syop(parser_ctx(parser), op));
- wantop = false;
+ wantop = !!(op->flags & OP_SUFFIX);
}
}
if (!parser_next(parser)) {
lex_ctx ctx = parser_ctx(parser);
+ (void)block; /* not touching */
+
/* skip the 'if', parse an optional 'not' and check for an opening paren */
if (!parser_next(parser)) {
parseerror(parser, "expected condition or 'not'");
lex_ctx ctx = parser_ctx(parser);
+ (void)block; /* not touching */
+
/* skip the 'while' and check for opening paren */
if (!parser_next(parser) || parser->tok != '(') {
parseerror(parser, "expected 'while' condition in parenthesis");
lex_ctx ctx = parser_ctx(parser);
+ (void)block; /* not touching */
+
/* skip the 'do' and get the body */
if (!parser_next(parser)) {
parseerror(parser, "expected loop body");
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 != ';')
ast_return *ret = NULL;
ast_value *expected = parser->function->vtype;
+ (void)block; /* not touching */
+
if (!parser_next(parser)) {
parseerror(parser, "expected return expression");
return false;
{
lex_ctx ctx = parser_ctx(parser);
+ (void)block; /* not touching */
+
if (!parser_next(parser) || parser->tok != ';') {
parseerror(parser, "expected semicolon");
return false;
lex_ctx ctx = parser_ctx(parser);
+ (void)block; /* not touching */
+
/* parse over the opening paren */
if (!parser_next(parser) || parser->tok != '(') {
parseerror(parser, "expected switch operand in parenthesis");
/* case list! */
while (parser->tok != '}') {
- ast_block *block;
+ ast_block *caseblock;
if (parser->tok != TOKEN_KEYWORD) {
ast_delete(switchnode);
parseerror(parser, "expected statements or case");
return false;
}
- block = ast_block_new(parser_ctx(parser));
- if (!block) {
+ caseblock = ast_block_new(parser_ctx(parser));
+ if (!caseblock) {
if (swcase.value) ast_unref(swcase.value);
ast_delete(switchnode);
return false;
}
- swcase.code = (ast_expression*)block;
+ swcase.code = (ast_expression*)caseblock;
vec_push(switchnode->cases, swcase);
while (true) {
ast_expression *expr;
break;
}
}
- if (!parse_statement(parser, block, &expr, true)) {
+ if (!parse_statement(parser, caseblock, &expr, true)) {
ast_delete(switchnode);
return false;
}
if (!expr)
continue;
- vec_push(block->exprs, expr);
+ vec_push(caseblock->exprs, expr);
}
}
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;
}
/* loop method */
-static bool create_vector_members(parser_t *parser, ast_value *var, varentry_t *ve)
+static bool create_vector_members(ast_value *var, varentry_t *ve)
{
size_t i;
size_t len = strlen(var->name);
continue;
}
- if (!create_vector_members(parser, param, ve)) {
+ if (!create_vector_members(param, ve)) {
ast_block_delete(block);
return false;
}
lex_ctx ctx = ast_ctx(array);
if (from+1 == afterend) {
- // set this value
+ /* set this value */
ast_block *block;
ast_return *ret;
ast_array_index *subscript;
+ ast_store *st;
int assignop = type_store_instr[value->expression.vtype];
if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
if (!subscript)
return NULL;
- ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value);
+ st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value);
if (!st) {
ast_delete(subscript);
return NULL;
lex_ctx ctx = ast_ctx(array);
if (from+1 == afterend) {
- // set this value
+ /* set this value */
ast_block *block;
ast_return *ret;
ast_entfield *entfield;
ast_array_index *subscript;
+ ast_store *st;
int assignop = type_storep_instr[value->expression.vtype];
if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
return NULL;
}
- ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value);
+ st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value);
if (!st) {
ast_delete(entfield);
return NULL;
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.
*/
isvector = true;
if (isvector) {
- if (!create_vector_members(parser, var, ve)) {
+ if (!create_vector_members(var, ve)) {
retval = false;
goto cleanup;
}
{
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 == '$')
return true;
}
+static uint16_t progdefs_crc_sum(uint16_t old, const char *str)
+{
+ return util_crc16(old, str, strlen(str));
+}
+
+static void progdefs_crc_file(const char *str)
+{
+ /* write to progdefs.h here */
+ (void)str;
+}
+
+static uint16_t progdefs_crc_both(uint16_t old, const char *str)
+{
+ old = progdefs_crc_sum(old, str);
+ progdefs_crc_file(str);
+ return old;
+}
+
+static void generate_checksum(parser_t *parser)
+{
+ uint16_t crc = 0xFFFF;
+ size_t i;
+
+ crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{");
+ crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n");
+ /*
+ progdefs_crc_file("\tint\tpad;\n");
+ progdefs_crc_file("\tint\tofs_return[3];\n");
+ progdefs_crc_file("\tint\tofs_parm0[3];\n");
+ progdefs_crc_file("\tint\tofs_parm1[3];\n");
+ progdefs_crc_file("\tint\tofs_parm2[3];\n");
+ progdefs_crc_file("\tint\tofs_parm3[3];\n");
+ progdefs_crc_file("\tint\tofs_parm4[3];\n");
+ progdefs_crc_file("\tint\tofs_parm5[3];\n");
+ progdefs_crc_file("\tint\tofs_parm6[3];\n");
+ progdefs_crc_file("\tint\tofs_parm7[3];\n");
+ */
+ for (i = 0; i < parser->crc_globals; ++i) {
+ if (!ast_istype(parser->globals[i].var, ast_value))
+ continue;
+ switch (parser->globals[i].var->expression.vtype) {
+ case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break;
+ case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
+ case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
+ case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
+ default:
+ crc = progdefs_crc_both(crc, "\tint\t");
+ break;
+ }
+ crc = progdefs_crc_both(crc, parser->globals[i].name);
+ crc = progdefs_crc_both(crc, ";\n");
+ }
+ crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n");
+ for (i = 0; i < parser->crc_fields; ++i) {
+ if (!ast_istype(parser->fields[i].var, ast_value))
+ continue;
+ switch (parser->fields[i].var->expression.next->expression.vtype) {
+ case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break;
+ case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
+ case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
+ case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
+ default:
+ crc = progdefs_crc_both(crc, "\tint\t");
+ break;
+ }
+ crc = progdefs_crc_both(crc, parser->fields[i].name);
+ crc = progdefs_crc_both(crc, ";\n");
+ }
+ crc = progdefs_crc_both(crc, "} entvars_t;\n\n");
+
+ code_crc = crc;
+}
+
static parser_t *parser;
bool parser_init()
mem_d(parser);
}
-static uint16_t progdefs_crc_sum(uint16_t old, const char *str)
-{
- return util_crc16(old, str, strlen(str));
-}
-
-static void progdefs_crc_file(const char *str)
-{
- /* write to progdefs.h here */
-}
-
-static uint16_t progdefs_crc_both(uint16_t old, const char *str)
-{
- old = progdefs_crc_sum(old, str);
- progdefs_crc_file(str);
- return old;
-}
-
-static void generate_checksum(parser_t *parser)
-{
- uint16_t crc = 0xFFFF;
- size_t i;
-
- crc = progdefs_crc_both(crc, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{");
- crc = progdefs_crc_sum(crc, "\tint\tpad[28];\n");
- /*
- progdefs_crc_file("\tint\tpad;\n");
- progdefs_crc_file("\tint\tofs_return[3];\n");
- progdefs_crc_file("\tint\tofs_parm0[3];\n");
- progdefs_crc_file("\tint\tofs_parm1[3];\n");
- progdefs_crc_file("\tint\tofs_parm2[3];\n");
- progdefs_crc_file("\tint\tofs_parm3[3];\n");
- progdefs_crc_file("\tint\tofs_parm4[3];\n");
- progdefs_crc_file("\tint\tofs_parm5[3];\n");
- progdefs_crc_file("\tint\tofs_parm6[3];\n");
- progdefs_crc_file("\tint\tofs_parm7[3];\n");
- */
- for (i = 0; i < parser->crc_globals; ++i) {
- if (!ast_istype(parser->globals[i].var, ast_value))
- continue;
- switch (parser->globals[i].var->expression.vtype) {
- case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break;
- case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
- case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
- case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
- default:
- crc = progdefs_crc_both(crc, "\tint\t");
- break;
- }
- crc = progdefs_crc_both(crc, parser->globals[i].name);
- crc = progdefs_crc_both(crc, ";\n");
- }
- crc = progdefs_crc_both(crc, "} globalvars_t;\n\ntypedef struct\n{\n");
- for (i = 0; i < parser->crc_fields; ++i) {
- if (!ast_istype(parser->fields[i].var, ast_value))
- continue;
- switch (parser->fields[i].var->expression.next->expression.vtype) {
- case TYPE_FLOAT: crc = progdefs_crc_both(crc, "\tfloat\t"); break;
- case TYPE_VECTOR: crc = progdefs_crc_both(crc, "\tvec3_t\t"); break;
- case TYPE_STRING: crc = progdefs_crc_both(crc, "\tstring_t\t"); break;
- case TYPE_FUNCTION: crc = progdefs_crc_both(crc, "\tfunc_t\t"); break;
- default:
- crc = progdefs_crc_both(crc, "\tint\t");
- break;
- }
- crc = progdefs_crc_both(crc, parser->fields[i].name);
- crc = progdefs_crc_both(crc, ";\n");
- }
- crc = progdefs_crc_both(crc, "} entvars_t;\n\n");
-
- code_crc = crc;
-}
-
bool parser_finish(const char *output)
{
size_t i;
projects / xonotic / gmqcc.git / blobdiff