16 MEM_VECTOR_MAKE(varentry_t, globals);
17 MEM_VECTOR_MAKE(varentry_t, fields);
18 MEM_VECTOR_MAKE(ast_function*, functions);
19 MEM_VECTOR_MAKE(ast_value*, imm_float);
20 MEM_VECTOR_MAKE(ast_value*, imm_string);
21 MEM_VECTOR_MAKE(ast_value*, imm_vector);
23 ast_value *imm_float_zero;
24 ast_value *imm_vector_zero;
26 ast_function *function;
27 MEM_VECTOR_MAKE(varentry_t, locals);
32 /* TYPE_FIELD -> parser_find_fields is used instead of find_var
33 * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard
34 * anything else: type error
39 MEM_VEC_FUNCTIONS(parser_t, varentry_t, globals)
40 MEM_VEC_FUNCTIONS(parser_t, varentry_t, fields)
41 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_float)
42 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_string)
43 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector)
44 MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals)
45 MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions)
47 static void parser_pop_local(parser_t *parser);
48 static bool parser_variable(parser_t *parser, ast_block *localblock);
49 static ast_block* parser_parse_block(parser_t *parser);
50 static ast_expression* parser_parse_statement_or_block(parser_t *parser);
51 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma);
52 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma);
54 void parseerror(parser_t *parser, const char *fmt, ...)
61 vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap);
67 /* returns true if it counts as an error */
68 bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
71 int lvl = LVL_WARNING;
73 if (!OPTS_WARN(warntype))
76 if (OPTS_WARN(WARN_ERROR)) {
82 vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
85 return OPTS_WARN(WARN_ERROR);
88 /**********************************************************************
89 * some maths used for constant folding
92 vector vec3_add(vector a, vector b)
101 vector vec3_sub(vector a, vector b)
110 qcfloat vec3_mulvv(vector a, vector b)
112 return (a.x * b.x + a.y * b.y + a.z * b.z);
115 vector vec3_mulvf(vector a, float b)
124 /**********************************************************************
128 bool parser_next(parser_t *parser)
130 /* lex_do kills the previous token */
131 parser->tok = lex_do(parser->lex);
132 if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
137 /* lift a token out of the parser so it's not destroyed by parser_next */
138 token *parser_lift(parser_t *parser)
140 token *tok = parser->lex->tok;
141 parser->lex->tok = NULL;
145 #define parser_tokval(p) (p->lex->tok->value)
146 #define parser_token(p) (p->lex->tok)
147 #define parser_ctx(p) (p->lex->tok->ctx)
149 ast_value* parser_const_float(parser_t *parser, double d)
153 for (i = 0; i < parser->imm_float_count; ++i) {
154 if (parser->imm_float[i]->constval.vfloat == d)
155 return parser->imm_float[i];
157 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
159 out->constval.vfloat = d;
160 if (!parser_t_imm_float_add(parser, out)) {
161 ast_value_delete(out);
167 ast_value* parser_const_float_0(parser_t *parser)
169 if (!parser->imm_float_zero)
170 parser->imm_float_zero = parser_const_float(parser, 0);
171 return parser->imm_float_zero;
174 ast_value* parser_const_string(parser_t *parser, const char *str)
178 for (i = 0; i < parser->imm_string_count; ++i) {
179 if (!strcmp(parser->imm_string[i]->constval.vstring, str))
180 return parser->imm_string[i];
182 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
184 out->constval.vstring = util_strdup(str);
185 if (!parser_t_imm_string_add(parser, out)) {
186 ast_value_delete(out);
192 ast_value* parser_const_vector(parser_t *parser, vector v)
196 for (i = 0; i < parser->imm_vector_count; ++i) {
197 if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
198 return parser->imm_vector[i];
200 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
202 out->constval.vvec = v;
203 if (!parser_t_imm_vector_add(parser, out)) {
204 ast_value_delete(out);
210 ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
216 return parser_const_vector(parser, v);
219 ast_value* parser_const_vector_0(parser_t *parser)
221 if (!parser->imm_vector_zero)
222 parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
223 return parser->imm_vector_zero;
226 ast_expression* parser_find_field(parser_t *parser, const char *name)
229 for (i = 0; i < parser->fields_count; ++i) {
230 if (!strcmp(parser->fields[i].name, name))
231 return parser->fields[i].var;
236 ast_expression* parser_find_global(parser_t *parser, const char *name)
239 for (i = 0; i < parser->globals_count; ++i) {
240 if (!strcmp(parser->globals[i].name, name))
241 return parser->globals[i].var;
246 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto)
250 for (i = parser->locals_count; i > upto;) {
252 if (!strcmp(parser->locals[i].name, name))
253 return parser->locals[i].var;
255 if (!parser->function)
257 fun = parser->function->vtype;
258 for (i = 0; i < fun->expression.params_count; ++i) {
259 if (!strcmp(fun->expression.params[i]->name, name))
260 return (ast_expression*)(fun->expression.params[i]);
265 ast_expression* parser_find_var(parser_t *parser, const char *name)
268 v = parser_find_local(parser, name, 0);
269 if (!v) v = parser_find_global(parser, name);
274 MEM_VECTOR_MAKE(ast_value*, p);
276 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
278 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
282 lex_ctx ctx = parser_ctx(parser);
283 int vtype = basetype;
287 MEM_VECTOR_INIT(¶ms, p);
291 if (parser->tok == '(') {
296 bool isfield = false;
299 if (!parser_next(parser))
302 if (parser->tok == ')')
305 if (parser->tok == '.') {
307 if (!parser_next(parser)) {
308 parseerror(parser, "expected field parameter type");
313 temptype = parser_token(parser)->constval.t;
314 if (!parser_next(parser))
317 param = parser_parse_type(parser, temptype, &dummy);
323 if (parser->tok == TOKEN_IDENT) {
324 /* named parameter */
325 if (!ast_value_set_name(param, parser_tokval(parser)))
327 if (!parser_next(parser))
332 fld = ast_value_new(ctx, param->name, TYPE_FIELD);
333 fld->expression.next = (ast_expression*)param;
337 if (!paramlist_t_p_add(¶ms, param)) {
338 parseerror(parser, "Out of memory while parsing typename");
342 if (parser->tok == ',')
344 if (parser->tok == ')')
346 parseerror(parser, "Unexpected token");
349 if (!parser_next(parser))
353 var = ast_value_new(ctx, "<unnamed>", vtype);
356 MEM_VECTOR_MOVE(¶ms, p, &var->expression, params);
359 for (i = 0; i < params.p_count; ++i)
360 ast_value_delete(params.p[i]);
361 MEM_VECTOR_CLEAR(¶ms, p);
367 size_t etype; /* 0 = expression, others are operators */
371 ast_block *block; /* for commas and function calls */
376 MEM_VECTOR_MAKE(sy_elem, out);
377 MEM_VECTOR_MAKE(sy_elem, ops);
379 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
380 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
382 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
392 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
395 e.out = (ast_expression*)v;
402 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
404 e.etype = 1 + (op - operators);
412 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
424 # define DEBUGSHUNTDO(x) x
426 # define DEBUGSHUNTDO(x)
429 static bool parser_sy_pop(parser_t *parser, shunt *sy)
433 ast_expression *out = NULL;
434 ast_expression *exprs[3];
435 ast_block *blocks[3];
436 ast_value *asvalue[3];
438 qcint generated_op = 0;
440 if (!sy->ops_count) {
441 parseerror(parser, "internal error: missing operator");
445 if (sy->ops[sy->ops_count-1].paren) {
446 parseerror(parser, "unmatched parenthesis");
450 op = &operators[sy->ops[sy->ops_count-1].etype - 1];
451 ctx = sy->ops[sy->ops_count-1].ctx;
453 DEBUGSHUNTDO(printf("apply %s\n", op->op));
455 if (sy->out_count < op->operands) {
456 parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count,
457 op->op, (int)op->id);
463 sy->out_count -= op->operands;
464 for (i = 0; i < op->operands; ++i) {
465 exprs[i] = sy->out[sy->out_count+i].out;
466 blocks[i] = sy->out[sy->out_count+i].block;
467 asvalue[i] = (ast_value*)exprs[i];
470 if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
471 parseerror(parser, "internal error: operator cannot be applied on empty blocks");
475 #define NotSameType(T) \
476 (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
477 exprs[0]->expression.vtype != T)
478 #define CanConstFold1(A) \
479 (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
480 #define CanConstFold(A, B) \
481 (CanConstFold1(A) && CanConstFold1(B))
482 #define ConstV(i) (asvalue[(i)]->constval.vvec)
483 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
487 parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
491 if (exprs[0]->expression.vtype == TYPE_ENTITY) {
492 if (exprs[1]->expression.vtype != TYPE_FIELD) {
493 parseerror(parser, "type error: right hand of member-operand should be an entity-field");
496 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
498 else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
499 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
503 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
510 if (!ast_block_exprs_add(blocks[0], exprs[1]))
513 blocks[0] = ast_block_new(ctx);
514 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
515 !ast_block_exprs_add(blocks[0], exprs[1]))
520 if (!ast_block_set_type(blocks[0], exprs[1]))
523 sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
527 switch (exprs[0]->expression.vtype) {
529 if (CanConstFold1(exprs[0]))
530 out = (ast_expression*)parser_const_float(parser, -ConstF(0));
532 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
533 (ast_expression*)parser_const_float_0(parser),
537 if (CanConstFold1(exprs[0]))
538 out = (ast_expression*)parser_const_vector_f(parser,
539 -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
541 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
542 (ast_expression*)parser_const_vector_0(parser),
546 parseerror(parser, "invalid types used in expression: cannot negate type %s",
547 type_name[exprs[0]->expression.vtype]);
553 switch (exprs[0]->expression.vtype) {
555 if (CanConstFold1(exprs[0]))
556 out = (ast_expression*)parser_const_float(parser, !ConstF(0));
558 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
561 if (CanConstFold1(exprs[0]))
562 out = (ast_expression*)parser_const_float(parser,
563 (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
565 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
568 parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
569 type_name[exprs[0]->expression.vtype]);
575 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
576 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
578 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
579 type_name[exprs[0]->expression.vtype],
580 type_name[exprs[1]->expression.vtype]);
583 switch (exprs[0]->expression.vtype) {
585 if (CanConstFold(exprs[0], exprs[1]))
587 out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
590 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
593 if (CanConstFold(exprs[0], exprs[1]))
594 out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
596 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
599 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
600 type_name[exprs[0]->expression.vtype],
601 type_name[exprs[1]->expression.vtype]);
606 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
607 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
609 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
610 type_name[exprs[1]->expression.vtype],
611 type_name[exprs[0]->expression.vtype]);
614 switch (exprs[0]->expression.vtype) {
616 if (CanConstFold(exprs[0], exprs[1]))
617 out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
619 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
622 if (CanConstFold(exprs[0], exprs[1]))
623 out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
625 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
628 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
629 type_name[exprs[1]->expression.vtype],
630 type_name[exprs[0]->expression.vtype]);
635 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
636 exprs[0]->expression.vtype != TYPE_VECTOR &&
637 exprs[0]->expression.vtype != TYPE_FLOAT &&
638 exprs[1]->expression.vtype != TYPE_VECTOR &&
639 exprs[1]->expression.vtype != TYPE_FLOAT)
641 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
642 type_name[exprs[1]->expression.vtype],
643 type_name[exprs[0]->expression.vtype]);
646 switch (exprs[0]->expression.vtype) {
648 if (exprs[1]->expression.vtype == TYPE_VECTOR)
650 if (CanConstFold(exprs[0], exprs[1]))
651 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
653 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
657 if (CanConstFold(exprs[0], exprs[1]))
658 out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
660 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
664 if (exprs[1]->expression.vtype == TYPE_FLOAT)
666 if (CanConstFold(exprs[0], exprs[1]))
667 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
669 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
673 if (CanConstFold(exprs[0], exprs[1]))
674 out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
676 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
680 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
681 type_name[exprs[1]->expression.vtype],
682 type_name[exprs[0]->expression.vtype]);
687 if (NotSameType(TYPE_FLOAT)) {
688 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
689 type_name[exprs[0]->expression.vtype],
690 type_name[exprs[1]->expression.vtype]);
693 if (CanConstFold(exprs[0], exprs[1]))
694 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
696 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
700 parseerror(parser, "qc does not have a modulo operator");
704 if (NotSameType(TYPE_FLOAT)) {
705 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
706 type_name[exprs[0]->expression.vtype],
707 type_name[exprs[1]->expression.vtype]);
710 if (CanConstFold(exprs[0], exprs[1]))
711 out = (ast_expression*)parser_const_float(parser,
712 (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
713 (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
715 out = (ast_expression*)ast_binary_new(ctx,
716 (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
720 parseerror(parser, "TODO: bitxor");
725 case opid3('<','<','='):
726 case opid3('>','>','='):
727 parseerror(parser, "TODO: shifts");
731 generated_op += 1; /* INSTR_OR */
733 generated_op += INSTR_AND;
734 if (NotSameType(TYPE_FLOAT)) {
735 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
736 type_name[exprs[0]->expression.vtype],
737 type_name[exprs[1]->expression.vtype]);
738 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
739 parseerror(parser, "TODO: optional early out");
742 if (opts_standard == COMPILER_GMQCC)
743 printf("TODO: early out logic\n");
744 if (CanConstFold(exprs[0], exprs[1]))
745 out = (ast_expression*)parser_const_float(parser,
746 (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
748 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
752 generated_op += 1; /* INSTR_GT */
754 generated_op += 1; /* INSTR_LT */
755 case opid2('>', '='):
756 generated_op += 1; /* INSTR_GE */
757 case opid2('<', '='):
758 generated_op += INSTR_LE;
759 if (NotSameType(TYPE_FLOAT)) {
760 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
761 type_name[exprs[0]->expression.vtype],
762 type_name[exprs[1]->expression.vtype]);
765 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
767 case opid2('!', '='):
768 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
769 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
770 type_name[exprs[0]->expression.vtype],
771 type_name[exprs[1]->expression.vtype]);
774 out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
776 case opid2('=', '='):
777 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
778 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
779 type_name[exprs[0]->expression.vtype],
780 type_name[exprs[1]->expression.vtype]);
783 out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
787 if (ast_istype(exprs[0], ast_entfield))
788 assignop = type_storep_instr[exprs[0]->expression.vtype];
790 assignop = type_store_instr[exprs[0]->expression.vtype];
791 out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
795 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
796 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
798 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
799 type_name[exprs[0]->expression.vtype],
800 type_name[exprs[1]->expression.vtype]);
803 if (ast_istype(exprs[0], ast_entfield))
804 assignop = type_storep_instr[exprs[0]->expression.vtype];
806 assignop = type_store_instr[exprs[0]->expression.vtype];
807 switch (exprs[0]->expression.vtype) {
809 out = (ast_expression*)ast_binstore_new(ctx, assignop,
810 (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
814 out = (ast_expression*)ast_binstore_new(ctx, assignop,
815 (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
819 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
820 type_name[exprs[0]->expression.vtype],
821 type_name[exprs[1]->expression.vtype]);
829 parseerror(parser, "failed to apply operand %s", op->op);
833 DEBUGSHUNTDO(printf("applied %s\n", op->op));
834 sy->out[sy->out_count++] = syexp(ctx, out);
838 static bool parser_close_call(parser_t *parser, shunt *sy)
840 /* was a function call */
848 fid = sy->ops[sy->ops_count].off;
850 /* out[fid] is the function
851 * everything above is parameters...
853 * 1 params = ast_expression
857 if (sy->out_count < 1 || sy->out_count <= fid) {
858 parseerror(parser, "internal error: function call needs function and parameter list...");
862 fun = sy->out[fid].out;
864 call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
866 parseerror(parser, "out of memory");
870 if (fid+1 == sy->out_count) {
873 } else if (fid+2 == sy->out_count) {
876 params = sy->out[sy->out_count].block;
880 if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
881 ast_delete(sy->out[sy->out_count].out);
882 parseerror(parser, "out of memory");
886 paramcount = params->exprs_count;
887 MEM_VECTOR_MOVE(params, exprs, call, params);
891 parseerror(parser, "invalid function call");
895 /* overwrite fid, the function, with a call */
896 sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
898 if (fun->expression.vtype != TYPE_FUNCTION) {
899 parseerror(parser, "not a function");
903 if (!fun->expression.next) {
904 parseerror(parser, "could not determine function return type");
907 if (fun->expression.params_count != paramcount) {
908 parseerror(parser, "expected %i parameters, got %i", (int)fun->expression.params_count, paramcount);
916 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
918 if (!sy->ops_count) {
919 parseerror(parser, "unmatched closing paren");
922 if (sy->ops[sy->ops_count-1].paren == 1) {
923 parseerror(parser, "empty parenthesis expression");
926 while (sy->ops_count) {
927 if (sy->ops[sy->ops_count-1].paren == 'f') {
928 if (!parser_close_call(parser, sy))
932 if (sy->ops[sy->ops_count-1].paren == 1) {
934 return !functions_only;
936 if (!parser_sy_pop(parser, sy))
942 static void parser_reclassify_token(parser_t *parser)
945 for (i = 0; i < operator_count; ++i) {
946 if (!strcmp(parser_tokval(parser), operators[i].op)) {
947 parser->tok = TOKEN_OPERATOR;
953 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
955 ast_expression *expr = NULL;
958 bool gotmemberof = false;
960 /* count the parens because an if starts with one, so the
961 * end of a condition is an unmatched closing paren
965 MEM_VECTOR_INIT(&sy, out);
966 MEM_VECTOR_INIT(&sy, ops);
968 parser->lex->flags.noops = false;
970 parser_reclassify_token(parser);
977 parser->memberof = 0;
979 if (parser->tok == TOKEN_IDENT)
983 parseerror(parser, "expected operator or end of statement");
988 if (opts_standard == COMPILER_GMQCC)
990 if (parser->memberof == TYPE_ENTITY) {
991 /* still get vars first since there could be a fieldpointer */
992 var = parser_find_var(parser, parser_tokval(parser));
994 var = parser_find_field(parser, parser_tokval(parser));
996 else if (parser->memberof == TYPE_VECTOR)
998 parseerror(parser, "TODO: implement effective vector member access");
1001 else if (parser->memberof) {
1002 parseerror(parser, "namespace for member not found");
1006 var = parser_find_var(parser, parser_tokval(parser));
1008 var = parser_find_var(parser, parser_tokval(parser));
1010 var = parser_find_field(parser, parser_tokval(parser));
1013 parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
1016 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
1017 parseerror(parser, "out of memory");
1020 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
1022 else if (parser->tok == TOKEN_FLOATCONST) {
1025 parseerror(parser, "expected operator or end of statement, got constant");
1029 val = parser_const_float(parser, (parser_token(parser)->constval.f));
1032 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1033 parseerror(parser, "out of memory");
1036 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
1038 else if (parser->tok == TOKEN_INTCONST) {
1041 parseerror(parser, "expected operator or end of statement, got constant");
1045 val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1048 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1049 parseerror(parser, "out of memory");
1052 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
1054 else if (parser->tok == TOKEN_STRINGCONST) {
1057 parseerror(parser, "expected operator or end of statement, got constant");
1061 val = parser_const_string(parser, parser_tokval(parser));
1064 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1065 parseerror(parser, "out of memory");
1068 DEBUGSHUNTDO(printf("push string\n"));
1070 else if (parser->tok == TOKEN_VECTORCONST) {
1073 parseerror(parser, "expected operator or end of statement, got constant");
1077 val = parser_const_vector(parser, parser_token(parser)->constval.v);
1080 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1081 parseerror(parser, "out of memory");
1084 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
1085 parser_token(parser)->constval.v.x,
1086 parser_token(parser)->constval.v.y,
1087 parser_token(parser)->constval.v.z));
1089 else if (parser->tok == '(') {
1091 DEBUGSHUNTDO(printf("push (\n"));
1093 /* we expected an operator, this is the function-call operator */
1094 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
1095 parseerror(parser, "out of memory");
1100 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
1101 parseerror(parser, "out of memory");
1104 DEBUGSHUNTDO(printf("push (\n"));
1108 else if (parser->tok == ')') {
1110 DEBUGSHUNTDO(printf("do[op] )\n"));
1114 /* we do expect an operator next */
1115 /* closing an opening paren */
1116 if (!parser_close_paren(parser, &sy, false))
1119 DEBUGSHUNTDO(printf("do[nop] )\n"));
1123 /* allowed for function calls */
1124 if (!parser_close_paren(parser, &sy, true))
1129 else if (parser->tok != TOKEN_OPERATOR) {
1131 parseerror(parser, "expected operator or end of statement");
1138 /* classify the operator */
1139 /* TODO: suffix operators */
1140 const oper_info *op;
1141 const oper_info *olast = NULL;
1143 for (o = 0; o < operator_count; ++o) {
1144 if ((!(operators[o].flags & OP_PREFIX) == wantop) &&
1145 !(operators[o].flags & OP_SUFFIX) && /* remove this */
1146 !strcmp(parser_tokval(parser), operators[o].op))
1152 if (o == operator_count) {
1153 /* no operator found... must be the end of the statement */
1156 /* found an operator */
1159 /* when declaring variables, a comma starts a new variable */
1160 if (op->id == opid1(',') && !parens && stopatcomma)
1163 if (op->id == opid1('.')) {
1164 /* for gmqcc standard: open up the namespace of the previous type */
1165 ast_expression *prevex = sy.out[sy.out_count-1].out;
1167 parseerror(parser, "unexpected member operator");
1170 if (prevex->expression.vtype == TYPE_ENTITY)
1171 parser->memberof = TYPE_ENTITY;
1172 else if (prevex->expression.vtype == TYPE_VECTOR)
1173 parser->memberof = TYPE_VECTOR;
1175 parseerror(parser, "type error: type has no members");
1181 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1182 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1185 (op->prec < olast->prec) ||
1186 (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1188 if (!parser_sy_pop(parser, &sy))
1190 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1191 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1196 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1197 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1200 if (!parser_next(parser)) {
1203 if (parser->tok == ';') {
1208 while (sy.ops_count) {
1209 if (!parser_sy_pop(parser, &sy))
1213 parser->lex->flags.noops = true;
1214 if (!sy.out_count) {
1215 parseerror(parser, "empty expression");
1218 expr = sy.out[0].out;
1219 MEM_VECTOR_CLEAR(&sy, out);
1220 MEM_VECTOR_CLEAR(&sy, ops);
1221 DEBUGSHUNTDO(printf("shunt done\n"));
1225 parser->lex->flags.noops = true;
1226 MEM_VECTOR_CLEAR(&sy, out);
1227 MEM_VECTOR_CLEAR(&sy, ops);
1231 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
1233 ast_expression *e = parser_expression_leave(parser, stopatcomma);
1236 if (!parser_next(parser)) {
1243 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1246 ast_expression *cond, *ontrue, *onfalse = NULL;
1248 lex_ctx ctx = parser_ctx(parser);
1250 /* skip the 'if' and check for opening paren */
1251 if (!parser_next(parser) || parser->tok != '(') {
1252 parseerror(parser, "expected 'if' condition in parenthesis");
1255 /* parse into the expression */
1256 if (!parser_next(parser)) {
1257 parseerror(parser, "expected 'if' condition after opening paren");
1260 /* parse the condition */
1261 cond = parser_expression_leave(parser, false);
1265 if (parser->tok != ')') {
1266 parseerror(parser, "expected closing paren after 'if' condition");
1270 /* parse into the 'then' branch */
1271 if (!parser_next(parser)) {
1272 parseerror(parser, "expected statement for on-true branch of 'if'");
1276 ontrue = parser_parse_statement_or_block(parser);
1281 /* check for an else */
1282 if (!strcmp(parser_tokval(parser), "else")) {
1283 /* parse into the 'else' branch */
1284 if (!parser_next(parser)) {
1285 parseerror(parser, "expected on-false branch after 'else'");
1290 onfalse = parser_parse_statement_or_block(parser);
1298 ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1299 *out = (ast_expression*)ifthen;
1303 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1306 ast_expression *cond, *ontrue;
1308 lex_ctx ctx = parser_ctx(parser);
1310 /* skip the 'while' and check for opening paren */
1311 if (!parser_next(parser) || parser->tok != '(') {
1312 parseerror(parser, "expected 'while' condition in parenthesis");
1315 /* parse into the expression */
1316 if (!parser_next(parser)) {
1317 parseerror(parser, "expected 'while' condition after opening paren");
1320 /* parse the condition */
1321 cond = parser_expression_leave(parser, false);
1325 if (parser->tok != ')') {
1326 parseerror(parser, "expected closing paren after 'while' condition");
1330 /* parse into the 'then' branch */
1331 if (!parser_next(parser)) {
1332 parseerror(parser, "expected while-loop body");
1336 ontrue = parser_parse_statement_or_block(parser);
1342 aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1343 *out = (ast_expression*)aloop;
1347 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1350 ast_expression *cond, *ontrue;
1352 lex_ctx ctx = parser_ctx(parser);
1354 /* skip the 'do' and get the body */
1355 if (!parser_next(parser)) {
1356 parseerror(parser, "expected loop body");
1359 ontrue = parser_parse_statement_or_block(parser);
1363 /* expect the "while" */
1364 if (parser->tok != TOKEN_KEYWORD ||
1365 strcmp(parser_tokval(parser), "while"))
1367 parseerror(parser, "expected 'while' and condition");
1372 /* skip the 'while' and check for opening paren */
1373 if (!parser_next(parser) || parser->tok != '(') {
1374 parseerror(parser, "expected 'while' condition in parenthesis");
1378 /* parse into the expression */
1379 if (!parser_next(parser)) {
1380 parseerror(parser, "expected 'while' condition after opening paren");
1384 /* parse the condition */
1385 cond = parser_expression_leave(parser, false);
1389 if (parser->tok != ')') {
1390 parseerror(parser, "expected closing paren after 'while' condition");
1396 if (!parser_next(parser) || parser->tok != ';') {
1397 parseerror(parser, "expected semicolon after condition");
1403 if (!parser_next(parser)) {
1404 parseerror(parser, "parse error");
1410 aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1411 *out = (ast_expression*)aloop;
1415 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1418 ast_expression *initexpr, *cond, *increment, *ontrue;
1419 size_t oldblocklocal;
1421 lex_ctx ctx = parser_ctx(parser);
1423 oldblocklocal = parser->blocklocal;
1424 parser->blocklocal = parser->locals_count;
1431 /* skip the 'while' and check for opening paren */
1432 if (!parser_next(parser) || parser->tok != '(') {
1433 parseerror(parser, "expected 'for' expressions in parenthesis");
1436 /* parse into the expression */
1437 if (!parser_next(parser)) {
1438 parseerror(parser, "expected 'for' initializer after opening paren");
1442 if (parser->tok == TOKEN_TYPENAME) {
1443 if (opts_standard != COMPILER_GMQCC) {
1444 if (parsewarning(parser, WARN_EXTENSIONS,
1445 "current standard does not allow variable declarations in for-loop initializers"))
1449 parseerror(parser, "TODO: assignment of new variables to be non-const");
1451 if (!parser_variable(parser, block))
1454 else if (parser->tok != ';')
1456 initexpr = parser_expression_leave(parser, false);
1461 /* move on to condition */
1462 if (parser->tok != ';') {
1463 parseerror(parser, "expected semicolon after for-loop initializer");
1466 if (!parser_next(parser)) {
1467 parseerror(parser, "expected for-loop condition");
1471 /* parse the condition */
1472 if (parser->tok != ';') {
1473 cond = parser_expression_leave(parser, false);
1478 /* move on to incrementor */
1479 if (parser->tok != ';') {
1480 parseerror(parser, "expected semicolon after for-loop initializer");
1483 if (!parser_next(parser)) {
1484 parseerror(parser, "expected for-loop condition");
1488 /* parse the incrementor */
1489 if (parser->tok != ')') {
1490 increment = parser_expression_leave(parser, false);
1496 if (parser->tok != ')') {
1497 parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1500 /* parse into the 'then' branch */
1501 if (!parser_next(parser)) {
1502 parseerror(parser, "expected for-loop body");
1505 ontrue = parser_parse_statement_or_block(parser);
1510 aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1511 *out = (ast_expression*)aloop;
1513 while (parser->locals_count > parser->blocklocal)
1514 parser_pop_local(parser);
1515 parser->blocklocal = oldblocklocal;
1518 if (initexpr) ast_delete(initexpr);
1519 if (cond) ast_delete(cond);
1520 if (increment) ast_delete(increment);
1521 while (parser->locals_count > parser->blocklocal)
1522 parser_pop_local(parser);
1523 parser->blocklocal = oldblocklocal;
1527 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1529 if (parser->tok == TOKEN_TYPENAME)
1531 /* local variable */
1533 parseerror(parser, "cannot declare a variable from here");
1536 if (opts_standard == COMPILER_QCC) {
1537 if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1540 if (!parser_variable(parser, block))
1545 else if (parser->tok == TOKEN_KEYWORD)
1547 if (!strcmp(parser_tokval(parser), "local"))
1550 parseerror(parser, "cannot declare a local variable here");
1553 if (!parser_next(parser)) {
1554 parseerror(parser, "expected variable declaration");
1557 if (!parser_variable(parser, block))
1562 else if (!strcmp(parser_tokval(parser), "return"))
1564 ast_expression *exp = NULL;
1565 ast_return *ret = NULL;
1566 ast_value *expected = parser->function->vtype;
1568 if (!parser_next(parser)) {
1569 parseerror(parser, "expected return expression");
1573 if (parser->tok != ';') {
1574 exp = parser_expression(parser, false);
1578 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1579 parseerror(parser, "return with invalid expression");
1582 ret = ast_return_new(exp->expression.node.context, exp);
1588 *out = (ast_expression*)ret;
1589 } else if (!parser_next(parser)) {
1590 parseerror(parser, "expected semicolon");
1591 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1592 parseerror(parser, "return without value");
1597 else if (!strcmp(parser_tokval(parser), "if"))
1599 return parser_parse_if(parser, block, out);
1601 else if (!strcmp(parser_tokval(parser), "while"))
1603 return parser_parse_while(parser, block, out);
1605 else if (!strcmp(parser_tokval(parser), "do"))
1607 return parser_parse_dowhile(parser, block, out);
1609 else if (!strcmp(parser_tokval(parser), "for"))
1611 if (opts_standard == COMPILER_QCC) {
1612 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1615 return parser_parse_for(parser, block, out);
1617 parseerror(parser, "Unexpected keyword");
1620 else if (parser->tok == '{')
1623 inner = parser_parse_block(parser);
1626 *out = (ast_expression*)inner;
1631 ast_expression *exp = parser_expression(parser, false);
1639 static void parser_pop_local(parser_t *parser)
1641 parser->locals_count--;
1642 mem_d(parser->locals[parser->locals_count].name);
1645 static ast_block* parser_parse_block(parser_t *parser)
1647 size_t oldblocklocal;
1648 ast_block *block = NULL;
1650 oldblocklocal = parser->blocklocal;
1651 parser->blocklocal = parser->locals_count;
1653 if (!parser_next(parser)) { /* skip the '{' */
1654 parseerror(parser, "expected function body");
1658 block = ast_block_new(parser_ctx(parser));
1660 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1662 ast_expression *expr;
1663 if (parser->tok == '}')
1666 if (!parser_parse_statement(parser, block, &expr)) {
1667 ast_block_delete(block);
1673 if (!ast_block_exprs_add(block, expr)) {
1675 ast_block_delete(block);
1681 if (parser->tok != '}') {
1682 ast_block_delete(block);
1685 (void)parser_next(parser);
1689 while (parser->locals_count > parser->blocklocal)
1690 parser_pop_local(parser);
1691 parser->blocklocal = oldblocklocal;
1692 /* unroll the local vector */
1696 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1698 ast_expression *expr;
1699 if (parser->tok == '{')
1700 return (ast_expression*)parser_parse_block(parser);
1701 if (!parser_parse_statement(parser, NULL, &expr))
1706 static bool parser_variable(parser_t *parser, ast_block *localblock)
1708 bool isfunc = false;
1709 ast_function *func = NULL;
1713 ast_expression *olddecl;
1715 int basetype = parser_token(parser)->constval.t;
1719 if (!parser_next(parser)) { /* skip basetype or comma */
1720 parseerror(parser, "expected variable declaration");
1727 ctx = parser_ctx(parser);
1728 var = parser_parse_type(parser, basetype, &isfunc);
1733 if (parser->tok != TOKEN_IDENT) {
1734 parseerror(parser, "expected variable name\n");
1739 if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1740 ast_value_delete(var);
1741 parseerror(parser, "global %s already declared here: %s:%i\n",
1742 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1746 if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1747 ast_value_delete(var);
1748 parseerror(parser, "local %s already declared here: %s:%i\n",
1749 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1754 if (!ast_value_set_name(var, parser_tokval(parser))) {
1755 parseerror(parser, "failed to set variable name\n");
1756 ast_value_delete(var);
1761 /* a function was defined */
1763 ast_value *proto = NULL;
1766 olddecl = parser_find_global(parser, parser_tokval(parser));
1768 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal);
1771 /* we had a prototype */
1772 if (!ast_istype(olddecl, ast_value)) {
1773 /* theoretically not possible you think?
1779 parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1780 parser_tokval(parser));
1781 ast_value_delete(var);
1785 proto = (ast_value*)olddecl;
1788 /* turn var into a value of TYPE_FUNCTION, with the old var
1791 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1792 func = ast_function_new(ctx, var->name, fval);
1793 if (!fval || !func) {
1794 ast_value_delete(var);
1795 if (fval) ast_value_delete(fval);
1796 if (func) ast_function_delete(func);
1800 fval->expression.next = (ast_expression*)var;
1801 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1803 /* we compare the type late here, but it's easier than
1804 * messing with the parameter-vector etc. earlier
1807 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1808 parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1810 ast_ctx(proto).file, ast_ctx(proto).line);
1811 ast_function_delete(func);
1812 ast_value_delete(fval);
1815 ast_function_delete(func);
1816 ast_value_delete(fval);
1818 func = var->constval.vfunc;
1822 if (!parser_t_functions_add(parser, func)) {
1823 ast_function_delete(func);
1824 ast_value_delete(fval);
1832 varent.name = util_strdup(var->name);
1833 varent.var = (ast_expression*)var;
1834 if (var->expression.vtype == TYPE_VECTOR)
1836 size_t len = strlen(varent.name);
1837 varentry_t vx, vy, vz;
1838 vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1839 vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1840 vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1841 vx.name = (char*)mem_a(len+3);
1842 vy.name = (char*)mem_a(len+3);
1843 vz.name = (char*)mem_a(len+3);
1844 memcpy(vx.name, varent.name, len);
1845 memcpy(vy.name, varent.name, len);
1846 memcpy(vz.name, varent.name, len);
1847 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1848 vx.name[len+1] = 'x';
1849 vy.name[len+1] = 'y';
1850 vz.name[len+1] = 'z';
1851 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1854 (void)!parser_t_globals_add(parser, varent);
1855 (void)!parser_t_globals_add(parser, vx);
1856 (void)!parser_t_globals_add(parser, vy);
1857 (void)!parser_t_globals_add(parser, vz);
1859 (void)!parser_t_locals_add(parser, varent);
1860 (void)!parser_t_locals_add(parser, vx);
1861 (void)!parser_t_locals_add(parser, vy);
1862 (void)!parser_t_locals_add(parser, vz);
1867 if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1868 ( localblock && !parser_t_locals_add(parser, varent)) )
1870 ast_value_delete(var);
1874 if (localblock && !ast_block_locals_add(localblock, var))
1876 parser_pop_local(parser);
1877 ast_value_delete(var);
1881 if (!parser_next(parser)) {
1882 ast_value_delete(var);
1886 if (parser->tok == ';') {
1887 if (!parser_next(parser))
1888 return parser->tok == TOKEN_EOF;
1892 if (parser->tok == ',') {
1897 if (parser->tok != '=') {
1898 parseerror(parser, "expected '=' or ';'");
1902 if (!parser_next(parser))
1905 if (parser->tok == '#') {
1907 parseerror(parser, "cannot declare builtins within functions");
1910 if (!isfunc || !func) {
1911 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1914 if (!parser_next(parser)) {
1915 parseerror(parser, "expected builtin number");
1918 if (parser->tok != TOKEN_INTCONST) {
1919 parseerror(parser, "builtin number must be an integer constant");
1922 if (parser_token(parser)->constval.i <= 0) {
1923 parseerror(parser, "builtin number must be positive integer greater than zero");
1927 func->builtin = -parser_token(parser)->constval.i;
1929 if (!parser_next(parser))
1931 } else if (parser->tok == '{') {
1934 ast_function *old = parser->function;
1937 parseerror(parser, "cannot declare functions within functions");
1941 parser->function = func;
1942 block = parser_parse_block(parser);
1943 parser->function = old;
1948 if (!ast_function_blocks_add(func, block)) {
1949 ast_block_delete(block);
1953 if (parser->tok == ';')
1954 return parser_next(parser) || parser->tok == TOKEN_EOF;
1955 else if (opts_standard == COMPILER_QCC)
1956 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
1959 ast_expression *cexp;
1962 cexp = parser_expression_leave(parser, true);
1963 cval = (ast_value*)cexp;
1964 if (!ast_istype(cval, ast_value) || !cval->isconst)
1965 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
1968 var->isconst = true;
1969 memcpy(&var->constval, &cval->constval, sizeof(var->constval));
1970 memset(&cval->constval, 0, sizeof(cval->constval));
1975 if (parser->tok == ',') {
1980 if (parser->tok != ';') {
1981 parseerror(parser, "missing semicolon");
1985 (void)parser_next(parser);
1991 static bool parser_do(parser_t *parser)
1993 if (parser->tok == TOKEN_TYPENAME)
1995 return parser_variable(parser, NULL);
1997 else if (parser->tok == TOKEN_KEYWORD)
1999 /* handle 'var' and 'const' */
2002 else if (parser->tok == '.')
2006 ast_expression *oldex;
2007 bool isfunc = false;
2009 lex_ctx ctx = parser_ctx(parser);
2012 /* entity-member declaration */
2013 if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
2014 parseerror(parser, "expected member variable definition");
2018 /* remember the base/return type */
2019 basetype = parser_token(parser)->constval.t;
2021 /* parse into the declaration */
2022 if (!parser_next(parser)) {
2023 parseerror(parser, "expected field def");
2027 /* parse the field type fully */
2028 var = parser_parse_type(parser, basetype, &isfunc);
2033 /* now the field name */
2034 if (parser->tok != TOKEN_IDENT) {
2035 parseerror(parser, "expected field name");
2040 /* check for an existing field
2041 * in original qc we also have to check for an existing
2042 * global named like the field
2044 if (opts_standard == COMPILER_QCC) {
2045 if (parser_find_global(parser, parser_tokval(parser))) {
2046 parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
2054 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
2056 ast_value_delete(var);
2059 fval->expression.next = (ast_expression*)var;
2060 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
2064 /* turn it into a field */
2065 fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
2066 fld->expression.next = (ast_expression*)var;
2068 if ( (oldex = parser_find_field(parser, parser_tokval(parser)))) {
2069 if (ast_istype(oldex, ast_member)) {
2070 parseerror(parser, "cannot declare a field with the same name as a vector component, component %s has been declared here: %s:%i",
2071 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2075 if (!ast_istype(oldex, ast_value)) {
2076 /* not possible / sanity check */
2077 parseerror(parser, "internal error: %s is not an ast_value", parser_tokval(parser));
2082 if (!ast_compare_type(oldex, (ast_expression*)fld)) {
2083 parseerror(parser, "field %s has previously been declared with a different type here: %s:%i",
2084 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2088 if (parsewarning(parser, WARN_FIELD_REDECLARED, "field %s has already been declared here: %s:%i",
2089 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line))
2100 varent.var = (ast_expression*)fld;
2101 varent.name = util_strdup(fld->name);
2102 (void)!parser_t_fields_add(parser, varent);
2104 if (var->expression.vtype == TYPE_VECTOR)
2106 /* create _x, _y and _z fields as well */
2108 varentry_t vx, vy, vz;
2110 len = strlen(varent.name);
2111 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
2112 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
2113 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
2114 vx.name = (char*)mem_a(len+3);
2115 vy.name = (char*)mem_a(len+3);
2116 vz.name = (char*)mem_a(len+3);
2117 memcpy(vx.name, varent.name, len);
2118 memcpy(vy.name, varent.name, len);
2119 memcpy(vz.name, varent.name, len);
2120 vx.name[len] = vy.name[len] = vz.name[len] = '_';
2121 vx.name[len+1] = 'x';
2122 vy.name[len+1] = 'y';
2123 vz.name[len+1] = 'z';
2124 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
2125 (void)!parser_t_fields_add(parser, vx);
2126 (void)!parser_t_fields_add(parser, vy);
2127 (void)!parser_t_fields_add(parser, vz);
2131 if (!parser_next(parser)) {
2132 parseerror(parser, "expected semicolon or another field name");
2135 if (parser->tok == ';')
2137 if (parser->tok != ',' || !parser_next(parser)) {
2138 parseerror(parser, "expected semicolon or another field name");
2143 /* skip the semicolon */
2144 if (!parser_next(parser))
2145 return parser->tok == TOKEN_EOF;
2151 parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
2157 static parser_t *parser;
2161 parser = (parser_t*)mem_a(sizeof(parser_t));
2165 memset(parser, 0, sizeof(*parser));
2169 bool parser_compile(const char *filename)
2171 parser->lex = lex_open(filename);
2173 printf("failed to open file \"%s\"\n", filename);
2177 /* initial lexer/parser state */
2178 parser->lex->flags.noops = true;
2180 if (parser_next(parser))
2182 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2184 if (!parser_do(parser)) {
2185 if (parser->tok == TOKEN_EOF)
2186 parseerror(parser, "unexpected eof");
2187 else if (!parser->errors)
2188 parseerror(parser, "parse error\n");
2189 lex_close(parser->lex);
2196 lex_close(parser->lex);
2198 return !parser->errors;
2201 void parser_cleanup()
2204 for (i = 0; i < parser->functions_count; ++i) {
2205 ast_delete(parser->functions[i]);
2207 for (i = 0; i < parser->imm_vector_count; ++i) {
2208 ast_delete(parser->imm_vector[i]);
2210 for (i = 0; i < parser->imm_string_count; ++i) {
2211 ast_delete(parser->imm_string[i]);
2213 for (i = 0; i < parser->imm_float_count; ++i) {
2214 ast_delete(parser->imm_float[i]);
2216 for (i = 0; i < parser->globals_count; ++i) {
2217 ast_delete(parser->globals[i].var);
2218 mem_d(parser->globals[i].name);
2220 MEM_VECTOR_CLEAR(parser, globals);
2225 bool parser_finish(const char *output)
2230 if (!parser->errors)
2232 ir = ir_builder_new("gmqcc_out");
2234 printf("failed to allocate builder\n");
2238 for (i = 0; i < parser->imm_float_count; ++i) {
2239 if (!ast_global_codegen(parser->imm_float[i], ir)) {
2240 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2241 ir_builder_delete(ir);
2245 for (i = 0; i < parser->imm_string_count; ++i) {
2246 if (!ast_global_codegen(parser->imm_string[i], ir)) {
2247 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2248 ir_builder_delete(ir);
2252 for (i = 0; i < parser->imm_vector_count; ++i) {
2253 if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2254 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2255 ir_builder_delete(ir);
2259 for (i = 0; i < parser->fields_count; ++i) {
2262 if (!ast_istype(parser->fields[i].var, ast_value))
2264 field = (ast_value*)parser->fields[i].var;
2265 isconst = field->isconst;
2266 field->isconst = false;
2267 if (!ast_global_codegen((ast_value*)field, ir)) {
2268 printf("failed to generate field %s\n", field->name);
2269 ir_builder_delete(ir);
2274 ast_expression *subtype;
2275 field->isconst = true;
2276 subtype = field->expression.next;
2277 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2278 if (subtype->expression.vtype == TYPE_FIELD)
2279 ifld->fieldtype = subtype->expression.next->expression.vtype;
2280 else if (subtype->expression.vtype == TYPE_FUNCTION)
2281 ifld->outtype = subtype->expression.next->expression.vtype;
2282 (void)!ir_value_set_field(field->ir_v, ifld);
2285 for (i = 0; i < parser->globals_count; ++i) {
2286 if (!ast_istype(parser->globals[i].var, ast_value))
2288 if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2289 printf("failed to generate global %s\n", parser->globals[i].name);
2290 ir_builder_delete(ir);
2294 for (i = 0; i < parser->functions_count; ++i) {
2295 if (!ast_function_codegen(parser->functions[i], ir)) {
2296 printf("failed to generate function %s\n", parser->functions[i]->name);
2297 ir_builder_delete(ir);
2300 if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2301 printf("failed to finalize function %s\n", parser->functions[i]->name);
2302 ir_builder_delete(ir);
2308 ir_builder_dump(ir, printf);
2310 if (!ir_builder_generate(ir, output)) {
2311 printf("*** failed to generate output file\n");
2312 ir_builder_delete(ir);
2316 ir_builder_delete(ir);
2320 printf("*** there were compile errors\n");