16 MEM_VECTOR_MAKE(varentry_t, globals);
17 MEM_VECTOR_MAKE(varentry_t, fields);
18 MEM_VECTOR_MAKE(ast_function*, functions);
19 MEM_VECTOR_MAKE(ast_value*, imm_float);
20 MEM_VECTOR_MAKE(ast_value*, imm_string);
21 MEM_VECTOR_MAKE(ast_value*, imm_vector);
23 ast_value *imm_float_zero;
24 ast_value *imm_vector_zero;
26 ast_function *function;
27 MEM_VECTOR_MAKE(varentry_t, locals);
32 /* TYPE_FIELD -> parser_find_fields is used instead of find_var
33 * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard
34 * anything else: type error
39 MEM_VEC_FUNCTIONS(parser_t, varentry_t, globals)
40 MEM_VEC_FUNCTIONS(parser_t, varentry_t, fields)
41 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_float)
42 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_string)
43 MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector)
44 MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals)
45 MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions)
47 static void parser_pop_local(parser_t *parser);
48 static bool parser_variable(parser_t *parser, ast_block *localblock);
49 static ast_block* parser_parse_block(parser_t *parser);
50 static ast_expression* parser_parse_statement_or_block(parser_t *parser);
51 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma);
52 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma);
54 void parseerror(parser_t *parser, const char *fmt, ...)
61 vprintmsg(LVL_ERROR, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "parse error", fmt, ap);
67 /* returns true if it counts as an error */
68 bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
71 int lvl = LVL_WARNING;
73 if (!OPTS_WARN(warntype))
76 if (OPTS_WARN(WARN_ERROR)) {
82 vprintmsg(lvl, parser->lex->tok->ctx.file, parser->lex->tok->ctx.line, "warning", fmt, ap);
85 return OPTS_WARN(WARN_ERROR);
88 /**********************************************************************
89 * some maths used for constant folding
92 vector vec3_add(vector a, vector b)
101 vector vec3_sub(vector a, vector b)
110 qcfloat vec3_mulvv(vector a, vector b)
112 return (a.x * b.x + a.y * b.y + a.z * b.z);
115 vector vec3_mulvf(vector a, float b)
124 /**********************************************************************
128 bool parser_next(parser_t *parser)
130 /* lex_do kills the previous token */
131 parser->tok = lex_do(parser->lex);
132 if (parser->tok == TOKEN_EOF || parser->tok >= TOKEN_ERROR)
137 /* lift a token out of the parser so it's not destroyed by parser_next */
138 token *parser_lift(parser_t *parser)
140 token *tok = parser->lex->tok;
141 parser->lex->tok = NULL;
145 #define parser_tokval(p) (p->lex->tok->value)
146 #define parser_token(p) (p->lex->tok)
147 #define parser_ctx(p) (p->lex->tok->ctx)
149 ast_value* parser_const_float(parser_t *parser, double d)
153 for (i = 0; i < parser->imm_float_count; ++i) {
154 if (parser->imm_float[i]->constval.vfloat == d)
155 return parser->imm_float[i];
157 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT);
159 out->constval.vfloat = d;
160 if (!parser_t_imm_float_add(parser, out)) {
161 ast_value_delete(out);
167 ast_value* parser_const_float_0(parser_t *parser)
169 if (!parser->imm_float_zero)
170 parser->imm_float_zero = parser_const_float(parser, 0);
171 return parser->imm_float_zero;
174 ast_value* parser_const_string(parser_t *parser, const char *str)
178 for (i = 0; i < parser->imm_string_count; ++i) {
179 if (!strcmp(parser->imm_string[i]->constval.vstring, str))
180 return parser->imm_string[i];
182 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING);
184 out->constval.vstring = util_strdup(str);
185 if (!parser_t_imm_string_add(parser, out)) {
186 ast_value_delete(out);
192 ast_value* parser_const_vector(parser_t *parser, vector v)
196 for (i = 0; i < parser->imm_vector_count; ++i) {
197 if (!memcmp(&parser->imm_vector[i]->constval.vvec, &v, sizeof(v)))
198 return parser->imm_vector[i];
200 out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR);
202 out->constval.vvec = v;
203 if (!parser_t_imm_vector_add(parser, out)) {
204 ast_value_delete(out);
210 ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z)
216 return parser_const_vector(parser, v);
219 ast_value* parser_const_vector_0(parser_t *parser)
221 if (!parser->imm_vector_zero)
222 parser->imm_vector_zero = parser_const_vector_f(parser, 0, 0, 0);
223 return parser->imm_vector_zero;
226 ast_expression* parser_find_field(parser_t *parser, const char *name)
229 for (i = 0; i < parser->fields_count; ++i) {
230 if (!strcmp(parser->fields[i].name, name))
231 return parser->fields[i].var;
236 ast_expression* parser_find_global(parser_t *parser, const char *name)
239 for (i = 0; i < parser->globals_count; ++i) {
240 if (!strcmp(parser->globals[i].name, name))
241 return parser->globals[i].var;
246 ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto)
250 for (i = parser->locals_count; i > upto;) {
252 if (!strcmp(parser->locals[i].name, name))
253 return parser->locals[i].var;
255 if (!parser->function)
257 fun = parser->function->vtype;
258 for (i = 0; i < fun->expression.params_count; ++i) {
259 if (!strcmp(fun->expression.params[i]->name, name))
260 return (ast_expression*)(fun->expression.params[i]);
265 ast_expression* parser_find_var(parser_t *parser, const char *name)
268 v = parser_find_local(parser, name, 0);
269 if (!v) v = parser_find_global(parser, name);
274 MEM_VECTOR_MAKE(ast_value*, p);
276 MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p)
278 static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc)
282 lex_ctx ctx = parser_ctx(parser);
283 int vtype = basetype;
287 MEM_VECTOR_INIT(¶ms, p);
291 if (parser->tok == '(') {
297 if (!parser_next(parser))
300 if (parser->tok == ')')
303 temptype = parser_token(parser)->constval.t;
304 if (!parser_next(parser))
307 param = parser_parse_type(parser, temptype, &dummy);
313 if (parser->tok == TOKEN_IDENT) {
314 /* named parameter */
315 if (!ast_value_set_name(param, parser_tokval(parser)))
317 if (!parser_next(parser))
321 if (!paramlist_t_p_add(¶ms, param)) {
322 parseerror(parser, "Out of memory while parsing typename");
326 if (parser->tok == ',')
328 if (parser->tok == ')')
330 parseerror(parser, "Unexpected token");
333 if (!parser_next(parser))
337 var = ast_value_new(ctx, "<unnamed>", vtype);
340 MEM_VECTOR_MOVE(¶ms, p, &var->expression, params);
343 for (i = 0; i < params.p_count; ++i)
344 ast_value_delete(params.p[i]);
345 MEM_VECTOR_CLEAR(¶ms, p);
351 size_t etype; /* 0 = expression, others are operators */
355 ast_block *block; /* for commas and function calls */
360 MEM_VECTOR_MAKE(sy_elem, out);
361 MEM_VECTOR_MAKE(sy_elem, ops);
363 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
364 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
366 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
376 static sy_elem syblock(lex_ctx ctx, ast_block *v) {
379 e.out = (ast_expression*)v;
386 static sy_elem syop(lex_ctx ctx, const oper_info *op) {
388 e.etype = 1 + (op - operators);
396 static sy_elem syparen(lex_ctx ctx, int p, size_t off) {
408 # define DEBUGSHUNTDO(x) x
410 # define DEBUGSHUNTDO(x)
413 static bool parser_sy_pop(parser_t *parser, shunt *sy)
417 ast_expression *out = NULL;
418 ast_expression *exprs[3];
419 ast_block *blocks[3];
420 ast_value *asvalue[3];
422 qcint generated_op = 0;
424 if (!sy->ops_count) {
425 parseerror(parser, "internal error: missing operator");
429 if (sy->ops[sy->ops_count-1].paren) {
430 parseerror(parser, "unmatched parenthesis");
434 op = &operators[sy->ops[sy->ops_count-1].etype - 1];
435 ctx = sy->ops[sy->ops_count-1].ctx;
437 DEBUGSHUNTDO(printf("apply %s\n", op->op));
439 if (sy->out_count < op->operands) {
440 parseerror(parser, "internal error: not enough operands: %i (operator %s (%i))", sy->out_count,
441 op->op, (int)op->id);
447 sy->out_count -= op->operands;
448 for (i = 0; i < op->operands; ++i) {
449 exprs[i] = sy->out[sy->out_count+i].out;
450 blocks[i] = sy->out[sy->out_count+i].block;
451 asvalue[i] = (ast_value*)exprs[i];
454 if (blocks[0] && !blocks[0]->exprs_count && op->id != opid1(',')) {
455 parseerror(parser, "internal error: operator cannot be applied on empty blocks");
459 #define NotSameType(T) \
460 (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \
461 exprs[0]->expression.vtype != T)
462 #define CanConstFold1(A) \
463 (ast_istype((A), ast_value) && ((ast_value*)(A))->isconst)
464 #define CanConstFold(A, B) \
465 (CanConstFold1(A) && CanConstFold1(B))
466 #define ConstV(i) (asvalue[(i)]->constval.vvec)
467 #define ConstF(i) (asvalue[(i)]->constval.vfloat)
471 parseerror(parser, "internal error: unhandled operand");
475 if (exprs[0]->expression.vtype == TYPE_ENTITY) {
476 if (exprs[1]->expression.vtype != TYPE_FIELD) {
477 parseerror(parser, "type error: right hand of member-operand should be an entity-field");
480 out = (ast_expression*)ast_entfield_new(ctx, exprs[0], exprs[1]);
482 else if (exprs[0]->expression.vtype == TYPE_VECTOR) {
483 parseerror(parser, "internal error: vector access is not supposed to be handled at this point");
487 parseerror(parser, "type error: member-of operator on something that is not an entity or vector");
494 if (!ast_block_exprs_add(blocks[0], exprs[1]))
497 blocks[0] = ast_block_new(ctx);
498 if (!ast_block_exprs_add(blocks[0], exprs[0]) ||
499 !ast_block_exprs_add(blocks[0], exprs[1]))
504 if (!ast_block_set_type(blocks[0], exprs[1]))
507 sy->out[sy->out_count++] = syblock(ctx, blocks[0]);
511 switch (exprs[0]->expression.vtype) {
513 if (CanConstFold1(exprs[0]))
514 out = (ast_expression*)parser_const_float(parser, -ConstF(0));
516 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F,
517 (ast_expression*)parser_const_float_0(parser),
521 if (CanConstFold1(exprs[0]))
522 out = (ast_expression*)parser_const_vector_f(parser,
523 -ConstV(0).x, -ConstV(0).y, -ConstV(0).z);
525 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V,
526 (ast_expression*)parser_const_vector_0(parser),
530 parseerror(parser, "invalid types used in expression: cannot negate type %s",
531 type_name[exprs[0]->expression.vtype]);
537 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
538 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
540 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
541 type_name[exprs[0]->expression.vtype],
542 type_name[exprs[1]->expression.vtype]);
545 switch (exprs[0]->expression.vtype) {
547 if (CanConstFold(exprs[0], exprs[1]))
549 out = (ast_expression*)parser_const_float(parser, ConstF(0) + ConstF(1));
552 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_F, exprs[0], exprs[1]);
555 if (CanConstFold(exprs[0], exprs[1]))
556 out = (ast_expression*)parser_const_vector(parser, vec3_add(ConstV(0), ConstV(1)));
558 out = (ast_expression*)ast_binary_new(ctx, INSTR_ADD_V, exprs[0], exprs[1]);
561 parseerror(parser, "invalid types used in expression: cannot add type %s and %s",
562 type_name[exprs[0]->expression.vtype],
563 type_name[exprs[1]->expression.vtype]);
568 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
569 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
571 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
572 type_name[exprs[1]->expression.vtype],
573 type_name[exprs[0]->expression.vtype]);
576 switch (exprs[0]->expression.vtype) {
578 if (CanConstFold(exprs[0], exprs[1]))
579 out = (ast_expression*)parser_const_float(parser, ConstF(0) - ConstF(1));
581 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_F, exprs[0], exprs[1]);
584 if (CanConstFold(exprs[0], exprs[1]))
585 out = (ast_expression*)parser_const_vector(parser, vec3_sub(ConstV(0), ConstV(1)));
587 out = (ast_expression*)ast_binary_new(ctx, INSTR_SUB_V, exprs[0], exprs[1]);
590 parseerror(parser, "invalid types used in expression: cannot subtract type %s from %s",
591 type_name[exprs[1]->expression.vtype],
592 type_name[exprs[0]->expression.vtype]);
597 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype &&
598 exprs[0]->expression.vtype != TYPE_VECTOR &&
599 exprs[0]->expression.vtype != TYPE_FLOAT &&
600 exprs[1]->expression.vtype != TYPE_VECTOR &&
601 exprs[1]->expression.vtype != TYPE_FLOAT)
603 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
604 type_name[exprs[1]->expression.vtype],
605 type_name[exprs[0]->expression.vtype]);
608 switch (exprs[0]->expression.vtype) {
610 if (exprs[1]->expression.vtype == TYPE_VECTOR)
612 if (CanConstFold(exprs[0], exprs[1]))
613 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(1), ConstF(0)));
615 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_FV, exprs[0], exprs[1]);
619 if (CanConstFold(exprs[0], exprs[1]))
620 out = (ast_expression*)parser_const_float(parser, ConstF(0) * ConstF(1));
622 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_F, exprs[0], exprs[1]);
626 if (exprs[1]->expression.vtype == TYPE_FLOAT)
628 if (CanConstFold(exprs[0], exprs[1]))
629 out = (ast_expression*)parser_const_vector(parser, vec3_mulvf(ConstV(0), ConstF(1)));
631 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_VF, exprs[0], exprs[1]);
635 if (CanConstFold(exprs[0], exprs[1]))
636 out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1)));
638 out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]);
642 parseerror(parser, "invalid types used in expression: cannot multiply types %s and %s",
643 type_name[exprs[1]->expression.vtype],
644 type_name[exprs[0]->expression.vtype]);
649 if (NotSameType(TYPE_FLOAT)) {
650 parseerror(parser, "invalid types used in expression: cannot divide types %s and %s",
651 type_name[exprs[0]->expression.vtype],
652 type_name[exprs[1]->expression.vtype]);
655 if (CanConstFold(exprs[0], exprs[1]))
656 out = (ast_expression*)parser_const_float(parser, ConstF(0) / ConstF(1));
658 out = (ast_expression*)ast_binary_new(ctx, INSTR_DIV_F, exprs[0], exprs[1]);
662 parseerror(parser, "qc does not have a modulo operator");
666 if (NotSameType(TYPE_FLOAT)) {
667 parseerror(parser, "invalid types used in expression: cannot perform bit operations between types %s and %s",
668 type_name[exprs[0]->expression.vtype],
669 type_name[exprs[1]->expression.vtype]);
672 if (CanConstFold(exprs[0], exprs[1]))
673 out = (ast_expression*)parser_const_float(parser,
674 (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) :
675 (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) ));
677 out = (ast_expression*)ast_binary_new(ctx,
678 (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND),
682 parseerror(parser, "TODO: bitxor");
687 case opid3('<','<','='):
688 case opid3('>','>','='):
689 parseerror(parser, "TODO: shifts");
693 generated_op += 1; /* INSTR_OR */
695 generated_op += INSTR_AND;
696 if (NotSameType(TYPE_FLOAT)) {
697 parseerror(parser, "invalid types used in expression: cannot perform logical operations between types %s and %s",
698 type_name[exprs[0]->expression.vtype],
699 type_name[exprs[1]->expression.vtype]);
700 parseerror(parser, "TODO: logical ops for arbitrary types using INSTR_NOT");
701 parseerror(parser, "TODO: optional early out");
704 if (opts_standard == COMPILER_GMQCC)
705 printf("TODO: early out logic\n");
706 if (CanConstFold(exprs[0], exprs[1]))
707 out = (ast_expression*)parser_const_float(parser,
708 (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
710 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
714 generated_op += 1; /* INSTR_GT */
716 generated_op += 1; /* INSTR_LT */
717 case opid2('>', '='):
718 generated_op += 1; /* INSTR_GE */
719 case opid2('<', '='):
720 generated_op += INSTR_LE;
721 if (NotSameType(TYPE_FLOAT)) {
722 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
723 type_name[exprs[0]->expression.vtype],
724 type_name[exprs[1]->expression.vtype]);
727 out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
729 case opid2('!', '='):
730 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
731 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
732 type_name[exprs[0]->expression.vtype],
733 type_name[exprs[1]->expression.vtype]);
736 out = (ast_expression*)ast_binary_new(ctx, type_ne_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
738 case opid2('=', '='):
739 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype) {
740 parseerror(parser, "invalid types used in expression: cannot perform comparison between types %s and %s",
741 type_name[exprs[0]->expression.vtype],
742 type_name[exprs[1]->expression.vtype]);
745 out = (ast_expression*)ast_binary_new(ctx, type_eq_instr[exprs[0]->expression.vtype], exprs[0], exprs[1]);
749 if (ast_istype(exprs[0], ast_entfield))
750 assignop = type_storep_instr[exprs[0]->expression.vtype];
752 assignop = type_store_instr[exprs[0]->expression.vtype];
753 out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]);
757 if (exprs[0]->expression.vtype != exprs[1]->expression.vtype ||
758 (exprs[0]->expression.vtype != TYPE_VECTOR && exprs[0]->expression.vtype != TYPE_FLOAT) )
760 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
761 type_name[exprs[0]->expression.vtype],
762 type_name[exprs[1]->expression.vtype]);
765 if (ast_istype(exprs[0], ast_entfield))
766 assignop = type_storep_instr[exprs[0]->expression.vtype];
768 assignop = type_store_instr[exprs[0]->expression.vtype];
769 switch (exprs[0]->expression.vtype) {
771 out = (ast_expression*)ast_binstore_new(ctx, assignop,
772 (op->id == opid2('+','=') ? INSTR_ADD_F : INSTR_SUB_F),
776 out = (ast_expression*)ast_binstore_new(ctx, assignop,
777 (op->id == opid2('+','=') ? INSTR_ADD_V : INSTR_SUB_V),
781 parseerror(parser, "invalid types used in expression: cannot add or subtract type %s and %s",
782 type_name[exprs[0]->expression.vtype],
783 type_name[exprs[1]->expression.vtype]);
791 parseerror(parser, "failed to apply operand %s", op->op);
795 DEBUGSHUNTDO(printf("applied %s\n", op->op));
796 sy->out[sy->out_count++] = syexp(ctx, out);
800 static bool parser_close_call(parser_t *parser, shunt *sy)
802 /* was a function call */
810 fid = sy->ops[sy->ops_count].off;
812 /* out[fid] is the function
813 * everything above is parameters...
815 * 1 params = ast_expression
819 if (sy->out_count < 1 || sy->out_count <= fid) {
820 parseerror(parser, "internal error: function call needs function and parameter list...");
824 fun = sy->out[fid].out;
826 call = ast_call_new(sy->ops[sy->ops_count].ctx, fun);
828 parseerror(parser, "out of memory");
832 if (fid+1 == sy->out_count) {
835 } else if (fid+2 == sy->out_count) {
838 params = sy->out[sy->out_count].block;
842 if (!ast_call_params_add(call, sy->out[sy->out_count].out)) {
843 ast_delete(sy->out[sy->out_count].out);
844 parseerror(parser, "out of memory");
848 paramcount = params->exprs_count;
849 MEM_VECTOR_MOVE(params, exprs, call, params);
853 parseerror(parser, "invalid function call");
857 /* overwrite fid, the function, with a call */
858 sy->out[fid] = syexp(call->expression.node.context, (ast_expression*)call);
860 if (fun->expression.vtype != TYPE_FUNCTION) {
861 parseerror(parser, "not a function");
865 if (!fun->expression.next) {
866 parseerror(parser, "could not determine function return type");
869 if (fun->expression.params_count != paramcount) {
870 parseerror(parser, "expected %i parameters, got %i", (int)fun->expression.params_count, paramcount);
878 static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
880 if (!sy->ops_count) {
881 parseerror(parser, "unmatched closing paren");
884 if (sy->ops[sy->ops_count-1].paren == 1) {
885 parseerror(parser, "empty parenthesis expression");
888 while (sy->ops_count) {
889 if (sy->ops[sy->ops_count-1].paren == 'f') {
890 if (!parser_close_call(parser, sy))
894 if (sy->ops[sy->ops_count-1].paren == 1) {
896 return !functions_only;
898 if (!parser_sy_pop(parser, sy))
904 static void parser_reclassify_token(parser_t *parser)
907 for (i = 0; i < operator_count; ++i) {
908 if (!strcmp(parser_tokval(parser), operators[i].op)) {
909 parser->tok = TOKEN_OPERATOR;
915 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma)
917 ast_expression *expr = NULL;
920 bool gotmemberof = false;
922 /* count the parens because an if starts with one, so the
923 * end of a condition is an unmatched closing paren
927 MEM_VECTOR_INIT(&sy, out);
928 MEM_VECTOR_INIT(&sy, ops);
930 parser->lex->flags.noops = false;
932 parser_reclassify_token(parser);
939 parser->memberof = 0;
941 if (parser->tok == TOKEN_IDENT)
945 parseerror(parser, "expected operator or end of statement");
950 if (opts_standard == COMPILER_GMQCC)
952 if (parser->memberof == TYPE_ENTITY)
953 var = parser_find_field(parser, parser_tokval(parser));
954 else if (parser->memberof == TYPE_VECTOR)
956 parseerror(parser, "TODO: implement effective vector member access");
959 else if (parser->memberof) {
960 parseerror(parser, "namespace for member not found");
964 var = parser_find_var(parser, parser_tokval(parser));
966 var = parser_find_var(parser, parser_tokval(parser));
968 var = parser_find_field(parser, parser_tokval(parser));
971 parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
974 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
975 parseerror(parser, "out of memory");
978 DEBUGSHUNTDO(printf("push %s\n", parser_tokval(parser)));
980 else if (parser->tok == TOKEN_FLOATCONST) {
983 parseerror(parser, "expected operator or end of statement, got constant");
987 val = parser_const_float(parser, (parser_token(parser)->constval.f));
990 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
991 parseerror(parser, "out of memory");
994 DEBUGSHUNTDO(printf("push %g\n", parser_token(parser)->constval.f));
996 else if (parser->tok == TOKEN_INTCONST) {
999 parseerror(parser, "expected operator or end of statement, got constant");
1003 val = parser_const_float(parser, (double)(parser_token(parser)->constval.i));
1006 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1007 parseerror(parser, "out of memory");
1010 DEBUGSHUNTDO(printf("push %i\n", parser_token(parser)->constval.i));
1012 else if (parser->tok == TOKEN_STRINGCONST) {
1015 parseerror(parser, "expected operator or end of statement, got constant");
1019 val = parser_const_string(parser, parser_tokval(parser));
1022 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1023 parseerror(parser, "out of memory");
1026 DEBUGSHUNTDO(printf("push string\n"));
1028 else if (parser->tok == TOKEN_VECTORCONST) {
1031 parseerror(parser, "expected operator or end of statement, got constant");
1035 val = parser_const_vector(parser, parser_token(parser)->constval.v);
1038 if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)val))) {
1039 parseerror(parser, "out of memory");
1042 DEBUGSHUNTDO(printf("push '%g %g %g'\n",
1043 parser_token(parser)->constval.v.x,
1044 parser_token(parser)->constval.v.y,
1045 parser_token(parser)->constval.v.z));
1047 else if (parser->tok == '(') {
1049 DEBUGSHUNTDO(printf("push (\n"));
1051 /* we expected an operator, this is the function-call operator */
1052 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
1053 parseerror(parser, "out of memory");
1058 if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
1059 parseerror(parser, "out of memory");
1062 DEBUGSHUNTDO(printf("push (\n"));
1066 else if (parser->tok == ')') {
1068 DEBUGSHUNTDO(printf("do[op] )\n"));
1072 /* we do expect an operator next */
1073 /* closing an opening paren */
1074 if (!parser_close_paren(parser, &sy, false))
1077 DEBUGSHUNTDO(printf("do[nop] )\n"));
1081 /* allowed for function calls */
1082 if (!parser_close_paren(parser, &sy, true))
1087 else if (parser->tok != TOKEN_OPERATOR) {
1089 parseerror(parser, "expected operator or end of statement");
1096 /* classify the operator */
1097 /* TODO: suffix operators */
1098 const oper_info *op;
1099 const oper_info *olast = NULL;
1101 for (o = 0; o < operator_count; ++o) {
1102 if ((!(operators[o].flags & OP_PREFIX) == wantop) &&
1103 !(operators[o].flags & OP_SUFFIX) && /* remove this */
1104 !strcmp(parser_tokval(parser), operators[o].op))
1110 if (o == operator_count) {
1111 /* no operator found... must be the end of the statement */
1114 /* found an operator */
1117 /* when declaring variables, a comma starts a new variable */
1118 if (op->id == opid1(',') && !parens && stopatcomma)
1121 if (op->id == opid1('.')) {
1122 /* for gmqcc standard: open up the namespace of the previous type */
1123 ast_expression *prevex = sy.out[sy.out_count-1].out;
1125 parseerror(parser, "unexpected member operator");
1128 if (prevex->expression.vtype == TYPE_ENTITY)
1129 parser->memberof = TYPE_ENTITY;
1130 else if (prevex->expression.vtype == TYPE_VECTOR)
1131 parser->memberof = TYPE_VECTOR;
1133 parseerror(parser, "type error: type has no members");
1139 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1140 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1143 (op->prec < olast->prec) ||
1144 (op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
1146 if (!parser_sy_pop(parser, &sy))
1148 if (sy.ops_count && !sy.ops[sy.ops_count-1].paren)
1149 olast = &operators[sy.ops[sy.ops_count-1].etype-1];
1154 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
1155 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
1158 if (!parser_next(parser)) {
1161 if (parser->tok == ';') {
1166 while (sy.ops_count) {
1167 if (!parser_sy_pop(parser, &sy))
1171 parser->lex->flags.noops = true;
1172 if (!sy.out_count) {
1173 parseerror(parser, "empty expression");
1176 expr = sy.out[0].out;
1177 MEM_VECTOR_CLEAR(&sy, out);
1178 MEM_VECTOR_CLEAR(&sy, ops);
1179 DEBUGSHUNTDO(printf("shunt done\n"));
1183 parser->lex->flags.noops = true;
1184 MEM_VECTOR_CLEAR(&sy, out);
1185 MEM_VECTOR_CLEAR(&sy, ops);
1189 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
1191 ast_expression *e = parser_expression_leave(parser, stopatcomma);
1194 if (!parser_next(parser)) {
1201 static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
1204 ast_expression *cond, *ontrue, *onfalse = NULL;
1206 lex_ctx ctx = parser_ctx(parser);
1208 /* skip the 'if' and check for opening paren */
1209 if (!parser_next(parser) || parser->tok != '(') {
1210 parseerror(parser, "expected 'if' condition in parenthesis");
1213 /* parse into the expression */
1214 if (!parser_next(parser)) {
1215 parseerror(parser, "expected 'if' condition after opening paren");
1218 /* parse the condition */
1219 cond = parser_expression_leave(parser, false);
1223 if (parser->tok != ')') {
1224 parseerror(parser, "expected closing paren after 'if' condition");
1228 /* parse into the 'then' branch */
1229 if (!parser_next(parser)) {
1230 parseerror(parser, "expected statement for on-true branch of 'if'");
1234 ontrue = parser_parse_statement_or_block(parser);
1239 /* check for an else */
1240 if (!strcmp(parser_tokval(parser), "else")) {
1241 /* parse into the 'else' branch */
1242 if (!parser_next(parser)) {
1243 parseerror(parser, "expected on-false branch after 'else'");
1248 onfalse = parser_parse_statement_or_block(parser);
1256 ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
1257 *out = (ast_expression*)ifthen;
1261 static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
1264 ast_expression *cond, *ontrue;
1266 lex_ctx ctx = parser_ctx(parser);
1268 /* skip the 'while' and check for opening paren */
1269 if (!parser_next(parser) || parser->tok != '(') {
1270 parseerror(parser, "expected 'while' condition in parenthesis");
1273 /* parse into the expression */
1274 if (!parser_next(parser)) {
1275 parseerror(parser, "expected 'while' condition after opening paren");
1278 /* parse the condition */
1279 cond = parser_expression_leave(parser, false);
1283 if (parser->tok != ')') {
1284 parseerror(parser, "expected closing paren after 'while' condition");
1288 /* parse into the 'then' branch */
1289 if (!parser_next(parser)) {
1290 parseerror(parser, "expected while-loop body");
1294 ontrue = parser_parse_statement_or_block(parser);
1300 aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
1301 *out = (ast_expression*)aloop;
1305 static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
1308 ast_expression *cond, *ontrue;
1310 lex_ctx ctx = parser_ctx(parser);
1312 /* skip the 'do' and get the body */
1313 if (!parser_next(parser)) {
1314 parseerror(parser, "expected loop body");
1317 ontrue = parser_parse_statement_or_block(parser);
1321 /* expect the "while" */
1322 if (parser->tok != TOKEN_KEYWORD ||
1323 strcmp(parser_tokval(parser), "while"))
1325 parseerror(parser, "expected 'while' and condition");
1330 /* skip the 'while' and check for opening paren */
1331 if (!parser_next(parser) || parser->tok != '(') {
1332 parseerror(parser, "expected 'while' condition in parenthesis");
1336 /* parse into the expression */
1337 if (!parser_next(parser)) {
1338 parseerror(parser, "expected 'while' condition after opening paren");
1342 /* parse the condition */
1343 cond = parser_expression_leave(parser, false);
1347 if (parser->tok != ')') {
1348 parseerror(parser, "expected closing paren after 'while' condition");
1354 if (!parser_next(parser) || parser->tok != ';') {
1355 parseerror(parser, "expected semicolon after condition");
1361 if (!parser_next(parser)) {
1362 parseerror(parser, "parse error");
1368 aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
1369 *out = (ast_expression*)aloop;
1373 static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
1376 ast_expression *initexpr, *cond, *increment, *ontrue;
1377 size_t oldblocklocal;
1379 lex_ctx ctx = parser_ctx(parser);
1381 oldblocklocal = parser->blocklocal;
1382 parser->blocklocal = parser->locals_count;
1389 /* skip the 'while' and check for opening paren */
1390 if (!parser_next(parser) || parser->tok != '(') {
1391 parseerror(parser, "expected 'for' expressions in parenthesis");
1394 /* parse into the expression */
1395 if (!parser_next(parser)) {
1396 parseerror(parser, "expected 'for' initializer after opening paren");
1400 if (parser->tok == TOKEN_TYPENAME) {
1401 if (opts_standard != COMPILER_GMQCC) {
1402 if (parsewarning(parser, WARN_EXTENSIONS,
1403 "current standard does not allow variable declarations in for-loop initializers"))
1407 parseerror(parser, "TODO: assignment of new variables to be non-const");
1409 if (!parser_variable(parser, block))
1412 else if (parser->tok != ';')
1414 initexpr = parser_expression_leave(parser, false);
1419 /* move on to condition */
1420 if (parser->tok != ';') {
1421 parseerror(parser, "expected semicolon after for-loop initializer");
1424 if (!parser_next(parser)) {
1425 parseerror(parser, "expected for-loop condition");
1429 /* parse the condition */
1430 if (parser->tok != ';') {
1431 cond = parser_expression_leave(parser, false);
1436 /* move on to incrementor */
1437 if (parser->tok != ';') {
1438 parseerror(parser, "expected semicolon after for-loop initializer");
1441 if (!parser_next(parser)) {
1442 parseerror(parser, "expected for-loop condition");
1446 /* parse the incrementor */
1447 if (parser->tok != ')') {
1448 increment = parser_expression_leave(parser, false);
1454 if (parser->tok != ')') {
1455 parseerror(parser, "expected closing paren after 'for-loop' incrementor");
1458 /* parse into the 'then' branch */
1459 if (!parser_next(parser)) {
1460 parseerror(parser, "expected for-loop body");
1463 ontrue = parser_parse_statement_or_block(parser);
1468 aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
1469 *out = (ast_expression*)aloop;
1471 while (parser->locals_count > parser->blocklocal)
1472 parser_pop_local(parser);
1473 parser->blocklocal = oldblocklocal;
1476 if (initexpr) ast_delete(initexpr);
1477 if (cond) ast_delete(cond);
1478 if (increment) ast_delete(increment);
1479 while (parser->locals_count > parser->blocklocal)
1480 parser_pop_local(parser);
1481 parser->blocklocal = oldblocklocal;
1485 static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)
1487 if (parser->tok == TOKEN_TYPENAME)
1489 /* local variable */
1491 parseerror(parser, "cannot declare a variable from here");
1494 if (opts_standard == COMPILER_QCC) {
1495 if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
1498 if (!parser_variable(parser, block))
1503 else if (parser->tok == TOKEN_KEYWORD)
1505 if (!strcmp(parser_tokval(parser), "local"))
1508 parseerror(parser, "cannot declare a local variable here");
1511 if (!parser_next(parser)) {
1512 parseerror(parser, "expected variable declaration");
1515 if (!parser_variable(parser, block))
1520 else if (!strcmp(parser_tokval(parser), "return"))
1522 ast_expression *exp = NULL;
1523 ast_return *ret = NULL;
1524 ast_value *expected = parser->function->vtype;
1526 if (!parser_next(parser)) {
1527 parseerror(parser, "expected return expression");
1531 if (parser->tok != ';') {
1532 exp = parser_expression(parser, false);
1536 if (exp->expression.vtype != expected->expression.next->expression.vtype) {
1537 parseerror(parser, "return with invalid expression");
1540 ret = ast_return_new(exp->expression.node.context, exp);
1546 *out = (ast_expression*)ret;
1547 } else if (!parser_next(parser)) {
1548 parseerror(parser, "expected semicolon");
1549 if (expected->expression.next->expression.vtype != TYPE_VOID) {
1550 parseerror(parser, "return without value");
1555 else if (!strcmp(parser_tokval(parser), "if"))
1557 return parser_parse_if(parser, block, out);
1559 else if (!strcmp(parser_tokval(parser), "while"))
1561 return parser_parse_while(parser, block, out);
1563 else if (!strcmp(parser_tokval(parser), "do"))
1565 return parser_parse_dowhile(parser, block, out);
1567 else if (!strcmp(parser_tokval(parser), "for"))
1569 if (opts_standard == COMPILER_QCC) {
1570 if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
1573 return parser_parse_for(parser, block, out);
1575 parseerror(parser, "Unexpected keyword");
1578 else if (parser->tok == '{')
1581 inner = parser_parse_block(parser);
1584 *out = (ast_expression*)inner;
1589 ast_expression *exp = parser_expression(parser, false);
1597 static void parser_pop_local(parser_t *parser)
1599 parser->locals_count--;
1600 mem_d(parser->locals[parser->locals_count].name);
1603 static ast_block* parser_parse_block(parser_t *parser)
1605 size_t oldblocklocal;
1606 ast_block *block = NULL;
1608 oldblocklocal = parser->blocklocal;
1609 parser->blocklocal = parser->locals_count;
1611 if (!parser_next(parser)) { /* skip the '{' */
1612 parseerror(parser, "expected function body");
1616 block = ast_block_new(parser_ctx(parser));
1618 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
1620 ast_expression *expr;
1621 if (parser->tok == '}')
1624 if (!parser_parse_statement(parser, block, &expr)) {
1625 ast_block_delete(block);
1631 if (!ast_block_exprs_add(block, expr)) {
1633 ast_block_delete(block);
1639 if (parser->tok != '}') {
1640 ast_block_delete(block);
1643 (void)parser_next(parser);
1647 while (parser->locals_count > parser->blocklocal)
1648 parser_pop_local(parser);
1649 parser->blocklocal = oldblocklocal;
1650 /* unroll the local vector */
1654 static ast_expression* parser_parse_statement_or_block(parser_t *parser)
1656 ast_expression *expr;
1657 if (parser->tok == '{')
1658 return (ast_expression*)parser_parse_block(parser);
1659 if (!parser_parse_statement(parser, NULL, &expr))
1664 static bool parser_variable(parser_t *parser, ast_block *localblock)
1666 bool isfunc = false;
1667 ast_function *func = NULL;
1671 ast_expression *olddecl;
1673 int basetype = parser_token(parser)->constval.t;
1677 if (!parser_next(parser)) { /* skip basetype or comma */
1678 parseerror(parser, "expected variable declaration");
1685 ctx = parser_ctx(parser);
1686 var = parser_parse_type(parser, basetype, &isfunc);
1691 if (parser->tok != TOKEN_IDENT) {
1692 parseerror(parser, "expected variable name\n");
1697 if (!localblock && (olddecl = parser_find_global(parser, parser_tokval(parser)))) {
1698 ast_value_delete(var);
1699 parseerror(parser, "global %s already declared here: %s:%i\n",
1700 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1704 if (localblock && parser_find_local(parser, parser_tokval(parser), parser->blocklocal)) {
1705 ast_value_delete(var);
1706 parseerror(parser, "local %s already declared here: %s:%i\n",
1707 parser_tokval(parser), ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line);
1712 if (!ast_value_set_name(var, parser_tokval(parser))) {
1713 parseerror(parser, "failed to set variable name\n");
1714 ast_value_delete(var);
1719 /* a function was defined */
1721 ast_value *proto = NULL;
1724 olddecl = parser_find_global(parser, parser_tokval(parser));
1726 olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal);
1729 /* we had a prototype */
1730 if (!ast_istype(olddecl, ast_value)) {
1731 /* theoretically not possible you think?
1737 parseerror(parser, "cannot declare a function with the same name as a vector's member: %s",
1738 parser_tokval(parser));
1739 ast_value_delete(var);
1743 proto = (ast_value*)olddecl;
1746 /* turn var into a value of TYPE_FUNCTION, with the old var
1749 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
1750 func = ast_function_new(ctx, var->name, fval);
1751 if (!fval || !func) {
1752 ast_value_delete(var);
1753 if (fval) ast_value_delete(fval);
1754 if (func) ast_function_delete(func);
1758 fval->expression.next = (ast_expression*)var;
1759 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
1761 /* we compare the type late here, but it's easier than
1762 * messing with the parameter-vector etc. earlier
1765 if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) {
1766 parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i",
1768 ast_ctx(proto).file, ast_ctx(proto).line);
1769 ast_function_delete(func);
1770 ast_value_delete(fval);
1773 ast_function_delete(func);
1774 ast_value_delete(fval);
1776 func = var->constval.vfunc;
1780 if (!parser_t_functions_add(parser, func)) {
1781 ast_function_delete(func);
1782 ast_value_delete(fval);
1790 varent.name = util_strdup(var->name);
1791 varent.var = (ast_expression*)var;
1792 if (var->expression.vtype == TYPE_VECTOR)
1794 size_t len = strlen(varent.name);
1795 varentry_t vx, vy, vz;
1796 vx.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 0);
1797 vy.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 1);
1798 vz.var = (ast_expression*)ast_member_new(var->expression.node.context, (ast_expression*)var, 2);
1799 vx.name = (char*)mem_a(len+3);
1800 vy.name = (char*)mem_a(len+3);
1801 vz.name = (char*)mem_a(len+3);
1802 memcpy(vx.name, varent.name, len);
1803 memcpy(vy.name, varent.name, len);
1804 memcpy(vz.name, varent.name, len);
1805 vx.name[len] = vy.name[len] = vz.name[len] = '_';
1806 vx.name[len+1] = 'x';
1807 vy.name[len+1] = 'y';
1808 vz.name[len+1] = 'z';
1809 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
1812 (void)!parser_t_globals_add(parser, varent);
1813 (void)!parser_t_globals_add(parser, vx);
1814 (void)!parser_t_globals_add(parser, vy);
1815 (void)!parser_t_globals_add(parser, vz);
1817 (void)!parser_t_locals_add(parser, varent);
1818 (void)!parser_t_locals_add(parser, vx);
1819 (void)!parser_t_locals_add(parser, vy);
1820 (void)!parser_t_locals_add(parser, vz);
1825 if ( (!localblock && !parser_t_globals_add(parser, varent)) ||
1826 ( localblock && !parser_t_locals_add(parser, varent)) )
1828 ast_value_delete(var);
1832 if (localblock && !ast_block_locals_add(localblock, var))
1834 parser_pop_local(parser);
1835 ast_value_delete(var);
1839 if (!parser_next(parser)) {
1840 ast_value_delete(var);
1844 if (parser->tok == ';') {
1845 if (!parser_next(parser))
1846 return parser->tok == TOKEN_EOF;
1850 if (parser->tok == ',') {
1855 if (parser->tok != '=') {
1856 parseerror(parser, "expected '=' or ';'");
1860 if (!parser_next(parser))
1863 if (parser->tok == '#') {
1865 parseerror(parser, "cannot declare builtins within functions");
1868 if (!isfunc || !func) {
1869 parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name);
1872 if (!parser_next(parser)) {
1873 parseerror(parser, "expected builtin number");
1876 if (parser->tok != TOKEN_INTCONST) {
1877 parseerror(parser, "builtin number must be an integer constant");
1880 if (parser_token(parser)->constval.i <= 0) {
1881 parseerror(parser, "builtin number must be positive integer greater than zero");
1885 func->builtin = -parser_token(parser)->constval.i;
1887 if (!parser_next(parser))
1889 } else if (parser->tok == '{') {
1892 ast_function *old = parser->function;
1895 parseerror(parser, "cannot declare functions within functions");
1899 parser->function = func;
1900 block = parser_parse_block(parser);
1901 parser->function = old;
1906 if (!ast_function_blocks_add(func, block)) {
1907 ast_block_delete(block);
1911 if (parser->tok == ';')
1912 return parser_next(parser) || parser->tok == TOKEN_EOF;
1913 else if (opts_standard == COMPILER_QCC)
1914 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
1917 ast_expression *cexp;
1920 cexp = parser_expression_leave(parser, true);
1921 cval = (ast_value*)cexp;
1922 if (!ast_istype(cval, ast_value) || !cval->isconst)
1923 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
1926 var->isconst = true;
1927 memcpy(&var->constval, &cval->constval, sizeof(var->constval));
1928 memset(&cval->constval, 0, sizeof(cval->constval));
1933 if (parser->tok == ',') {
1938 if (parser->tok != ';') {
1939 parseerror(parser, "missing semicolon");
1943 (void)parser_next(parser);
1949 static bool parser_do(parser_t *parser)
1951 if (parser->tok == TOKEN_TYPENAME)
1953 return parser_variable(parser, NULL);
1955 else if (parser->tok == TOKEN_KEYWORD)
1957 /* handle 'var' and 'const' */
1960 else if (parser->tok == '.')
1964 bool isfunc = false;
1966 lex_ctx ctx = parser_ctx(parser);
1969 /* entity-member declaration */
1970 if (!parser_next(parser) || parser->tok != TOKEN_TYPENAME) {
1971 parseerror(parser, "expected member variable definition");
1975 /* remember the base/return type */
1976 basetype = parser_token(parser)->constval.t;
1978 /* parse into the declaration */
1979 if (!parser_next(parser)) {
1980 parseerror(parser, "expected field def");
1984 /* parse the field type fully */
1985 var = parser_parse_type(parser, basetype, &isfunc);
1990 /* now the field name */
1991 if (parser->tok != TOKEN_IDENT) {
1992 parseerror(parser, "expected field name");
1997 /* check for an existing field
1998 * in original qc we also have to check for an existing
1999 * global named like the field
2001 if (opts_standard == COMPILER_QCC) {
2002 if (parser_find_global(parser, parser_tokval(parser))) {
2003 parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
2008 if (parser_find_field(parser, parser_tokval(parser))) {
2009 parseerror(parser, "field %s already exists", parser_tokval(parser));
2014 /* if it was a function, turn it into a function */
2017 /* turn var into a value of TYPE_FUNCTION, with the old var
2020 fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
2022 ast_value_delete(var);
2023 ast_value_delete(fval);
2027 fval->expression.next = (ast_expression*)var;
2028 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
2033 /* turn it into a field */
2034 fld = ast_value_new(ctx, parser_tokval(parser), TYPE_FIELD);
2035 fld->expression.next = (ast_expression*)var;
2037 varent.var = (ast_expression*)fld;
2038 varent.name = util_strdup(fld->name);
2039 (void)!parser_t_fields_add(parser, varent);
2041 if (var->expression.vtype == TYPE_VECTOR)
2043 /* create _x, _y and _z fields as well */
2045 varentry_t vx, vy, vz;
2047 len = strlen(varent.name);
2048 vx.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 0);
2049 vy.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 1);
2050 vz.var = (ast_expression*)ast_member_new(ast_ctx(fld), (ast_expression*)fld, 2);
2051 vx.name = (char*)mem_a(len+3);
2052 vy.name = (char*)mem_a(len+3);
2053 vz.name = (char*)mem_a(len+3);
2054 memcpy(vx.name, varent.name, len);
2055 memcpy(vy.name, varent.name, len);
2056 memcpy(vz.name, varent.name, len);
2057 vx.name[len] = vy.name[len] = vz.name[len] = '_';
2058 vx.name[len+1] = 'x';
2059 vy.name[len+1] = 'y';
2060 vz.name[len+1] = 'z';
2061 vx.name[len+2] = vy.name[len+2] = vz.name[len+2] = 0;
2062 (void)!parser_t_fields_add(parser, vx);
2063 (void)!parser_t_fields_add(parser, vy);
2064 (void)!parser_t_fields_add(parser, vz);
2067 if (!parser_next(parser)) {
2068 parseerror(parser, "expected semicolon or another field name");
2071 if (parser->tok == ';')
2073 if (parser->tok != ',' || !parser_next(parser)) {
2074 parseerror(parser, "expected semicolon or another field name");
2079 /* skip the semicolon */
2080 if (!parser_next(parser))
2081 return parser->tok == TOKEN_EOF;
2087 parseerror(parser, "unexpected token: %s", parser->lex->tok->value);
2093 static parser_t *parser;
2097 parser = (parser_t*)mem_a(sizeof(parser_t));
2101 memset(parser, 0, sizeof(*parser));
2105 bool parser_compile(const char *filename)
2107 parser->lex = lex_open(filename);
2109 printf("failed to open file \"%s\"\n", filename);
2113 /* initial lexer/parser state */
2114 parser->lex->flags.noops = true;
2116 if (parser_next(parser))
2118 while (parser->tok != TOKEN_EOF && parser->tok < TOKEN_ERROR)
2120 if (!parser_do(parser)) {
2121 if (parser->tok == TOKEN_EOF)
2122 parseerror(parser, "unexpected eof");
2123 else if (!parser->errors)
2124 parseerror(parser, "parse error\n");
2125 lex_close(parser->lex);
2132 lex_close(parser->lex);
2134 return !parser->errors;
2137 void parser_cleanup()
2140 for (i = 0; i < parser->functions_count; ++i) {
2141 ast_delete(parser->functions[i]);
2143 for (i = 0; i < parser->imm_vector_count; ++i) {
2144 ast_delete(parser->imm_vector[i]);
2146 for (i = 0; i < parser->imm_string_count; ++i) {
2147 ast_delete(parser->imm_string[i]);
2149 for (i = 0; i < parser->imm_float_count; ++i) {
2150 ast_delete(parser->imm_float[i]);
2152 for (i = 0; i < parser->globals_count; ++i) {
2153 ast_delete(parser->globals[i].var);
2154 mem_d(parser->globals[i].name);
2156 MEM_VECTOR_CLEAR(parser, globals);
2161 bool parser_finish(const char *output)
2166 if (!parser->errors)
2168 ir = ir_builder_new("gmqcc_out");
2170 printf("failed to allocate builder\n");
2174 for (i = 0; i < parser->imm_float_count; ++i) {
2175 if (!ast_global_codegen(parser->imm_float[i], ir)) {
2176 printf("failed to generate global %s\n", parser->imm_float[i]->name);
2177 ir_builder_delete(ir);
2181 for (i = 0; i < parser->imm_string_count; ++i) {
2182 if (!ast_global_codegen(parser->imm_string[i], ir)) {
2183 printf("failed to generate global %s\n", parser->imm_string[i]->name);
2184 ir_builder_delete(ir);
2188 for (i = 0; i < parser->imm_vector_count; ++i) {
2189 if (!ast_global_codegen(parser->imm_vector[i], ir)) {
2190 printf("failed to generate global %s\n", parser->imm_vector[i]->name);
2191 ir_builder_delete(ir);
2195 for (i = 0; i < parser->fields_count; ++i) {
2198 if (!ast_istype(parser->fields[i].var, ast_value))
2200 field = (ast_value*)parser->fields[i].var;
2201 isconst = field->isconst;
2202 field->isconst = false;
2203 if (!ast_global_codegen((ast_value*)field, ir)) {
2204 printf("failed to generate field %s\n", field->name);
2205 ir_builder_delete(ir);
2210 ast_expression *subtype;
2211 field->isconst = true;
2212 subtype = field->expression.next;
2213 ifld = ir_builder_create_field(ir, field->name, subtype->expression.vtype);
2214 if (subtype->expression.vtype == TYPE_FIELD)
2215 ifld->fieldtype = subtype->expression.next->expression.vtype;
2216 else if (subtype->expression.vtype == TYPE_FUNCTION)
2217 ifld->outtype = subtype->expression.next->expression.vtype;
2218 (void)!ir_value_set_field(field->ir_v, ifld);
2221 for (i = 0; i < parser->globals_count; ++i) {
2222 if (!ast_istype(parser->globals[i].var, ast_value))
2224 if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
2225 printf("failed to generate global %s\n", parser->globals[i].name);
2226 ir_builder_delete(ir);
2230 for (i = 0; i < parser->functions_count; ++i) {
2231 if (!ast_function_codegen(parser->functions[i], ir)) {
2232 printf("failed to generate function %s\n", parser->functions[i]->name);
2233 ir_builder_delete(ir);
2236 if (!ir_function_finalize(parser->functions[i]->ir_func)) {
2237 printf("failed to finalize function %s\n", parser->functions[i]->name);
2238 ir_builder_delete(ir);
2244 ir_builder_dump(ir, printf);
2246 if (!ir_builder_generate(ir, output)) {
2247 printf("*** failed to generate output file\n");
2248 ir_builder_delete(ir);
2252 ir_builder_delete(ir);
2256 printf("*** there were compile errors\n");