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