winspool: Implement SetPrinterW for level 2.
[wine] / dlls / vbscript / parser.y
1 /*
2  * Copyright 2011 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 %{
20
21 #include "vbscript.h"
22 #include "parse.h"
23
24 #include "wine/debug.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
27
28 #define YYLEX_PARAM ctx
29 #define YYPARSE_PARAM ctx
30
31 static int parser_error(const char*);
32
33 static void parse_complete(parser_ctx_t*,BOOL);
34
35 static void source_add_statement(parser_ctx_t*,statement_t*);
36 static void source_add_class(parser_ctx_t*,class_decl_t*);
37
38 static void *new_expression(parser_ctx_t*,expression_type_t,size_t);
39 static expression_t *new_bool_expression(parser_ctx_t*,VARIANT_BOOL);
40 static expression_t *new_string_expression(parser_ctx_t*,const WCHAR*);
41 static expression_t *new_long_expression(parser_ctx_t*,expression_type_t,LONG);
42 static expression_t *new_double_expression(parser_ctx_t*,double);
43 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
44 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
45 static expression_t *new_new_expression(parser_ctx_t*,const WCHAR*);
46
47 static member_expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
48
49 static void *new_statement(parser_ctx_t*,statement_type_t,size_t);
50 static statement_t *new_call_statement(parser_ctx_t*,member_expression_t*);
51 static statement_t *new_assign_statement(parser_ctx_t*,member_expression_t*,expression_t*);
52 static statement_t *new_set_statement(parser_ctx_t*,member_expression_t*,expression_t*);
53 static statement_t *new_dim_statement(parser_ctx_t*,dim_decl_t*);
54 static statement_t *new_while_statement(parser_ctx_t*,statement_type_t,expression_t*,statement_t*);
55 static statement_t *new_forto_statement(parser_ctx_t*,const WCHAR*,expression_t*,expression_t*,expression_t*,statement_t*);
56 static statement_t *new_foreach_statement(parser_ctx_t*,const WCHAR*,expression_t*,statement_t*);
57 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,elseif_decl_t*,statement_t*);
58 static statement_t *new_function_statement(parser_ctx_t*,function_decl_t*);
59 static statement_t *new_onerror_statement(parser_ctx_t*,BOOL);
60 static statement_t *new_const_statement(parser_ctx_t*,const_decl_t*);
61
62 static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,dim_decl_t*);
63 static elseif_decl_t *new_elseif_decl(parser_ctx_t*,expression_t*,statement_t*);
64 static function_decl_t *new_function_decl(parser_ctx_t*,const WCHAR*,function_type_t,unsigned,arg_decl_t*,statement_t*);
65 static arg_decl_t *new_argument_decl(parser_ctx_t*,const WCHAR*,BOOL);
66 static const_decl_t *new_const_decl(parser_ctx_t*,const WCHAR*,expression_t*);
67
68 static class_decl_t *new_class_decl(parser_ctx_t*);
69 static class_decl_t *add_class_function(parser_ctx_t*,class_decl_t*,function_decl_t*);
70 static class_decl_t *add_variant_prop(parser_ctx_t*,class_decl_t*,const WCHAR*,unsigned);
71
72 static statement_t *link_statements(statement_t*,statement_t*);
73
74 static const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0};
75
76 #define STORAGE_IS_PRIVATE    1
77 #define STORAGE_IS_DEFAULT    2
78
79 #define CHECK_ERROR if(((parser_ctx_t*)ctx)->hres != S_OK) YYABORT
80
81 %}
82
83 %pure_parser
84 %start Program
85
86 %union {
87     const WCHAR *string;
88     statement_t *statement;
89     expression_t *expression;
90     member_expression_t *member;
91     elseif_decl_t *elseif;
92     dim_decl_t *dim_decl;
93     function_decl_t *func_decl;
94     arg_decl_t *arg_decl;
95     class_decl_t *class_decl;
96     const_decl_t *const_decl;
97     unsigned uint;
98     LONG lng;
99     BOOL bool;
100     double dbl;
101 }
102
103 %token tEOF tNL tREM tEMPTYBRACKETS
104 %token tTRUE tFALSE
105 %token tNOT tAND tOR tXOR tEQV tIMP tNEQ
106 %token tIS tLTEQ tGTEQ tMOD
107 %token tCALL tDIM tSUB tFUNCTION tPROPERTY tGET tLET tCONST
108 %token tIF tELSE tELSEIF tEND tTHEN tEXIT
109 %token tWHILE tWEND tDO tLOOP tUNTIL tFOR tTO tSTEP tEACH tIN
110 %token tBYREF tBYVAL
111 %token tOPTION tEXPLICIT
112 %token tSTOP
113 %token tNOTHING tEMPTY tNULL
114 %token tCLASS tSET tNEW tPUBLIC tPRIVATE tDEFAULT tME
115 %token tERROR tNEXT tON tRESUME tGOTO
116 %token <string> tIdentifier tString
117 %token <lng> tLong tShort
118 %token <dbl> tDouble
119
120 %type <statement> Statement SimpleStatement StatementNl StatementsNl StatementsNl_opt IfStatement Else_opt
121 %type <expression> Expression LiteralExpression PrimaryExpression EqualityExpression CallExpression
122 %type <expression> ConcatExpression AdditiveExpression ModExpression IntdivExpression MultiplicativeExpression ExpExpression
123 %type <expression> NotExpression UnaryExpression AndExpression OrExpression XorExpression EqvExpression
124 %type <member> MemberExpression
125 %type <expression> Arguments_opt ArgumentList_opt ArgumentList Step_opt
126 %type <bool> OptionExplicit_opt DoType
127 %type <arg_decl> ArgumentsDecl_opt ArgumentDeclList ArgumentDecl
128 %type <func_decl> FunctionDecl PropertyDecl
129 %type <elseif> ElseIfs_opt ElseIfs ElseIf
130 %type <class_decl> ClassDeclaration ClassBody
131 %type <uint> Storage Storage_opt
132 %type <dim_decl> DimDeclList
133 %type <const_decl> ConstDecl ConstDeclList
134 %type <string> Identifier
135
136 %%
137
138 Program
139     : OptionExplicit_opt SourceElements tEOF    { parse_complete(ctx, $1); }
140
141 OptionExplicit_opt
142     : /* empty */                { $$ = FALSE; }
143     | tOPTION tEXPLICIT tNL      { $$ = TRUE; }
144
145 SourceElements
146     : /* empty */
147     | SourceElements StatementNl            { source_add_statement(ctx, $2); }
148     | SourceElements ClassDeclaration       { source_add_class(ctx, $2); }
149
150 StatementsNl_opt
151     : /* empty */                           { $$ = NULL; }
152     | StatementsNl                          { $$ = $1; }
153
154 StatementsNl
155     : StatementNl                           { $$ = $1; }
156     | StatementNl StatementsNl              { $$ = link_statements($1, $2); }
157
158 StatementNl
159     : Statement tNL                 { $$ = $1; }
160
161 Statement
162     : ':'                                   { $$ = NULL; }
163     | ':' Statement                         { $$ = $2; }
164     | SimpleStatement                       { $$ = $1; }
165     | SimpleStatement ':' Statement         { $1->next = $3; $$ = $1; }
166     | SimpleStatement ':'                   { $$ = $1; }
167
168 SimpleStatement
169     : MemberExpression ArgumentList_opt     { $1->args = $2; $$ = new_call_statement(ctx, $1); CHECK_ERROR; }
170     | tCALL MemberExpression Arguments_opt  { $2->args = $3; $$ = new_call_statement(ctx, $2); CHECK_ERROR; }
171     | MemberExpression Arguments_opt '=' Expression
172                                             { $1->args = $2; $$ = new_assign_statement(ctx, $1, $4); CHECK_ERROR; }
173     | tDIM DimDeclList                      { $$ = new_dim_statement(ctx, $2); CHECK_ERROR; }
174     | IfStatement                           { $$ = $1; }
175     | tWHILE Expression tNL StatementsNl_opt tWEND
176                                             { $$ = new_while_statement(ctx, STAT_WHILE, $2, $4); CHECK_ERROR; }
177     | tDO DoType Expression tNL StatementsNl_opt tLOOP
178                                             { $$ = new_while_statement(ctx, $2 ? STAT_WHILELOOP : STAT_UNTIL, $3, $5);
179                                               CHECK_ERROR; }
180     | tDO tNL StatementsNl_opt tLOOP DoType Expression
181                                             { $$ = new_while_statement(ctx, $5 ? STAT_DOWHILE : STAT_DOUNTIL, $6, $3);
182                                               CHECK_ERROR; }
183     | FunctionDecl                          { $$ = new_function_statement(ctx, $1); CHECK_ERROR; }
184     | tEXIT tDO                             { $$ = new_statement(ctx, STAT_EXITDO, 0); CHECK_ERROR; }
185     | tEXIT tFOR                            { $$ = new_statement(ctx, STAT_EXITFOR, 0); CHECK_ERROR; }
186     | tEXIT tFUNCTION                       { $$ = new_statement(ctx, STAT_EXITFUNC, 0); CHECK_ERROR; }
187     | tEXIT tPROPERTY                       { $$ = new_statement(ctx, STAT_EXITPROP, 0); CHECK_ERROR; }
188     | tEXIT tSUB                            { $$ = new_statement(ctx, STAT_EXITSUB, 0); CHECK_ERROR; }
189     | tSET MemberExpression Arguments_opt '=' Expression
190                                             { $2->args = $3; $$ = new_set_statement(ctx, $2, $5); CHECK_ERROR; }
191     | tSTOP                                 { $$ = new_statement(ctx, STAT_STOP, 0); CHECK_ERROR; }
192     | tON tERROR tRESUME tNEXT              { $$ = new_onerror_statement(ctx, TRUE); CHECK_ERROR; }
193     | tON tERROR tGOTO '0'                  { $$ = new_onerror_statement(ctx, FALSE); CHECK_ERROR; }
194     | tCONST ConstDeclList                  { $$ = new_const_statement(ctx, $2); CHECK_ERROR; }
195     | tFOR Identifier '=' Expression tTO Expression Step_opt tNL StatementsNl_opt tNEXT
196                                             { $$ = new_forto_statement(ctx, $2, $4, $6, $7, $9); CHECK_ERROR; }
197     | tFOR tEACH Identifier tIN Expression tNL StatementsNl_opt tNEXT
198                                             { $$ = new_foreach_statement(ctx, $3, $5, $7); }
199
200 MemberExpression
201     : Identifier                            { $$ = new_member_expression(ctx, NULL, $1); CHECK_ERROR; }
202     | CallExpression '.' Identifier         { $$ = new_member_expression(ctx, $1, $3); CHECK_ERROR; }
203
204 DimDeclList /* FIXME: Support arrays */
205     : Identifier                            { $$ = new_dim_decl(ctx, $1, NULL); CHECK_ERROR; }
206     | Identifier ',' DimDeclList            { $$ = new_dim_decl(ctx, $1, $3); CHECK_ERROR; }
207
208 ConstDeclList
209     : ConstDecl                             { $$ = $1; }
210     | ConstDecl ',' ConstDeclList           { $1->next = $3; $$ = $1; }
211
212 ConstDecl
213     : Identifier '=' LiteralExpression      { $$ = new_const_decl(ctx, $1, $3); CHECK_ERROR; }
214
215 DoType
216     : tWHILE        { $$ = TRUE; }
217     | tUNTIL        { $$ = FALSE; }
218
219 Step_opt
220     : /* empty */                           { $$ = NULL;}
221     | tSTEP Expression                      { $$ = $2; }
222
223 IfStatement
224     : tIF Expression tTHEN tNL StatementsNl ElseIfs_opt Else_opt tEND tIF
225                                             { $$ = new_if_statement(ctx, $2, $5, $6, $7); CHECK_ERROR; }
226     | tIF Expression tTHEN Statement        { $$ = new_if_statement(ctx, $2, $4, NULL, NULL); CHECK_ERROR; }
227     | tIF Expression tTHEN Statement tELSE Statement EndIf_opt
228                                             { $$ = new_if_statement(ctx, $2, $4, NULL, $6); CHECK_ERROR; }
229
230 EndIf_opt
231     : /* empty */
232     | tEND tIF
233
234 ElseIfs_opt
235     : /* empty */                           { $$ = NULL; }
236     | ElseIfs                               { $$ = $1; }
237
238 ElseIfs
239     : ElseIf                                { $$ = $1; }
240     | ElseIf ElseIfs                        { $1->next = $2; $$ = $1; }
241
242 ElseIf
243     : tELSEIF Expression tTHEN tNL StatementsNl
244                                             { $$ = new_elseif_decl(ctx, $2, $5); }
245
246 Else_opt
247     : /* empty */                           { $$ = NULL; }
248     | tELSE tNL StatementsNl                { $$ = $3; }
249
250 Arguments_opt
251     : EmptyBrackets_opt             { $$ = NULL; }
252     | '(' ArgumentList ')'          { $$ = $2; }
253
254 ArgumentList_opt
255     : EmptyBrackets_opt             { $$ = NULL; }
256     | ArgumentList                  { $$ = $1; }
257
258 ArgumentList
259     : Expression                    { $$ = $1; }
260     | Expression ',' ArgumentList   { $1->next = $3; $$ = $1; }
261
262 EmptyBrackets_opt
263     : /* empty */
264     | tEMPTYBRACKETS
265
266 Expression
267     : EqvExpression                             { $$ = $1; }
268     | Expression tIMP EqvExpression             { $$ = new_binary_expression(ctx, EXPR_IMP, $1, $3); CHECK_ERROR; }
269
270 EqvExpression
271     : XorExpression                             { $$ = $1; }
272     | EqvExpression tEQV XorExpression          { $$ = new_binary_expression(ctx, EXPR_EQV, $1, $3); CHECK_ERROR; }
273
274 XorExpression
275     : OrExpression                              { $$ = $1; }
276     | XorExpression tXOR OrExpression           { $$ = new_binary_expression(ctx, EXPR_XOR, $1, $3); CHECK_ERROR; }
277
278 OrExpression
279     : AndExpression                             { $$ = $1; }
280     | OrExpression tOR AndExpression            { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); CHECK_ERROR; }
281
282 AndExpression
283     : NotExpression                             { $$ = $1; }
284     | AndExpression tAND NotExpression          { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); CHECK_ERROR; }
285
286 NotExpression
287     : EqualityExpression            { $$ = $1; }
288     | tNOT NotExpression            { $$ = new_unary_expression(ctx, EXPR_NOT, $2); CHECK_ERROR; }
289
290 EqualityExpression
291     : ConcatExpression                          { $$ = $1; }
292     | EqualityExpression '=' ConcatExpression   { $$ = new_binary_expression(ctx, EXPR_EQUAL, $1, $3); CHECK_ERROR; }
293     | EqualityExpression tNEQ ConcatExpression  { $$ = new_binary_expression(ctx, EXPR_NEQUAL, $1, $3); CHECK_ERROR; }
294     | EqualityExpression '>' ConcatExpression   { $$ = new_binary_expression(ctx, EXPR_GT, $1, $3); CHECK_ERROR; }
295     | EqualityExpression '<' ConcatExpression   { $$ = new_binary_expression(ctx, EXPR_LT, $1, $3); CHECK_ERROR; }
296     | EqualityExpression tGTEQ ConcatExpression { $$ = new_binary_expression(ctx, EXPR_GTEQ, $1, $3); CHECK_ERROR; }
297     | EqualityExpression tLTEQ ConcatExpression { $$ = new_binary_expression(ctx, EXPR_LTEQ, $1, $3); CHECK_ERROR; }
298     | EqualityExpression tIS ConcatExpression   { $$ = new_binary_expression(ctx, EXPR_IS, $1, $3); CHECK_ERROR; }
299
300 ConcatExpression
301     : AdditiveExpression                        { $$ = $1; }
302     | ConcatExpression '&' AdditiveExpression   { $$ = new_binary_expression(ctx, EXPR_CONCAT, $1, $3); CHECK_ERROR; }
303
304 AdditiveExpression
305     : ModExpression                             { $$ = $1; }
306     | AdditiveExpression '+' ModExpression      { $$ = new_binary_expression(ctx, EXPR_ADD, $1, $3); CHECK_ERROR; }
307     | AdditiveExpression '-' ModExpression      { $$ = new_binary_expression(ctx, EXPR_SUB, $1, $3); CHECK_ERROR; }
308
309 ModExpression
310     : IntdivExpression                          { $$ = $1; }
311     | ModExpression tMOD IntdivExpression       { $$ = new_binary_expression(ctx, EXPR_MOD, $1, $3); CHECK_ERROR; }
312
313 IntdivExpression
314     : MultiplicativeExpression                  { $$ = $1; }
315     | IntdivExpression '\\' MultiplicativeExpression
316                                                 { $$ = new_binary_expression(ctx, EXPR_IDIV, $1, $3); CHECK_ERROR; }
317
318 MultiplicativeExpression
319     : ExpExpression                             { $$ = $1; }
320     | MultiplicativeExpression '*' ExpExpression
321                                                 { $$ = new_binary_expression(ctx, EXPR_MUL, $1, $3); CHECK_ERROR; }
322     | MultiplicativeExpression '/' ExpExpression
323                                                 { $$ = new_binary_expression(ctx, EXPR_DIV, $1, $3); CHECK_ERROR; }
324
325 ExpExpression
326     : UnaryExpression                           { $$ = $1; }
327     | ExpExpression '^' UnaryExpression         { $$ = new_binary_expression(ctx, EXPR_EXP, $1, $3); CHECK_ERROR; }
328
329 UnaryExpression
330     : LiteralExpression             { $$ = $1; }
331     | CallExpression                { $$ = $1; }
332     | tNEW Identifier               { $$ = new_new_expression(ctx, $2); CHECK_ERROR; }
333     | '-' UnaryExpression           { $$ = new_unary_expression(ctx, EXPR_NEG, $2); CHECK_ERROR; }
334
335 CallExpression
336     : PrimaryExpression                 { $$ = $1; }
337     | MemberExpression Arguments_opt    { $1->args = $2; $$ = &$1->expr; }
338
339 LiteralExpression
340     : tTRUE                         { $$ = new_bool_expression(ctx, VARIANT_TRUE); CHECK_ERROR; }
341     | tFALSE                        { $$ = new_bool_expression(ctx, VARIANT_FALSE); CHECK_ERROR; }
342     | tString                       { $$ = new_string_expression(ctx, $1); CHECK_ERROR; }
343     | tShort                        { $$ = new_long_expression(ctx, EXPR_USHORT, $1); CHECK_ERROR; }
344     | '0'                           { $$ = new_long_expression(ctx, EXPR_USHORT, 0); CHECK_ERROR; }
345     | tLong                         { $$ = new_long_expression(ctx, EXPR_ULONG, $1); CHECK_ERROR; }
346     | tDouble                       { $$ = new_double_expression(ctx, $1); CHECK_ERROR; }
347     | tEMPTY                        { $$ = new_expression(ctx, EXPR_EMPTY, 0); CHECK_ERROR; }
348     | tNULL                         { $$ = new_expression(ctx, EXPR_NULL, 0); CHECK_ERROR; }
349     | tNOTHING                      { $$ = new_expression(ctx, EXPR_NOTHING, 0); CHECK_ERROR; }
350
351 PrimaryExpression
352     : '(' Expression ')'            { $$ = $2; }
353     | tME                           { $$ = new_expression(ctx, EXPR_ME, 0); CHECK_ERROR; }
354
355 ClassDeclaration
356     : tCLASS Identifier tNL ClassBody tEND tCLASS tNL       { $4->name = $2; $$ = $4; }
357
358 ClassBody
359     : /* empty */                               { $$ = new_class_decl(ctx); }
360     | FunctionDecl tNL ClassBody                { $$ = add_class_function(ctx, $3, $1); CHECK_ERROR; }
361     | Storage tIdentifier tNL ClassBody         { $$ = add_variant_prop(ctx, $4, $2, $1); CHECK_ERROR; }
362     | PropertyDecl tNL ClassBody                { $$ = add_class_function(ctx, $3, $1); CHECK_ERROR; }
363
364 PropertyDecl
365     : Storage_opt tPROPERTY tGET tIdentifier EmptyBrackets_opt tNL StatementsNl_opt tEND tPROPERTY
366                                     { $$ = new_function_decl(ctx, $4, FUNC_PROPGET, $1, NULL, $7); CHECK_ERROR; }
367     | Storage_opt tPROPERTY tLET tIdentifier '(' ArgumentDecl ')' tNL StatementsNl_opt tEND tPROPERTY
368                                     { $$ = new_function_decl(ctx, $4, FUNC_PROPLET, $1, $6, $9); CHECK_ERROR; }
369     | Storage_opt tPROPERTY tSET tIdentifier '(' ArgumentDecl ')' tNL StatementsNl_opt tEND tPROPERTY
370                                     { $$ = new_function_decl(ctx, $4, FUNC_PROPSET, $1, $6, $9); CHECK_ERROR; }
371
372 FunctionDecl
373     : Storage_opt tSUB Identifier ArgumentsDecl_opt tNL StatementsNl_opt tEND tSUB
374                                     { $$ = new_function_decl(ctx, $3, FUNC_SUB, $1, $4, $6); CHECK_ERROR; }
375     | Storage_opt tFUNCTION Identifier ArgumentsDecl_opt tNL StatementsNl_opt tEND tFUNCTION
376                                     { $$ = new_function_decl(ctx, $3, FUNC_FUNCTION, $1, $4, $6); CHECK_ERROR; }
377
378 Storage_opt
379     : /* empty*/                    { $$ = 0; }
380     | Storage                       { $$ = $1; }
381
382 Storage
383     : tPUBLIC tDEFAULT              { $$ = STORAGE_IS_DEFAULT; }
384     | tPUBLIC                       { $$ = 0; }
385     | tPRIVATE                      { $$ = STORAGE_IS_PRIVATE; }
386
387 ArgumentsDecl_opt
388     : EmptyBrackets_opt                         { $$ = NULL; }
389     | '(' ArgumentDeclList ')'                  { $$ = $2; }
390
391 ArgumentDeclList
392     : ArgumentDecl                              { $$ = $1; }
393     | ArgumentDecl ',' ArgumentDeclList         { $1->next = $3; $$ = $1; }
394
395 ArgumentDecl
396     : Identifier                                { $$ = new_argument_decl(ctx, $1, TRUE); }
397     | tBYREF Identifier                         { $$ = new_argument_decl(ctx, $2, TRUE); }
398     | tBYVAL Identifier                         { $$ = new_argument_decl(ctx, $2, FALSE); }
399
400 /* 'property' may be both keyword and identifier, depending on context */
401 Identifier
402     : tIdentifier    { $$ = $1; }
403     | tPROPERTY      { $$ = propertyW; }
404 %%
405
406 static int parser_error(const char *str)
407 {
408     return 0;
409 }
410
411 static void source_add_statement(parser_ctx_t *ctx, statement_t *stat)
412 {
413     if(!stat)
414         return;
415
416     if(ctx->stats) {
417         ctx->stats_tail->next = stat;
418         ctx->stats_tail = stat;
419     }else {
420         ctx->stats = ctx->stats_tail = stat;
421     }
422 }
423
424 static void source_add_class(parser_ctx_t *ctx, class_decl_t *class_decl)
425 {
426     class_decl->next = ctx->class_decls;
427     ctx->class_decls = class_decl;
428 }
429
430 static void parse_complete(parser_ctx_t *ctx, BOOL option_explicit)
431 {
432     ctx->parse_complete = TRUE;
433     ctx->option_explicit = option_explicit;
434 }
435
436 static void *new_expression(parser_ctx_t *ctx, expression_type_t type, size_t size)
437 {
438     expression_t *expr;
439
440     expr = parser_alloc(ctx, size ? size : sizeof(*expr));
441     if(expr) {
442         expr->type = type;
443         expr->next = NULL;
444     }
445
446     return expr;
447 }
448
449 static expression_t *new_bool_expression(parser_ctx_t *ctx, VARIANT_BOOL value)
450 {
451     bool_expression_t *expr;
452
453     expr = new_expression(ctx, EXPR_BOOL, sizeof(*expr));
454     if(!expr)
455         return NULL;
456
457     expr->value = value;
458     return &expr->expr;
459 }
460
461 static expression_t *new_string_expression(parser_ctx_t *ctx, const WCHAR *value)
462 {
463     string_expression_t *expr;
464
465     expr = new_expression(ctx, EXPR_STRING, sizeof(*expr));
466     if(!expr)
467         return NULL;
468
469     expr->value = value;
470     return &expr->expr;
471 }
472
473 static expression_t *new_long_expression(parser_ctx_t *ctx, expression_type_t type, LONG value)
474 {
475     int_expression_t *expr;
476
477     expr = new_expression(ctx, type, sizeof(*expr));
478     if(!expr)
479         return NULL;
480
481     expr->value = value;
482     return &expr->expr;
483 }
484
485 static expression_t *new_double_expression(parser_ctx_t *ctx, double value)
486 {
487     double_expression_t *expr;
488
489     expr = new_expression(ctx, EXPR_DOUBLE, sizeof(*expr));
490     if(!expr)
491         return NULL;
492
493     expr->value = value;
494     return &expr->expr;
495 }
496
497 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *subexpr)
498 {
499     unary_expression_t *expr;
500
501     expr = new_expression(ctx, type, sizeof(*expr));
502     if(!expr)
503         return NULL;
504
505     expr->subexpr = subexpr;
506     return &expr->expr;
507 }
508
509 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *left, expression_t *right)
510 {
511     binary_expression_t *expr;
512
513     expr = new_expression(ctx, type, sizeof(*expr));
514     if(!expr)
515         return NULL;
516
517     expr->left = left;
518     expr->right = right;
519     return &expr->expr;
520 }
521
522 static member_expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *obj_expr, const WCHAR *identifier)
523 {
524     member_expression_t *expr;
525
526     expr = new_expression(ctx, EXPR_MEMBER, sizeof(*expr));
527     if(!expr)
528         return NULL;
529
530     expr->obj_expr = obj_expr;
531     expr->identifier = identifier;
532     expr->args = NULL;
533     return expr;
534 }
535
536 static expression_t *new_new_expression(parser_ctx_t *ctx, const WCHAR *identifier)
537 {
538     string_expression_t *expr;
539
540     expr = new_expression(ctx, EXPR_NEW, sizeof(*expr));
541     if(!expr)
542         return NULL;
543
544     expr->value = identifier;
545     return &expr->expr;
546 }
547
548 static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size)
549 {
550     statement_t *stat;
551
552     stat = parser_alloc(ctx, size ? size : sizeof(*stat));
553     if(stat) {
554         stat->type = type;
555         stat->next = NULL;
556     }
557
558     return stat;
559 }
560
561 static statement_t *new_call_statement(parser_ctx_t *ctx, member_expression_t *expr)
562 {
563     call_statement_t *stat;
564
565     stat = new_statement(ctx, STAT_CALL, sizeof(*stat));
566     if(!stat)
567         return NULL;
568
569     stat->expr = expr;
570     return &stat->stat;
571 }
572
573 static statement_t *new_assign_statement(parser_ctx_t *ctx, member_expression_t *left, expression_t *right)
574 {
575     assign_statement_t *stat;
576
577     stat = new_statement(ctx, STAT_ASSIGN, sizeof(*stat));
578     if(!stat)
579         return NULL;
580
581     stat->member_expr = left;
582     stat->value_expr = right;
583     return &stat->stat;
584 }
585
586 static statement_t *new_set_statement(parser_ctx_t *ctx, member_expression_t *left, expression_t *right)
587 {
588     assign_statement_t *stat;
589
590     stat = new_statement(ctx, STAT_SET, sizeof(*stat));
591     if(!stat)
592         return NULL;
593
594     stat->member_expr = left;
595     stat->value_expr = right;
596     return &stat->stat;
597 }
598
599 static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, dim_decl_t *next)
600 {
601     dim_decl_t *decl;
602
603     decl = parser_alloc(ctx, sizeof(*decl));
604     if(!decl)
605         return NULL;
606
607     decl->name = name;
608     decl->next = next;
609     return decl;
610 }
611
612 static statement_t *new_dim_statement(parser_ctx_t *ctx, dim_decl_t *decls)
613 {
614     dim_statement_t *stat;
615
616     stat = new_statement(ctx, STAT_DIM, sizeof(*stat));
617     if(!stat)
618         return NULL;
619
620     stat->dim_decls = decls;
621     return &stat->stat;
622 }
623
624 static elseif_decl_t *new_elseif_decl(parser_ctx_t *ctx, expression_t *expr, statement_t *stat)
625 {
626     elseif_decl_t *decl;
627
628     decl = parser_alloc(ctx, sizeof(*decl));
629     if(!decl)
630         return NULL;
631
632     decl->expr = expr;
633     decl->stat = stat;
634     decl->next = NULL;
635     return decl;
636 }
637
638 static statement_t *new_while_statement(parser_ctx_t *ctx, statement_type_t type, expression_t *expr, statement_t *body)
639 {
640     while_statement_t *stat;
641
642     stat = new_statement(ctx, type, sizeof(*stat));
643     if(!stat)
644         return NULL;
645
646     stat->expr = expr;
647     stat->body = body;
648     return &stat->stat;
649 }
650
651 static statement_t *new_forto_statement(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *from_expr,
652         expression_t *to_expr, expression_t *step_expr, statement_t *body)
653 {
654     forto_statement_t *stat;
655
656     stat = new_statement(ctx, STAT_FORTO, sizeof(*stat));
657     if(!stat)
658         return NULL;
659
660     stat->identifier = identifier;
661     stat->from_expr = from_expr;
662     stat->to_expr = to_expr;
663     stat->step_expr = step_expr;
664     stat->body = body;
665     return &stat->stat;
666 }
667
668 static statement_t *new_foreach_statement(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *group_expr,
669         statement_t *body)
670 {
671     foreach_statement_t *stat;
672
673     stat = new_statement(ctx, STAT_FOREACH, sizeof(*stat));
674     if(!stat)
675         return NULL;
676
677     stat->identifier = identifier;
678     stat->group_expr = group_expr;
679     stat->body = body;
680     return &stat->stat;
681 }
682
683 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, elseif_decl_t *elseif_decl,
684         statement_t *else_stat)
685 {
686     if_statement_t *stat;
687
688     stat = new_statement(ctx, STAT_IF, sizeof(*stat));
689     if(!stat)
690         return NULL;
691
692     stat->expr = expr;
693     stat->if_stat = if_stat;
694     stat->elseifs = elseif_decl;
695     stat->else_stat = else_stat;
696     return &stat->stat;
697 }
698
699 static statement_t *new_onerror_statement(parser_ctx_t *ctx, BOOL resume_next)
700 {
701     onerror_statement_t *stat;
702
703     stat = new_statement(ctx, STAT_ONERROR, sizeof(*stat));
704     if(!stat)
705         return NULL;
706
707     stat->resume_next = resume_next;
708     return &stat->stat;
709 }
710
711 static arg_decl_t *new_argument_decl(parser_ctx_t *ctx, const WCHAR *name, BOOL by_ref)
712 {
713     arg_decl_t *arg_decl;
714
715     arg_decl = parser_alloc(ctx, sizeof(*arg_decl));
716     if(!arg_decl)
717         return NULL;
718
719     arg_decl->name = name;
720     arg_decl->by_ref = by_ref;
721     arg_decl->next = NULL;
722     return arg_decl;
723 }
724
725 static function_decl_t *new_function_decl(parser_ctx_t *ctx, const WCHAR *name, function_type_t type,
726         unsigned storage_flags, arg_decl_t *arg_decl, statement_t *body)
727 {
728     function_decl_t *decl;
729
730     if(storage_flags & STORAGE_IS_DEFAULT) {
731         if(type == FUNC_PROPGET) {
732             type = FUNC_DEFGET;
733         }else {
734             FIXME("Invalid default property\n");
735             ctx->hres = E_FAIL;
736             return NULL;
737         }
738     }
739
740     decl = parser_alloc(ctx, sizeof(*decl));
741     if(!decl)
742         return NULL;
743
744     decl->name = name;
745     decl->type = type;
746     decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
747     decl->args = arg_decl;
748     decl->body = body;
749     decl->next = NULL;
750     decl->next_prop_func = NULL;
751     return decl;
752 }
753
754 static statement_t *new_function_statement(parser_ctx_t *ctx, function_decl_t *decl)
755 {
756     function_statement_t *stat;
757
758     stat = new_statement(ctx, STAT_FUNC, sizeof(*stat));
759     if(!stat)
760         return NULL;
761
762     stat->func_decl = decl;
763     return &stat->stat;
764 }
765
766 static class_decl_t *new_class_decl(parser_ctx_t *ctx)
767 {
768     class_decl_t *class_decl;
769
770     class_decl = parser_alloc(ctx, sizeof(*class_decl));
771     if(!class_decl)
772         return NULL;
773
774     class_decl->funcs = NULL;
775     class_decl->props = NULL;
776     class_decl->next = NULL;
777     return class_decl;
778 }
779
780 static class_decl_t *add_class_function(parser_ctx_t *ctx, class_decl_t *class_decl, function_decl_t *decl)
781 {
782     function_decl_t *iter;
783
784     for(iter = class_decl->funcs; iter; iter = iter->next) {
785         if(!strcmpiW(iter->name, decl->name)) {
786             if(decl->type == FUNC_SUB || decl->type == FUNC_FUNCTION) {
787                 FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
788                 ctx->hres = E_FAIL;
789                 return NULL;
790             }
791
792             while(1) {
793                 if(iter->type == decl->type) {
794                     FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
795                     ctx->hres = E_FAIL;
796                     return NULL;
797                 }
798                 if(!iter->next_prop_func)
799                     break;
800                 iter = iter->next_prop_func;
801             }
802
803             iter->next_prop_func = decl;
804             return class_decl;
805         }
806     }
807
808     decl->next = class_decl->funcs;
809     class_decl->funcs = decl;
810     return class_decl;
811 }
812
813 static class_decl_t *add_variant_prop(parser_ctx_t *ctx, class_decl_t *class_decl, const WCHAR *identifier, unsigned storage_flags)
814 {
815     class_prop_decl_t *prop;
816
817     if(storage_flags & STORAGE_IS_DEFAULT) {
818         FIXME("variant prop van't be default value\n");
819         ctx->hres = E_FAIL;
820         return NULL;
821     }
822
823     prop = parser_alloc(ctx, sizeof(*prop));
824     if(!prop)
825         return NULL;
826
827     prop->name = identifier;
828     prop->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
829     prop->next = class_decl->props;
830     class_decl->props = prop;
831     return class_decl;
832 }
833
834 static const_decl_t *new_const_decl(parser_ctx_t *ctx, const WCHAR *name, expression_t *expr)
835 {
836     const_decl_t *decl;
837
838     decl = parser_alloc(ctx, sizeof(*decl));
839     if(!decl)
840         return NULL;
841
842     decl->name = name;
843     decl->value_expr = expr;
844     decl->next = NULL;
845     return decl;
846 }
847
848 static statement_t *new_const_statement(parser_ctx_t *ctx, const_decl_t *decls)
849 {
850     const_statement_t *stat;
851
852     stat = new_statement(ctx, STAT_CONST, sizeof(*stat));
853     if(!stat)
854         return NULL;
855
856     stat->decls = decls;
857     return &stat->stat;
858 }
859
860 static statement_t *link_statements(statement_t *head, statement_t *tail)
861 {
862     statement_t *iter;
863
864     for(iter = head; iter->next; iter = iter->next);
865     iter->next = tail;
866
867     return head;
868 }
869
870 void *parser_alloc(parser_ctx_t *ctx, size_t size)
871 {
872     void *ret;
873
874     ret = vbsheap_alloc(&ctx->heap, size);
875     if(!ret)
876         ctx->hres = E_OUTOFMEMORY;
877     return ret;
878 }
879
880 HRESULT parse_script(parser_ctx_t *ctx, const WCHAR *code)
881 {
882     ctx->code = ctx->ptr = code;
883     ctx->end = ctx->code + strlenW(ctx->code);
884
885     vbsheap_init(&ctx->heap);
886
887     ctx->parse_complete = FALSE;
888     ctx->hres = S_OK;
889
890     ctx->last_token = tNL;
891     ctx->last_nl = 0;
892     ctx->stats = ctx->stats_tail = NULL;
893     ctx->class_decls = NULL;
894     ctx->option_explicit = FALSE;
895
896     parser_parse(ctx);
897
898     if(FAILED(ctx->hres))
899         return ctx->hres;
900     if(!ctx->parse_complete) {
901         FIXME("parser failed on parsing %s\n", debugstr_w(ctx->ptr));
902         return E_FAIL;
903     }
904
905     return S_OK;
906 }
907
908 void parser_release(parser_ctx_t *ctx)
909 {
910     vbsheap_free(&ctx->heap);
911 }