#define PARSER_HT_SIZE 512
#define TYPEDEF_HT_SIZE 512
-static ast_expression * const intrinsic_debug_typestring = (ast_expression*)0x1;
-
static void parser_enterblock(parser_t *parser);
static bool parser_leaveblock(parser_t *parser);
static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
return NULL;
}
-static ast_expression* parser_find_global(parser_t *parser, const char *name)
+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 NULL;
}
-/* include intrinsics */
-#include "intrin.h"
-
typedef struct
{
size_t etype; /* 0 = expression, others are operators */
return true;
}
+static bool check_write_to(lex_ctx_t ctx, ast_expression *expr)
+{
+ if (ast_istype(expr, ast_value)) {
+ ast_value *val = (ast_value*)expr;
+ if (val->cvq == CV_CONST) {
+ if (val->name[0] == '#')
+ compile_error(ctx, "invalid assignment to a literal constant");
+ else
+ compile_error(ctx, "assignment to constant `%s`", val->name);
+ return false;
+ }
+ }
+ return true;
+}
+
static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
{
const oper_info *op;
ast_expression *out = NULL;
ast_expression *exprs[3];
ast_block *blocks[3];
- ast_value *asvalue[3];
ast_binstore *asbinstore;
size_t i, assignop, addop, subop;
qcint_t generated_op = 0;
ctx = vec_last(sy->ops).ctx;
if (vec_size(sy->out) < op->operands) {
- compile_error(ctx, "internal error: not enough operands: %i (operator %s (%i))", vec_size(sy->out),
- op->op, (int)op->id);
+ if (op->flags & OP_PREFIX)
+ compile_error(ctx, "expected expression after unary operator `%s`", op->op, (int)op->id);
+ else /* this should have errored previously already */
+ compile_error(ctx, "expected expression after operator `%s`", op->op, (int)op->id);
return false;
}
for (i = 0; i < op->operands; ++i) {
exprs[i] = sy->out[vec_size(sy->out)+i].out;
blocks[i] = sy->out[vec_size(sy->out)+i].block;
- asvalue[i] = (ast_value*)exprs[i];
if (exprs[i]->vtype == TYPE_NOEXPR &&
!(i != 0 && op->id == opid2('?',':')) &&
#define NotSameType(T) \
(exprs[0]->vtype != exprs[1]->vtype || \
exprs[0]->vtype != T)
-
- /* preform any constant folding on operator usage first */
- /*if ((out = fold_op(parser->fold, op, exprs)))*/
- /*goto complete;*/
-
switch (op->id)
{
default:
return false;
} else if (!(out = fold_op(parser->fold, op, exprs))) {
/* generate a call to __builtin_mod */
- ast_expression *mod = intrin_func(parser, "mod");
+ ast_expression *mod = intrin_func(parser->intrin, "mod");
ast_call *call = NULL;
if (!mod) return false; /* can return null for missing floor */
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]->vtype],
- type_name[exprs[1]->vtype]);
- return false;
- }
- if (!(out = fold_op(parser->fold, op, exprs)))
- out = (ast_expression*)ast_binary_new(ctx,
- (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
- exprs[0], exprs[1]);
- break;
case opid1('^'):
- /*
- * Okay lets designate what the hell is an acceptable use
- * of the ^ operator. In many vector processing units, XOR
- * is allowed to be used on vectors, but only if the first
- * operand is a vector, the second operand can be a float
- * or vector. It's never legal for the first operand to be
- * a float, and then the following operand to be a vector.
- * Further more, the only time it is legal to do XOR otherwise
- * is when both operand are floats. This nicely crafted if
- * statement catches them all.
- *
- * In the event that the first operand is a vector, two
- * possible situations can arise, thus, each element of
- * vector A (operand A) is exclusive-ORed with the corresponding
- * element of vector B (operand B), If B is scalar, the
- * scalar value is first replicated for each element.
- *
- * The QCVM itself lacks a BITXOR instruction. Thus emulating
- * the mathematics of it is required. The following equation
- * is used: (LHS | RHS) & ~(LHS & RHS). However, due to the
- * QCVM also lacking a BITNEG instruction, we need to emulate
- * ~FOO with -1 - FOO, the whole process becoming this nicely
- * crafted expression: (LHS | RHS) & (-1 - (LHS & RHS)).
- *
- * When A is not scalar, this process is repeated for all
- * components of vector A with the value in operand B,
- * only if operand B is scalar. When A is not scalar, and B
- * is also not scalar, this process is repeated for all
- * components of the vector A with the components of vector B.
- * Finally when A is scalar and B is scalar, this process is
- * simply used once for A and B being LHS and RHS respectfully.
- *
- * Yes the semantics are a bit strange (no pun intended).
- * But then again BITXOR is strange itself, consdering it's
- * commutative, assocative, and elements of the BITXOR operation
- * are their own inverse.
- */
if ( !(exprs[0]->vtype == TYPE_FLOAT && exprs[1]->vtype == TYPE_FLOAT) &&
!(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_FLOAT) &&
!(exprs[0]->vtype == TYPE_VECTOR && exprs[1]->vtype == TYPE_VECTOR))
* since scalar ^ vector is not allowed.
*/
if (exprs[0]->vtype == TYPE_FLOAT) {
- ast_binary *expr = ast_binary_new(
- ctx,
- INSTR_SUB_F,
- (ast_expression*)parser->fold->imm_float[2],
- (ast_expression*)ast_binary_new(
- ctx,
- INSTR_BITAND,
- exprs[0],
- exprs[1]
- )
- );
- expr->refs = AST_REF_NONE;
-
- out = (ast_expression*)
- ast_binary_new(
- ctx,
- INSTR_BITAND,
- (ast_expression*)ast_binary_new(
- ctx,
- INSTR_BITOR,
- exprs[0],
- exprs[1]
- ),
- (ast_expression*)expr
- );
+ out = (ast_expression*)ast_binary_new(ctx,
+ (op->id == opid1('^') ? VINSTR_BITXOR : op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
+ exprs[0], exprs[1]);
} else {
/*
- * The first is a vector: vector is allowed to xor with vector and
+ * The first is a vector: vector is allowed to bitop with vector and
* with scalar, branch here for the second operand.
*/
if (exprs[1]->vtype == TYPE_VECTOR) {
/*
- * Xor all the values of the vector components against the
+ * Bitop all the values of the vector components against the
* vectors components in question.
*/
- compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector");
- return false;
+ out = (ast_expression*)ast_binary_new(ctx,
+ (op->id == opid1('^') ? VINSTR_BITXOR_V : op->id == opid1('|') ? VINSTR_BITOR_V : VINSTR_BITAND_V),
+ exprs[0], exprs[1]);
} else {
- compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float");
- return false;
+ out = (ast_expression*)ast_binary_new(ctx,
+ (op->id == opid1('^') ? VINSTR_BITXOR_VF : op->id == opid1('|') ? VINSTR_BITOR_VF : VINSTR_BITAND_VF),
+ exprs[0], exprs[1]);
}
}
}
compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-shifts");
return false;
}
+ break;
case opid2('|','|'):
generated_op += 1; /* INSTR_OR */
ty1, ty2);
return false;
}
-
+
if (!(out = fold_op(parser->fold, op, exprs))) {
- ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser, "pow"));
+ ast_call *gencall = ast_call_new(parser_ctx(parser), intrin_func(parser->intrin, "pow"));
vec_push(gencall->params, exprs[0]);
vec_push(gencall->params, exprs[1]);
out = (ast_expression*)gencall;
}
break;
+ case opid2('>', '<'):
+ if (NotSameType(TYPE_VECTOR)) {
+ 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 cross product: %s and %s",
+ ty1, ty2);
+ return false;
+ }
+
+ if (!(out = fold_op(parser->fold, op, exprs))) {
+ out = (ast_expression*)ast_binary_new(
+ parser_ctx(parser),
+ VINSTR_CROSS,
+ exprs[0],
+ exprs[1]
+ );
+ }
+
+ break;
+
case opid3('<','=','>'): /* -1, 0, or 1 */
if (NotSameType(TYPE_FLOAT)) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ty1, ty2);
return false;
- }
+ }
if (!(out = fold_op(parser->fold, op, exprs))) {
ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
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) {
- compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
- }
+ (void)check_write_to(ctx, exprs[0]);
out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
break;
case opid3('+','+','P'):
addop = INSTR_ADD_F;
else
addop = INSTR_SUB_F;
- 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);
- }
+ (void)check_write_to(ast_ctx(exprs[0]), exprs[0]);
if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
exprs[0],
addop = INSTR_SUB_F;
subop = INSTR_ADD_F;
}
- 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);
- }
+ (void)check_write_to(ast_ctx(exprs[0]), exprs[0]);
if (ast_istype(exprs[0], ast_entfield)) {
out = (ast_expression*)ast_binstore_new(ctx, INSTR_STOREP_F, addop,
exprs[0],
ty1, ty2);
return false;
}
- if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
- compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
- }
+ (void)check_write_to(ctx, exprs[0]);
if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->vtype];
else
ty1, ty2);
return false;
}
- if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
- compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
- }
+ (void)check_write_to(ctx, exprs[0]);
if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->vtype];
else
break;
case opid2('&','='):
case opid2('|','='):
- if (NotSameType(TYPE_FLOAT)) {
+ case opid2('^','='):
+ if (NotSameType(TYPE_FLOAT) && NotSameType(TYPE_VECTOR)) {
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 expression: %s and %s",
ty1, ty2);
return false;
}
- if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
- compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
- }
+ (void)check_write_to(ctx, exprs[0]);
if (ast_istype(exprs[0], ast_entfield))
assignop = type_storep_instr[exprs[0]->vtype];
else
assignop = type_store_instr[exprs[0]->vtype];
- out = (ast_expression*)ast_binstore_new(ctx, assignop,
- (op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
- exprs[0], exprs[1]);
+ if (exprs[0]->vtype == TYPE_FLOAT)
+ out = (ast_expression*)ast_binstore_new(ctx, assignop,
+ (op->id == opid2('^','=') ? VINSTR_BITXOR : op->id == opid2('&','=') ? INSTR_BITAND : INSTR_BITOR),
+ exprs[0], exprs[1]);
+ else
+ out = (ast_expression*)ast_binstore_new(ctx, assignop,
+ (op->id == opid2('^','=') ? VINSTR_BITXOR_V : op->id == opid2('&','=') ? VINSTR_BITAND_V : VINSTR_BITOR_V),
+ 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)) {
+ if (NotSameType(TYPE_FLOAT) && NotSameType(TYPE_VECTOR)) {
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 expression: %s and %s",
assignop = type_storep_instr[exprs[0]->vtype];
else
assignop = type_store_instr[exprs[0]->vtype];
- out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
+ if (exprs[0]->vtype == TYPE_FLOAT)
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]);
+ else
+ out = (ast_expression*)ast_binary_new(ctx, VINSTR_BITAND_V, exprs[0], exprs[1]);
if (!out)
return false;
- if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) {
- compile_error(ctx, "assignment to constant `%s`", asvalue[0]->name);
- }
- asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
+ (void)check_write_to(ctx, exprs[0]);
+ if (exprs[0]->vtype == TYPE_FLOAT)
+ asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out);
+ else
+ asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_V, exprs[0], out);
asbinstore->keep_dest = true;
out = (ast_expression*)asbinstore;
break;
case opid2('~', 'P'):
- if (exprs[0]->vtype != TYPE_FLOAT) {
+ if (exprs[0]->vtype != TYPE_FLOAT && exprs[0]->vtype != TYPE_VECTOR) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1));
compile_error(ast_ctx(exprs[0]), "invalid type for bit not: %s", ty1);
return false;
}
- if (!(out = fold_op(parser->fold, op, exprs)))
- out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser->fold->imm_float[2], exprs[0]);
+ if (!(out = fold_op(parser->fold, op, exprs))) {
+ if (exprs[0]->vtype == TYPE_FLOAT) {
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser->fold->imm_float[2], exprs[0]);
+ } else {
+ out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, (ast_expression*)parser->fold->imm_vector[1], exprs[0]);
+ }
+ }
break;
}
#undef NotSameType
-/*complete:*/
if (!out) {
compile_error(ctx, "failed to apply operator %s", op->op);
return false;
size_t fid;
size_t paramcount, i;
+ bool fold = true;
fid = vec_last(sy->ops).off;
vec_shrinkby(sy->ops, 1);
return false;
}
- fun = sy->out[fid].out;
-
- if (fun == intrinsic_debug_typestring) {
+ /*
+ * TODO handle this at the intrinsic level with an ast_intrinsic
+ * node and codegen.
+ */
+ if ((fun = sy->out[fid].out) == intrin_debug_typestring(parser->intrin)) {
char ty[1024];
if (fid+2 != vec_size(sy->out) ||
vec_last(sy->out).block)
return true;
}
+ /*
+ * Now we need to determine if the function that is being called is
+ * an intrinsic so we can evaluate if the arguments to it are constant
+ * and than fruitfully fold them.
+ */
+#define fold_can_1(X) \
+ (ast_istype(((ast_expression*)(X)), ast_value) && (X)->hasvalue && ((X)->cvq == CV_CONST) && \
+ ((ast_expression*)(X))->vtype != TYPE_FUNCTION)
+
+ if (fid + 1 < vec_size(sy->out))
+ ++paramcount;
+
+ for (i = 0; i < paramcount; ++i) {
+ if (!fold_can_1((ast_value*)sy->out[fid + 1 + i].out)) {
+ fold = false;
+ break;
+ }
+ }
+
+ /*
+ * All is well which ends well, if we make it into here we can ignore the
+ * intrinsic call and just evaluate it i.e constant fold it.
+ */
+ if (fold && ast_istype(fun, ast_value) && ((ast_value*)fun)->intrinsic) {
+ ast_expression **exprs = NULL;
+ ast_expression *foldval = NULL;
+
+ for (i = 0; i < paramcount; i++)
+ vec_push(exprs, sy->out[fid+1 + i].out);
+
+ if (!(foldval = intrin_fold(parser->intrin, (ast_value*)fun, exprs))) {
+ vec_free(exprs);
+ goto fold_leave;
+ }
+
+ /*
+ * Blub: what sorts of unreffing and resizing of
+ * sy->out should I be doing here?
+ */
+ sy->out[fid] = syexp(foldval->node.context, foldval);
+ vec_shrinkby(sy->out, 1);
+ vec_free(exprs);
+
+ return true;
+ }
+
+ fold_leave:
call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
+
if (!call)
return false;
- if (fid+1 < vec_size(sy->out))
- ++paramcount;
-
if (fid+1 + paramcount != vec_size(sy->out)) {
parseerror(parser, "internal error: parameter count mismatch: (%lu+1+%lu), %lu",
(unsigned long)fid, (unsigned long)paramcount, (unsigned long)vec_size(sy->out));
}
/* not to be exposed */
-extern bool ftepp_predef_exists(const char *name);
-
+bool ftepp_predef_exists(const char *name);
static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels)
{
if (OPTS_FLAG(TRANSLATABLE_STRINGS) &&
/* a_vector.{x,y,z} */
if (!vec_size(sy->ops) ||
!vec_last(sy->ops).etype ||
- operators[vec_last(sy->ops).etype-1].id != opid1('.') ||
- (prev >= intrinsic_debug_typestring &&
- prev <= intrinsic_debug_typestring))
+ operators[vec_last(sy->ops).etype-1].id != opid1('.'))
{
/* When adding more intrinsics, fix the above condition */
prev = NULL;
if (!var && !strcmp(parser_tokval(parser), "__FUNC__"))
var = (ast_expression*)fold_constgen_string(parser->fold, parser->function->name, false);
if (!var) {
- /* intrinsics */
- if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
- var = (ast_expression*)intrinsic_debug_typestring;
- }
- /* now we try for the real intrinsic hashtable. If the string
+ /*
+ * now we try for the real intrinsic hashtable. If the string
* begins with __builtin, we simply skip past it, otherwise we
* use the identifier as is.
*/
- else if (!strncmp(parser_tokval(parser), "__builtin_", 10)) {
- var = intrin_func(parser, parser_tokval(parser) + 10 /* skip __builtin */);
+ if (!strncmp(parser_tokval(parser), "__builtin_", 10)) {
+ var = intrin_func(parser->intrin, parser_tokval(parser));
}
if (!var) {
/* only warn once about an assignment in a truth value because the current code
* would trigger twice on: if(a = b && ...), once for the if-truth-value, once for the && part
*/
- bool warn_truthvalue = true;
+ bool warn_parenthesis = true;
/* count the parens because an if starts with one, so the
* end of a condition is an unmatched closing paren
}
}
if (o == operator_count) {
- compile_error(parser_ctx(parser), "unknown operator: %s", parser_tokval(parser));
+ compile_error(parser_ctx(parser), "unexpected operator: %s", parser_tokval(parser));
goto onerr;
}
/* found an operator */
if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
olast = &operators[vec_last(sy.ops).etype-1];
+ /* first only apply higher precedences, assoc_left+equal comes after we warn about precedence rules */
+ while (olast && op->prec < olast->prec)
+ {
+ if (!parser_sy_apply_operator(parser, &sy))
+ goto onerr;
+ if (vec_size(sy.ops) && !vec_last(sy.ops).isparen)
+ olast = &operators[vec_last(sy.ops).etype-1];
+ else
+ olast = NULL;
+ }
+
#define IsAssignOp(x) (\
(x) == opid1('=') || \
(x) == opid2('+','=') || \
(x) == opid2('|','=') || \
(x) == opid3('&','~','=') \
)
- if (warn_truthvalue) {
+ if (warn_parenthesis) {
if ( (olast && IsAssignOp(olast->id) && (op->id == opid2('&','&') || op->id == opid2('|','|'))) ||
(olast && IsAssignOp(op->id) && (olast->id == opid2('&','&') || olast->id == opid2('|','|'))) ||
(truthvalue && !vec_size(sy.paren) && IsAssignOp(op->id))
)
{
(void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around assignment used as truth value");
- warn_truthvalue = false;
+ warn_parenthesis = false;
+ }
+
+ if (olast && olast->id != op->id) {
+ if ((op->id == opid1('&') || op->id == opid1('|') || op->id == opid1('^')) &&
+ (olast->id == opid1('&') || olast->id == opid1('|') || olast->id == opid1('^')))
+ {
+ (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around bitwise operations");
+ warn_parenthesis = false;
+ }
+ else if ((op->id == opid2('&','&') || op->id == opid2('|','|')) &&
+ (olast->id == opid2('&','&') || olast->id == opid2('|','|')))
+ {
+ (void)!parsewarning(parser, WARN_PARENTHESIS, "suggesting parenthesis around logical operations");
+ warn_parenthesis = false;
+ }
}
}
parser->lex->flags.noops = true;
if (vec_size(sy.out) != 1) {
- parseerror(parser, "expression with not 1 but %lu output values...", (unsigned long) vec_size(sy.out));
+ parseerror(parser, "expression expected");
expr = NULL;
} else
expr = sy.out[0].out;
else if (!strcmp(parser_tokval(parser), "inline")) {
flags |= AST_FLAG_INLINE;
if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
- parseerror(parser, "`noref` attribute has no parameters, expected `]]`");
+ parseerror(parser, "`inline` attribute has no parameters, expected `]]`");
+ *cvq = CV_WRONG;
+ return false;
+ }
+ }
+ else if (!strcmp(parser_tokval(parser), "eraseable")) {
+ flags |= AST_FLAG_ERASEABLE;
+ if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) {
+ parseerror(parser, "`eraseable` attribute has no parameters, expected `]]`");
*cvq = CV_WRONG;
return false;
}
self_think = (ast_expression*)ast_entfield_new(ctx, gbl_self, fld_think);
time_plus_1 = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F,
- gbl_time, (ast_expression*)fold_constgen_float(parser->fold, 0.1));
+ gbl_time, (ast_expression*)fold_constgen_float(parser->fold, 0.1f));
if (!self_frame || !self_nextthink || !self_think || !time_plus_1) {
if (self_frame) ast_delete(self_frame);
* The base type makes up every bit of type information which comes *before* the
* variable name.
*
+ * NOTE: The value must either be named, have a NULL name, or a name starting
+ * with '<'. In the first case, this will be the actual variable or type
+ * name, in the other cases it is assumed that the name will appear
+ * later, and an error is generated otherwise.
+ *
* The following will be parsed in its entirety:
* void() foo()
* The 'basetype' in this case is 'void()'
if (!typevar)
return false;
+ /* while parsing types, the ast_value's get named '<something>' */
+ if (!typevar->name || typevar->name[0] == '<') {
+ parseerror(parser, "missing name in typedef");
+ ast_delete(typevar);
+ return false;
+ }
+
if ( (old = parser_find_var(parser, typevar->name)) ) {
parseerror(parser, "cannot define a type with the same name as a variable: %s\n"
" -> `%s` has been declared here: %s:%i",
return false;
}
+ /* while parsing types, the ast_value's get named '<something>' */
+ if (!var->name || var->name[0] == '<') {
+ parseerror(parser, "declaration does not declare anything");
+ if (basetype)
+ ast_delete(basetype);
+ return false;
+ }
+
while (true) {
proto = NULL;
wasarray = false;
}
if (OPTS_OPTION_U32(OPTION_STANDARD) != COMPILER_GMQCC) {
ast_delete(var);
- var = NULL;
- goto skipvar;
+ if (ast_istype(old, ast_value))
+ var = (ast_value*)old;
+ else {
+ var = NULL;
+ goto skipvar;
+ }
}
}
}
parseerror(parser, "error parsing break definition");
break;
}
- (void)!!parsewarning(parser, WARN_BREAKDEF, "break definition ignored (suggest removing it)");
+ (void)!parsewarning(parser, WARN_BREAKDEF, "break definition ignored (suggest removing it)");
} else {
parseerror(parser, "missing semicolon or initializer, got: `%s`", parser_tokval(parser));
break;
parser->reserved_version = NULL;
}
- parser->fold = fold_init(parser);
+ parser->fold = fold_init (parser);
+ parser->intrin = intrin_init(parser);
return parser;
}
ast_value_delete(parser->reserved_version);
util_htdel(parser->aliases);
- intrin_intrinsics_destroy(parser);
fold_cleanup(parser->fold);
+ intrin_cleanup(parser->intrin);
}
void parser_cleanup(parser_t *parser)