*/
#include <stdio.h>
#include <stdarg.h>
+#include <math.h>
#include "gmqcc.h"
#include "lexer.h"
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;
size_t crc_fields;
ast_function *function;
+ ht aliases;
/* All the labels the function defined...
* Should they be in ast_function instead?
static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname);
static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname);
static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef);
+static ast_expression *parser_builtin_pow(parser_t *);
static void parseerror(parser_t *parser, const char *fmt, ...)
{
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 ast_expression* parser_find_global(parser_t *parser, const char *name)
{
+ ast_expression *var = (ast_expression*)util_htget(parser->aliases, parser_tokval(parser));
+ if (var)
+ return var;
return (ast_expression*)util_htget(parser->htglobals, name);
}
*/
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;
}
return false;
}
}
- if (!ast_block_set_type(blocks[0], exprs[1]))
- return false;
+ ast_block_set_type(blocks[0], exprs[1]);
vec_push(sy->out, syblock(ctx, blocks[0]));
return true;
return false;
case opid1('|'):
case opid1('&'):
- case opid1('~'):
if (NotSameType(TYPE_FLOAT)) {
compile_error(ctx, "invalid types used in expression: cannot perform bit operations between types %s and %s",
type_name[exprs[0]->expression.vtype],
out = (ast_expression*)ast_ternary_new(ctx, exprs[0], exprs[1], exprs[2]);
break;
+ case opid2('*', '*'):
+ if (NotSameType(TYPE_FLOAT)) {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+ compile_error(ctx, "invalid types used in exponentiation: %s and %s",
+ ty1, ty2);
+
+ return false;
+ }
+
+ if (CanConstFold(exprs[0], exprs[1])) {
+ out = (ast_expression*)parser_const_float(parser, powf(ConstF(0), ConstF(1)));
+ } else {
+ out = parser_builtin_pow(parser);
+ }
+ break;
+
+ case opid3('<','=','>'): /* -1, 0, or 1 */
+ if (NotSameType(TYPE_FLOAT)) {
+ ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+ ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+ compile_error(ctx, "invalid types used in comparision: %s and %s",
+ ty1, ty2);
+
+ return false;
+ }
+
+ if (CanConstFold(exprs[0], exprs[1])) {
+ if (ConstF(0) < ConstF(1))
+ out = (ast_expression*)parser_const_float_neg1(parser);
+ else if (ConstF(0) == ConstF(1))
+ out = (ast_expression*)parser_const_float_0(parser);
+ else if (ConstF(0) > ConstF(1))
+ out = (ast_expression*)parser_const_float_1(parser);
+ } else {
+ ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
+
+ eq->refs = (ast_binary_ref)false; /* references nothing */
+
+ /* if (lt) { */
+ out = (ast_expression*)ast_ternary_new(ctx,
+ (ast_expression*)ast_binary_new(ctx, INSTR_LT, exprs[0], exprs[1]),
+ /* out = -1 */
+ (ast_expression*)parser_const_float_neg1(parser),
+ /* } else { */
+ /* if (eq) { */
+ (ast_expression*)ast_ternary_new(ctx, (ast_expression*)eq,
+ /* out = 0 */
+ (ast_expression*)parser_const_float_0(parser),
+ /* } else { */
+ /* out = 1 */
+ (ast_expression*)parser_const_float_1(parser)
+ /* } */
+ )
+ /* } */
+ );
+
+ }
+ break;
+
case opid1('>'):
generated_op += 1; /* INSTR_GT */
case opid1('<'):
return false;
}
- if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
- compile_error(ast_ctx(exprs[0]), "assignment to constant `%s`", asvalue[0]->name);
- }
-
- out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser_const_float(parser, -1), exprs[0]);
+ 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
if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
var = (ast_expression*)intrinsic_debug_typestring;
}
- else
- {
+ if (!strcmp(parser_tokval(parser), "__builtin_pow"))
+ var = parser_builtin_pow(parser);
+
+ if (!var) {
char *correct = NULL;
size_t i;
}
}
if (o == operator_count) {
- /* no operator found... must be the end of the statement */
- break;
+ compile_error(parser_ctx(parser), "unknown operator: %s", parser_tokval(parser));
+ goto onerr;
}
/* found an operator */
op = &operators[o];
return false;
}
}
+ else if (!strcmp(parser_tokval(parser), "alias") && !(flags & AST_FLAG_ALIAS)) {
+ flags |= AST_FLAG_ALIAS;
+ *message = NULL;
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error in attribute");
+ goto argerr;
+ }
+ if (parser->tok == '(') {
+ if (!parser_next(parser) || parser->tok != TOKEN_STRINGCONST) {
+ parseerror(parser, "`alias` attribute missing parameter");
+ goto argerr;
+ }
+
+ *message = util_strdup(parser_tokval(parser));
+
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error in attribute");
+ goto argerr;
+ }
+
+ if (parser->tok != ')') {
+ parseerror(parser, "`alias` attribute expected `)` after parameter");
+ goto argerr;
+ }
+
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error in attribute");
+ goto argerr;
+ }
+ }
+
+ if (parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
+ parseerror(parser, "`alias` attribute expected `]]`");
+ goto argerr;
+ }
+ }
else if (!strcmp(parser_tokval(parser), "deprecated") && !(flags & AST_FLAG_DEPRECATED)) {
flags |= AST_FLAG_DEPRECATED;
*message = NULL;
return true;
}
+ast_expression *parser_builtin_pow(parser_t *parser) {
+ /*
+ * float __builtin_pow(float x, float y) {
+ * float value = 1.0f;
+ * while (y > 0) {
+ * while (!(y&1)) {
+ * y *= 2;
+ * x *= x;
+ * }
+ * y = y - 1;
+ * value = x * value;
+ * }
+ * return value;
+ * }
+ */
+ static ast_function *pow_func = NULL;
+ static ast_value *pow_func_val = NULL;
+ if (!pow_func) {
+ ast_value *pow_arguments[2];
+ ast_value *pow_value = ast_value_new (parser_ctx(parser), "value", TYPE_FLOAT);
+ ast_block *pow_body = ast_block_new (parser_ctx(parser));
+ ast_block *pow_loop_body = ast_block_new (parser_ctx(parser));
+ ast_block *pow_loop_nest_body = ast_block_new (parser_ctx(parser));
+ ast_loop *pow_loop = NULL;
+ ast_loop *pow_loop_nest = NULL;
+
+ pow_arguments[0] = ast_value_new (parser_ctx(parser), "x", TYPE_FLOAT);
+ pow_arguments[1] = ast_value_new (parser_ctx(parser), "x", TYPE_FLOAT);
+ pow_func_val = ast_value_new (parser_ctx(parser), "__builtin_pow", TYPE_FUNCTION);
+ pow_func_val->expression.next = (ast_expression*)ast_value_new(parser_ctx(parser), "<float>", TYPE_FLOAT);
+
+ vec_push(pow_func_val->expression.params, pow_arguments[0]);
+ vec_push(pow_func_val->expression.params, pow_arguments[1]);
+
+ pow_func = ast_function_new(parser_ctx(parser), "__builtin_pow", pow_func_val);
+
+ /* float value; */
+ vec_push(pow_body->locals, pow_value);
+ /* value = 1.0f; */
+ vec_push(pow_body->exprs,
+ (ast_expression*)ast_store_new(
+ parser_ctx(parser),
+ INSTR_STORE_F,
+ (ast_expression*)pow_value,
+ (ast_expression*)parser_const_float_1(parser)
+ )
+ );
+
+ /* y >>= 2 */
+ vec_push(pow_loop_nest_body->exprs,
+ (ast_expression*)ast_binstore_new(
+ parser_ctx(parser),
+ INSTR_STORE_F,
+ INSTR_MUL_F,
+ (ast_expression*)pow_arguments[1],
+ (ast_expression*)parser_const_float(parser, 0.25f)
+ )
+ );
+ vec_push(pow_loop_nest_body->exprs,
+ (ast_expression*)ast_binstore_new(
+ parser_ctx(parser),
+ INSTR_STORE_F,
+ INSTR_MUL_F,
+ (ast_expression*)pow_arguments[0],
+ (ast_expression*)pow_arguments[0]
+ )
+ );
+
+ /* while (!(y&1)) */
+ pow_loop_nest = ast_loop_new (
+ parser_ctx(parser),
+ NULL,
+ (ast_expression*)ast_binary_new(
+ parser_ctx(parser),
+ INSTR_AND,
+ (ast_expression*)pow_arguments[1],
+ (ast_expression*)parser_const_float_1(parser)
+ ),
+ true,
+ NULL,
+ false,
+ NULL,
+ (ast_expression*)pow_loop_nest_body
+ );
+
+ vec_push(pow_loop_body->exprs, (ast_expression*)pow_loop_nest);
+ vec_push(pow_loop_body->exprs,
+ (ast_expression*)ast_binstore_new(
+ parser_ctx(parser),
+ INSTR_STORE_F,
+ INSTR_SUB_F,
+ (ast_expression*)pow_arguments[1],
+ (ast_expression*)parser_const_float_1(parser)
+ )
+ );
+ vec_push(pow_loop_body->exprs,
+ (ast_expression*)ast_binstore_new(
+ parser_ctx(parser),
+ INSTR_STORE_F,
+ INSTR_MUL_F,
+ (ast_expression*)pow_value,
+ (ast_expression*)pow_arguments[0]
+ )
+ );
+
+ /* while (y > 0) { */
+ pow_loop = ast_loop_new(
+ parser_ctx(parser),
+ NULL,
+ (ast_expression*)ast_binary_new(
+ parser_ctx(parser),
+ INSTR_GT,
+ (ast_expression*)pow_arguments[1],
+ (ast_expression*)parser_const_float_0(parser)
+ ),
+ false,
+ NULL,
+ false,
+ NULL,
+ (ast_expression*)pow_loop_body
+ );
+ /* } */
+ vec_push(pow_body->exprs, (ast_expression*)pow_loop);
+ /* return value; */
+ vec_push(pow_body->exprs,
+ (ast_expression*)ast_return_new(
+ parser_ctx(parser),
+ (ast_expression*)pow_value
+ )
+ );
+
+ vec_push(pow_func->blocks, pow_body);
+ vec_push(parser->globals, (ast_expression*)pow_func_val);
+ vec_push(parser->functions, pow_func);
+ }
+
+ return (ast_expression*)pow_func_val;
+}
+
/* parse computed goto sides */
static ast_expression *parse_goto_computed(parser_t *parser, ast_expression **side) {
ast_expression *on_true;
has_frame_think = false;
old = parser->function;
+ if (var->expression.flags & AST_FLAG_ALIAS) {
+ parseerror(parser, "function aliases cannot have bodies");
+ return false;
+ }
+
if (vec_size(parser->gotos) || vec_size(parser->labels)) {
parseerror(parser, "gotos/labels leaking");
return false;
ast_expression *functype = fld_think->expression.next;
thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype);
- if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) {
+ if (!thinkfunc) { /* || !ast_type_adopt(thinkfunc, functype)*/
ast_unref(framenum);
parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser));
return false;
}
+ ast_type_adopt(thinkfunc, functype);
if (!parser_next(parser)) {
ast_unref(framenum);
}
}
+ 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);
var->cvq = qualifier;
var->expression.flags |= qflags;
- if (var->expression.flags & AST_FLAG_DEPRECATED)
+
+ /*
+ * store the vstring back to var for alias and
+ * deprecation messages.
+ */
+ if (var->expression.flags & AST_FLAG_DEPRECATED ||
+ var->expression.flags & AST_FLAG_ALIAS)
var->desc = vstring;
/* Part 1:
}
}
else {
- parser_addglobal(parser, var->name, (ast_expression*)var);
- if (isvector) {
- for (i = 0; i < 3; ++i) {
- parser_addglobal(parser, me[i]->name, (ast_expression*)me[i]);
+ if (!(var->expression.flags & AST_FLAG_ALIAS)) {
+ parser_addglobal(parser, var->name, (ast_expression*)var);
+ if (isvector) {
+ for (i = 0; i < 3; ++i) {
+ parser_addglobal(parser, me[i]->name, (ast_expression*)me[i]);
+ }
+ }
+ } else {
+ ast_expression *find = parser_find_global(parser, var->desc);
+
+ if (!find) {
+ compile_error(parser_ctx(parser), "undeclared variable `%s` for alias `%s`", var->desc, var->name);
+ return false;
+ }
+
+ if (var->expression.vtype != find->expression.vtype) {
+ char ty1[1024];
+ char ty2[1024];
+
+ ast_type_to_string(find, ty1, sizeof(ty1));
+ ast_type_to_string((ast_expression*)var, ty2, sizeof(ty2));
+
+ compile_error(parser_ctx(parser), "incompatible types `%s` and `%s` for alias `%s`",
+ ty1, ty2, var->name
+ );
+ return false;
+ }
+
+ /*
+ * add alias to aliases table and to corrector
+ * so corrections can apply for aliases as well.
+ */
+ util_htset(parser->aliases, var->name, find);
+
+ /*
+ * add to corrector so corrections can work
+ * even for aliases too.
+ */
+ correct_add (
+ vec_last(parser->correct_variables),
+ &vec_last(parser->correct_variables_score),
+ var->name
+ );
+
+ /* generate aliases for vector components */
+ if (isvector) {
+ char *buffer[3];
+
+ util_asprintf(&buffer[0], "%s_x", var->desc);
+ util_asprintf(&buffer[1], "%s_y", var->desc);
+ util_asprintf(&buffer[2], "%s_z", var->desc);
+
+ util_htset(parser->aliases, me[0]->name, parser_find_global(parser, buffer[0]));
+ util_htset(parser->aliases, me[1]->name, parser_find_global(parser, buffer[1]));
+ util_htset(parser->aliases, me[2]->name, parser_find_global(parser, buffer[2]));
+
+ mem_d(buffer[0]);
+ mem_d(buffer[1]);
+ mem_d(buffer[2]);
+
+ /*
+ * add to corrector so corrections can work
+ * even for aliases too.
+ */
+ correct_add (
+ vec_last(parser->correct_variables),
+ &vec_last(parser->correct_variables_score),
+ me[0]->name
+ );
+ correct_add (
+ vec_last(parser->correct_variables),
+ &vec_last(parser->correct_variables_score),
+ me[1]->name
+ );
+ correct_add (
+ vec_last(parser->correct_variables),
+ &vec_last(parser->correct_variables_score),
+ me[2]->name
+ );
}
}
}
}
else
{
- parseerror(parser, "unexpected token: %s", parser->lex->tok.value);
+ parseerror(parser, "unexpected token: `%s`", parser->lex->tok.value);
return false;
}
return true;
vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
vec_push(parser->_blocktypedefs, 0);
+ parser->aliases = util_htnew(PARSER_HT_SIZE);
+
/* corrector */
vec_push(parser->correct_variables, correct_trie_new());
vec_push(parser->correct_variables_score, NULL);
ast_value_delete(parser->const_vec[1]);
ast_value_delete(parser->const_vec[2]);
+ util_htdel(parser->aliases);
+
mem_d(parser);
}
projects / xonotic / gmqcc.git / blobdiff