git.oblomov.eu Git - wine/blob - 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
  29 #include "parser.tab.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  35
  36 #define LONGLONG_MAX (((LONGLONG)0x7fffffff<<32)|0xffffffff)
  37
  38 static const WCHAR breakW[] = {'b','r','e','a','k',0};
  39 static const WCHAR caseW[] = {'c','a','s','e',0};
  40 static const WCHAR catchW[] = {'c','a','t','c','h',0};
  41 static const WCHAR continueW[] = {'c','o','n','t','i','n','u','e',0};
  42 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
  43 static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
  44 static const WCHAR doW[] = {'d','o',0};
  45 static const WCHAR elseW[] = {'e','l','s','e',0};
  46 static const WCHAR falseW[] = {'f','a','l','s','e',0};
  47 static const WCHAR finallyW[] = {'f','i','n','a','l','l','y',0};
  48 static const WCHAR forW[] = {'f','o','r',0};
  49 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',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 switchW[] = {'s','w','i','t','c','h',0};
  57 static const WCHAR thisW[] = {'t','h','i','s',0};
  58 static const WCHAR throwW[] = {'t','h','r','o','w',0};
  59 static const WCHAR trueW[] = {'t','r','u','e',0};
  60 static const WCHAR tryW[] = {'t','r','y',0};
  61 static const WCHAR typeofW[] = {'t','y','p','e','o','f',0};
  62 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',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 struct {
  69     const WCHAR *word;
  70     int token;
  71 } keywords[] = {
  72     {breakW,       kBREAK},
  73     {caseW,        kCASE},
  74     {catchW,       kCATCH},
  75     {continueW,    kCONTINUE},
  76     {defaultW,     kDEFAULT},
  77     {deleteW,      kDELETE},
  78     {doW,          kDO},
  79     {elseW,        kELSE},
  80     {falseW,       kFALSE},
  81     {finallyW,     kFINALLY},
  82     {forW,         kFOR},
  83     {functionW,    kFUNCTION},
  84     {ifW,          kIF},
  85     {inW,          kIN},
  86     {instanceofW,  kINSTANCEOF},
  87     {newW,         kNEW},
  88     {nullW,        kNULL},
  89     {returnW,      kRETURN},
  90     {switchW,      kSWITCH},
  91     {thisW,        kTHIS},
  92     {throwW,       kTHROW},
  93     {trueW,        kTRUE},
  94     {tryW,         kTRY},
  95     {typeofW,      kTYPEOF},
  96     {varW,         kVAR},
  97     {voidW,        kVOID},
  98     {whileW,       kWHILE},
  99     {withW,        kWITH}
 100 };
 101
 102 static int lex_error(parser_ctx_t *ctx, HRESULT hres)
 103 {
 104     ctx->hres = hres;
 105     ctx->lexer_error = TRUE;
 106     return -1;
 107 }
 108
 109 /* ECMA-262 3rd Edition    7.6 */
 110 static BOOL is_identifier_char(WCHAR c)
 111 {
 112     return isalnumW(c) || c == '$' || c == '_' || c == '\\';
 113 }
 114
 115 static int check_keyword(parser_ctx_t *ctx, const WCHAR *word, const WCHAR **lval)
 116 {
 117     const WCHAR *p1 = ctx->ptr;
 118     const WCHAR *p2 = word;
 119
 120     while(p1 < ctx->end && *p2) {
 121         if(*p1 != *p2)
 122             return *p1 - *p2;
 123         p1++;
 124         p2++;
 125     }
 126
 127     if(*p2 || (p1 < ctx->end && is_identifier_char(*p1)))
 128         return 1;
 129
 130     if(lval)
 131         *lval = ctx->ptr;
 132     ctx->ptr = p1;
 133     return 0;
 134 }
 135
 136 /* ECMA-262 3rd Edition    7.3 */
 137 static BOOL is_endline(WCHAR c)
 138 {
 139     return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;
 140 }
 141
 142 static int hex_to_int(WCHAR c)
 143 {
 144     if('0' <= c && c <= '9')
 145         return c-'0';
 146
 147     if('a' <= c && c <= 'f')
 148         return c-'a'+10;
 149
 150     if('A' <= c && c <= 'F')
 151         return c-'A'+10;
 152
 153     return -1;
 154 }
 155
 156 static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
 157 {
 158     int min = 0, max = sizeof(keywords)/sizeof(keywords[0])-1, r, i;
 159
 160     while(min <= max) {
 161         i = (min+max)/2;
 162
 163         r = check_keyword(ctx, keywords[i].word, lval);
 164         if(!r)
 165             return keywords[i].token;
 166
 167         if(r > 0)
 168             min = i+1;
 169         else
 170             max = i-1;
 171     }
 172
 173     return 0;
 174 }
 175
 176 static void skip_spaces(parser_ctx_t *ctx)
 177 {
 178     while(ctx->ptr < ctx->end && isspaceW(*ctx->ptr)) {
 179         if(is_endline(*ctx->ptr++))
 180             ctx->nl = TRUE;
 181     }
 182 }
 183
 184 static BOOL skip_html_comment(parser_ctx_t *ctx)
 185 {
 186     const WCHAR html_commentW[] = {'<','!','-','-',0};
 187
 188     if(!ctx->is_html || ctx->ptr+3 >= ctx->end ||
 189         memcmp(ctx->ptr, html_commentW, sizeof(WCHAR)*4))
 190         return FALSE;
 191
 192     ctx->nl = TRUE;
 193     while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr++));
 194
 195     return TRUE;
 196 }
 197
 198 static BOOL skip_comment(parser_ctx_t *ctx)
 199 {
 200     if(ctx->ptr+1 >= ctx->end)
 201         return FALSE;
 202
 203     if(*ctx->ptr != '/') {
 204         if(*ctx->ptr == '@' && ctx->ptr+2 < ctx->end && ctx->ptr[1] == '*' && ctx->ptr[2] == '/') {
 205             ctx->ptr += 3;
 206             return TRUE;
 207         }
 208
 209         return FALSE;
 210     }
 211
 212     switch(ctx->ptr[1]) {
 213     case '*':
 214         ctx->ptr += 2;
 215         if(ctx->ptr+2 < ctx->end && *ctx->ptr == '@' && is_identifier_char(ctx->ptr[1]))
 216             return FALSE;
 217         while(ctx->ptr+1 < ctx->end && (ctx->ptr[0] != '*' || ctx->ptr[1] != '/'))
 218             ctx->ptr++;
 219
 220         if(ctx->ptr[0] == '*' && ctx->ptr[1] == '/') {
 221             ctx->ptr += 2;
 222         }else {
 223             WARN("unexpected end of file (missing end of comment)\n");
 224             ctx->ptr = ctx->end;
 225         }
 226         break;
 227     case '/':
 228         ctx->ptr += 2;
 229         if(ctx->ptr+2 < ctx->end && *ctx->ptr == '@' && is_identifier_char(ctx->ptr[1]))
 230             return FALSE;
 231         while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr))
 232             ctx->ptr++;
 233         break;
 234     default:
 235         return FALSE;
 236     }
 237
 238     return TRUE;
 239 }
 240
 241 static BOOL unescape(WCHAR *str)
 242 {
 243     WCHAR *pd, *p, c;
 244     int i;
 245
 246     pd = p = str;
 247     while(*p) {
 248         if(*p != '\\') {
 249             *pd++ = *p++;
 250             continue;
 251         }
 252
 253         p++;
 254
 255         switch(*p) {
 256         case '\'':
 257         case '\"':
 258         case '\\':
 259             c = *p;
 260             break;
 261         case 'b':
 262             c = '\b';
 263             break;
 264         case 't':
 265             c = '\t';
 266             break;
 267         case 'n':
 268             c = '\n';
 269             break;
 270         case 'f':
 271             c = '\f';
 272             break;
 273         case 'r':
 274             c = '\r';
 275             break;
 276         case 'x':
 277             i = hex_to_int(*++p);
 278             if(i == -1)
 279                 return FALSE;
 280             c = i << 4;
 281
 282             i = hex_to_int(*++p);
 283             if(i == -1)
 284                 return FALSE;
 285             c += i;
 286             break;
 287         case 'u':
 288             i = hex_to_int(*++p);
 289             if(i == -1)
 290                 return FALSE;
 291             c = i << 12;
 292
 293             i = hex_to_int(*++p);
 294             if(i == -1)
 295                 return FALSE;
 296             c += i << 8;
 297
 298             i = hex_to_int(*++p);
 299             if(i == -1)
 300                 return FALSE;
 301             c += i << 4;
 302
 303             i = hex_to_int(*++p);
 304             if(i == -1)
 305                 return FALSE;
 306             c += i;
 307             break;
 308         default:
 309             if(isdigitW(*p)) {
 310                 c = *p++ - '0';
 311                 if(isdigitW(*p)) {
 312                     c = c*8 + (*p++ - '0');
 313                     if(isdigitW(*p))
 314                         c = c*8 + (*p++ - '0');
 315                 }
 316                 p--;
 317             }
 318             else
 319                 c = *p;
 320         }
 321
 322         *pd++ = c;
 323         p++;
 324     }
 325
 326     *pd = 0;
 327     return TRUE;
 328 }
 329
 330 static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
 331 {
 332     const WCHAR *ptr = ctx->ptr++;
 333     WCHAR *wstr;
 334     int len;
 335
 336     while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr))
 337         ctx->ptr++;
 338
 339     len = ctx->ptr-ptr;
 340
 341     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 342     memcpy(wstr, ptr, len*sizeof(WCHAR));
 343     wstr[len] = 0;
 344
 345     /* FIXME: unescape */
 346     return tIdentifier;
 347 }
 348
 349 static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret, WCHAR endch)
 350 {
 351     const WCHAR *ptr = ++ctx->ptr;
 352     WCHAR *wstr;
 353     int len;
 354
 355     while(ctx->ptr < ctx->end && *ctx->ptr != endch) {
 356         if(*ctx->ptr++ == '\\')
 357             ctx->ptr++;
 358     }
 359
 360     if(ctx->ptr == ctx->end)
 361         return lex_error(ctx, JS_E_UNTERMINATED_STRING);
 362
 363     len = ctx->ptr-ptr;
 364
 365     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 366     memcpy(wstr, ptr, len*sizeof(WCHAR));
 367     wstr[len] = 0;
 368
 369     ctx->ptr++;
 370
 371     if(!unescape(wstr)) {
 372         WARN("unescape failed\n");
 373         return lex_error(ctx, E_FAIL);
 374     }
 375
 376     return tStringLiteral;
 377 }
 378
 379 static literal_t *new_double_literal(parser_ctx_t *ctx, DOUBLE d)
 380 {
 381     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 382
 383     ret->type = LT_DOUBLE;
 384     ret->u.dval = d;
 385     return ret;
 386 }
 387
 388 literal_t *new_boolean_literal(parser_ctx_t *ctx, VARIANT_BOOL bval)
 389 {
 390     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 391
 392     ret->type = LT_BOOL;
 393     ret->u.bval = bval;
 394
 395     return ret;
 396 }
 397
 398 static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **literal)
 399 {
 400     LONGLONG d, hlp;
 401     int exp = 0;
 402
 403     d = int_part;
 404     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 405         hlp = d*10 + *(ctx->ptr++) - '0';
 406         if(d>LONGLONG_MAX/10 || hlp<0) {
 407             exp++;
 408             break;
 409         }
 410         else
 411             d = hlp;
 412     }
 413     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 414         exp++;
 415         ctx->ptr++;
 416     }
 417
 418     if(*ctx->ptr == '.') {
 419         ctx->ptr++;
 420
 421         while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 422             hlp = d*10 + *(ctx->ptr++) - '0';
 423             if(d>LONGLONG_MAX/10 || hlp<0)
 424                 break;
 425
 426             d = hlp;
 427             exp--;
 428         }
 429         while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
 430             ctx->ptr++;
 431     }
 432
 433     if(ctx->ptr < ctx->end && (*ctx->ptr == 'e' || *ctx->ptr == 'E')) {
 434         int sign = 1, e = 0;
 435
 436         ctx->ptr++;
 437         if(ctx->ptr < ctx->end) {
 438             if(*ctx->ptr == '+') {
 439                 ctx->ptr++;
 440             }else if(*ctx->ptr == '-') {
 441                 sign = -1;
 442                 ctx->ptr++;
 443             }else if(!isdigitW(*ctx->ptr)) {
 444                 WARN("Expected exponent part\n");
 445                 return lex_error(ctx, E_FAIL);
 446             }
 447         }
 448
 449         if(ctx->ptr == ctx->end) {
 450             WARN("unexpected end of file\n");
 451             return lex_error(ctx, E_FAIL);
 452         }
 453
 454         while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 455             if(e > INT_MAX/10 || (e = e*10 + *ctx->ptr++ - '0')<0)
 456                 e = INT_MAX;
 457         }
 458         e *= sign;
 459
 460         if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
 461         else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
 462         else exp += e;
 463     }
 464
 465     *literal = new_double_literal(ctx, exp>=0 ? d*pow(10, exp) : d/pow(10, -exp));
 466     return tNumericLiteral;
 467 }
 468
 469 static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal)
 470 {
 471     LONG l, d;
 472
 473     l = *ctx->ptr++ - '0';
 474     if(!l) {
 475         if(*ctx->ptr == 'x' || *ctx->ptr == 'X') {
 476             if(++ctx->ptr == ctx->end) {
 477                 ERR("unexpected end of file\n");
 478                 return 0;
 479             }
 480
 481             while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) {
 482                 l = l*16 + d;
 483                 ctx->ptr++;
 484             }
 485
 486             if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) {
 487                 WARN("unexpected identifier char\n");
 488                 return lex_error(ctx, E_FAIL);
 489             }
 490
 491             *literal = new_double_literal(ctx, l);
 492             return tNumericLiteral;
 493         }
 494
 495         if(is_identifier_char(*ctx->ptr)) {
 496             WARN("wrong char after zero\n");
 497             return lex_error(ctx, E_FAIL);
 498         }
 499
 500         if(isdigitW(*ctx->ptr)) {
 501             FIXME("octal literals not implemented\n");
 502             return lex_error(ctx, E_NOTIMPL);
 503         }
 504     }
 505
 506     return parse_double_literal(ctx, l, literal);
 507 }
 508
 509 static int next_token(parser_ctx_t *ctx, void *lval)
 510 {
 511     do {
 512         skip_spaces(ctx);
 513         if(ctx->ptr == ctx->end)
 514             return tEOF;
 515     }while(skip_comment(ctx) || skip_html_comment(ctx));
 516
 517     if(isalphaW(*ctx->ptr)) {
 518         int ret = check_keywords(ctx, lval);
 519         if(ret)
 520             return ret;
 521
 522         return parse_identifier(ctx, lval);
 523     }
 524
 525     if(isdigitW(*ctx->ptr))
 526         return parse_numeric_literal(ctx, lval);
 527
 528     switch(*ctx->ptr) {
 529     case '{':
 530     case '(':
 531     case ')':
 532     case '[':
 533     case ']':
 534     case ';':
 535     case ',':
 536     case '~':
 537     case '?':
 538     case ':':
 539         return *ctx->ptr++;
 540
 541     case '}':
 542         *(const WCHAR**)lval = ctx->ptr++;
 543         return '}';
 544
 545     case '.':
 546         if(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
 547             return parse_double_literal(ctx, 0, lval);
 548         return '.';
 549
 550     case '<':
 551         if(++ctx->ptr == ctx->end) {
 552             *(int*)lval = EXPR_LESS;
 553             return tRelOper;
 554         }
 555
 556         switch(*ctx->ptr) {
 557         case '=':  /* <= */
 558             ctx->ptr++;
 559             *(int*)lval = EXPR_LESSEQ;
 560             return tRelOper;
 561         case '<':  /* << */
 562             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* <<= */
 563                 ctx->ptr++;
 564                 *(int*)lval = EXPR_ASSIGNLSHIFT;
 565                 return tAssignOper;
 566             }
 567             *(int*)lval = EXPR_LSHIFT;
 568             return tShiftOper;
 569         default: /* < */
 570             *(int*)lval = EXPR_LESS;
 571             return tRelOper;
 572         }
 573
 574     case '>':
 575         if(++ctx->ptr == ctx->end) { /* > */
 576             *(int*)lval = EXPR_GREATER;
 577             return tRelOper;
 578         }
 579
 580         switch(*ctx->ptr) {
 581         case '=':  /* >= */
 582             ctx->ptr++;
 583             *(int*)lval = EXPR_GREATEREQ;
 584             return tRelOper;
 585         case '>':  /* >> */
 586             if(++ctx->ptr < ctx->end) {
 587                 if(*ctx->ptr == '=') {  /* >>= */
 588                     ctx->ptr++;
 589                     *(int*)lval = EXPR_ASSIGNRSHIFT;
 590                     return tAssignOper;
 591                 }
 592                 if(*ctx->ptr == '>') {  /* >>> */
 593                     if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* >>>= */
 594                         ctx->ptr++;
 595                         *(int*)lval = EXPR_ASSIGNRRSHIFT;
 596                         return tAssignOper;
 597                     }
 598                     *(int*)lval = EXPR_RRSHIFT;
 599                     return tRelOper;
 600                 }
 601             }
 602             *(int*)lval = EXPR_RSHIFT;
 603             return tShiftOper;
 604         default:
 605             *(int*)lval = EXPR_GREATER;
 606             return tRelOper;
 607         }
 608
 609     case '+':
 610         ctx->ptr++;
 611         if(ctx->ptr < ctx->end) {
 612             switch(*ctx->ptr) {
 613             case '+':  /* ++ */
 614                 ctx->ptr++;
 615                 return tINC;
 616             case '=':  /* += */
 617                 ctx->ptr++;
 618                 *(int*)lval = EXPR_ASSIGNADD;
 619                 return tAssignOper;
 620             }
 621         }
 622         return '+';
 623
 624     case '-':
 625         ctx->ptr++;
 626         if(ctx->ptr < ctx->end) {
 627             switch(*ctx->ptr) {
 628             case '-':  /* -- or --> */
 629                 ctx->ptr++;
 630                 if(ctx->is_html && ctx->nl && ctx->ptr < ctx->end && *ctx->ptr == '>') {
 631                     ctx->ptr++;
 632                     return tHTMLCOMMENT;
 633                 }
 634                 return tDEC;
 635             case '=':  /* -= */
 636                 ctx->ptr++;
 637                 *(int*)lval = EXPR_ASSIGNSUB;
 638                 return tAssignOper;
 639             }
 640         }
 641         return '-';
 642
 643     case '*':
 644         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* *= */
 645             ctx->ptr++;
 646             *(int*)lval = EXPR_ASSIGNMUL;
 647             return tAssignOper;
 648         }
 649         return '*';
 650
 651     case '%':
 652         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* %= */
 653             ctx->ptr++;
 654             *(int*)lval = EXPR_ASSIGNMOD;
 655             return tAssignOper;
 656         }
 657         return '%';
 658
 659     case '&':
 660         if(++ctx->ptr < ctx->end) {
 661             switch(*ctx->ptr) {
 662             case '=':  /* &= */
 663                 ctx->ptr++;
 664                 *(int*)lval = EXPR_ASSIGNAND;
 665                 return tAssignOper;
 666             case '&':  /* && */
 667                 ctx->ptr++;
 668                 return tANDAND;
 669             }
 670         }
 671         return '&';
 672
 673     case '|':
 674         if(++ctx->ptr < ctx->end) {
 675             switch(*ctx->ptr) {
 676             case '=':  /* |= */
 677                 ctx->ptr++;
 678                 *(int*)lval = EXPR_ASSIGNOR;
 679                 return tAssignOper;
 680             case '|':  /* || */
 681                 ctx->ptr++;
 682                 return tOROR;
 683             }
 684         }
 685         return '|';
 686
 687     case '^':
 688         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* ^= */
 689             ctx->ptr++;
 690             *(int*)lval = EXPR_ASSIGNXOR;
 691             return tAssignOper;
 692         }
 693         return '^';
 694
 695     case '!':
 696         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* != */
 697             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* !== */
 698                 ctx->ptr++;
 699                 *(int*)lval = EXPR_NOTEQEQ;
 700                 return tEqOper;
 701             }
 702             *(int*)lval = EXPR_NOTEQ;
 703             return tEqOper;
 704         }
 705         return '!';
 706
 707     case '=':
 708         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* == */
 709             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* === */
 710                 ctx->ptr++;
 711                 *(int*)lval = EXPR_EQEQ;
 712                 return tEqOper;
 713             }
 714             *(int*)lval = EXPR_EQ;
 715             return tEqOper;
 716         }
 717         return '=';
 718
 719     case '/':
 720         if(++ctx->ptr < ctx->end) {
 721             if(*ctx->ptr == '=') {  /* /= */
 722                 ctx->ptr++;
 723                 *(int*)lval = EXPR_ASSIGNDIV;
 724                 return kDIVEQ;
 725             }
 726         }
 727         return '/';
 728
 729     case '\"':
 730     case '\'':
 731         return parse_string_literal(ctx, lval, *ctx->ptr);
 732
 733     case '_':
 734     case '$':
 735         return parse_identifier(ctx, lval);
 736
 737     case '@':
 738         return '@';
 739     }
 740
 741     WARN("unexpected char '%c' %d\n", *ctx->ptr, *ctx->ptr);
 742     return 0;
 743 }
 744
 745 struct _cc_var_t {
 746     BOOL is_num;
 747     union {
 748         VARIANT_BOOL b;
 749         DOUBLE n;
 750     } u;
 751     struct _cc_var_t *next;
 752     unsigned name_len;
 753     WCHAR name[0];
 754 };
 755
 756 void release_cc(cc_ctx_t *cc)
 757 {
 758     cc_var_t *iter, *next;
 759
 760     for(iter = cc->vars; iter; iter = next) {
 761         next = iter->next;
 762         heap_free(iter);
 763     }
 764
 765     heap_free(cc);
 766 }
 767
 768 static BOOL add_cc_var(cc_ctx_t *cc, const WCHAR *name, cc_var_t *v)
 769 {
 770     cc_var_t *new_v;
 771     unsigned len;
 772
 773     len = strlenW(name);
 774
 775     new_v = heap_alloc(sizeof(cc_var_t) + (len+1)*sizeof(WCHAR));
 776     if(!new_v)
 777         return FALSE;
 778
 779     memcpy(new_v, v, sizeof(*v));
 780     memcpy(new_v->name, name, (len+1)*sizeof(WCHAR));
 781     new_v->name_len = len;
 782     new_v->next = cc->vars;
 783     cc->vars = new_v;
 784     return TRUE;
 785 }
 786
 787 static cc_var_t *find_cc_var(cc_ctx_t *cc, const WCHAR *name, unsigned name_len)
 788 {
 789     cc_var_t *iter;
 790
 791     for(iter = cc->vars; iter; iter = iter->next) {
 792         if(iter->name_len == name_len && !memcmp(iter->name, name, name_len*sizeof(WCHAR)))
 793             return iter;
 794     }
 795
 796     return NULL;
 797 }
 798
 799 static int init_cc(parser_ctx_t *ctx)
 800 {
 801     cc_ctx_t *cc;
 802     cc_var_t v;
 803
 804     static const WCHAR _win32W[] = {'_','w','i','n','3','2',0};
 805     static const WCHAR _win64W[] = {'_','w','i','n','6','4',0};
 806     static const WCHAR _x86W[] = {'_','x','8','6',0};
 807     static const WCHAR _amd64W[] = {'_','a','m','d','6','4',0};
 808     static const WCHAR _jscriptW[] = {'_','j','s','c','r','i','p','t',0};
 809     static const WCHAR _jscript_buildW[] = {'_','j','s','c','r','i','p','t','_','b','u','i','l','d',0};
 810     static const WCHAR _jscript_versionW[] = {'_','j','s','c','r','i','p','t','_','v','e','r','s','i','o','n',0};
 811
 812     if(ctx->script->cc)
 813         return 0;
 814
 815     cc = heap_alloc(sizeof(cc_ctx_t));
 816     if(!cc)
 817         return lex_error(ctx, E_OUTOFMEMORY);
 818
 819     cc->vars = NULL;
 820     v.is_num = FALSE;
 821     v.u.b = VARIANT_TRUE;
 822     if(!add_cc_var(cc, _jscriptW, &v)
 823        || !add_cc_var(cc, sizeof(void*) == 8 ? _win64W : _win32W, &v)
 824        || !add_cc_var(cc, sizeof(void*) == 8 ? _amd64W : _x86W, &v)) {
 825         release_cc(cc);
 826         return lex_error(ctx, E_OUTOFMEMORY);
 827     }
 828
 829     v.is_num = TRUE;
 830     v.u.n = JSCRIPT_BUILD_VERSION;
 831     if(!add_cc_var(cc, _jscript_buildW, &v)) {
 832         release_cc(cc);
 833         return lex_error(ctx, E_OUTOFMEMORY);
 834     }
 835
 836     v.u.n = JSCRIPT_MAJOR_VERSION + (DOUBLE)JSCRIPT_MINOR_VERSION/10.0;
 837     if(!add_cc_var(cc, _jscript_versionW, &v)) {
 838         release_cc(cc);
 839         return lex_error(ctx, E_OUTOFMEMORY);
 840     }
 841
 842     ctx->script->cc = cc;
 843     return 0;
 844 }
 845
 846 static int cc_token(parser_ctx_t *ctx, void *lval)
 847 {
 848     unsigned id_len = 0;
 849     cc_var_t *var;
 850
 851     static const WCHAR cc_onW[] = {'c','c','_','o','n',0};
 852     static const WCHAR setW[] = {'s','e','t',0};
 853     static const WCHAR elifW[] = {'e','l','i','f',0};
 854     static const WCHAR endW[] = {'e','n','d',0};
 855
 856     ctx->ptr++;
 857
 858     if(!check_keyword(ctx, cc_onW, NULL))
 859         return init_cc(ctx);
 860
 861     if(!check_keyword(ctx, setW, NULL)) {
 862         FIXME("@set not implemented\n");
 863         return lex_error(ctx, E_NOTIMPL);
 864     }
 865
 866     if(!check_keyword(ctx, ifW, NULL)) {
 867         FIXME("@if not implemented\n");
 868         return lex_error(ctx, E_NOTIMPL);
 869     }
 870
 871     if(!check_keyword(ctx, elifW, NULL)) {
 872         FIXME("@elif not implemented\n");
 873         return lex_error(ctx, E_NOTIMPL);
 874     }
 875
 876     if(!check_keyword(ctx, elseW, NULL)) {
 877         FIXME("@else not implemented\n");
 878         return lex_error(ctx, E_NOTIMPL);
 879     }
 880
 881     if(!check_keyword(ctx, endW, NULL)) {
 882         FIXME("@end not implemented\n");
 883         return lex_error(ctx, E_NOTIMPL);
 884     }
 885
 886     if(!ctx->script->cc)
 887         return lex_error(ctx, JS_E_DISABLED_CC);
 888
 889     while(ctx->ptr+id_len < ctx->end && is_identifier_char(ctx->ptr[id_len]))
 890         id_len++;
 891     if(!id_len)
 892         return '@';
 893
 894     TRACE("var %s\n", debugstr_wn(ctx->ptr, id_len));
 895
 896     var = find_cc_var(ctx->script->cc, ctx->ptr, id_len);
 897     ctx->ptr += id_len;
 898     if(!var || var->is_num) {
 899         *(literal_t**)lval = new_double_literal(ctx, var ? var->u.n : NAN);
 900         return tNumericLiteral;
 901     }
 902
 903     *(literal_t**)lval = new_boolean_literal(ctx, var->u.b);
 904     return tBooleanLiteral;
 905 }
 906
 907 int parser_lex(void *lval, parser_ctx_t *ctx)
 908 {
 909     int ret;
 910
 911     ctx->nl = ctx->ptr == ctx->begin;
 912
 913     do {
 914         ret = next_token(ctx, lval);
 915     } while(ret == '@' && !(ret = cc_token(ctx, lval)));
 916
 917     return ret;
 918 }
 919
 920 literal_t *parse_regexp(parser_ctx_t *ctx)
 921 {
 922     const WCHAR *re, *flags_ptr;
 923     BOOL in_class = FALSE;
 924     DWORD re_len, flags;
 925     literal_t *ret;
 926     HRESULT hres;
 927
 928     TRACE("\n");
 929
 930     while(*--ctx->ptr != '/');
 931
 932     /* Simple regexp pre-parser; '/' if used in char class does not terminate regexp literal */
 933     re = ++ctx->ptr;
 934     while(ctx->ptr < ctx->end) {
 935         if(*ctx->ptr == '\\') {
 936             if(++ctx->ptr == ctx->end)
 937                 break;
 938         }else if(in_class) {
 939             if(*ctx->ptr == '\n')
 940                 break;
 941             if(*ctx->ptr == ']')
 942                 in_class = FALSE;
 943         }else {
 944             if(*ctx->ptr == '/')
 945                 break;
 946
 947             if(*ctx->ptr == '[')
 948                 in_class = TRUE;
 949         }
 950         ctx->ptr++;
 951     }
 952
 953     if(ctx->ptr == ctx->end || *ctx->ptr != '/') {
 954         WARN("pre-parsing failed\n");
 955         return NULL;
 956     }
 957
 958     re_len = ctx->ptr-re;
 959
 960     flags_ptr = ++ctx->ptr;
 961     while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr))
 962         ctx->ptr++;
 963
 964     hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
 965     if(FAILED(hres))
 966         return NULL;
 967
 968     ret = parser_alloc(ctx, sizeof(literal_t));
 969     ret->type = LT_REGEXP;
 970     ret->u.regexp.str = re;
 971     ret->u.regexp.str_len = re_len;
 972     ret->u.regexp.flags = flags;
 973     return ret;
 974 }