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