dlls/jscript/lex.c

   1 /*
   2  * Copyright 2008 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 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <limits.h>
  23
  24 #include "jscript.h"
  25 #include "activscp.h"
  26 #include "objsafe.h"
  27 #include "engine.h"
  28 #include "parser.h"
  29
  30 #include "parser.tab.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  36
  37 static const WCHAR breakW[] = {'b','r','e','a','k',0};
  38 static const WCHAR caseW[] = {'c','a','s','e',0};
  39 static const WCHAR catchW[] = {'c','a','t','c','h',0};
  40 static const WCHAR continueW[] = {'c','o','n','t','i','n','u','e',0};
  41 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
  42 static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
  43 static const WCHAR doW[] = {'d','o',0};
  44 static const WCHAR elseW[] = {'e','l','s','e',0};
  45 static const WCHAR falseW[] = {'f','a','l','s','e',0};
  46 static const WCHAR finallyW[] = {'f','i','n','a','l','l','y',0};
  47 static const WCHAR forW[] = {'f','o','r',0};
  48 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
  49 static const WCHAR getW[] = {'g','e','t',0};
  50 static const WCHAR ifW[] = {'i','f',0};
  51 static const WCHAR inW[] = {'i','n',0};
  52 static const WCHAR instanceofW[] = {'i','n','s','t','a','n','c','e','o','f',0};
  53 static const WCHAR newW[] = {'n','e','w',0};
  54 static const WCHAR nullW[] = {'n','u','l','l',0};
  55 static const WCHAR returnW[] = {'r','e','t','u','r','n',0};
  56 static const WCHAR setW[] = {'s','e','t',0};
  57 static const WCHAR switchW[] = {'s','w','i','t','c','h',0};
  58 static const WCHAR thisW[] = {'t','h','i','s',0};
  59 static const WCHAR throwW[] = {'t','h','r','o','w',0};
  60 static const WCHAR trueW[] = {'t','r','u','e',0};
  61 static const WCHAR tryW[] = {'t','r','y',0};
  62 static const WCHAR typeofW[] = {'t','y','p','e','o','f',0};
  63 static const WCHAR varW[] = {'v','a','r',0};
  64 static const WCHAR voidW[] = {'v','o','i','d',0};
  65 static const WCHAR whileW[] = {'w','h','i','l','e',0};
  66 static const WCHAR withW[] = {'w','i','t','h',0};
  67
  68 static const WCHAR elifW[] = {'e','l','i','f',0};
  69 static const WCHAR endW[] = {'e','n','d',0};
  70
  71 static const struct {
  72     const WCHAR *word;
  73     int token;
  74     BOOL no_nl;
  75     unsigned min_version;
  76 } keywords[] = {
  77     {breakW,       kBREAK,       TRUE},
  78     {caseW,        kCASE},
  79     {catchW,       kCATCH},
  80     {continueW,    kCONTINUE,    TRUE},
  81     {defaultW,     kDEFAULT},
  82     {deleteW,      kDELETE},
  83     {doW,          kDO},
  84     {elseW,        kELSE},
  85     {falseW,       kFALSE},
  86     {finallyW,     kFINALLY},
  87     {forW,         kFOR},
  88     {functionW,    kFUNCTION},
  89     {getW,         kGET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
  90     {ifW,          kIF},
  91     {inW,          kIN},
  92     {instanceofW,  kINSTANCEOF},
  93     {newW,         kNEW},
  94     {nullW,        kNULL},
  95     {returnW,      kRETURN,      TRUE},
  96     {setW,         kSET,         FALSE, SCRIPTLANGUAGEVERSION_ES5},
  97     {switchW,      kSWITCH},
  98     {thisW,        kTHIS},
  99     {throwW,       kTHROW},
 100     {trueW,        kTRUE},
 101     {tryW,         kTRY},
 102     {typeofW,      kTYPEOF},
 103     {varW,         kVAR},
 104     {voidW,        kVOID},
 105     {whileW,       kWHILE},
 106     {withW,        kWITH}
 107 };
 108
 109 static int lex_error(parser_ctx_t *ctx, HRESULT hres)
 110 {
 111     ctx->hres = hres;
 112     ctx->lexer_error = TRUE;
 113     return -1;
 114 }
 115
 116 /* ECMA-262 3rd Edition    7.6 */
 117 BOOL is_identifier_char(WCHAR c)
 118 {
 119     return isalnumW(c) || c == '$' || c == '_' || c == '\\';
 120 }
 121
 122 static BOOL is_identifier_first_char(WCHAR c)
 123 {
 124     return isalphaW(c) || c == '$' || c == '_' || c == '\\';
 125 }
 126
 127 static int check_keyword(parser_ctx_t *ctx, const WCHAR *word, const WCHAR **lval)
 128 {
 129     const WCHAR *p1 = ctx->ptr;
 130     const WCHAR *p2 = word;
 131
 132     while(p1 < ctx->end && *p2) {
 133         if(*p1 != *p2)
 134             return *p1 - *p2;
 135         p1++;
 136         p2++;
 137     }
 138
 139     if(*p2 || (p1 < ctx->end && is_identifier_char(*p1)))
 140         return 1;
 141
 142     if(lval)
 143         *lval = word;
 144     ctx->ptr = p1;
 145     return 0;
 146 }
 147
 148 /* ECMA-262 3rd Edition    7.3 */
 149 static BOOL is_endline(WCHAR c)
 150 {
 151     return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;
 152 }
 153
 154 static int hex_to_int(WCHAR c)
 155 {
 156     if('0' <= c && c <= '9')
 157         return c-'0';
 158
 159     if('a' <= c && c <= 'f')
 160         return c-'a'+10;
 161
 162     if('A' <= c && c <= 'F')
 163         return c-'A'+10;
 164
 165     return -1;
 166 }
 167
 168 static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
 169 {
 170     int min = 0, max = ARRAY_SIZE(keywords)-1, r, i;
 171
 172     while(min <= max) {
 173         i = (min+max)/2;
 174
 175         r = check_keyword(ctx, keywords[i].word, lval);
 176         if(!r) {
 177             if(ctx->script->version < keywords[i].min_version) {
 178                 TRACE("ignoring keyword %s in incompatible mode\n",
 179                       debugstr_w(keywords[i].word));
 180                 ctx->ptr -= strlenW(keywords[i].word);
 181                 return 0;
 182             }
 183             ctx->implicit_nl_semicolon = keywords[i].no_nl;
 184             return keywords[i].token;
 185         }
 186
 187         if(r > 0)
 188             min = i+1;
 189         else
 190             max = i-1;
 191     }
 192
 193     return 0;
 194 }
 195
 196 static BOOL skip_html_comment(parser_ctx_t *ctx)
 197 {
 198     const WCHAR html_commentW[] = {'<','!','-','-',0};
 199
 200     if(!ctx->is_html || ctx->ptr+3 >= ctx->end ||
 201         memcmp(ctx->ptr, html_commentW, sizeof(WCHAR)*4))
 202         return FALSE;
 203
 204     ctx->nl = TRUE;
 205     while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr++));
 206
 207     return TRUE;
 208 }
 209
 210 static BOOL skip_comment(parser_ctx_t *ctx)
 211 {
 212     if(ctx->ptr+1 >= ctx->end)
 213         return FALSE;
 214
 215     if(*ctx->ptr != '/') {
 216         if(*ctx->ptr == '@' && ctx->ptr+2 < ctx->end && ctx->ptr[1] == '*' && ctx->ptr[2] == '/') {
 217             ctx->ptr += 3;
 218             return TRUE;
 219         }
 220
 221         return FALSE;
 222     }
 223
 224     switch(ctx->ptr[1]) {
 225     case '*':
 226         ctx->ptr += 2;
 227         if(ctx->ptr+2 < ctx->end && *ctx->ptr == '@' && is_identifier_char(ctx->ptr[1]))
 228             return FALSE;
 229         while(ctx->ptr+1 < ctx->end && (ctx->ptr[0] != '*' || ctx->ptr[1] != '/'))
 230             ctx->ptr++;
 231
 232         if(ctx->ptr[0] == '*' && ctx->ptr[1] == '/') {
 233             ctx->ptr += 2;
 234         }else {
 235             WARN("unexpected end of file (missing end of comment)\n");
 236             ctx->ptr = ctx->end;
 237         }
 238         break;
 239     case '/':
 240         ctx->ptr += 2;
 241         if(ctx->ptr+2 < ctx->end && *ctx->ptr == '@' && is_identifier_char(ctx->ptr[1]))
 242             return FALSE;
 243         while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr))
 244             ctx->ptr++;
 245         break;
 246     default:
 247         return FALSE;
 248     }
 249
 250     return TRUE;
 251 }
 252
 253 static BOOL skip_spaces(parser_ctx_t *ctx)
 254 {
 255     while(ctx->ptr < ctx->end && (isspaceW(*ctx->ptr) || *ctx->ptr == 0xFEFF /* UTF16 BOM */)) {
 256         if(is_endline(*ctx->ptr++))
 257             ctx->nl = TRUE;
 258     }
 259
 260     return ctx->ptr != ctx->end;
 261 }
 262
 263 BOOL unescape(WCHAR *str)
 264 {
 265     WCHAR *pd, *p, c;
 266     int i;
 267
 268     pd = p = str;
 269     while(*p) {
 270         if(*p != '\\') {
 271             *pd++ = *p++;
 272             continue;
 273         }
 274
 275         p++;
 276
 277         switch(*p) {
 278         case '\'':
 279         case '\"':
 280         case '\\':
 281             c = *p;
 282             break;
 283         case 'b':
 284             c = '\b';
 285             break;
 286         case 't':
 287             c = '\t';
 288             break;
 289         case 'n':
 290             c = '\n';
 291             break;
 292         case 'f':
 293             c = '\f';
 294             break;
 295         case 'r':
 296             c = '\r';
 297             break;
 298         case 'x':
 299             i = hex_to_int(*++p);
 300             if(i == -1)
 301                 return FALSE;
 302             c = i << 4;
 303
 304             i = hex_to_int(*++p);
 305             if(i == -1)
 306                 return FALSE;
 307             c += i;
 308             break;
 309         case 'u':
 310             i = hex_to_int(*++p);
 311             if(i == -1)
 312                 return FALSE;
 313             c = i << 12;
 314
 315             i = hex_to_int(*++p);
 316             if(i == -1)
 317                 return FALSE;
 318             c += i << 8;
 319
 320             i = hex_to_int(*++p);
 321             if(i == -1)
 322                 return FALSE;
 323             c += i << 4;
 324
 325             i = hex_to_int(*++p);
 326             if(i == -1)
 327                 return FALSE;
 328             c += i;
 329             break;
 330         default:
 331             if(isdigitW(*p)) {
 332                 c = *p++ - '0';
 333                 if(isdigitW(*p)) {
 334                     c = c*8 + (*p++ - '0');
 335                     if(isdigitW(*p))
 336                         c = c*8 + (*p++ - '0');
 337                 }
 338                 p--;
 339             }
 340             else
 341                 c = *p;
 342         }
 343
 344         *pd++ = c;
 345         p++;
 346     }
 347
 348     *pd = 0;
 349     return TRUE;
 350 }
 351
 352 static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
 353 {
 354     const WCHAR *ptr = ctx->ptr++;
 355     WCHAR *wstr;
 356     int len;
 357
 358     while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr))
 359         ctx->ptr++;
 360
 361     len = ctx->ptr-ptr;
 362
 363     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 364     memcpy(wstr, ptr, len*sizeof(WCHAR));
 365     wstr[len] = 0;
 366
 367     /* FIXME: unescape */
 368     return tIdentifier;
 369 }
 370
 371 static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret, WCHAR endch)
 372 {
 373     const WCHAR *ptr = ++ctx->ptr;
 374     WCHAR *wstr;
 375     int len;
 376
 377     while(ctx->ptr < ctx->end && *ctx->ptr != endch) {
 378         if(*ctx->ptr++ == '\\')
 379             ctx->ptr++;
 380     }
 381
 382     if(ctx->ptr == ctx->end)
 383         return lex_error(ctx, JS_E_UNTERMINATED_STRING);
 384
 385     len = ctx->ptr-ptr;
 386
 387     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 388     memcpy(wstr, ptr, len*sizeof(WCHAR));
 389     wstr[len] = 0;
 390
 391     ctx->ptr++;
 392
 393     if(!unescape(wstr)) {
 394         WARN("unescape failed\n");
 395         return lex_error(ctx, E_FAIL);
 396     }
 397
 398     return tStringLiteral;
 399 }
 400
 401 static literal_t *new_double_literal(parser_ctx_t *ctx, DOUBLE d)
 402 {
 403     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 404
 405     ret->type = LT_DOUBLE;
 406     ret->u.dval = d;
 407     return ret;
 408 }
 409
 410 literal_t *new_boolean_literal(parser_ctx_t *ctx, BOOL bval)
 411 {
 412     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 413
 414     ret->type = LT_BOOL;
 415     ret->u.bval = bval;
 416
 417     return ret;
 418 }
 419
 420 HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret)
 421 {
 422     const WCHAR *ptr = *iter;
 423     LONGLONG d = 0, hlp;
 424     int exp = 0;
 425
 426     while(ptr < end && isdigitW(*ptr)) {
 427         hlp = d*10 + *(ptr++) - '0';
 428         if(d>MAXLONGLONG/10 || hlp<0) {
 429             exp++;
 430             break;
 431         }
 432         else
 433             d = hlp;
 434     }
 435     while(ptr < end && isdigitW(*ptr)) {
 436         exp++;
 437         ptr++;
 438     }
 439
 440     if(*ptr == '.') {
 441         ptr++;
 442
 443         while(ptr < end && isdigitW(*ptr)) {
 444             hlp = d*10 + *(ptr++) - '0';
 445             if(d>MAXLONGLONG/10 || hlp<0)
 446                 break;
 447
 448             d = hlp;
 449             exp--;
 450         }
 451         while(ptr < end && isdigitW(*ptr))
 452             ptr++;
 453     }
 454
 455     if(ptr < end && (*ptr == 'e' || *ptr == 'E')) {
 456         int sign = 1, e = 0;
 457
 458         if(++ptr < end) {
 459             if(*ptr == '+') {
 460                 ptr++;
 461             }else if(*ptr == '-') {
 462                 sign = -1;
 463                 ptr++;
 464             }else if(!isdigitW(*ptr)) {
 465                 WARN("Expected exponent part\n");
 466                 return E_FAIL;
 467             }
 468         }
 469
 470         if(ptr == end) {
 471             WARN("unexpected end of file\n");
 472             return E_FAIL;
 473         }
 474
 475         while(ptr < end && isdigitW(*ptr)) {
 476             if(e > INT_MAX/10 || (e = e*10 + *ptr++ - '0')<0)
 477                 e = INT_MAX;
 478         }
 479         e *= sign;
 480
 481         if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
 482         else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
 483         else exp += e;
 484     }
 485
 486     if(is_identifier_char(*ptr)) {
 487         WARN("wrong char after zero\n");
 488         return JS_E_MISSING_SEMICOLON;
 489     }
 490
 491     *ret = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp);
 492     *iter = ptr;
 493     return S_OK;
 494 }
 495
 496 static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret)
 497 {
 498     HRESULT hres;
 499
 500     if(*ctx->ptr == '0') {
 501         ctx->ptr++;
 502
 503         if(*ctx->ptr == 'x' || *ctx->ptr == 'X') {
 504             double r = 0;
 505             int d;
 506             if(++ctx->ptr == ctx->end) {
 507                 ERR("unexpected end of file\n");
 508                 return FALSE;
 509             }
 510
 511             while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) {
 512                 r = r*16 + d;
 513                 ctx->ptr++;
 514             }
 515
 516             if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) {
 517                 WARN("unexpected identifier char\n");
 518                 lex_error(ctx, JS_E_MISSING_SEMICOLON);
 519                 return FALSE;
 520             }
 521
 522             *ret = r;
 523             return TRUE;
 524         }
 525
 526         if(isdigitW(*ctx->ptr)) {
 527             unsigned base = 8;
 528             const WCHAR *ptr;
 529             double val = 0;
 530
 531             for(ptr = ctx->ptr; ptr < ctx->end && isdigitW(*ptr); ptr++) {
 532                 if(*ptr > '7') {
 533                     base = 10;
 534                     break;
 535                 }
 536             }
 537
 538             do {
 539                 val = val*base + *ctx->ptr-'0';
 540             }while(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr));
 541
 542             /* FIXME: Do we need it here? */
 543             if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) {
 544                 WARN("wrong char after octal literal: '%c'\n", *ctx->ptr);
 545                 lex_error(ctx, JS_E_MISSING_SEMICOLON);
 546                 return FALSE;
 547             }
 548
 549             *ret = val;
 550             return TRUE;
 551         }
 552
 553         if(is_identifier_char(*ctx->ptr)) {
 554             WARN("wrong char after zero\n");
 555             lex_error(ctx, JS_E_MISSING_SEMICOLON);
 556             return FALSE;
 557         }
 558     }
 559
 560     hres = parse_decimal(&ctx->ptr, ctx->end, ret);
 561     if(FAILED(hres)) {
 562         lex_error(ctx, hres);
 563         return FALSE;
 564     }
 565
 566     return TRUE;
 567 }
 568
 569 static int next_token(parser_ctx_t *ctx, void *lval)
 570 {
 571     do {
 572         if(!skip_spaces(ctx))
 573             return tEOF;
 574     }while(skip_comment(ctx) || skip_html_comment(ctx));
 575
 576     if(ctx->implicit_nl_semicolon) {
 577         if(ctx->nl)
 578             return ';';
 579         ctx->implicit_nl_semicolon = FALSE;
 580     }
 581
 582     if(isalphaW(*ctx->ptr)) {
 583         int ret = check_keywords(ctx, lval);
 584         if(ret)
 585             return ret;
 586
 587         return parse_identifier(ctx, lval);
 588     }
 589
 590     if(isdigitW(*ctx->ptr)) {
 591         double n;
 592
 593         if(!parse_numeric_literal(ctx, &n))
 594             return -1;
 595
 596         *(literal_t**)lval = new_double_literal(ctx, n);
 597         return tNumericLiteral;
 598     }
 599
 600     switch(*ctx->ptr) {
 601     case '{':
 602     case '(':
 603     case ')':
 604     case '[':
 605     case ']':
 606     case ';':
 607     case ',':
 608     case '~':
 609     case '?':
 610         return *ctx->ptr++;
 611
 612     case '}':
 613         *(const WCHAR**)lval = ctx->ptr++;
 614         return '}';
 615
 616     case '.':
 617         if(ctx->ptr+1 < ctx->end && isdigitW(ctx->ptr[1])) {
 618             double n;
 619             HRESULT hres;
 620             hres = parse_decimal(&ctx->ptr, ctx->end, &n);
 621             if(FAILED(hres)) {
 622                 lex_error(ctx, hres);
 623                 return -1;
 624             }
 625             *(literal_t**)lval = new_double_literal(ctx, n);
 626             return tNumericLiteral;
 627         }
 628         ctx->ptr++;
 629         return '.';
 630
 631     case '<':
 632         if(++ctx->ptr == ctx->end) {
 633             *(int*)lval = EXPR_LESS;
 634             return tRelOper;
 635         }
 636
 637         switch(*ctx->ptr) {
 638         case '=':  /* <= */
 639             ctx->ptr++;
 640             *(int*)lval = EXPR_LESSEQ;
 641             return tRelOper;
 642         case '<':  /* << */
 643             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* <<= */
 644                 ctx->ptr++;
 645                 *(int*)lval = EXPR_ASSIGNLSHIFT;
 646                 return tAssignOper;
 647             }
 648             *(int*)lval = EXPR_LSHIFT;
 649             return tShiftOper;
 650         default: /* < */
 651             *(int*)lval = EXPR_LESS;
 652             return tRelOper;
 653         }
 654
 655     case '>':
 656         if(++ctx->ptr == ctx->end) { /* > */
 657             *(int*)lval = EXPR_GREATER;
 658             return tRelOper;
 659         }
 660
 661         switch(*ctx->ptr) {
 662         case '=':  /* >= */
 663             ctx->ptr++;
 664             *(int*)lval = EXPR_GREATEREQ;
 665             return tRelOper;
 666         case '>':  /* >> */
 667             if(++ctx->ptr < ctx->end) {
 668                 if(*ctx->ptr == '=') {  /* >>= */
 669                     ctx->ptr++;
 670                     *(int*)lval = EXPR_ASSIGNRSHIFT;
 671                     return tAssignOper;
 672                 }
 673                 if(*ctx->ptr == '>') {  /* >>> */
 674                     if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* >>>= */
 675                         ctx->ptr++;
 676                         *(int*)lval = EXPR_ASSIGNRRSHIFT;
 677                         return tAssignOper;
 678                     }
 679                     *(int*)lval = EXPR_RRSHIFT;
 680                     return tRelOper;
 681                 }
 682             }
 683             *(int*)lval = EXPR_RSHIFT;
 684             return tShiftOper;
 685         default:
 686             *(int*)lval = EXPR_GREATER;
 687             return tRelOper;
 688         }
 689
 690     case '+':
 691         ctx->ptr++;
 692         if(ctx->ptr < ctx->end) {
 693             switch(*ctx->ptr) {
 694             case '+':  /* ++ */
 695                 ctx->ptr++;
 696                 return tINC;
 697             case '=':  /* += */
 698                 ctx->ptr++;
 699                 *(int*)lval = EXPR_ASSIGNADD;
 700                 return tAssignOper;
 701             }
 702         }
 703         return '+';
 704
 705     case '-':
 706         ctx->ptr++;
 707         if(ctx->ptr < ctx->end) {
 708             switch(*ctx->ptr) {
 709             case '-':  /* -- or --> */
 710                 ctx->ptr++;
 711                 if(ctx->is_html && ctx->nl && ctx->ptr < ctx->end && *ctx->ptr == '>') {
 712                     ctx->ptr++;
 713                     return tHTMLCOMMENT;
 714                 }
 715                 return tDEC;
 716             case '=':  /* -= */
 717                 ctx->ptr++;
 718                 *(int*)lval = EXPR_ASSIGNSUB;
 719                 return tAssignOper;
 720             }
 721         }
 722         return '-';
 723
 724     case '*':
 725         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* *= */
 726             ctx->ptr++;
 727             *(int*)lval = EXPR_ASSIGNMUL;
 728             return tAssignOper;
 729         }
 730         return '*';
 731
 732     case '%':
 733         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* %= */
 734             ctx->ptr++;
 735             *(int*)lval = EXPR_ASSIGNMOD;
 736             return tAssignOper;
 737         }
 738         return '%';
 739
 740     case '&':
 741         if(++ctx->ptr < ctx->end) {
 742             switch(*ctx->ptr) {
 743             case '=':  /* &= */
 744                 ctx->ptr++;
 745                 *(int*)lval = EXPR_ASSIGNAND;
 746                 return tAssignOper;
 747             case '&':  /* && */
 748                 ctx->ptr++;
 749                 return tANDAND;
 750             }
 751         }
 752         return '&';
 753
 754     case '|':
 755         if(++ctx->ptr < ctx->end) {
 756             switch(*ctx->ptr) {
 757             case '=':  /* |= */
 758                 ctx->ptr++;
 759                 *(int*)lval = EXPR_ASSIGNOR;
 760                 return tAssignOper;
 761             case '|':  /* || */
 762                 ctx->ptr++;
 763                 return tOROR;
 764             }
 765         }
 766         return '|';
 767
 768     case '^':
 769         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* ^= */
 770             ctx->ptr++;
 771             *(int*)lval = EXPR_ASSIGNXOR;
 772             return tAssignOper;
 773         }
 774         return '^';
 775
 776     case '!':
 777         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* != */
 778             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* !== */
 779                 ctx->ptr++;
 780                 *(int*)lval = EXPR_NOTEQEQ;
 781                 return tEqOper;
 782             }
 783             *(int*)lval = EXPR_NOTEQ;
 784             return tEqOper;
 785         }
 786         return '!';
 787
 788     case '=':
 789         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* == */
 790             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* === */
 791                 ctx->ptr++;
 792                 *(int*)lval = EXPR_EQEQ;
 793                 return tEqOper;
 794             }
 795             *(int*)lval = EXPR_EQ;
 796             return tEqOper;
 797         }
 798         return '=';
 799
 800     case '/':
 801         if(++ctx->ptr < ctx->end) {
 802             if(*ctx->ptr == '=') {  /* /= */
 803                 ctx->ptr++;
 804                 *(int*)lval = EXPR_ASSIGNDIV;
 805                 return kDIVEQ;
 806             }
 807         }
 808         return '/';
 809
 810     case ':':
 811         if(++ctx->ptr < ctx->end && *ctx->ptr == ':') {
 812             ctx->ptr++;
 813             return kDCOL;
 814         }
 815         return ':';
 816
 817     case '\"':
 818     case '\'':
 819         return parse_string_literal(ctx, lval, *ctx->ptr);
 820
 821     case '_':
 822     case '$':
 823         return parse_identifier(ctx, lval);
 824
 825     case '@':
 826         return '@';
 827     }
 828
 829     WARN("unexpected char '%c' %d\n", *ctx->ptr, *ctx->ptr);
 830     return 0;
 831 }
 832
 833 struct _cc_var_t {
 834     ccval_t val;
 835     struct _cc_var_t *next;
 836     unsigned name_len;
 837     WCHAR name[0];
 838 };
 839
 840 void release_cc(cc_ctx_t *cc)
 841 {
 842     cc_var_t *iter, *next;
 843
 844     for(iter = cc->vars; iter; iter = next) {
 845         next = iter->next;
 846         heap_free(iter);
 847     }
 848
 849     heap_free(cc);
 850 }
 851
 852 static BOOL new_cc_var(cc_ctx_t *cc, const WCHAR *name, int len, ccval_t v)
 853 {
 854     cc_var_t *new_v;
 855
 856     if(len == -1)
 857         len = strlenW(name);
 858
 859     new_v = heap_alloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR));
 860     if(!new_v)
 861         return FALSE;
 862
 863     new_v->val = v;
 864     memcpy(new_v->name, name, (len+1)*sizeof(WCHAR));
 865     new_v->name_len = len;
 866     new_v->next = cc->vars;
 867     cc->vars = new_v;
 868     return TRUE;
 869 }
 870
 871 static cc_var_t *find_cc_var(cc_ctx_t *cc, const WCHAR *name, unsigned name_len)
 872 {
 873     cc_var_t *iter;
 874
 875     for(iter = cc->vars; iter; iter = iter->next) {
 876         if(iter->name_len == name_len && !memcmp(iter->name, name, name_len*sizeof(WCHAR)))
 877             return iter;
 878     }
 879
 880     return NULL;
 881 }
 882
 883 static BOOL init_cc(parser_ctx_t *ctx)
 884 {
 885     cc_ctx_t *cc;
 886
 887     static const WCHAR _win32W[] = {'_','w','i','n','3','2',0};
 888     static const WCHAR _win64W[] = {'_','w','i','n','6','4',0};
 889     static const WCHAR _x86W[] = {'_','x','8','6',0};
 890     static const WCHAR _amd64W[] = {'_','a','m','d','6','4',0};
 891     static const WCHAR _jscriptW[] = {'_','j','s','c','r','i','p','t',0};
 892     static const WCHAR _jscript_buildW[] = {'_','j','s','c','r','i','p','t','_','b','u','i','l','d',0};
 893     static const WCHAR _jscript_versionW[] = {'_','j','s','c','r','i','p','t','_','v','e','r','s','i','o','n',0};
 894
 895     if(ctx->script->cc)
 896         return TRUE;
 897
 898     cc = heap_alloc(sizeof(cc_ctx_t));
 899     if(!cc) {
 900         lex_error(ctx, E_OUTOFMEMORY);
 901         return FALSE;
 902     }
 903
 904     cc->vars = NULL;
 905
 906     if(!new_cc_var(cc, _jscriptW, -1, ccval_bool(TRUE))
 907        || !new_cc_var(cc, sizeof(void*) == 8 ? _win64W : _win32W, -1, ccval_bool(TRUE))
 908        || !new_cc_var(cc, sizeof(void*) == 8 ? _amd64W : _x86W, -1, ccval_bool(TRUE))
 909        || !new_cc_var(cc, _jscript_versionW, -1, ccval_num(JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0))
 910        || !new_cc_var(cc, _jscript_buildW, -1, ccval_num(JSCRIPT_BUILD_VERSION))) {
 911         release_cc(cc);
 912         lex_error(ctx, E_OUTOFMEMORY);
 913         return FALSE;
 914     }
 915
 916     ctx->script->cc = cc;
 917     return TRUE;
 918 }
 919
 920 static BOOL parse_cc_identifier(parser_ctx_t *ctx, const WCHAR **ret, unsigned *ret_len)
 921 {
 922     if(*ctx->ptr != '@') {
 923         lex_error(ctx, JS_E_EXPECTED_AT);
 924         return FALSE;
 925     }
 926
 927     if(!is_identifier_first_char(*++ctx->ptr)) {
 928         lex_error(ctx, JS_E_EXPECTED_IDENTIFIER);
 929         return FALSE;
 930     }
 931
 932     *ret = ctx->ptr;
 933     while(++ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr));
 934     *ret_len = ctx->ptr - *ret;
 935     return TRUE;
 936 }
 937
 938 int try_parse_ccval(parser_ctx_t *ctx, ccval_t *r)
 939 {
 940     if(!skip_spaces(ctx))
 941         return -1;
 942
 943     if(isdigitW(*ctx->ptr)) {
 944         double n;
 945
 946         if(!parse_numeric_literal(ctx, &n))
 947             return -1;
 948
 949         *r = ccval_num(n);
 950         return 1;
 951     }
 952
 953     if(*ctx->ptr == '@') {
 954         const WCHAR *ident;
 955         unsigned ident_len;
 956         cc_var_t *cc_var;
 957
 958         if(!parse_cc_identifier(ctx, &ident, &ident_len))
 959             return -1;
 960
 961         cc_var = find_cc_var(ctx->script->cc, ident, ident_len);
 962         *r = cc_var ? cc_var->val : ccval_num(NAN);
 963         return 1;
 964     }
 965
 966     if(!check_keyword(ctx, trueW, NULL)) {
 967         *r = ccval_bool(TRUE);
 968         return 1;
 969     }
 970
 971     if(!check_keyword(ctx, falseW, NULL)) {
 972         *r = ccval_bool(FALSE);
 973         return 1;
 974     }
 975
 976     return 0;
 977 }
 978
 979 static int skip_code(parser_ctx_t *ctx, BOOL exec_else)
 980 {
 981     int if_depth = 1;
 982     const WCHAR *ptr;
 983
 984     while(1) {
 985         ptr = strchrW(ctx->ptr, '@');
 986         if(!ptr) {
 987             WARN("No @end\n");
 988             return lex_error(ctx, JS_E_EXPECTED_CCEND);
 989         }
 990         ctx->ptr = ptr+1;
 991
 992         if(!check_keyword(ctx, endW, NULL)) {
 993             if(--if_depth)
 994                 continue;
 995             return 0;
 996         }
 997
 998         if(exec_else && !check_keyword(ctx, elifW, NULL)) {
 999             if(if_depth > 1)
1000                 continue;
1001
1002             if(!skip_spaces(ctx) || *ctx->ptr != '(')
1003                 return lex_error(ctx, JS_E_MISSING_LBRACKET);
1004
1005             if(!parse_cc_expr(ctx))
1006                 return -1;
1007
1008             if(!get_ccbool(ctx->ccval))
1009                 continue; /* skip block of code */
1010
1011             /* continue parsing */
1012             ctx->cc_if_depth++;
1013             return 0;
1014         }
1015
1016         if(exec_else && !check_keyword(ctx, elseW, NULL)) {
1017             if(if_depth > 1)
1018                 continue;
1019
1020             /* parse else block */
1021             ctx->cc_if_depth++;
1022             return 0;
1023         }
1024
1025         if(!check_keyword(ctx, ifW, NULL)) {
1026             if_depth++;
1027             continue;
1028         }
1029
1030         ctx->ptr++;
1031     }
1032 }
1033
1034 static int cc_token(parser_ctx_t *ctx, void *lval)
1035 {
1036     unsigned id_len = 0;
1037     cc_var_t *var;
1038
1039     static const WCHAR cc_onW[] = {'c','c','_','o','n',0};
1040     static const WCHAR setW[] = {'s','e','t',0};
1041
1042     ctx->ptr++;
1043
1044     if(!check_keyword(ctx, cc_onW, NULL))
1045         return init_cc(ctx) ? 0 : -1;
1046
1047     if(!check_keyword(ctx, setW, NULL)) {
1048         const WCHAR *ident;
1049         unsigned ident_len;
1050         cc_var_t *var;
1051
1052         if(!init_cc(ctx))
1053             return -1;
1054
1055         if(!skip_spaces(ctx))
1056             return lex_error(ctx, JS_E_EXPECTED_AT);
1057
1058         if(!parse_cc_identifier(ctx, &ident, &ident_len))
1059             return -1;
1060
1061         if(!skip_spaces(ctx) || *ctx->ptr != '=')
1062             return lex_error(ctx, JS_E_EXPECTED_ASSIGN);
1063         ctx->ptr++;
1064
1065         if(!parse_cc_expr(ctx)) {
1066             WARN("parsing CC expression failed\n");
1067             return -1;
1068         }
1069
1070         var = find_cc_var(ctx->script->cc, ident, ident_len);
1071         if(var) {
1072             var->val = ctx->ccval;
1073         }else {
1074             if(!new_cc_var(ctx->script->cc, ident, ident_len, ctx->ccval))
1075                 return lex_error(ctx, E_OUTOFMEMORY);
1076         }
1077
1078         return 0;
1079     }
1080
1081     if(!check_keyword(ctx, ifW, NULL)) {
1082         if(!init_cc(ctx))
1083             return -1;
1084
1085         if(!skip_spaces(ctx) || *ctx->ptr != '(')
1086             return lex_error(ctx, JS_E_MISSING_LBRACKET);
1087
1088         if(!parse_cc_expr(ctx))
1089             return -1;
1090
1091         if(get_ccbool(ctx->ccval)) {
1092             /* continue parsing block inside if */
1093             ctx->cc_if_depth++;
1094             return 0;
1095         }
1096
1097         return skip_code(ctx, TRUE);
1098     }
1099
1100     if(!check_keyword(ctx, elifW, NULL) || !check_keyword(ctx, elseW, NULL)) {
1101         if(!ctx->cc_if_depth)
1102             return lex_error(ctx, JS_E_SYNTAX);
1103
1104         return skip_code(ctx, FALSE);
1105     }
1106
1107     if(!check_keyword(ctx, endW, NULL)) {
1108         if(!ctx->cc_if_depth)
1109             return lex_error(ctx, JS_E_SYNTAX);
1110
1111         ctx->cc_if_depth--;
1112         return 0;
1113     }
1114
1115     if(!ctx->script->cc)
1116         return lex_error(ctx, JS_E_DISABLED_CC);
1117
1118     while(ctx->ptr+id_len < ctx->end && is_identifier_char(ctx->ptr[id_len]))
1119         id_len++;
1120     if(!id_len)
1121         return '@';
1122
1123     TRACE("var %s\n", debugstr_wn(ctx->ptr, id_len));
1124
1125     var = find_cc_var(ctx->script->cc, ctx->ptr, id_len);
1126     ctx->ptr += id_len;
1127     if(!var || var->val.is_num) {
1128         *(literal_t**)lval = new_double_literal(ctx, var ? var->val.u.n : NAN);
1129         return tNumericLiteral;
1130     }
1131
1132     *(literal_t**)lval = new_boolean_literal(ctx, var->val.u.b);
1133     return tBooleanLiteral;
1134 }
1135
1136 int parser_lex(void *lval, parser_ctx_t *ctx)
1137 {
1138     int ret;
1139
1140     ctx->nl = ctx->ptr == ctx->begin;
1141
1142     do {
1143         ret = next_token(ctx, lval);
1144     } while(ret == '@' && !(ret = cc_token(ctx, lval)));
1145
1146     return ret;
1147 }
1148
1149 literal_t *parse_regexp(parser_ctx_t *ctx)
1150 {
1151     const WCHAR *re, *flags_ptr;
1152     BOOL in_class = FALSE;
1153     DWORD re_len, flags;
1154     literal_t *ret;
1155     HRESULT hres;
1156
1157     TRACE("\n");
1158
1159     while(*--ctx->ptr != '/');
1160
1161     /* Simple regexp pre-parser; '/' if used in char class does not terminate regexp literal */
1162     re = ++ctx->ptr;
1163     while(ctx->ptr < ctx->end) {
1164         if(*ctx->ptr == '\\') {
1165             if(++ctx->ptr == ctx->end)
1166                 break;
1167         }else if(in_class) {
1168             if(*ctx->ptr == '\n')
1169                 break;
1170             if(*ctx->ptr == ']')
1171                 in_class = FALSE;
1172         }else {
1173             if(*ctx->ptr == '/')
1174                 break;
1175
1176             if(*ctx->ptr == '[')
1177                 in_class = TRUE;
1178         }
1179         ctx->ptr++;
1180     }
1181
1182     if(ctx->ptr == ctx->end || *ctx->ptr != '/') {
1183         WARN("pre-parsing failed\n");
1184         return NULL;
1185     }
1186
1187     re_len = ctx->ptr-re;
1188
1189     flags_ptr = ++ctx->ptr;
1190     while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr))
1191         ctx->ptr++;
1192
1193     hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
1194     if(FAILED(hres))
1195         return NULL;
1196
1197     ret = parser_alloc(ctx, sizeof(literal_t));
1198     ret->type = LT_REGEXP;
1199     ret->u.regexp.str = re;
1200     ret->u.regexp.str_len = re_len;
1201     ret->u.regexp.flags = flags;
1202     return ret;
1203 }