va_start(ap, fmt);
vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap);
va_end(ap);
-
- printf("\n");
}
/* returns true if it counts as an error */
if (!OPTS_WARN(warntype))
return false;
- if (OPTS_WARN(WARN_ERROR)) {
+ if (opts_werror) {
parser->errors++;
lvl = LVL_ERROR;
}
vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
va_end(ap);
- return OPTS_WARN(WARN_ERROR);
+ return opts_werror;
}
/**********************************************************************
return parser->imm_float_zero;
}
+char *parser_strdup(const char *str)
+{
+ if (str && !*str) {
+ /* actually dup empty strings */
+ char *out = mem_a(1);
+ *out = 0;
+ return out;
+ }
+ return util_strdup(str);
+}
+
ast_value* parser_const_string(parser_t *parser, const char *str)
{
size_t i;
}
out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
out->isconst = true;
- out->constval.vstring = util_strdup(str);
+ out->constval.vstring = parser_strdup(str);
if (!parser_t_imm_string_add(parser, out)) {
ast_value_delete(out);
return NULL;
*isfunc = true;
while (true) {
ast_value *param;
+ ast_value *fld;
+ bool isfield = false;
bool dummy;
if (!parser_next(parser))
if (parser->tok == ')')
break;
+ if (parser->tok == '.') {
+ isfield = true;
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected field parameter type");
+ goto on_error;
+ }
+ }
+
temptype = parser_token(parser)->constval.t;
if (!parser_next(parser))
goto on_error;
goto on_error;
}
+ if (isfield) {
+ fld = ast_value_new(ctx, param->name, TYPE_FIELD);
+ fld->expression.next = (ast_expression*)param;
+ param = fld;
+ }
+
if (!paramlist_t_p_add(¶ms, param)) {
parseerror(parser, "Out of memory while parsing typename");
goto on_error;
(CanConstFold1(A) && CanConstFold1(B))
#define ConstV(i) (asvalue[(i)]->constval.vvec)
#define ConstF(i) (asvalue[(i)]->constval.vfloat)
+#define ConstS(i) (asvalue[(i)]->constval.vstring)
switch (op->id)
{
default:
- parseerror(parser, "internal error: unhandled operand");
+ parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
return false;
case opid1('.'):
}
break;
+ case opid2('!','P'):
+ switch (exprs[0]->expression.vtype) {
+ case TYPE_FLOAT:
+ if (CanConstFold1(exprs[0]))
+ out = (ast_expression*)parser_const_float(parser, !ConstF(0));
+ else
+ out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
+ break;
+ case TYPE_VECTOR:
+ if (CanConstFold1(exprs[0]))
+ out = (ast_expression*)parser_const_float(parser,
+ (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
+ else
+ out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
+ break;
+ case TYPE_STRING:
+ if (CanConstFold1(exprs[0]))
+ out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
+ else
+ out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
+ break;
+ /* we don't constant-fold NOT for these types */
+ case TYPE_ENTITY:
+ out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
+ break;
+ case TYPE_FUNCTION:
+ out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
+ break;
+ default:
+ parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
+ type_name[exprs[0]->expression.vtype]);
+ return false;
+ }
+ break;
+
case opid1('+'):
if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
(exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
if (fun->expression.vtype != TYPE_FUNCTION) {
- parseerror(parser, "not a function");
+ parseerror(parser, "not a function (%s)", type_name[fun->expression.vtype]);
return false;
}
/* variable */
if (opts_standard == COMPILER_GMQCC)
{
- if (parser->memberof == TYPE_ENTITY)
- var = parser_find_field(parser, parser_tokval(parser));
+ if (parser->memberof == TYPE_ENTITY) {
+ /* still get vars first since there could be a fieldpointer */
+ var = parser_find_var(parser, parser_tokval(parser));
+ if (!var)
+ var = parser_find_field(parser, parser_tokval(parser));
+ }
else if (parser->memberof == TYPE_VECTOR)
{
parseerror(parser, "TODO: implement effective vector member access");
parser_token(parser)->constval.v.z));
}
else if (parser->tok == '(') {
- if (wantop) {
- DEBUGSHUNTDO(printf("push (\n"));
- ++parens;
- /* we expected an operator, this is the function-call operator */
- if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
- parseerror(parser, "out of memory");
- goto onerr;
- }
- } else {
- ++parens;
- if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
- parseerror(parser, "out of memory");
- goto onerr;
- }
- DEBUGSHUNTDO(printf("push (\n"));
- }
- wantop = false;
+ parseerror(parser, "internal error: '(' should be classified as operator");
+ goto onerr;
}
else if (parser->tok == ')') {
if (wantop) {
break;
}
}
- wantop = false;
if (o == operator_count) {
/* no operator found... must be the end of the statement */
break;
olast = NULL;
}
- DEBUGSHUNTDO(printf("push operator %s\n", op->op));
- if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
- goto onerr;
+ if (op->id == opid1('(')) {
+ if (wantop) {
+ DEBUGSHUNTDO(printf("push (\n"));
+ ++parens;
+ /* we expected an operator, this is the function-call operator */
+ if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
+ parseerror(parser, "out of memory");
+ goto onerr;
+ }
+ } else {
+ ++parens;
+ if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
+ parseerror(parser, "out of memory");
+ goto onerr;
+ }
+ DEBUGSHUNTDO(printf("push (\n"));
+ }
+ wantop = false;
+ } else {
+ DEBUGSHUNTDO(printf("push operator %s\n", op->op));
+ if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
+ goto onerr;
+ wantop = false;
+ }
}
if (!parser_next(parser)) {
goto onerr;
(void)!parser_t_locals_add(parser, vx);
(void)!parser_t_locals_add(parser, vy);
(void)!parser_t_locals_add(parser, vz);
+ if (!ast_block_locals_add(localblock, var) ||
+ !ast_block_collect(localblock, vx.var) ||
+ !ast_block_collect(localblock, vy.var) ||
+ !ast_block_collect(localblock, vz.var))
+ {
+ parser_pop_local(parser);
+ parser_pop_local(parser);
+ parser_pop_local(parser);
+ parser_pop_local(parser);
+ ast_value_delete(var);
+ return false;
+ }
}
}
else
ast_value_delete(var);
return false;
}
- }
- if (localblock && !ast_block_locals_add(localblock, var))
- {
- parser_pop_local(parser);
- ast_value_delete(var);
- return false;
+ if (localblock && !ast_block_locals_add(localblock, var))
+ {
+ parser_pop_local(parser);
+ ast_value_delete(var);
+ return false;
+ }
}
if (!parser_next(parser)) {
{
ast_value *var;
ast_value *fld;
+ ast_expression *oldex;
bool isfunc = false;
int basetype;
lex_ctx ctx = parser_ctx(parser);
return false;
}
}
- if (parser_find_field(parser, parser_tokval(parser))) {
- parseerror(parser, "field %s already exists", parser_tokval(parser));
- ast_delete(var);
- return false;
- }
- /* if it was a function, turn it into a function */
if (isfunc) {
ast_value *fval;
- /* turn var into a value of TYPE_FUNCTION, with the old var
- * as return type
- */
fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
if (!fval) {
ast_value_delete(var);
- ast_value_delete(fval);
return false;
}
-
fval->expression.next = (ast_expression*)var;
MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
-
var = fval;
}
fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
fld->expression.next = (ast_expression*)var;
+ if ( (oldex = parser_find_field(parser, parser_tokval(parser)))) {
+ if (ast_istype(oldex, ast_member)) {
+ parseerror(parser, "cannot declare a field with the same name as a vector component, component %s has been declared here: %s:%i",
+ parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
+ ast_delete(fld);
+ return false;
+ }
+ if (!ast_istype(oldex, ast_value)) {
+ /* not possible / sanity check */
+ parseerror(parser, "internal error: %s is not an ast_value", parser_tokval(parser));
+ ast_delete(fld);
+ return false;
+ }
+
+ if (!ast_compare_type(oldex, (ast_expression*)fld)) {
+ parseerror(parser, "field %s has previously been declared with a different type here: %s:%i",
+ parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
+ ast_delete(fld);
+ return false;
+ } else {
+ if (parsewarning(parser, WARN_FIELD_REDECLARED, "field %s has already been declared here: %s:%i",
+ parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line))
+ {
+ ast_delete(fld);
+ return false;
+ }
+ }
+
+ ast_delete(fld);
+ goto nextfield;
+ }
+
varent.var = (ast_expression*)fld;
varent.name = util_strdup(fld->name);
(void)!parser_t_fields_add(parser, varent);
(void)!parser_t_fields_add(parser, vz);
}
+nextfield:
if (!parser_next(parser)) {
parseerror(parser, "expected semicolon or another field name");
return false;
return true;
}
+ else if (parser->tok == '$')
+ {
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error");
+ return false;
+ }
+ }
else
{
parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
else if (!parser->errors)
parseerror(parser, "parse error\n");
lex_close(parser->lex);
- mem_d(parser);
return false;
}
}
for (i = 0; i < parser->imm_float_count; ++i) {
ast_delete(parser->imm_float[i]);
}
+ for (i = 0; i < parser->fields_count; ++i) {
+ ast_delete(parser->fields[i].var);
+ mem_d(parser->fields[i].name);
+ }
for (i = 0; i < parser->globals_count; ++i) {
ast_delete(parser->globals[i].var);
mem_d(parser->globals[i].name);
}
+ MEM_VECTOR_CLEAR(parser, functions);
+ MEM_VECTOR_CLEAR(parser, imm_vector);
+ MEM_VECTOR_CLEAR(parser, imm_string);
+ MEM_VECTOR_CLEAR(parser, imm_float);
MEM_VECTOR_CLEAR(parser, globals);
+ MEM_VECTOR_CLEAR(parser, fields);
+ MEM_VECTOR_CLEAR(parser, locals);
mem_d(parser);
}