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;
if (op->id == opid1(',') && !parens && stopatcomma)
break;
+ if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
+ olast = &operators[sy.ops[sy.ops_count-1].etype-1];
+
+ while (olast && (
+ (op->prec < olast->prec) ||
+ (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
+ {
+ if (!parser_sy_pop(parser, &sy))
+ goto onerr;
+ if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
+ olast = &operators[sy.ops[sy.ops_count-1].etype-1];
+ else
+ olast = NULL;
+ }
+
if (op->id == opid1('.')) {
/* for gmqcc standard: open up the namespace of the previous type */
ast_expression *prevex = sy.out[sy.out_count-1].out;
gotmemberof = true;
}
- if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
- olast = &operators[sy.ops[sy.ops_count-1].etype-1];
-
- while (olast && (
- (op->prec < olast->prec) ||
- (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
- {
- if (!parser_sy_pop(parser, &sy))
+ 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;
- if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
- olast = &operators[sy.ops[sy.ops_count-1].etype-1];
- else
- olast = NULL;
+ wantop = false;
}
-
- DEBUGSHUNTDO(printf("push operator %s\n", op->op));
- if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
- goto onerr;
}
if (!parser_next(parser)) {
goto onerr;
ast_delete(exp);
return false;
}
-
- *out = (ast_expression*)ret;
- } else if (!parser_next(parser)) {
- parseerror(parser, "expected semicolon");
+ } else {
+ if (!parser_next(parser))
+ parseerror(parser, "parse error");
if (expected->expression.next->expression.vtype != TYPE_VOID) {
parseerror(parser, "return without value");
}
+ ret = ast_return_new(parser_ctx(parser), NULL);
}
+ *out = (ast_expression*)ret;
return true;
}
else if (!strcmp(parser_tokval(parser), "if"))
break;
if (!parser_parse_statement(parser, block, &expr)) {
+ parseerror(parser, "parse error");
ast_block_delete(block);
block = NULL;
goto cleanup;
static ast_expression* parser_parse_statement_or_block(parser_t *parser)
{
- ast_expression *expr;
+ ast_expression *expr = NULL;
if (parser->tok == '{')
return (ast_expression*)parser_parse_block(parser);
if (!parser_parse_statement(parser, NULL, &expr))
varentry_t varent;
ast_expression *olddecl;
+ bool hadproto;
+
int basetype = parser_token(parser)->constval.t;
while (true)
{
+ hadproto = false;
+
if (!parser_next(parser)) { /* skip basetype or comma */
parseerror(parser, "expected variable declaration");
return false;
}
ast_function_delete(func);
ast_value_delete(fval);
- var = proto;
- func = var->constval.vfunc;
+ fval = proto;
+ func = proto->constval.vfunc;
+ hadproto = true;
}
else
{
var = fval;
}
- varent.name = util_strdup(var->name);
- varent.var = (ast_expression*)var;
- if (var->expression.vtype == TYPE_VECTOR)
- {
- size_t len = strlen(varent.name);
- varentry_t vx, vy, vz;
- vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
- vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
- vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
- vx.name = (char*)mem_a(len+3);
- vy.name = (char*)mem_a(len+3);
- vz.name = (char*)mem_a(len+3);
- memcpy(vx.name, varent.name, len);
- memcpy(vy.name, varent.name, len);
- memcpy(vz.name, varent.name, len);
- vx.name[len] = vy.name[len] = vz.name[len] = '_';
- vx.name[len+1] = 'x';
- vy.name[len+1] = 'y';
- vz.name[len+1] = 'z';
- vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
-
- if (!localblock) {
- (void)!parser_t_globals_add(parser, varent);
- (void)!parser_t_globals_add(parser, vx);
- (void)!parser_t_globals_add(parser, vy);
- (void)!parser_t_globals_add(parser, vz);
- } else {
- (void)!parser_t_locals_add(parser, varent);
- (void)!parser_t_locals_add(parser, vx);
- (void)!parser_t_locals_add(parser, vy);
- (void)!parser_t_locals_add(parser, vz);
+ if (!hadproto) {
+ varent.name = util_strdup(var->name);
+ varent.var = (ast_expression*)var;
+ if (var->expression.vtype == TYPE_VECTOR)
+ {
+ size_t len = strlen(varent.name);
+ varentry_t vx, vy, vz;
+ vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
+ vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
+ vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
+ vx.name = (char*)mem_a(len+3);
+ vy.name = (char*)mem_a(len+3);
+ vz.name = (char*)mem_a(len+3);
+ memcpy(vx.name, varent.name, len);
+ memcpy(vy.name, varent.name, len);
+ memcpy(vz.name, varent.name, len);
+ vx.name[len] = vy.name[len] = vz.name[len] = '_';
+ vx.name[len+1] = 'x';
+ vy.name[len+1] = 'y';
+ vz.name[len+1] = 'z';
+ vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
+
+ if (!localblock) {
+ (void)!parser_t_globals_add(parser, varent);
+ (void)!parser_t_globals_add(parser, vx);
+ (void)!parser_t_globals_add(parser, vy);
+ (void)!parser_t_globals_add(parser, vz);
+ } else {
+ (void)!parser_t_locals_add(parser, varent);
+ (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
- {
- if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
- ( localblock && !parser_t_locals_add(parser, varent)) )
+ else
{
- ast_value_delete(var);
- return false;
+ if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
+ ( localblock && !parser_t_locals_add(parser, varent)) )
+ {
+ 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_delete(var);
else if (parser->tok == '.')
{
ast_value *var;
+ ast_value *typevar;
ast_value *fld;
+ ast_expression *oldex;
bool isfunc = false;
int basetype;
lex_ctx ctx = parser_ctx(parser);
}
/* parse the field type fully */
- var = parser_parse_type(parser, basetype, &isfunc);
+ typevar = var = parser_parse_type(parser, basetype, &isfunc);
if (!var)
return false;
while (true) {
+ var = ast_value_copy(typevar);
/* now the field name */
if (parser->tok != TOKEN_IDENT) {
parseerror(parser, "expected field name");
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 false;
}
}
+ ast_delete(typevar);
/* skip the semicolon */
if (!parser_next(parser))
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);
+ parser->lex = NULL;
return false;
}
}
}
lex_close(parser->lex);
+ parser->lex = NULL;
return !parser->errors;
}
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);
}
projects / xonotic / gmqcc.git / blobdiff