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