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 char *parser_strdup(const char *str)
177 /* actually dup empty strings */
178 char *out = mem_a(1);
182 return util_strdup(str);
185 ast_value* parser_const_string(parser_t *parser, const char *str)
189 for (i = 0; i < parser->imm_string_count; ++i) {
190 if (!strcmp(parser->imm_string[i]->constval.vstring, str))
191 return parser->imm_string[i];
193 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
195 out->constval.vstring = parser_strdup(str);
196 if (!parser_t_imm_string_add(parser, out)) {
197 ast_value_delete(out);
203 ast_value* parser_const_vector(parser_t *parser, vector v)
207 for (i = 0; i < parser->imm_vector_count; ++i) {
208 if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
209 return parser->imm_vector[i];
211 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
213 out->constval.vvec = v;
214 if (!parser_t_imm_vector_add(parser, out)) {
215 ast_value_delete(out);
221 ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
227 return parser_const_vector(parser, v);
230 ast_value* parser_const_vector_0(parser_t *parser)
232 if (!parser->imm_vector_zero)
233 parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
234 return parser->imm_vector_zero;
237 ast_expression* parser_find_field(parser_t *parser, const char *name)
240 for (i = 0; i < parser->fields_count; ++i) {
241 if (!strcmp(parser->fields[i].name, name))
242 return parser->fields[i].var;
247 ast_expression* parser_find_global(parser_t *parser, const char *name)
250 for (i = 0; i < parser->globals_count; ++i) {
251 if (!strcmp(parser->globals[i].name, name))
252 return parser->globals[i].var;
257 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto)
261 for (i = parser->locals_count; i > upto;) {
263 if (!strcmp(parser->locals[i].name, name))
264 return parser->locals[i].var;
266 if (!parser->function)
268 fun = parser->function->vtype;
269 for (i = 0; i < fun->expression.params_count; ++i) {
270 if (!strcmp(fun->expression.params[i]->name, name))
271 return (ast_expression*)(fun->expression.params[i]);
276 ast_expression* parser_find_var(parser_t *parser, const char *name)
279 v = parser_find_local(parser, name, 0);
280 if (!v) v = parser_find_global(parser, name);
285 MEM_VECTOR_MAKE(ast_value*, p);
287 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
289 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
293 lex_ctx ctx = parser_ctx(parser);
294 int vtype = basetype;
298 MEM_VECTOR_INIT(¶ms, p);
302 if (parser->tok == '(') {
307 bool isfield = false;
310 if (!parser_next(parser))
313 if (parser->tok == ')')
316 if (parser->tok == '.') {
318 if (!parser_next(parser)) {
319 parseerror(parser, "expected field parameter type");
324 temptype = parser_token(parser)->constval.t;
325 if (!parser_next(parser))
328 param = parser_parse_type(parser, temptype, &dummy);
334 if (parser->tok == TOKEN_IDENT) {
335 /* named parameter */
336 if (!ast_value_set_name(param, parser_tokval(parser)))
338 if (!parser_next(parser))
343 fld = ast_value_new(ctx, param->name, TYPE_FIELD);
344 fld->expression.next = (ast_expression*)param;
348 if (!paramlist_t_p_add(¶ms, param)) {
349 parseerror(parser, "Out of memory while parsing typename");
353 if (parser->tok == ',')
355 if (parser->tok == ')')
357 parseerror(parser, "Unexpected token");
360 if (!parser_next(parser))
364 var = ast_value_new(ctx, "<unnamed>", vtype);
367 MEM_VECTOR_MOVE(¶ms, p, &var->expression, params);
370 for (i = 0; i < params.p_count; ++i)
371 ast_value_delete(params.p[i]);
372 MEM_VECTOR_CLEAR(¶ms, p);
378 size_t etype; /* 0 = expression, others are operators */
382 ast_block *block; /* for commas and function calls */
387 MEM_VECTOR_MAKE(sy_elem, out);
388 MEM_VECTOR_MAKE(sy_elem, ops);
390 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
391 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
393 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
403 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
406 e.out = (ast_expression*)v;
413 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
415 e.etype = 1 + (op - operators);
423 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
435 # define DEBUGSHUNTDO(x) x
437 # define DEBUGSHUNTDO(x)
440 static bool parser_sy_pop(parser_t *parser, shunt *sy)
444 ast_expression *out = NULL;
445 ast_expression *exprs[3];
446 ast_block *blocks[3];
447 ast_value *asvalue[3];
449 qcint generated_op = 0;
451 if (!sy->ops_count) {
452 parseerror(parser, "internal error: missing operator");
456 if (sy->ops[sy->ops_count-1].paren) {
457 parseerror(parser, "unmatched parenthesis");
461 op = &operators[sy->ops[sy->ops_count-1].etype - 1];
462 ctx = sy->ops[sy->ops_count-1].ctx;
464 DEBUGSHUNTDO(printf("apply %s\n", op->op));
466 if (sy->out_count < op->operands) {
467 parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count,
468 op->op, (int)op->id);
474 sy->out_count -= op->operands;
475 for (i = 0; i < op->operands; ++i) {
476 exprs[i] = sy->out[sy->out_count+i].out;
477 blocks[i] = sy->out[sy->out_count+i].block;
478 asvalue[i] = (ast_value*)exprs[i];
481 if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
482 parseerror(parser, "internal error: operator cannot be applied on empty blocks");
486 #define NotSameType(T) \
487 (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
488 exprs[0]->expression.vtype != T)
489 #define CanConstFold1(A) \
490 (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
491 #define CanConstFold(A, B) \
492 (CanConstFold1(A) && CanConstFold1(B))
493 #define ConstV(i) (asvalue[(i)]->constval.vvec)
494 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
495 #define ConstS(i) (asvalue[(i)]->constval.vstring)
499 parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
503 if (exprs[0]->expression.vtype == TYPE_ENTITY) {
504 if (exprs[1]->expression.vtype != TYPE_FIELD) {
505 parseerror(parser, "type error: right hand of member-operand should be an entity-field");
508 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
510 else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
511 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
515 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
522 if (!ast_block_exprs_add(blocks[0], exprs[1]))
525 blocks[0] = ast_block_new(ctx);
526 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
527 !ast_block_exprs_add(blocks[0], exprs[1]))
532 if (!ast_block_set_type(blocks[0], exprs[1]))
535 sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
539 switch (exprs[0]->expression.vtype) {
541 if (CanConstFold1(exprs[0]))
542 out = (ast_expression*)parser_const_float(parser, -ConstF(0));
544 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
545 (ast_expression*)parser_const_float_0(parser),
549 if (CanConstFold1(exprs[0]))
550 out = (ast_expression*)parser_const_vector_f(parser,
551 -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
553 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
554 (ast_expression*)parser_const_vector_0(parser),
558 parseerror(parser, "invalid types used in expression: cannot negate type %s",
559 type_name[exprs[0]->expression.vtype]);
565 switch (exprs[0]->expression.vtype) {
567 if (CanConstFold1(exprs[0]))
568 out = (ast_expression*)parser_const_float(parser, !ConstF(0));
570 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
573 if (CanConstFold1(exprs[0]))
574 out = (ast_expression*)parser_const_float(parser,
575 (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
577 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
580 if (CanConstFold1(exprs[0]))
581 out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
583 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
585 /* we don't constant-fold NOT for these types */
587 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
590 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
593 parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
594 type_name[exprs[0]->expression.vtype]);
600 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
601 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
603 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
604 type_name[exprs[0]->expression.vtype],
605 type_name[exprs[1]->expression.vtype]);
608 switch (exprs[0]->expression.vtype) {
610 if (CanConstFold(exprs[0], exprs[1]))
612 out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
615 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
618 if (CanConstFold(exprs[0], exprs[1]))
619 out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
621 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
624 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
625 type_name[exprs[0]->expression.vtype],
626 type_name[exprs[1]->expression.vtype]);
631 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
632 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
634 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
635 type_name[exprs[1]->expression.vtype],
636 type_name[exprs[0]->expression.vtype]);
639 switch (exprs[0]->expression.vtype) {
641 if (CanConstFold(exprs[0], exprs[1]))
642 out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
644 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
647 if (CanConstFold(exprs[0], exprs[1]))
648 out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
650 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
653 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
654 type_name[exprs[1]->expression.vtype],
655 type_name[exprs[0]->expression.vtype]);
660 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
661 exprs[0]->expression.vtype != TYPE_VECTOR &&
662 exprs[0]->expression.vtype != TYPE_FLOAT &&
663 exprs[1]->expression.vtype != TYPE_VECTOR &&
664 exprs[1]->expression.vtype != TYPE_FLOAT)
666 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
667 type_name[exprs[1]->expression.vtype],
668 type_name[exprs[0]->expression.vtype]);
671 switch (exprs[0]->expression.vtype) {
673 if (exprs[1]->expression.vtype == TYPE_VECTOR)
675 if (CanConstFold(exprs[0], exprs[1]))
676 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
678 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
682 if (CanConstFold(exprs[0], exprs[1]))
683 out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
685 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
689 if (exprs[1]->expression.vtype == TYPE_FLOAT)
691 if (CanConstFold(exprs[0], exprs[1]))
692 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
694 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
698 if (CanConstFold(exprs[0], exprs[1]))
699 out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
701 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
705 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
706 type_name[exprs[1]->expression.vtype],
707 type_name[exprs[0]->expression.vtype]);
712 if (NotSameType(TYPE_FLOAT)) {
713 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
714 type_name[exprs[0]->expression.vtype],
715 type_name[exprs[1]->expression.vtype]);
718 if (CanConstFold(exprs[0], exprs[1]))
719 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
721 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
725 parseerror(parser, "qc does not have a modulo operator");
729 if (NotSameType(TYPE_FLOAT)) {
730 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
731 type_name[exprs[0]->expression.vtype],
732 type_name[exprs[1]->expression.vtype]);
735 if (CanConstFold(exprs[0], exprs[1]))
736 out = (ast_expression*)parser_const_float(parser,
737 (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
738 (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
740 out = (ast_expression*)ast_binary_new(ctx,
741 (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
745 parseerror(parser, "TODO: bitxor");
750 case opid3('<','<','='):
751 case opid3('>','>','='):
752 parseerror(parser, "TODO: shifts");
756 generated_op += 1; /* INSTR_OR */
758 generated_op += INSTR_AND;
759 if (NotSameType(TYPE_FLOAT)) {
760 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
761 type_name[exprs[0]->expression.vtype],
762 type_name[exprs[1]->expression.vtype]);
763 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
764 parseerror(parser, "TODO: optional early out");
767 if (opts_standard == COMPILER_GMQCC)
768 printf("TODO: early out logic\n");
769 if (CanConstFold(exprs[0], exprs[1]))
770 out = (ast_expression*)parser_const_float(parser,
771 (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
773 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
777 generated_op += 1; /* INSTR_GT */
779 generated_op += 1; /* INSTR_LT */
780 case opid2('>', '='):
781 generated_op += 1; /* INSTR_GE */
782 case opid2('<', '='):
783 generated_op += INSTR_LE;
784 if (NotSameType(TYPE_FLOAT)) {
785 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
786 type_name[exprs[0]->expression.vtype],
787 type_name[exprs[1]->expression.vtype]);
790 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
792 case opid2('!', '='):
793 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
794 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
795 type_name[exprs[0]->expression.vtype],
796 type_name[exprs[1]->expression.vtype]);
799 out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
801 case opid2('=', '='):
802 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
803 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
804 type_name[exprs[0]->expression.vtype],
805 type_name[exprs[1]->expression.vtype]);
808 out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
812 if (ast_istype(exprs[0], ast_entfield))
813 assignop = type_storep_instr[exprs[0]->expression.vtype];
815 assignop = type_store_instr[exprs[0]->expression.vtype];
816 out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
820 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
821 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
823 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
824 type_name[exprs[0]->expression.vtype],
825 type_name[exprs[1]->expression.vtype]);
828 if (ast_istype(exprs[0], ast_entfield))
829 assignop = type_storep_instr[exprs[0]->expression.vtype];
831 assignop = type_store_instr[exprs[0]->expression.vtype];
832 switch (exprs[0]->expression.vtype) {
834 out = (ast_expression*)ast_binstore_new(ctx, assignop,
835 (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
839 out = (ast_expression*)ast_binstore_new(ctx, assignop,
840 (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
844 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
845 type_name[exprs[0]->expression.vtype],
846 type_name[exprs[1]->expression.vtype]);
854 parseerror(parser, "failed to apply operand %s", op->op);
858 DEBUGSHUNTDO(printf("applied %s\n", op->op));
859 sy->out[sy->out_count++] = syexp(ctx, out);
863 static bool parser_close_call(parser_t *parser, shunt *sy)
865 /* was a function call */
873 fid = sy->ops[sy->ops_count].off;
875 /* out[fid] is the function
876 * everything above is parameters...
878 * 1 params = ast_expression
882 if (sy->out_count < 1 || sy->out_count <= fid) {
883 parseerror(parser, "internal error: function call needs function and parameter list...");
887 fun = sy->out[fid].out;
889 call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
891 parseerror(parser, "out of memory");
895 if (fid+1 == sy->out_count) {
898 } else if (fid+2 == sy->out_count) {
901 params = sy->out[sy->out_count].block;
905 if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
906 ast_delete(sy->out[sy->out_count].out);
907 parseerror(parser, "out of memory");
911 paramcount = params->exprs_count;
912 MEM_VECTOR_MOVE(params, exprs, call, params);
916 parseerror(parser, "invalid function call");
920 /* overwrite fid, the function, with a call */
921 sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
923 if (fun->expression.vtype != TYPE_FUNCTION) {
924 parseerror(parser, "not a function");
928 if (!fun->expression.next) {
929 parseerror(parser, "could not determine function return type");
932 if (fun->expression.params_count != paramcount) {
933 parseerror(parser, "expected %i parameters, got %i", (int)fun->expression.params_count, paramcount);
941 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
943 if (!sy->ops_count) {
944 parseerror(parser, "unmatched closing paren");
947 if (sy->ops[sy->ops_count-1].paren == 1) {
948 parseerror(parser, "empty parenthesis expression");
951 while (sy->ops_count) {
952 if (sy->ops[sy->ops_count-1].paren == 'f') {
953 if (!parser_close_call(parser, sy))
957 if (sy->ops[sy->ops_count-1].paren == 1) {
959 return !functions_only;
961 if (!parser_sy_pop(parser, sy))
967 static void parser_reclassify_token(parser_t *parser)
970 for (i = 0; i < operator_count; ++i) {
971 if (!strcmp(parser_tokval(parser), operators[i].op)) {
972 parser->tok = TOKEN_OPERATOR;
978 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
980 ast_expression *expr = NULL;
983 bool gotmemberof = false;
985 /* count the parens because an if starts with one, so the
986 * end of a condition is an unmatched closing paren
990 MEM_VECTOR_INIT(&sy, out);
991 MEM_VECTOR_INIT(&sy, ops);
993 parser->lex->flags.noops = false;
995 parser_reclassify_token(parser);
1000 gotmemberof = false;
1002 parser->memberof = 0;
1004 if (parser->tok == TOKEN_IDENT)
1006 ast_expression *var;
1008 parseerror(parser, "expected operator or end of statement");
1013 if (opts_standard == COMPILER_GMQCC)
1015 if (parser->memberof == TYPE_ENTITY) {
1016 /* still get vars first since there could be a fieldpointer */
1017 var = parser_find_var(parser, parser_tokval(parser));
1019 var = parser_find_field(parser, parser_tokval(parser));
1021 else if (parser->memberof == TYPE_VECTOR)
1023 parseerror(parser, "TODO: implement effective vector member access");
1026 else if (parser->memberof) {
1027 parseerror(parser, "namespace for member not found");
1031 var = parser_find_var(parser, parser_tokval(parser));
1033 var = parser_find_var(parser, parser_tokval(parser));
1035 var = parser_find_field(parser, parser_tokval(parser));
1038 parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
1041 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
1042 parseerror(parser, "out of memory");
1045 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
1047 else if (parser->tok == TOKEN_FLOATCONST) {
1050 parseerror(parser, "expected operator or end of statement, got constant");
1054 val = parser_const_float(parser, (parser_token(parser)->constval.f));
1057 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1058 parseerror(parser, "out of memory");
1061 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
1063 else if (parser->tok == TOKEN_INTCONST) {
1066 parseerror(parser, "expected operator or end of statement, got constant");
1070 val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1073 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1074 parseerror(parser, "out of memory");
1077 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
1079 else if (parser->tok == TOKEN_STRINGCONST) {
1082 parseerror(parser, "expected operator or end of statement, got constant");
1086 val = parser_const_string(parser, parser_tokval(parser));
1089 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1090 parseerror(parser, "out of memory");
1093 DEBUGSHUNTDO(printf("push string\n"));
1095 else if (parser->tok == TOKEN_VECTORCONST) {
1098 parseerror(parser, "expected operator or end of statement, got constant");
1102 val = parser_const_vector(parser, parser_token(parser)->constval.v);
1105 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1106 parseerror(parser, "out of memory");
1109 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
1110 parser_token(parser)->constval.v.x,
1111 parser_token(parser)->constval.v.y,
1112 parser_token(parser)->constval.v.z));
1114 else if (parser->tok == '(') {
1116 DEBUGSHUNTDO(printf("push (\n"));
1118 /* we expected an operator, this is the function-call operator */
1119 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
1120 parseerror(parser, "out of memory");
1125 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
1126 parseerror(parser, "out of memory");
1129 DEBUGSHUNTDO(printf("push (\n"));
1133 else if (parser->tok == ')') {
1135 DEBUGSHUNTDO(printf("do[op] )\n"));
1139 /* we do expect an operator next */
1140 /* closing an opening paren */
1141 if (!parser_close_paren(parser, &sy, false))
1144 DEBUGSHUNTDO(printf("do[nop] )\n"));
1148 /* allowed for function calls */
1149 if (!parser_close_paren(parser, &sy, true))
1154 else if (parser->tok != TOKEN_OPERATOR) {
1156 parseerror(parser, "expected operator or end of statement");
1163 /* classify the operator */
1164 /* TODO: suffix operators */
1165 const oper_info *op;
1166 const oper_info *olast = NULL;
1168 for (o = 0; o < operator_count; ++o) {
1169 if ((!(operators[o].flags & OP_PREFIX) == wantop) &&
1170 !(operators[o].flags & OP_SUFFIX) && /* remove this */
1171 !strcmp(parser_tokval(parser), operators[o].op))
1177 if (o == operator_count) {
1178 /* no operator found... must be the end of the statement */
1181 /* found an operator */
1184 /* when declaring variables, a comma starts a new variable */
1185 if (op->id == opid1(',') && !parens && stopatcomma)
1188 if (op->id == opid1('.')) {
1189 /* for gmqcc standard: open up the namespace of the previous type */
1190 ast_expression *prevex = sy.out[sy.out_count-1].out;
1192 parseerror(parser, "unexpected member operator");
1195 if (prevex->expression.vtype == TYPE_ENTITY)
1196 parser->memberof = TYPE_ENTITY;
1197 else if (prevex->expression.vtype == TYPE_VECTOR)
1198 parser->memberof = TYPE_VECTOR;
1200 parseerror(parser, "type error: type has no members");
1206 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1207 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1210 (op->prec < olast->prec) ||
1211 (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1213 if (!parser_sy_pop(parser, &sy))
1215 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1216 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1221 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1222 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1225 if (!parser_next(parser)) {
1228 if (parser->tok == ';') {
1233 while (sy.ops_count) {
1234 if (!parser_sy_pop(parser, &sy))
1238 parser->lex->flags.noops = true;
1239 if (!sy.out_count) {
1240 parseerror(parser, "empty expression");
1243 expr = sy.out[0].out;
1244 MEM_VECTOR_CLEAR(&sy, out);
1245 MEM_VECTOR_CLEAR(&sy, ops);
1246 DEBUGSHUNTDO(printf("shunt done\n"));
1250 parser->lex->flags.noops = true;
1251 MEM_VECTOR_CLEAR(&sy, out);
1252 MEM_VECTOR_CLEAR(&sy, ops);
1256 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
1258 ast_expression *e = parser_expression_leave(parser, stopatcomma);
1261 if (!parser_next(parser)) {
1268 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1271 ast_expression *cond, *ontrue, *onfalse = NULL;
1273 lex_ctx ctx = parser_ctx(parser);
1275 /* skip the 'if' and check for opening paren */
1276 if (!parser_next(parser) || parser->tok != '(') {
1277 parseerror(parser, "expected 'if' condition in parenthesis");
1280 /* parse into the expression */
1281 if (!parser_next(parser)) {
1282 parseerror(parser, "expected 'if' condition after opening paren");
1285 /* parse the condition */
1286 cond = parser_expression_leave(parser, false);
1290 if (parser->tok != ')') {
1291 parseerror(parser, "expected closing paren after 'if' condition");
1295 /* parse into the 'then' branch */
1296 if (!parser_next(parser)) {
1297 parseerror(parser, "expected statement for on-true branch of 'if'");
1301 ontrue = parser_parse_statement_or_block(parser);
1306 /* check for an else */
1307 if (!strcmp(parser_tokval(parser), "else")) {
1308 /* parse into the 'else' branch */
1309 if (!parser_next(parser)) {
1310 parseerror(parser, "expected on-false branch after 'else'");
1315 onfalse = parser_parse_statement_or_block(parser);
1323 ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1324 *out = (ast_expression*)ifthen;
1328 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1331 ast_expression *cond, *ontrue;
1333 lex_ctx ctx = parser_ctx(parser);
1335 /* skip the 'while' and check for opening paren */
1336 if (!parser_next(parser) || parser->tok != '(') {
1337 parseerror(parser, "expected 'while' condition in parenthesis");
1340 /* parse into the expression */
1341 if (!parser_next(parser)) {
1342 parseerror(parser, "expected 'while' condition after opening paren");
1345 /* parse the condition */
1346 cond = parser_expression_leave(parser, false);
1350 if (parser->tok != ')') {
1351 parseerror(parser, "expected closing paren after 'while' condition");
1355 /* parse into the 'then' branch */
1356 if (!parser_next(parser)) {
1357 parseerror(parser, "expected while-loop body");
1361 ontrue = parser_parse_statement_or_block(parser);
1367 aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1368 *out = (ast_expression*)aloop;
1372 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1375 ast_expression *cond, *ontrue;
1377 lex_ctx ctx = parser_ctx(parser);
1379 /* skip the 'do' and get the body */
1380 if (!parser_next(parser)) {
1381 parseerror(parser, "expected loop body");
1384 ontrue = parser_parse_statement_or_block(parser);
1388 /* expect the "while" */
1389 if (parser->tok != TOKEN_KEYWORD ||
1390 strcmp(parser_tokval(parser), "while"))
1392 parseerror(parser, "expected 'while' and condition");
1397 /* skip the 'while' and check for opening paren */
1398 if (!parser_next(parser) || parser->tok != '(') {
1399 parseerror(parser, "expected 'while' condition in parenthesis");
1403 /* parse into the expression */
1404 if (!parser_next(parser)) {
1405 parseerror(parser, "expected 'while' condition after opening paren");
1409 /* parse the condition */
1410 cond = parser_expression_leave(parser, false);
1414 if (parser->tok != ')') {
1415 parseerror(parser, "expected closing paren after 'while' condition");
1421 if (!parser_next(parser) || parser->tok != ';') {
1422 parseerror(parser, "expected semicolon after condition");
1428 if (!parser_next(parser)) {
1429 parseerror(parser, "parse error");
1435 aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1436 *out = (ast_expression*)aloop;
1440 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1443 ast_expression *initexpr, *cond, *increment, *ontrue;
1444 size_t oldblocklocal;
1446 lex_ctx ctx = parser_ctx(parser);
1448 oldblocklocal = parser->blocklocal;
1449 parser->blocklocal = parser->locals_count;
1456 /* skip the 'while' and check for opening paren */
1457 if (!parser_next(parser) || parser->tok != '(') {
1458 parseerror(parser, "expected 'for' expressions in parenthesis");
1461 /* parse into the expression */
1462 if (!parser_next(parser)) {
1463 parseerror(parser, "expected 'for' initializer after opening paren");
1467 if (parser->tok == TOKEN_TYPENAME) {
1468 if (opts_standard != COMPILER_GMQCC) {
1469 if (parsewarning(parser, WARN_EXTENSIONS,
1470 "current standard does not allow variable declarations in for-loop initializers"))
1474 parseerror(parser, "TODO: assignment of new variables to be non-const");
1476 if (!parser_variable(parser, block))
1479 else if (parser->tok != ';')
1481 initexpr = parser_expression_leave(parser, false);
1486 /* move on to condition */
1487 if (parser->tok != ';') {
1488 parseerror(parser, "expected semicolon after for-loop initializer");
1491 if (!parser_next(parser)) {
1492 parseerror(parser, "expected for-loop condition");
1496 /* parse the condition */
1497 if (parser->tok != ';') {
1498 cond = parser_expression_leave(parser, false);
1503 /* move on to incrementor */
1504 if (parser->tok != ';') {
1505 parseerror(parser, "expected semicolon after for-loop initializer");
1508 if (!parser_next(parser)) {
1509 parseerror(parser, "expected for-loop condition");
1513 /* parse the incrementor */
1514 if (parser->tok != ')') {
1515 increment = parser_expression_leave(parser, false);
1521 if (parser->tok != ')') {
1522 parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1525 /* parse into the 'then' branch */
1526 if (!parser_next(parser)) {
1527 parseerror(parser, "expected for-loop body");
1530 ontrue = parser_parse_statement_or_block(parser);
1535 aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1536 *out = (ast_expression*)aloop;
1538 while (parser->locals_count > parser->blocklocal)
1539 parser_pop_local(parser);
1540 parser->blocklocal = oldblocklocal;
1543 if (initexpr) ast_delete(initexpr);
1544 if (cond) ast_delete(cond);
1545 if (increment) ast_delete(increment);
1546 while (parser->locals_count > parser->blocklocal)
1547 parser_pop_local(parser);
1548 parser->blocklocal = oldblocklocal;
1552 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1554 if (parser->tok == TOKEN_TYPENAME)
1556 /* local variable */
1558 parseerror(parser, "cannot declare a variable from here");
1561 if (opts_standard == COMPILER_QCC) {
1562 if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1565 if (!parser_variable(parser, block))
1570 else if (parser->tok == TOKEN_KEYWORD)
1572 if (!strcmp(parser_tokval(parser), "local"))
1575 parseerror(parser, "cannot declare a local variable here");
1578 if (!parser_next(parser)) {
1579 parseerror(parser, "expected variable declaration");
1582 if (!parser_variable(parser, block))
1587 else if (!strcmp(parser_tokval(parser), "return"))
1589 ast_expression *exp = NULL;
1590 ast_return *ret = NULL;
1591 ast_value *expected = parser->function->vtype;
1593 if (!parser_next(parser)) {
1594 parseerror(parser, "expected return expression");
1598 if (parser->tok != ';') {
1599 exp = parser_expression(parser, false);
1603 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1604 parseerror(parser, "return with invalid expression");
1607 ret = ast_return_new(exp->expression.node.context, exp);
1613 *out = (ast_expression*)ret;
1614 } else if (!parser_next(parser)) {
1615 parseerror(parser, "expected semicolon");
1616 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1617 parseerror(parser, "return without value");
1622 else if (!strcmp(parser_tokval(parser), "if"))
1624 return parser_parse_if(parser, block, out);
1626 else if (!strcmp(parser_tokval(parser), "while"))
1628 return parser_parse_while(parser, block, out);
1630 else if (!strcmp(parser_tokval(parser), "do"))
1632 return parser_parse_dowhile(parser, block, out);
1634 else if (!strcmp(parser_tokval(parser), "for"))
1636 if (opts_standard == COMPILER_QCC) {
1637 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1640 return parser_parse_for(parser, block, out);
1642 parseerror(parser, "Unexpected keyword");
1645 else if (parser->tok == '{')
1648 inner = parser_parse_block(parser);
1651 *out = (ast_expression*)inner;
1656 ast_expression *exp = parser_expression(parser, false);
1664 static void parser_pop_local(parser_t *parser)
1666 parser->locals_count--;
1667 mem_d(parser->locals[parser->locals_count].name);
1670 static ast_block* parser_parse_block(parser_t *parser)
1672 size_t oldblocklocal;
1673 ast_block *block = NULL;
1675 oldblocklocal = parser->blocklocal;
1676 parser->blocklocal = parser->locals_count;
1678 if (!parser_next(parser)) { /* skip the '{' */
1679 parseerror(parser, "expected function body");
1683 block = ast_block_new(parser_ctx(parser));
1685 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1687 ast_expression *expr;
1688 if (parser->tok == '}')
1691 if (!parser_parse_statement(parser, block, &expr)) {
1692 ast_block_delete(block);
1698 if (!ast_block_exprs_add(block, expr)) {
1700 ast_block_delete(block);
1706 if (parser->tok != '}') {
1707 ast_block_delete(block);
1710 (void)parser_next(parser);
1714 while (parser->locals_count > parser->blocklocal)
1715 parser_pop_local(parser);
1716 parser->blocklocal = oldblocklocal;
1717 /* unroll the local vector */
1721 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1723 ast_expression *expr;
1724 if (parser->tok == '{')
1725 return (ast_expression*)parser_parse_block(parser);
1726 if (!parser_parse_statement(parser, NULL, &expr))
1731 static bool parser_variable(parser_t *parser, ast_block *localblock)
1733 bool isfunc = false;
1734 ast_function *func = NULL;
1738 ast_expression *olddecl;
1740 int basetype = parser_token(parser)->constval.t;
1744 if (!parser_next(parser)) { /* skip basetype or comma */
1745 parseerror(parser, "expected variable declaration");
1752 ctx = parser_ctx(parser);
1753 var = parser_parse_type(parser, basetype, &isfunc);
1758 if (parser->tok != TOKEN_IDENT) {
1759 parseerror(parser, "expected variable name\n");
1764 if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1765 ast_value_delete(var);
1766 parseerror(parser, "global %s already declared here: %s:%i\n",
1767 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1771 if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1772 ast_value_delete(var);
1773 parseerror(parser, "local %s already declared here: %s:%i\n",
1774 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1779 if (!ast_value_set_name(var, parser_tokval(parser))) {
1780 parseerror(parser, "failed to set variable name\n");
1781 ast_value_delete(var);
1786 /* a function was defined */
1788 ast_value *proto = NULL;
1791 olddecl = parser_find_global(parser, parser_tokval(parser));
1793 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal);
1796 /* we had a prototype */
1797 if (!ast_istype(olddecl, ast_value)) {
1798 /* theoretically not possible you think?
1804 parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1805 parser_tokval(parser));
1806 ast_value_delete(var);
1810 proto = (ast_value*)olddecl;
1813 /* turn var into a value of TYPE_FUNCTION, with the old var
1816 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1817 func = ast_function_new(ctx, var->name, fval);
1818 if (!fval || !func) {
1819 ast_value_delete(var);
1820 if (fval) ast_value_delete(fval);
1821 if (func) ast_function_delete(func);
1825 fval->expression.next = (ast_expression*)var;
1826 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1828 /* we compare the type late here, but it's easier than
1829 * messing with the parameter-vector etc. earlier
1832 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1833 parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1835 ast_ctx(proto).file, ast_ctx(proto).line);
1836 ast_function_delete(func);
1837 ast_value_delete(fval);
1840 ast_function_delete(func);
1841 ast_value_delete(fval);
1843 func = var->constval.vfunc;
1847 if (!parser_t_functions_add(parser, func)) {
1848 ast_function_delete(func);
1849 ast_value_delete(fval);
1857 varent.name = util_strdup(var->name);
1858 varent.var = (ast_expression*)var;
1859 if (var->expression.vtype == TYPE_VECTOR)
1861 size_t len = strlen(varent.name);
1862 varentry_t vx, vy, vz;
1863 vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1864 vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1865 vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1866 vx.name = (char*)mem_a(len+3);
1867 vy.name = (char*)mem_a(len+3);
1868 vz.name = (char*)mem_a(len+3);
1869 memcpy(vx.name, varent.name, len);
1870 memcpy(vy.name, varent.name, len);
1871 memcpy(vz.name, varent.name, len);
1872 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1873 vx.name[len+1] = 'x';
1874 vy.name[len+1] = 'y';
1875 vz.name[len+1] = 'z';
1876 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1879 (void)!parser_t_globals_add(parser, varent);
1880 (void)!parser_t_globals_add(parser, vx);
1881 (void)!parser_t_globals_add(parser, vy);
1882 (void)!parser_t_globals_add(parser, vz);
1884 (void)!parser_t_locals_add(parser, varent);
1885 (void)!parser_t_locals_add(parser, vx);
1886 (void)!parser_t_locals_add(parser, vy);
1887 (void)!parser_t_locals_add(parser, vz);
1892 if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1893 ( localblock && !parser_t_locals_add(parser, varent)) )
1895 ast_value_delete(var);
1899 if (localblock && !ast_block_locals_add(localblock, var))
1901 parser_pop_local(parser);
1902 ast_value_delete(var);
1906 if (!parser_next(parser)) {
1907 ast_value_delete(var);
1911 if (parser->tok == ';') {
1912 if (!parser_next(parser))
1913 return parser->tok == TOKEN_EOF;
1917 if (parser->tok == ',') {
1922 if (parser->tok != '=') {
1923 parseerror(parser, "expected '=' or ';'");
1927 if (!parser_next(parser))
1930 if (parser->tok == '#') {
1932 parseerror(parser, "cannot declare builtins within functions");
1935 if (!isfunc || !func) {
1936 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1939 if (!parser_next(parser)) {
1940 parseerror(parser, "expected builtin number");
1943 if (parser->tok != TOKEN_INTCONST) {
1944 parseerror(parser, "builtin number must be an integer constant");
1947 if (parser_token(parser)->constval.i <= 0) {
1948 parseerror(parser, "builtin number must be positive integer greater than zero");
1952 func->builtin = -parser_token(parser)->constval.i;
1954 if (!parser_next(parser))
1956 } else if (parser->tok == '{') {
1959 ast_function *old = parser->function;
1962 parseerror(parser, "cannot declare functions within functions");
1966 parser->function = func;
1967 block = parser_parse_block(parser);
1968 parser->function = old;
1973 if (!ast_function_blocks_add(func, block)) {
1974 ast_block_delete(block);
1978 if (parser->tok == ';')
1979 return parser_next(parser) || parser->tok == TOKEN_EOF;
1980 else if (opts_standard == COMPILER_QCC)
1981 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
1984 ast_expression *cexp;
1987 cexp = parser_expression_leave(parser, true);
1988 cval = (ast_value*)cexp;
1989 if (!ast_istype(cval, ast_value) || !cval->isconst)
1990 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
1993 var->isconst = true;
1994 memcpy(&var->constval, &cval->constval, sizeof(var->constval));
1995 memset(&cval->constval, 0, sizeof(cval->constval));
2000 if (parser->tok == ',') {
2005 if (parser->tok != ';') {
2006 parseerror(parser, "missing semicolon");
2010 (void)parser_next(parser);
2016 static bool parser_do(parser_t *parser)
2018 if (parser->tok == TOKEN_TYPENAME)
2020 return parser_variable(parser, NULL);
2022 else if (parser->tok == TOKEN_KEYWORD)
2024 /* handle 'var' and 'const' */
2027 else if (parser->tok == '.')
2031 ast_expression *oldex;
2032 bool isfunc = false;
2034 lex_ctx ctx = parser_ctx(parser);
2037 /* entity-member declaration */
2038 if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
2039 parseerror(parser, "expected member variable definition");
2043 /* remember the base/return type */
2044 basetype = parser_token(parser)->constval.t;
2046 /* parse into the declaration */
2047 if (!parser_next(parser)) {
2048 parseerror(parser, "expected field def");
2052 /* parse the field type fully */
2053 var = parser_parse_type(parser, basetype, &isfunc);
2058 /* now the field name */
2059 if (parser->tok != TOKEN_IDENT) {
2060 parseerror(parser, "expected field name");
2065 /* check for an existing field
2066 * in original qc we also have to check for an existing
2067 * global named like the field
2069 if (opts_standard == COMPILER_QCC) {
2070 if (parser_find_global(parser, parser_tokval(parser))) {
2071 parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
2079 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
2081 ast_value_delete(var);
2084 fval->expression.next = (ast_expression*)var;
2085 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
2089 /* turn it into a field */
2090 fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
2091 fld->expression.next = (ast_expression*)var;
2093 if ( (oldex = parser_find_field(parser, parser_tokval(parser)))) {
2094 if (ast_istype(oldex, ast_member)) {
2095 parseerror(parser, "cannot declare a field with the same name as a vector component, component %s has been declared here: %s:%i",
2096 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2100 if (!ast_istype(oldex, ast_value)) {
2101 /* not possible / sanity check */
2102 parseerror(parser, "internal error: %s is not an ast_value", parser_tokval(parser));
2107 if (!ast_compare_type(oldex, (ast_expression*)fld)) {
2108 parseerror(parser, "field %s has previously been declared with a different type here: %s:%i",
2109 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2113 if (parsewarning(parser, WARN_FIELD_REDECLARED, "field %s has already been declared here: %s:%i",
2114 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line))
2125 varent.var = (ast_expression*)fld;
2126 varent.name = util_strdup(fld->name);
2127 (void)!parser_t_fields_add(parser, varent);
2129 if (var->expression.vtype == TYPE_VECTOR)
2131 /* create _x, _y and _z fields as well */
2133 varentry_t vx, vy, vz;
2135 len = strlen(varent.name);
2136 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
2137 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
2138 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
2139 vx.name = (char*)mem_a(len+3);
2140 vy.name = (char*)mem_a(len+3);
2141 vz.name = (char*)mem_a(len+3);
2142 memcpy(vx.name, varent.name, len);
2143 memcpy(vy.name, varent.name, len);
2144 memcpy(vz.name, varent.name, len);
2145 vx.name[len] = vy.name[len] = vz.name[len] = '_';
2146 vx.name[len+1] = 'x';
2147 vy.name[len+1] = 'y';
2148 vz.name[len+1] = 'z';
2149 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
2150 (void)!parser_t_fields_add(parser, vx);
2151 (void)!parser_t_fields_add(parser, vy);
2152 (void)!parser_t_fields_add(parser, vz);
2156 if (!parser_next(parser)) {
2157 parseerror(parser, "expected semicolon or another field name");
2160 if (parser->tok == ';')
2162 if (parser->tok != ',' || !parser_next(parser)) {
2163 parseerror(parser, "expected semicolon or another field name");
2168 /* skip the semicolon */
2169 if (!parser_next(parser))
2170 return parser->tok == TOKEN_EOF;
2174 else if (parser->tok == '$')
2176 if (!parser_next(parser)) {
2177 parseerror(parser, "parse error");
2183 parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
2189 static parser_t *parser;
2193 parser = (parser_t*)mem_a(sizeof(parser_t));
2197 memset(parser, 0, sizeof(*parser));
2201 bool parser_compile(const char *filename)
2203 parser->lex = lex_open(filename);
2205 printf("failed to open file \"%s\"\n", filename);
2209 /* initial lexer/parser state */
2210 parser->lex->flags.noops = true;
2212 if (parser_next(parser))
2214 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2216 if (!parser_do(parser)) {
2217 if (parser->tok == TOKEN_EOF)
2218 parseerror(parser, "unexpected eof");
2219 else if (!parser->errors)
2220 parseerror(parser, "parse error\n");
2221 lex_close(parser->lex);
2228 lex_close(parser->lex);
2230 return !parser->errors;
2233 void parser_cleanup()
2236 for (i = 0; i < parser->functions_count; ++i) {
2237 ast_delete(parser->functions[i]);
2239 for (i = 0; i < parser->imm_vector_count; ++i) {
2240 ast_delete(parser->imm_vector[i]);
2242 for (i = 0; i < parser->imm_string_count; ++i) {
2243 ast_delete(parser->imm_string[i]);
2245 for (i = 0; i < parser->imm_float_count; ++i) {
2246 ast_delete(parser->imm_float[i]);
2248 for (i = 0; i < parser->globals_count; ++i) {
2249 ast_delete(parser->globals[i].var);
2250 mem_d(parser->globals[i].name);
2252 MEM_VECTOR_CLEAR(parser, globals);
2257 bool parser_finish(const char *output)
2262 if (!parser->errors)
2264 ir = ir_builder_new("gmqcc_out");
2266 printf("failed to allocate builder\n");
2270 for (i = 0; i < parser->imm_float_count; ++i) {
2271 if (!ast_global_codegen(parser->imm_float[i], ir)) {
2272 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2273 ir_builder_delete(ir);
2277 for (i = 0; i < parser->imm_string_count; ++i) {
2278 if (!ast_global_codegen(parser->imm_string[i], ir)) {
2279 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2280 ir_builder_delete(ir);
2284 for (i = 0; i < parser->imm_vector_count; ++i) {
2285 if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2286 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2287 ir_builder_delete(ir);
2291 for (i = 0; i < parser->fields_count; ++i) {
2294 if (!ast_istype(parser->fields[i].var, ast_value))
2296 field = (ast_value*)parser->fields[i].var;
2297 isconst = field->isconst;
2298 field->isconst = false;
2299 if (!ast_global_codegen((ast_value*)field, ir)) {
2300 printf("failed to generate field %s\n", field->name);
2301 ir_builder_delete(ir);
2306 ast_expression *subtype;
2307 field->isconst = true;
2308 subtype = field->expression.next;
2309 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2310 if (subtype->expression.vtype == TYPE_FIELD)
2311 ifld->fieldtype = subtype->expression.next->expression.vtype;
2312 else if (subtype->expression.vtype == TYPE_FUNCTION)
2313 ifld->outtype = subtype->expression.next->expression.vtype;
2314 (void)!ir_value_set_field(field->ir_v, ifld);
2317 for (i = 0; i < parser->globals_count; ++i) {
2318 if (!ast_istype(parser->globals[i].var, ast_value))
2320 if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2321 printf("failed to generate global %s\n", parser->globals[i].name);
2322 ir_builder_delete(ir);
2326 for (i = 0; i < parser->functions_count; ++i) {
2327 if (!ast_function_codegen(parser->functions[i], ir)) {
2328 printf("failed to generate function %s\n", parser->functions[i]->name);
2329 ir_builder_delete(ir);
2332 if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2333 printf("failed to finalize function %s\n", parser->functions[i]->name);
2334 ir_builder_delete(ir);
2340 ir_builder_dump(ir, printf);
2342 if (!ir_builder_generate(ir, output)) {
2343 printf("*** failed to generate output file\n");
2344 ir_builder_delete(ir);
2348 ir_builder_delete(ir);
2352 printf("*** there were compile errors\n");