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);
65 /* returns true if it counts as an error */
66 bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
69 int lvl = LVL_WARNING;
71 if (!OPTS_WARN(warntype))
80 vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
86 /**********************************************************************
87 * some maths used for constant folding
90 vector vec3_add(vector a, vector b)
99 vector vec3_sub(vector a, vector b)
108 qcfloat vec3_mulvv(vector a, vector b)
110 return (a.x * b.x + a.y * b.y + a.z * b.z);
113 vector vec3_mulvf(vector a, float b)
122 /**********************************************************************
126 bool parser_next(parser_t *parser)
128 /* lex_do kills the previous token */
129 parser->tok = lex_do(parser->lex);
130 if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
135 /* lift a token out of the parser so it's not destroyed by parser_next */
136 token *parser_lift(parser_t *parser)
138 token *tok = parser->lex->tok;
139 parser->lex->tok = NULL;
143 #define parser_tokval(p) (p->lex->tok->value)
144 #define parser_token(p) (p->lex->tok)
145 #define parser_ctx(p) (p->lex->tok->ctx)
147 ast_value* parser_const_float(parser_t *parser, double d)
151 for (i = 0; i < parser->imm_float_count; ++i) {
152 if (parser->imm_float[i]->constval.vfloat == d)
153 return parser->imm_float[i];
155 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
157 out->constval.vfloat = d;
158 if (!parser_t_imm_float_add(parser, out)) {
159 ast_value_delete(out);
165 ast_value* parser_const_float_0(parser_t *parser)
167 if (!parser->imm_float_zero)
168 parser->imm_float_zero = parser_const_float(parser, 0);
169 return parser->imm_float_zero;
172 char *parser_strdup(const char *str)
175 /* actually dup empty strings */
176 char *out = mem_a(1);
180 return util_strdup(str);
183 ast_value* parser_const_string(parser_t *parser, const char *str)
187 for (i = 0; i < parser->imm_string_count; ++i) {
188 if (!strcmp(parser->imm_string[i]->constval.vstring, str))
189 return parser->imm_string[i];
191 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
193 out->constval.vstring = parser_strdup(str);
194 if (!parser_t_imm_string_add(parser, out)) {
195 ast_value_delete(out);
201 ast_value* parser_const_vector(parser_t *parser, vector v)
205 for (i = 0; i < parser->imm_vector_count; ++i) {
206 if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
207 return parser->imm_vector[i];
209 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
211 out->constval.vvec = v;
212 if (!parser_t_imm_vector_add(parser, out)) {
213 ast_value_delete(out);
219 ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
225 return parser_const_vector(parser, v);
228 ast_value* parser_const_vector_0(parser_t *parser)
230 if (!parser->imm_vector_zero)
231 parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
232 return parser->imm_vector_zero;
235 ast_expression* parser_find_field(parser_t *parser, const char *name)
238 for (i = 0; i < parser->fields_count; ++i) {
239 if (!strcmp(parser->fields[i].name, name))
240 return parser->fields[i].var;
245 ast_expression* parser_find_global(parser_t *parser, const char *name)
248 for (i = 0; i < parser->globals_count; ++i) {
249 if (!strcmp(parser->globals[i].name, name))
250 return parser->globals[i].var;
255 ast_expression* parser_find_param(parser_t *parser, const char *name)
259 if (!parser->function)
261 fun = parser->function->vtype;
262 for (i = 0; i < fun->expression.params_count; ++i) {
263 if (!strcmp(fun->expression.params[i]->name, name))
264 return (ast_expression*)(fun->expression.params[i]);
269 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
273 for (i = parser->locals_count; i > upto;) {
275 if (!strcmp(parser->locals[i].name, name))
276 return parser->locals[i].var;
279 return parser_find_param(parser, name);
282 ast_expression* parser_find_var(parser_t *parser, const char *name)
286 v = parser_find_local(parser, name, 0, &dummy);
287 if (!v) v = parser_find_global(parser, name);
292 MEM_VECTOR_MAKE(ast_value*, p);
294 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
296 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
300 lex_ctx ctx = parser_ctx(parser);
301 int vtype = basetype;
305 MEM_VECTOR_INIT(¶ms, p);
309 if (parser->tok == '(') {
314 bool isfield = false;
317 if (!parser_next(parser))
320 if (parser->tok == ')')
323 if (parser->tok == '.') {
325 if (!parser_next(parser)) {
326 parseerror(parser, "expected field parameter type");
331 temptype = parser_token(parser)->constval.t;
332 if (!parser_next(parser))
335 param = parser_parse_type(parser, temptype, &dummy);
341 if (parser->tok == TOKEN_IDENT) {
342 /* named parameter */
343 if (!ast_value_set_name(param, parser_tokval(parser)))
345 if (!parser_next(parser))
350 fld = ast_value_new(ctx, param->name, TYPE_FIELD);
351 fld->expression.next = (ast_expression*)param;
355 if (!paramlist_t_p_add(¶ms, param)) {
356 parseerror(parser, "Out of memory while parsing typename");
360 if (parser->tok == ',')
362 if (parser->tok == ')')
364 parseerror(parser, "Unexpected token");
367 if (!parser_next(parser))
371 var = ast_value_new(ctx, "<unnamed>", vtype);
374 MEM_VECTOR_MOVE(¶ms, p, &var->expression, params);
377 for (i = 0; i < params.p_count; ++i)
378 ast_value_delete(params.p[i]);
379 MEM_VECTOR_CLEAR(¶ms, p);
385 size_t etype; /* 0 = expression, others are operators */
389 ast_block *block; /* for commas and function calls */
394 MEM_VECTOR_MAKE(sy_elem, out);
395 MEM_VECTOR_MAKE(sy_elem, ops);
397 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
398 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
400 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
410 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
413 e.out = (ast_expression*)v;
420 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
422 e.etype = 1 + (op - operators);
430 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
442 # define DEBUGSHUNTDO(x) x
444 # define DEBUGSHUNTDO(x)
447 static bool parser_sy_pop(parser_t *parser, shunt *sy)
451 ast_expression *out = NULL;
452 ast_expression *exprs[3];
453 ast_block *blocks[3];
454 ast_value *asvalue[3];
456 qcint generated_op = 0;
458 if (!sy->ops_count) {
459 parseerror(parser, "internal error: missing operator");
463 if (sy->ops[sy->ops_count-1].paren) {
464 parseerror(parser, "unmatched parenthesis");
468 op = &operators[sy->ops[sy->ops_count-1].etype - 1];
469 ctx = sy->ops[sy->ops_count-1].ctx;
471 DEBUGSHUNTDO(printf("apply %s\n", op->op));
473 if (sy->out_count < op->operands) {
474 parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count,
475 op->op, (int)op->id);
481 sy->out_count -= op->operands;
482 for (i = 0; i < op->operands; ++i) {
483 exprs[i] = sy->out[sy->out_count+i].out;
484 blocks[i] = sy->out[sy->out_count+i].block;
485 asvalue[i] = (ast_value*)exprs[i];
488 if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
489 parseerror(parser, "internal error: operator cannot be applied on empty blocks");
493 #define NotSameType(T) \
494 (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
495 exprs[0]->expression.vtype != T)
496 #define CanConstFold1(A) \
497 (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
498 #define CanConstFold(A, B) \
499 (CanConstFold1(A) && CanConstFold1(B))
500 #define ConstV(i) (asvalue[(i)]->constval.vvec)
501 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
502 #define ConstS(i) (asvalue[(i)]->constval.vstring)
506 parseerror(parser, "internal error: unhandled operator: %s (%i)", op->op, (int)op->id);
510 if (exprs[0]->expression.vtype == TYPE_ENTITY) {
511 if (exprs[1]->expression.vtype != TYPE_FIELD) {
512 parseerror(parser, "type error: right hand of member-operand should be an entity-field");
515 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
517 else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
518 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
522 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
529 if (!ast_block_exprs_add(blocks[0], exprs[1]))
532 blocks[0] = ast_block_new(ctx);
533 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
534 !ast_block_exprs_add(blocks[0], exprs[1]))
539 if (!ast_block_set_type(blocks[0], exprs[1]))
542 sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
546 switch (exprs[0]->expression.vtype) {
548 if (CanConstFold1(exprs[0]))
549 out = (ast_expression*)parser_const_float(parser, -ConstF(0));
551 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
552 (ast_expression*)parser_const_float_0(parser),
556 if (CanConstFold1(exprs[0]))
557 out = (ast_expression*)parser_const_vector_f(parser,
558 -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
560 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
561 (ast_expression*)parser_const_vector_0(parser),
565 parseerror(parser, "invalid types used in expression: cannot negate type %s",
566 type_name[exprs[0]->expression.vtype]);
572 switch (exprs[0]->expression.vtype) {
574 if (CanConstFold1(exprs[0]))
575 out = (ast_expression*)parser_const_float(parser, !ConstF(0));
577 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, exprs[0]);
580 if (CanConstFold1(exprs[0]))
581 out = (ast_expression*)parser_const_float(parser,
582 (!ConstV(0).x && !ConstV(0).y && !ConstV(0).z));
584 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[0]);
587 if (CanConstFold1(exprs[0]))
588 out = (ast_expression*)parser_const_float(parser, !ConstS(0) || !*ConstS(0));
590 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[0]);
592 /* we don't constant-fold NOT for these types */
594 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_ENT, exprs[0]);
597 out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_FNC, exprs[0]);
600 parseerror(parser, "invalid types used in expression: cannot logically negate type %s",
601 type_name[exprs[0]->expression.vtype]);
607 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
608 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
610 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
611 type_name[exprs[0]->expression.vtype],
612 type_name[exprs[1]->expression.vtype]);
615 switch (exprs[0]->expression.vtype) {
617 if (CanConstFold(exprs[0], exprs[1]))
619 out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
622 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
625 if (CanConstFold(exprs[0], exprs[1]))
626 out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
628 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
631 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
632 type_name[exprs[0]->expression.vtype],
633 type_name[exprs[1]->expression.vtype]);
638 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
639 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
641 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
642 type_name[exprs[1]->expression.vtype],
643 type_name[exprs[0]->expression.vtype]);
646 switch (exprs[0]->expression.vtype) {
648 if (CanConstFold(exprs[0], exprs[1]))
649 out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
651 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
654 if (CanConstFold(exprs[0], exprs[1]))
655 out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
657 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
660 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
661 type_name[exprs[1]->expression.vtype],
662 type_name[exprs[0]->expression.vtype]);
667 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
668 exprs[0]->expression.vtype != TYPE_VECTOR &&
669 exprs[0]->expression.vtype != TYPE_FLOAT &&
670 exprs[1]->expression.vtype != TYPE_VECTOR &&
671 exprs[1]->expression.vtype != TYPE_FLOAT)
673 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
674 type_name[exprs[1]->expression.vtype],
675 type_name[exprs[0]->expression.vtype]);
678 switch (exprs[0]->expression.vtype) {
680 if (exprs[1]->expression.vtype == TYPE_VECTOR)
682 if (CanConstFold(exprs[0], exprs[1]))
683 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
685 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
689 if (CanConstFold(exprs[0], exprs[1]))
690 out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
692 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
696 if (exprs[1]->expression.vtype == TYPE_FLOAT)
698 if (CanConstFold(exprs[0], exprs[1]))
699 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
701 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
705 if (CanConstFold(exprs[0], exprs[1]))
706 out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
708 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
712 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
713 type_name[exprs[1]->expression.vtype],
714 type_name[exprs[0]->expression.vtype]);
719 if (NotSameType(TYPE_FLOAT)) {
720 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
721 type_name[exprs[0]->expression.vtype],
722 type_name[exprs[1]->expression.vtype]);
725 if (CanConstFold(exprs[0], exprs[1]))
726 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
728 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
732 parseerror(parser, "qc does not have a modulo operator");
736 if (NotSameType(TYPE_FLOAT)) {
737 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
738 type_name[exprs[0]->expression.vtype],
739 type_name[exprs[1]->expression.vtype]);
742 if (CanConstFold(exprs[0], exprs[1]))
743 out = (ast_expression*)parser_const_float(parser,
744 (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
745 (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
747 out = (ast_expression*)ast_binary_new(ctx,
748 (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
752 parseerror(parser, "TODO: bitxor");
757 case opid3('<','<','='):
758 case opid3('>','>','='):
759 parseerror(parser, "TODO: shifts");
763 generated_op += 1; /* INSTR_OR */
765 generated_op += INSTR_AND;
766 if (NotSameType(TYPE_FLOAT)) {
767 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
768 type_name[exprs[0]->expression.vtype],
769 type_name[exprs[1]->expression.vtype]);
770 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
771 parseerror(parser, "TODO: optional early out");
774 if (opts_standard == COMPILER_GMQCC)
775 printf("TODO: early out logic\n");
776 if (CanConstFold(exprs[0], exprs[1]))
777 out = (ast_expression*)parser_const_float(parser,
778 (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
780 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
784 generated_op += 1; /* INSTR_GT */
786 generated_op += 1; /* INSTR_LT */
787 case opid2('>', '='):
788 generated_op += 1; /* INSTR_GE */
789 case opid2('<', '='):
790 generated_op += INSTR_LE;
791 if (NotSameType(TYPE_FLOAT)) {
792 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
793 type_name[exprs[0]->expression.vtype],
794 type_name[exprs[1]->expression.vtype]);
797 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
799 case opid2('!', '='):
800 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
801 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
802 type_name[exprs[0]->expression.vtype],
803 type_name[exprs[1]->expression.vtype]);
806 out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
808 case opid2('=', '='):
809 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
810 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
811 type_name[exprs[0]->expression.vtype],
812 type_name[exprs[1]->expression.vtype]);
815 out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
819 if (ast_istype(exprs[0], ast_entfield))
820 assignop = type_storep_instr[exprs[0]->expression.vtype];
822 assignop = type_store_instr[exprs[0]->expression.vtype];
823 out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
827 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
828 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
830 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
831 type_name[exprs[0]->expression.vtype],
832 type_name[exprs[1]->expression.vtype]);
835 if (ast_istype(exprs[0], ast_entfield))
836 assignop = type_storep_instr[exprs[0]->expression.vtype];
838 assignop = type_store_instr[exprs[0]->expression.vtype];
839 switch (exprs[0]->expression.vtype) {
841 out = (ast_expression*)ast_binstore_new(ctx, assignop,
842 (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
846 out = (ast_expression*)ast_binstore_new(ctx, assignop,
847 (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
851 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
852 type_name[exprs[0]->expression.vtype],
853 type_name[exprs[1]->expression.vtype]);
861 parseerror(parser, "failed to apply operand %s", op->op);
865 DEBUGSHUNTDO(printf("applied %s\n", op->op));
866 sy->out[sy->out_count++] = syexp(ctx, out);
870 static bool parser_close_call(parser_t *parser, shunt *sy)
872 /* was a function call */
880 fid = sy->ops[sy->ops_count].off;
882 /* out[fid] is the function
883 * everything above is parameters...
885 * 1 params = ast_expression
889 if (sy->out_count < 1 || sy->out_count <= fid) {
890 parseerror(parser, "internal error: function call needs function and parameter list...");
894 fun = sy->out[fid].out;
896 call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
898 parseerror(parser, "out of memory");
902 if (fid+1 == sy->out_count) {
905 } else if (fid+2 == sy->out_count) {
908 params = sy->out[sy->out_count].block;
912 if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
913 ast_delete(sy->out[sy->out_count].out);
914 parseerror(parser, "out of memory");
918 paramcount = params->exprs_count;
919 MEM_VECTOR_MOVE(params, exprs, call, params);
923 parseerror(parser, "invalid function call");
927 /* overwrite fid, the function, with a call */
928 sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
930 if (fun->expression.vtype != TYPE_FUNCTION) {
931 parseerror(parser, "not a function (%s)", type_name[fun->expression.vtype]);
935 if (!fun->expression.next) {
936 parseerror(parser, "could not determine function return type");
939 if (fun->expression.params_count != paramcount) {
941 fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
942 if (opts_standard == COMPILER_GMQCC)
945 parseerror(parser, "too few parameters for call to %s: expected %i, got %i",
946 fval->name, (int)fun->expression.params_count, paramcount);
948 parseerror(parser, "too few parameters for function call: expected %i, got %i",
949 (int)fun->expression.params_count, paramcount);
955 return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
956 "too few parameters for call to %s: expected %i, got %i",
957 fval->name, (int)fun->expression.params_count, paramcount);
959 return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
960 "too few parameters for function call: expected %i, got %i",
961 (int)fun->expression.params_count, paramcount);
969 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
971 if (!sy->ops_count) {
972 parseerror(parser, "unmatched closing paren");
975 if (sy->ops[sy->ops_count-1].paren == 1) {
976 parseerror(parser, "empty parenthesis expression");
979 while (sy->ops_count) {
980 if (sy->ops[sy->ops_count-1].paren == 'f') {
981 if (!parser_close_call(parser, sy))
985 if (sy->ops[sy->ops_count-1].paren == 1) {
987 return !functions_only;
989 if (!parser_sy_pop(parser, sy))
995 static void parser_reclassify_token(parser_t *parser)
998 for (i = 0; i < operator_count; ++i) {
999 if (!strcmp(parser_tokval(parser), operators[i].op)) {
1000 parser->tok = TOKEN_OPERATOR;
1006 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
1008 ast_expression *expr = NULL;
1010 bool wantop = false;
1011 bool gotmemberof = false;
1013 /* count the parens because an if starts with one, so the
1014 * end of a condition is an unmatched closing paren
1018 MEM_VECTOR_INIT(&sy, out);
1019 MEM_VECTOR_INIT(&sy, ops);
1021 parser->lex->flags.noops = false;
1023 parser_reclassify_token(parser);
1028 gotmemberof = false;
1030 parser->memberof = 0;
1032 if (parser->tok == TOKEN_IDENT)
1034 ast_expression *var;
1036 parseerror(parser, "expected operator or end of statement");
1041 if (opts_standard == COMPILER_GMQCC)
1043 if (parser->memberof == TYPE_ENTITY) {
1044 /* still get vars first since there could be a fieldpointer */
1045 var = parser_find_var(parser, parser_tokval(parser));
1047 var = parser_find_field(parser, parser_tokval(parser));
1049 else if (parser->memberof == TYPE_VECTOR)
1051 parseerror(parser, "TODO: implement effective vector member access");
1054 else if (parser->memberof) {
1055 parseerror(parser, "namespace for member not found");
1059 var = parser_find_var(parser, parser_tokval(parser));
1061 var = parser_find_var(parser, parser_tokval(parser));
1063 var = parser_find_field(parser, parser_tokval(parser));
1066 parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
1069 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
1070 parseerror(parser, "out of memory");
1073 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
1075 else if (parser->tok == TOKEN_FLOATCONST) {
1078 parseerror(parser, "expected operator or end of statement, got constant");
1082 val = parser_const_float(parser, (parser_token(parser)->constval.f));
1085 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1086 parseerror(parser, "out of memory");
1089 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
1091 else if (parser->tok == TOKEN_INTCONST) {
1094 parseerror(parser, "expected operator or end of statement, got constant");
1098 val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1101 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1102 parseerror(parser, "out of memory");
1105 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
1107 else if (parser->tok == TOKEN_STRINGCONST) {
1110 parseerror(parser, "expected operator or end of statement, got constant");
1114 val = parser_const_string(parser, parser_tokval(parser));
1117 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1118 parseerror(parser, "out of memory");
1121 DEBUGSHUNTDO(printf("push string\n"));
1123 else if (parser->tok == TOKEN_VECTORCONST) {
1126 parseerror(parser, "expected operator or end of statement, got constant");
1130 val = parser_const_vector(parser, parser_token(parser)->constval.v);
1133 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1134 parseerror(parser, "out of memory");
1137 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
1138 parser_token(parser)->constval.v.x,
1139 parser_token(parser)->constval.v.y,
1140 parser_token(parser)->constval.v.z));
1142 else if (parser->tok == '(') {
1143 parseerror(parser, "internal error: '(' should be classified as operator");
1146 else if (parser->tok == ')') {
1148 DEBUGSHUNTDO(printf("do[op] )\n"));
1152 /* we do expect an operator next */
1153 /* closing an opening paren */
1154 if (!parser_close_paren(parser, &sy, false))
1157 DEBUGSHUNTDO(printf("do[nop] )\n"));
1161 /* allowed for function calls */
1162 if (!parser_close_paren(parser, &sy, true))
1167 else if (parser->tok != TOKEN_OPERATOR) {
1169 parseerror(parser, "expected operator or end of statement");
1176 /* classify the operator */
1177 /* TODO: suffix operators */
1178 const oper_info *op;
1179 const oper_info *olast = NULL;
1181 for (o = 0; o < operator_count; ++o) {
1182 if ((!(operators[o].flags & OP_PREFIX) == wantop) &&
1183 !(operators[o].flags & OP_SUFFIX) && /* remove this */
1184 !strcmp(parser_tokval(parser), operators[o].op))
1189 if (o == operator_count) {
1190 /* no operator found... must be the end of the statement */
1193 /* found an operator */
1196 /* when declaring variables, a comma starts a new variable */
1197 if (op->id == opid1(',') && !parens && stopatcomma)
1200 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1201 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1204 (op->prec < olast->prec) ||
1205 (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1207 if (!parser_sy_pop(parser, &sy))
1209 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1210 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1215 if (op->id == opid1('.') && opts_standard == COMPILER_GMQCC) {
1216 /* for gmqcc standard: open up the namespace of the previous type */
1217 ast_expression *prevex = sy.out[sy.out_count-1].out;
1219 parseerror(parser, "unexpected member operator");
1222 if (prevex->expression.vtype == TYPE_ENTITY)
1223 parser->memberof = TYPE_ENTITY;
1224 else if (prevex->expression.vtype == TYPE_VECTOR)
1225 parser->memberof = TYPE_VECTOR;
1227 parseerror(parser, "type error: type has no members");
1233 if (op->id == opid1('(')) {
1235 DEBUGSHUNTDO(printf("push (\n"));
1237 /* we expected an operator, this is the function-call operator */
1238 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
1239 parseerror(parser, "out of memory");
1244 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
1245 parseerror(parser, "out of memory");
1248 DEBUGSHUNTDO(printf("push (\n"));
1252 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1253 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1258 if (!parser_next(parser)) {
1261 if (parser->tok == ';') {
1266 while (sy.ops_count) {
1267 if (!parser_sy_pop(parser, &sy))
1271 parser->lex->flags.noops = true;
1272 if (!sy.out_count) {
1273 parseerror(parser, "empty expression");
1276 expr = sy.out[0].out;
1277 MEM_VECTOR_CLEAR(&sy, out);
1278 MEM_VECTOR_CLEAR(&sy, ops);
1279 DEBUGSHUNTDO(printf("shunt done\n"));
1283 parser->lex->flags.noops = true;
1284 MEM_VECTOR_CLEAR(&sy, out);
1285 MEM_VECTOR_CLEAR(&sy, ops);
1289 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
1291 ast_expression *e = parser_expression_leave(parser, stopatcomma);
1294 if (!parser_next(parser)) {
1301 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1304 ast_expression *cond, *ontrue, *onfalse = NULL;
1306 lex_ctx ctx = parser_ctx(parser);
1308 /* skip the 'if' and check for opening paren */
1309 if (!parser_next(parser) || parser->tok != '(') {
1310 parseerror(parser, "expected 'if' condition in parenthesis");
1313 /* parse into the expression */
1314 if (!parser_next(parser)) {
1315 parseerror(parser, "expected 'if' condition after opening paren");
1318 /* parse the condition */
1319 cond = parser_expression_leave(parser, false);
1323 if (parser->tok != ')') {
1324 parseerror(parser, "expected closing paren after 'if' condition");
1328 /* parse into the 'then' branch */
1329 if (!parser_next(parser)) {
1330 parseerror(parser, "expected statement for on-true branch of 'if'");
1334 ontrue = parser_parse_statement_or_block(parser);
1339 /* check for an else */
1340 if (!strcmp(parser_tokval(parser), "else")) {
1341 /* parse into the 'else' branch */
1342 if (!parser_next(parser)) {
1343 parseerror(parser, "expected on-false branch after 'else'");
1348 onfalse = parser_parse_statement_or_block(parser);
1356 ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1357 *out = (ast_expression*)ifthen;
1361 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1364 ast_expression *cond, *ontrue;
1366 lex_ctx ctx = parser_ctx(parser);
1368 /* skip the 'while' and check for opening paren */
1369 if (!parser_next(parser) || parser->tok != '(') {
1370 parseerror(parser, "expected 'while' condition in parenthesis");
1373 /* parse into the expression */
1374 if (!parser_next(parser)) {
1375 parseerror(parser, "expected 'while' condition after opening paren");
1378 /* parse the condition */
1379 cond = parser_expression_leave(parser, false);
1383 if (parser->tok != ')') {
1384 parseerror(parser, "expected closing paren after 'while' condition");
1388 /* parse into the 'then' branch */
1389 if (!parser_next(parser)) {
1390 parseerror(parser, "expected while-loop body");
1394 ontrue = parser_parse_statement_or_block(parser);
1400 aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1401 *out = (ast_expression*)aloop;
1405 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1408 ast_expression *cond, *ontrue;
1410 lex_ctx ctx = parser_ctx(parser);
1412 /* skip the 'do' and get the body */
1413 if (!parser_next(parser)) {
1414 parseerror(parser, "expected loop body");
1417 ontrue = parser_parse_statement_or_block(parser);
1421 /* expect the "while" */
1422 if (parser->tok != TOKEN_KEYWORD ||
1423 strcmp(parser_tokval(parser), "while"))
1425 parseerror(parser, "expected 'while' and condition");
1430 /* skip the 'while' and check for opening paren */
1431 if (!parser_next(parser) || parser->tok != '(') {
1432 parseerror(parser, "expected 'while' condition in parenthesis");
1436 /* parse into the expression */
1437 if (!parser_next(parser)) {
1438 parseerror(parser, "expected 'while' condition after opening paren");
1442 /* parse the condition */
1443 cond = parser_expression_leave(parser, false);
1447 if (parser->tok != ')') {
1448 parseerror(parser, "expected closing paren after 'while' condition");
1454 if (!parser_next(parser) || parser->tok != ';') {
1455 parseerror(parser, "expected semicolon after condition");
1461 if (!parser_next(parser)) {
1462 parseerror(parser, "parse error");
1468 aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1469 *out = (ast_expression*)aloop;
1473 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1476 ast_expression *initexpr, *cond, *increment, *ontrue;
1477 size_t oldblocklocal;
1479 lex_ctx ctx = parser_ctx(parser);
1481 oldblocklocal = parser->blocklocal;
1482 parser->blocklocal = parser->locals_count;
1489 /* skip the 'while' and check for opening paren */
1490 if (!parser_next(parser) || parser->tok != '(') {
1491 parseerror(parser, "expected 'for' expressions in parenthesis");
1494 /* parse into the expression */
1495 if (!parser_next(parser)) {
1496 parseerror(parser, "expected 'for' initializer after opening paren");
1500 if (parser->tok == TOKEN_TYPENAME) {
1501 if (opts_standard != COMPILER_GMQCC) {
1502 if (parsewarning(parser, WARN_EXTENSIONS,
1503 "current standard does not allow variable declarations in for-loop initializers"))
1507 parseerror(parser, "TODO: assignment of new variables to be non-const");
1509 if (!parser_variable(parser, block))
1512 else if (parser->tok != ';')
1514 initexpr = parser_expression_leave(parser, false);
1519 /* move on to condition */
1520 if (parser->tok != ';') {
1521 parseerror(parser, "expected semicolon after for-loop initializer");
1524 if (!parser_next(parser)) {
1525 parseerror(parser, "expected for-loop condition");
1529 /* parse the condition */
1530 if (parser->tok != ';') {
1531 cond = parser_expression_leave(parser, false);
1536 /* move on to incrementor */
1537 if (parser->tok != ';') {
1538 parseerror(parser, "expected semicolon after for-loop initializer");
1541 if (!parser_next(parser)) {
1542 parseerror(parser, "expected for-loop condition");
1546 /* parse the incrementor */
1547 if (parser->tok != ')') {
1548 increment = parser_expression_leave(parser, false);
1554 if (parser->tok != ')') {
1555 parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1558 /* parse into the 'then' branch */
1559 if (!parser_next(parser)) {
1560 parseerror(parser, "expected for-loop body");
1563 ontrue = parser_parse_statement_or_block(parser);
1568 aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1569 *out = (ast_expression*)aloop;
1571 while (parser->locals_count > parser->blocklocal)
1572 parser_pop_local(parser);
1573 parser->blocklocal = oldblocklocal;
1576 if (initexpr) ast_delete(initexpr);
1577 if (cond) ast_delete(cond);
1578 if (increment) ast_delete(increment);
1579 while (parser->locals_count > parser->blocklocal)
1580 parser_pop_local(parser);
1581 parser->blocklocal = oldblocklocal;
1585 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1587 if (parser->tok == TOKEN_TYPENAME)
1589 /* local variable */
1591 parseerror(parser, "cannot declare a variable from here");
1594 if (opts_standard == COMPILER_QCC) {
1595 if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1598 if (!parser_variable(parser, block))
1603 else if (parser->tok == TOKEN_KEYWORD)
1605 if (!strcmp(parser_tokval(parser), "local"))
1608 parseerror(parser, "cannot declare a local variable here");
1611 if (!parser_next(parser)) {
1612 parseerror(parser, "expected variable declaration");
1615 if (!parser_variable(parser, block))
1620 else if (!strcmp(parser_tokval(parser), "return"))
1622 ast_expression *exp = NULL;
1623 ast_return *ret = NULL;
1624 ast_value *expected = parser->function->vtype;
1626 if (!parser_next(parser)) {
1627 parseerror(parser, "expected return expression");
1631 if (parser->tok != ';') {
1632 exp = parser_expression(parser, false);
1636 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1637 parseerror(parser, "return with invalid expression");
1640 ret = ast_return_new(exp->expression.node.context, exp);
1646 if (!parser_next(parser))
1647 parseerror(parser, "parse error");
1648 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1649 if (opts_standard != COMPILER_GMQCC)
1650 (void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
1652 parseerror(parser, "return without value");
1654 ret = ast_return_new(parser_ctx(parser), NULL);
1656 *out = (ast_expression*)ret;
1659 else if (!strcmp(parser_tokval(parser), "if"))
1661 return parser_parse_if(parser, block, out);
1663 else if (!strcmp(parser_tokval(parser), "while"))
1665 return parser_parse_while(parser, block, out);
1667 else if (!strcmp(parser_tokval(parser), "do"))
1669 return parser_parse_dowhile(parser, block, out);
1671 else if (!strcmp(parser_tokval(parser), "for"))
1673 if (opts_standard == COMPILER_QCC) {
1674 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1677 return parser_parse_for(parser, block, out);
1679 parseerror(parser, "Unexpected keyword");
1682 else if (parser->tok == '{')
1685 inner = parser_parse_block(parser);
1688 *out = (ast_expression*)inner;
1693 ast_expression *exp = parser_expression(parser, false);
1701 static void parser_pop_local(parser_t *parser)
1703 parser->locals_count--;
1704 mem_d(parser->locals[parser->locals_count].name);
1707 static ast_block* parser_parse_block(parser_t *parser)
1709 size_t oldblocklocal;
1710 ast_block *block = NULL;
1712 oldblocklocal = parser->blocklocal;
1713 parser->blocklocal = parser->locals_count;
1715 if (!parser_next(parser)) { /* skip the '{' */
1716 parseerror(parser, "expected function body");
1720 block = ast_block_new(parser_ctx(parser));
1722 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1724 ast_expression *expr;
1725 if (parser->tok == '}')
1728 if (!parser_parse_statement(parser, block, &expr)) {
1729 parseerror(parser, "parse error");
1730 ast_block_delete(block);
1736 if (!ast_block_exprs_add(block, expr)) {
1738 ast_block_delete(block);
1744 if (parser->tok != '}') {
1745 ast_block_delete(block);
1748 (void)parser_next(parser);
1752 while (parser->locals_count > parser->blocklocal)
1753 parser_pop_local(parser);
1754 parser->blocklocal = oldblocklocal;
1755 /* unroll the local vector */
1759 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1761 ast_expression *expr = NULL;
1762 if (parser->tok == '{')
1763 return (ast_expression*)parser_parse_block(parser);
1764 if (!parser_parse_statement(parser, NULL, &expr))
1769 static bool parser_variable(parser_t *parser, ast_block *localblock)
1771 bool isfunc = false;
1772 ast_function *func = NULL;
1776 ast_expression *olddecl;
1781 int basetype = parser_token(parser)->constval.t;
1787 if (!parser_next(parser)) { /* skip basetype or comma */
1788 parseerror(parser, "expected variable declaration");
1796 ctx = parser_ctx(parser);
1797 var = parser_parse_type(parser, basetype, &isfunc);
1802 if (parser->tok != TOKEN_IDENT) {
1803 parseerror(parser, "expected variable name\n");
1808 if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1809 ast_value_delete(var);
1810 parseerror(parser, "global `%s` already declared here: %s:%i",
1811 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1816 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &isparam);
1817 if (opts_standard == COMPILER_GMQCC)
1822 ast_value_delete(var);
1823 parseerror(parser, "local `%s` already declared here: %s:%i",
1824 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1829 if( (!isparam && olddecl) || (olddecl = parser_find_local(parser, parser_tokval(parser), 0, &isparam)) )
1831 if (parsewarning(parser, WARN_LOCAL_SHADOWS,
1832 "local `%s` is shadowing a parameter", parser_tokval(parser)))
1834 ast_value_delete(var);
1835 parseerror(parser, "local `%s` already declared here: %s:%i",
1836 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1846 parsewarning(parser, WARN_LOCAL_SHADOWS,
1847 "a parameter is shadowing local `%s`", parser_tokval(parser)))
1849 ast_value_delete(var);
1854 ast_value_delete(var);
1855 parseerror(parser, "local `%s` already declared here: %s:%i",
1856 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1864 if (!ast_value_set_name(var, parser_tokval(parser))) {
1865 parseerror(parser, "failed to set variable name\n");
1866 ast_value_delete(var);
1871 /* a function was defined */
1873 ast_value *proto = NULL;
1877 olddecl = parser_find_global(parser, parser_tokval(parser));
1879 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &dummy);
1882 /* we had a prototype */
1883 if (!ast_istype(olddecl, ast_value)) {
1884 /* theoretically not possible you think?
1890 parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1891 parser_tokval(parser));
1892 ast_value_delete(var);
1896 proto = (ast_value*)olddecl;
1899 /* turn var into a value of TYPE_FUNCTION, with the old var
1902 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1903 func = ast_function_new(ctx, var->name, fval);
1904 if (!fval || !func) {
1905 ast_value_delete(var);
1906 if (fval) ast_value_delete(fval);
1907 if (func) ast_function_delete(func);
1911 fval->expression.next = (ast_expression*)var;
1912 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1914 /* we compare the type late here, but it's easier than
1915 * messing with the parameter-vector etc. earlier
1919 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1920 parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1922 ast_ctx(proto).file, ast_ctx(proto).line);
1923 ast_function_delete(func);
1924 ast_value_delete(fval);
1927 /* copy over the parameter names */
1928 for (param = 0; param < fval->expression.params_count; ++param)
1929 ast_value_set_name(proto->expression.params[param], fval->expression.params[param]->name);
1931 /* now ditch the rest of the new data */
1932 ast_function_delete(func);
1933 ast_value_delete(fval);
1935 func = proto->constval.vfunc;
1940 if (!parser_t_functions_add(parser, func)) {
1941 ast_function_delete(func);
1942 ast_value_delete(fval);
1951 varent.name = util_strdup(var->name);
1952 varent.var = (ast_expression*)var;
1953 if (var->expression.vtype == TYPE_VECTOR)
1955 size_t len = strlen(varent.name);
1956 varentry_t vx, vy, vz;
1957 vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1958 vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1959 vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1960 vx.name = (char*)mem_a(len+3);
1961 vy.name = (char*)mem_a(len+3);
1962 vz.name = (char*)mem_a(len+3);
1963 memcpy(vx.name, varent.name, len);
1964 memcpy(vy.name, varent.name, len);
1965 memcpy(vz.name, varent.name, len);
1966 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1967 vx.name[len+1] = 'x';
1968 vy.name[len+1] = 'y';
1969 vz.name[len+1] = 'z';
1970 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1973 (void)!parser_t_globals_add(parser, varent);
1974 (void)!parser_t_globals_add(parser, vx);
1975 (void)!parser_t_globals_add(parser, vy);
1976 (void)!parser_t_globals_add(parser, vz);
1978 (void)!parser_t_locals_add(parser, varent);
1979 (void)!parser_t_locals_add(parser, vx);
1980 (void)!parser_t_locals_add(parser, vy);
1981 (void)!parser_t_locals_add(parser, vz);
1982 if (!ast_block_locals_add(localblock, var) ||
1983 !ast_block_collect(localblock, vx.var) ||
1984 !ast_block_collect(localblock, vy.var) ||
1985 !ast_block_collect(localblock, vz.var))
1987 parser_pop_local(parser);
1988 parser_pop_local(parser);
1989 parser_pop_local(parser);
1990 parser_pop_local(parser);
1991 ast_value_delete(var);
1998 if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1999 ( localblock && !parser_t_locals_add(parser, varent)) )
2001 ast_value_delete(var);
2004 if (localblock && !ast_block_locals_add(localblock, var))
2006 parser_pop_local(parser);
2007 ast_value_delete(var);
2013 if (!parser_next(parser)) {
2014 ast_value_delete(var);
2018 if (parser->tok == ';') {
2019 if (!parser_next(parser))
2020 return parser->tok == TOKEN_EOF;
2024 if (parser->tok == ',') {
2029 if (parser->tok != '=') {
2030 parseerror(parser, "expected '=' or ';'");
2034 if (!parser_next(parser))
2037 if (parser->tok == '#') {
2039 parseerror(parser, "cannot declare builtins within functions");
2042 if (!isfunc || !func) {
2043 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
2046 if (!parser_next(parser)) {
2047 parseerror(parser, "expected builtin number");
2050 if (parser->tok != TOKEN_INTCONST) {
2051 parseerror(parser, "builtin number must be an integer constant");
2054 if (parser_token(parser)->constval.i <= 0) {
2055 parseerror(parser, "builtin number must be positive integer greater than zero");
2059 func->builtin = -parser_token(parser)->constval.i;
2061 if (!parser_next(parser))
2063 } else if (parser->tok == '{') {
2066 ast_function *old = parser->function;
2069 parseerror(parser, "cannot declare functions within functions");
2073 parser->function = func;
2074 block = parser_parse_block(parser);
2075 parser->function = old;
2080 if (!ast_function_blocks_add(func, block)) {
2081 ast_block_delete(block);
2085 if (parser->tok == ';')
2086 return parser_next(parser) || parser->tok == TOKEN_EOF;
2087 else if (opts_standard == COMPILER_QCC)
2088 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
2091 ast_expression *cexp;
2094 cexp = parser_expression_leave(parser, true);
2095 cval = (ast_value*)cexp;
2096 if (!ast_istype(cval, ast_value) || !cval->isconst)
2097 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
2100 var->isconst = true;
2101 memcpy(&var->constval, &cval->constval, sizeof(var->constval));
2102 memset(&cval->constval, 0, sizeof(cval->constval));
2107 if (parser->tok == ',') {
2112 if (parser->tok != ';') {
2113 parseerror(parser, "missing semicolon");
2117 (void)parser_next(parser);
2123 static bool parser_do(parser_t *parser)
2125 if (parser->tok == TOKEN_TYPENAME)
2127 return parser_variable(parser, NULL);
2129 else if (parser->tok == TOKEN_KEYWORD)
2131 /* handle 'var' and 'const' */
2134 else if (parser->tok == '.')
2139 ast_expression *oldex;
2140 bool isfunc = false;
2142 lex_ctx ctx = parser_ctx(parser);
2145 /* entity-member declaration */
2146 if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
2147 parseerror(parser, "expected member variable definition");
2151 /* remember the base/return type */
2152 basetype = parser_token(parser)->constval.t;
2154 /* parse into the declaration */
2155 if (!parser_next(parser)) {
2156 parseerror(parser, "expected field def");
2160 /* parse the field type fully */
2161 typevar = var = parser_parse_type(parser, basetype, &isfunc);
2166 var = ast_value_copy(typevar);
2167 /* now the field name */
2168 if (parser->tok != TOKEN_IDENT) {
2169 parseerror(parser, "expected field name");
2174 /* check for an existing field
2175 * in original qc we also have to check for an existing
2176 * global named like the field
2178 if (opts_standard == COMPILER_QCC) {
2179 if (parser_find_global(parser, parser_tokval(parser))) {
2180 parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
2188 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
2190 ast_value_delete(var);
2193 fval->expression.next = (ast_expression*)var;
2194 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
2198 /* turn it into a field */
2199 fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
2200 fld->expression.next = (ast_expression*)var;
2202 if ( (oldex = parser_find_field(parser, parser_tokval(parser)))) {
2203 if (ast_istype(oldex, ast_member)) {
2204 parseerror(parser, "cannot declare a field with the same name as a vector component, component %s has been declared here: %s:%i",
2205 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2209 if (!ast_istype(oldex, ast_value)) {
2210 /* not possible / sanity check */
2211 parseerror(parser, "internal error: %s is not an ast_value", parser_tokval(parser));
2216 if (!ast_compare_type(oldex, (ast_expression*)fld)) {
2217 parseerror(parser, "field %s has previously been declared with a different type here: %s:%i",
2218 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line);
2222 if (parsewarning(parser, WARN_FIELD_REDECLARED, "field %s has already been declared here: %s:%i",
2223 parser_tokval(parser), ast_ctx(oldex).file, (int)ast_ctx(oldex).line))
2234 varent.var = (ast_expression*)fld;
2235 varent.name = util_strdup(fld->name);
2236 (void)!parser_t_fields_add(parser, varent);
2238 if (var->expression.vtype == TYPE_VECTOR)
2240 /* create _x, _y and _z fields as well */
2242 varentry_t vx, vy, vz;
2244 len = strlen(varent.name);
2245 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
2246 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
2247 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
2248 vx.name = (char*)mem_a(len+3);
2249 vy.name = (char*)mem_a(len+3);
2250 vz.name = (char*)mem_a(len+3);
2251 memcpy(vx.name, varent.name, len);
2252 memcpy(vy.name, varent.name, len);
2253 memcpy(vz.name, varent.name, len);
2254 vx.name[len] = vy.name[len] = vz.name[len] = '_';
2255 vx.name[len+1] = 'x';
2256 vy.name[len+1] = 'y';
2257 vz.name[len+1] = 'z';
2258 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
2259 (void)!parser_t_fields_add(parser, vx);
2260 (void)!parser_t_fields_add(parser, vy);
2261 (void)!parser_t_fields_add(parser, vz);
2265 if (!parser_next(parser)) {
2266 parseerror(parser, "expected semicolon or another field name");
2269 if (parser->tok == ';')
2271 if (parser->tok != ',' || !parser_next(parser)) {
2272 parseerror(parser, "expected semicolon or another field name");
2276 ast_delete(typevar);
2278 /* skip the semicolon */
2279 if (!parser_next(parser))
2280 return parser->tok == TOKEN_EOF;
2284 else if (parser->tok == '$')
2286 if (!parser_next(parser)) {
2287 parseerror(parser, "parse error");
2293 parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
2299 static parser_t *parser;
2303 parser = (parser_t*)mem_a(sizeof(parser_t));
2307 memset(parser, 0, sizeof(*parser));
2311 bool parser_compile(const char *filename)
2313 parser->lex = lex_open(filename);
2315 printf("failed to open file \"%s\"\n", filename);
2319 /* initial lexer/parser state */
2320 parser->lex->flags.noops = true;
2322 if (parser_next(parser))
2324 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2326 if (!parser_do(parser)) {
2327 if (parser->tok == TOKEN_EOF)
2328 parseerror(parser, "unexpected eof");
2329 else if (!parser->errors)
2330 parseerror(parser, "parse error\n");
2331 lex_close(parser->lex);
2338 lex_close(parser->lex);
2341 return !parser->errors;
2344 void parser_cleanup()
2347 for (i = 0; i < parser->functions_count; ++i) {
2348 ast_delete(parser->functions[i]);
2350 for (i = 0; i < parser->imm_vector_count; ++i) {
2351 ast_delete(parser->imm_vector[i]);
2353 for (i = 0; i < parser->imm_string_count; ++i) {
2354 ast_delete(parser->imm_string[i]);
2356 for (i = 0; i < parser->imm_float_count; ++i) {
2357 ast_delete(parser->imm_float[i]);
2359 for (i = 0; i < parser->fields_count; ++i) {
2360 ast_delete(parser->fields[i].var);
2361 mem_d(parser->fields[i].name);
2363 for (i = 0; i < parser->globals_count; ++i) {
2364 ast_delete(parser->globals[i].var);
2365 mem_d(parser->globals[i].name);
2367 MEM_VECTOR_CLEAR(parser, functions);
2368 MEM_VECTOR_CLEAR(parser, imm_vector);
2369 MEM_VECTOR_CLEAR(parser, imm_string);
2370 MEM_VECTOR_CLEAR(parser, imm_float);
2371 MEM_VECTOR_CLEAR(parser, globals);
2372 MEM_VECTOR_CLEAR(parser, fields);
2373 MEM_VECTOR_CLEAR(parser, locals);
2378 bool parser_finish(const char *output)
2383 if (!parser->errors)
2385 ir = ir_builder_new("gmqcc_out");
2387 printf("failed to allocate builder\n");
2391 for (i = 0; i < parser->imm_float_count; ++i) {
2392 if (!ast_global_codegen(parser->imm_float[i], ir)) {
2393 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2394 ir_builder_delete(ir);
2398 for (i = 0; i < parser->imm_string_count; ++i) {
2399 if (!ast_global_codegen(parser->imm_string[i], ir)) {
2400 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2401 ir_builder_delete(ir);
2405 for (i = 0; i < parser->imm_vector_count; ++i) {
2406 if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2407 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2408 ir_builder_delete(ir);
2412 for (i = 0; i < parser->fields_count; ++i) {
2415 if (!ast_istype(parser->fields[i].var, ast_value))
2417 field = (ast_value*)parser->fields[i].var;
2418 isconst = field->isconst;
2419 field->isconst = false;
2420 if (!ast_global_codegen((ast_value*)field, ir)) {
2421 printf("failed to generate field %s\n", field->name);
2422 ir_builder_delete(ir);
2427 ast_expression *subtype;
2428 field->isconst = true;
2429 subtype = field->expression.next;
2430 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2431 if (subtype->expression.vtype == TYPE_FIELD)
2432 ifld->fieldtype = subtype->expression.next->expression.vtype;
2433 else if (subtype->expression.vtype == TYPE_FUNCTION)
2434 ifld->outtype = subtype->expression.next->expression.vtype;
2435 (void)!ir_value_set_field(field->ir_v, ifld);
2438 for (i = 0; i < parser->globals_count; ++i) {
2439 if (!ast_istype(parser->globals[i].var, ast_value))
2441 if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2442 printf("failed to generate global %s\n", parser->globals[i].name);
2443 ir_builder_delete(ir);
2447 for (i = 0; i < parser->functions_count; ++i) {
2448 if (!ast_function_codegen(parser->functions[i], ir)) {
2449 printf("failed to generate function %s\n", parser->functions[i]->name);
2450 ir_builder_delete(ir);
2453 if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2454 printf("failed to finalize function %s\n", parser->functions[i]->name);
2455 ir_builder_delete(ir);
2461 ir_builder_dump(ir, printf);
2463 if (!ir_builder_generate(ir, output)) {
2464 printf("*** failed to generate output file\n");
2465 ir_builder_delete(ir);
2469 ir_builder_delete(ir);
2473 printf("*** there were compile errors\n");