BROKEN: more ast nodes converted
[xonotic/gmqcc.git] / parser.cpp
1 #include <string.h>
2 #include <math.h>
3
4 #include "intrin.h"
5 #include "fold.h"
6 #include "ast.h"
7 #include "parser.h"
8
9 #define PARSER_HT_LOCALS  2
10 #define PARSER_HT_SIZE    512
11 #define TYPEDEF_HT_SIZE   512
12
13 static void parser_enterblock(parser_t *parser);
14 static bool parser_leaveblock(parser_t *parser);
15 static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
16 static void parser_addglobal(parser_t *parser, const char *name, ast_expression *e);
17 static bool parse_typedef(parser_t *parser);
18 static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref, bool is_static, uint32_t qflags, char *vstring);
19 static ast_block* parse_block(parser_t *parser);
20 static bool parse_block_into(parser_t *parser, ast_block *block);
21 static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
22 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases);
23 static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma, bool truthvalue, bool with_labels);
24 static ast_expression* parse_expression(parser_t *parser, bool stopatcomma, bool with_labels);
25 static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value *array, const char *funcname);
26 static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname);
27 static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef, bool *is_vararg);
28
29 static void parseerror(parser_t *parser, const char *fmt, ...)
30 {
31     va_list ap;
32     va_start(ap, fmt);
33     vcompile_error(parser->lex->tok.ctx, fmt, ap);
34     va_end(ap);
35 }
36
37 /* returns true if it counts as an error */
38 static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
39 {
40     bool    r;
41     va_list ap;
42     va_start(ap, fmt);
43     r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
44     va_end(ap);
45     return r;
46 }
47
48 /**********************************************************************
49  * parsing
50  */
51
52 static bool parser_next(parser_t *parser)
53 {
54     /* lex_do kills the previous token */
55     parser->tok = lex_do(parser->lex);
56     if (parser->tok == TOKEN_EOF)
57         return true;
58     if (parser->tok >= TOKEN_ERROR) {
59         parseerror(parser, "lex error");
60         return false;
61     }
62     return true;
63 }
64
65 #define parser_tokval(p) ((p)->lex->tok.value)
66 #define parser_token(p)  (&((p)->lex->tok))
67
68 char *parser_strdup(const char *str)
69 {
70     if (str && !*str) {
71         /* actually dup empty strings */
72         char *out = (char*)mem_a(1);
73         *out = 0;
74         return out;
75     }
76     return util_strdup(str);
77 }
78
79 static ast_expression* parser_find_field(parser_t *parser, const char *name)
80 {
81     return ( ast_expression*)util_htget(parser->htfields, name);
82 }
83
84 static ast_expression* parser_find_label(parser_t *parser, const char *name)
85 {
86     for (auto &it : parser->labels)
87         if (!strcmp(it->m_name, name))
88             return (ast_expression*)it;
89     return nullptr;
90 }
91
92 ast_expression* parser_find_global(parser_t *parser, const char *name)
93 {
94     ast_expression *var = (ast_expression*)util_htget(parser->aliases, parser_tokval(parser));
95     if (var)
96         return var;
97     return (ast_expression*)util_htget(parser->htglobals, name);
98 }
99
100 static ast_expression* parser_find_param(parser_t *parser, const char *name)
101 {
102     ast_value *fun;
103     if (!parser->function)
104         return nullptr;
105     fun = parser->function->m_function_type;
106     for (auto &it : fun->m_type_params) {
107         if (!strcmp(it->m_name, name))
108             return (ast_expression*)it;
109     }
110     return nullptr;
111 }
112
113 static ast_expression* parser_find_local(parser_t *parser, const char *name, size_t upto, bool *isparam)
114 {
115     size_t          i, hash;
116     ast_expression *e;
117
118     hash = util_hthash(parser->htglobals, name);
119
120     *isparam = false;
121     for (i = vec_size(parser->variables); i > upto;) {
122         --i;
123         if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) )
124             return e;
125     }
126     *isparam = true;
127     return parser_find_param(parser, name);
128 }
129
130 static ast_expression* parser_find_var(parser_t *parser, const char *name)
131 {
132     bool dummy;
133     ast_expression *v;
134     v         = parser_find_local(parser, name, 0, &dummy);
135     if (!v) v = parser_find_global(parser, name);
136     return v;
137 }
138
139 static ast_value* parser_find_typedef(parser_t *parser, const char *name, size_t upto)
140 {
141     size_t     i, hash;
142     ast_value *e;
143     hash = util_hthash(parser->typedefs[0], name);
144
145     for (i = vec_size(parser->typedefs); i > upto;) {
146         --i;
147         if ( (e = (ast_value*)util_htgeth(parser->typedefs[i], name, hash)) )
148             return e;
149     }
150     return nullptr;
151 }
152
153 struct sy_elem {
154     size_t etype; /* 0 = expression, others are operators */
155     bool isparen;
156     size_t off;
157     ast_expression *out;
158     ast_block *block; /* for commas and function calls */
159     lex_ctx_t ctx;
160 };
161
162 enum {
163     PAREN_EXPR,
164     PAREN_FUNC,
165     PAREN_INDEX,
166     PAREN_TERNARY1,
167     PAREN_TERNARY2
168 };
169
170 struct shunt {
171     std::vector<sy_elem> out;
172     std::vector<sy_elem> ops;
173     std::vector<size_t> argc;
174     std::vector<unsigned int> paren;
175 };
176
177 static sy_elem syexp(lex_ctx_t ctx, ast_expression *v) {
178     sy_elem e;
179     e.etype = 0;
180     e.off   = 0;
181     e.out   = v;
182     e.block = nullptr;
183     e.ctx   = ctx;
184     e.isparen = false;
185     return e;
186 }
187
188 static sy_elem syblock(lex_ctx_t ctx, ast_block *v) {
189     sy_elem e;
190     e.etype = 0;
191     e.off   = 0;
192     e.out   = (ast_expression*)v;
193     e.block = v;
194     e.ctx   = ctx;
195     e.isparen = false;
196     return e;
197 }
198
199 static sy_elem syop(lex_ctx_t ctx, const oper_info *op) {
200     sy_elem e;
201     e.etype = 1 + (op - operators);
202     e.off   = 0;
203     e.out   = nullptr;
204     e.block = nullptr;
205     e.ctx   = ctx;
206     e.isparen = false;
207     return e;
208 }
209
210 static sy_elem syparen(lex_ctx_t ctx, size_t off) {
211     sy_elem e;
212     e.etype = 0;
213     e.off   = off;
214     e.out   = nullptr;
215     e.block = nullptr;
216     e.ctx   = ctx;
217     e.isparen = true;
218     return e;
219 }
220
221 /* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n],
222  * so we need to rotate it to become ent.(foo[n]).
223  */
224 static bool rotate_entfield_array_index_nodes(ast_expression **out)
225 {
226     ast_array_index *index, *oldindex;
227     ast_entfield    *entfield;
228
229     ast_value       *field;
230     ast_expression  *sub;
231     ast_expression  *entity;
232
233     lex_ctx_t ctx = (*out)->m_context;
234
235     if (!ast_istype(*out, ast_array_index))
236         return false;
237     index = (ast_array_index*)*out;
238
239     if (!ast_istype(index->m_array, ast_entfield))
240         return false;
241     entfield = (ast_entfield*)index->m_array;
242
243     if (!ast_istype(entfield->m_field, ast_value))
244         return false;
245     field = (ast_value*)entfield->m_field;
246
247     sub    = index->m_index;
248     entity = entfield->m_entity;
249
250     oldindex = index;
251
252     index = ast_array_index_new(ctx, (ast_expression*)field, sub);
253     entfield =