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 <math.h>
  20 #include <limits.h>
  21
  22 #include "jscript.h"
  23 #include "activscp.h"
  24 #include "objsafe.h"
  25 #include "engine.h"
  26
  27 #include "parser.tab.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/unicode.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  33
  34 #define LONGLONG_MAX (((LONGLONG)0x7fffffff<<32)|0xffffffff)
  35
  36 static const WCHAR breakW[] = {'b','r','e','a','k',0};
  37 static const WCHAR caseW[] = {'c','a','s','e',0};
  38 static const WCHAR catchW[] = {'c','a','t','c','h',0};
  39 static const WCHAR continueW[] = {'c','o','n','t','i','n','u','e',0};
  40 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
  41 static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
  42 static const WCHAR doW[] = {'d','o',0};
  43 static const WCHAR elseW[] = {'e','l','s','e',0};
  44 static const WCHAR falseW[] = {'f','a','l','s','e',0};
  45 static const WCHAR finallyW[] = {'f','i','n','a','l','l','y',0};
  46 static const WCHAR forW[] = {'f','o','r',0};
  47 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
  48 static const WCHAR ifW[] = {'i','f',0};
  49 static const WCHAR inW[] = {'i','n',0};
  50 static const WCHAR instanceofW[] = {'i','n','s','t','a','n','c','e','o','f',0};
  51 static const WCHAR newW[] = {'n','e','w',0};
  52 static const WCHAR nullW[] = {'n','u','l','l',0};
  53 static const WCHAR returnW[] = {'r','e','t','u','r','n',0};
  54 static const WCHAR switchW[] = {'s','w','i','t','c','h',0};
  55 static const WCHAR thisW[] = {'t','h','i','s',0};
  56 static const WCHAR throwW[] = {'t','h','r','o','w',0};
  57 static const WCHAR trueW[] = {'t','r','u','e',0};
  58 static const WCHAR tryW[] = {'t','r','y',0};
  59 static const WCHAR typeofW[] = {'t','y','p','e','o','f',0};
  60 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
  61 static const WCHAR varW[] = {'v','a','r',0};
  62 static const WCHAR voidW[] = {'v','o','i','d',0};
  63 static const WCHAR whileW[] = {'w','h','i','l','e',0};
  64 static const WCHAR withW[] = {'w','i','t','h',0};
  65
  66 static const struct {
  67     const WCHAR *word;
  68     int token;
  69 } keywords[] = {
  70     {breakW,       kBREAK},
  71     {caseW,        kCASE},
  72     {catchW,       kCATCH},
  73     {continueW,    kCONTINUE},
  74     {defaultW,     kDEFAULT},
  75     {deleteW,      kDELETE},
  76     {doW,          kDO},
  77     {elseW,        kELSE},
  78     {falseW,       kFALSE},
  79     {finallyW,     kFINALLY},
  80     {forW,         kFOR},
  81     {functionW,    kFUNCTION},
  82     {ifW,          kIF},
  83     {inW,          kIN},
  84     {instanceofW,  kINSTANCEOF},
  85     {newW,         kNEW},
  86     {nullW,        kNULL},
  87     {returnW,      kRETURN},
  88     {switchW,      kSWITCH},
  89     {thisW,        kTHIS},
  90     {throwW,       kTHROW},
  91     {trueW,        kTRUE},
  92     {tryW,         kTRY},
  93     {typeofW,      kTYPEOF},
  94     {undefinedW,   kUNDEFINED},
  95     {varW,         kVAR},
  96     {voidW,        kVOID},
  97     {whileW,       kWHILE},
  98     {withW,        kWITH}
  99 };
 100
 101 static int lex_error(parser_ctx_t *ctx, HRESULT hres)
 102 {
 103     ctx->hres = JSCRIPT_ERROR|hres;
 104     ctx->lexer_error = TRUE;
 105     return -1;
 106 }
 107
 108 /* ECMA-262 3rd Edition    7.6 */
 109 static BOOL is_identifier_char(WCHAR c)
 110 {
 111     return isalnumW(c) || c == '$' || c == '_' || c == '\\';
 112 }
 113
 114 static int check_keyword(parser_ctx_t *ctx, const WCHAR *word, const WCHAR **lval)
 115 {
 116     const WCHAR *p1 = ctx->ptr;
 117     const WCHAR *p2 = word;
 118
 119     while(p1 < ctx->end && *p2) {
 120         if(*p1 != *p2)
 121             return *p1 - *p2;
 122         p1++;
 123         p2++;
 124     }
 125
 126     if(*p2 || (p1 < ctx->end && is_identifier_char(*p1)))
 127         return 1;
 128
 129     *lval = ctx->ptr;
 130     ctx->ptr = p1;
 131     return 0;
 132 }
 133
 134 /* ECMA-262 3rd Edition    7.3 */
 135 static BOOL is_endline(WCHAR c)
 136 {
 137     return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;
 138 }
 139
 140 static int hex_to_int(WCHAR c)
 141 {
 142     if('0' <= c && c <= '9')
 143         return c-'0';
 144
 145     if('a' <= c && c <= 'f')
 146         return c-'a'+10;
 147
 148     if('A' <= c && c <= 'F')
 149         return c-'A'+10;
 150
 151     return -1;
 152 }
 153
 154 static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
 155 {
 156     int min = 0, max = sizeof(keywords)/sizeof(keywords[0])-1, r, i;
 157
 158     while(min <= max) {
 159         i = (min+max)/2;
 160
 161         r = check_keyword(ctx, keywords[i].word, lval);
 162         if(!r)
 163             return keywords[i].token;
 164
 165         if(r > 0)
 166             min = i+1;
 167         else
 168             max = i-1;
 169     }
 170
 171     return 0;
 172 }
 173
 174 static void skip_spaces(parser_ctx_t *ctx)
 175 {
 176     while(ctx->ptr < ctx->end && isspaceW(*ctx->ptr)) {
 177         if(is_endline(*ctx->ptr++))
 178             ctx->nl = TRUE;
 179     }
 180 }
 181
 182 static BOOL skip_html_comment(parser_ctx_t *ctx)
 183 {
 184     const WCHAR html_commentW[] = {'<','!','-','-',0};
 185
 186     if(!ctx->is_html || ctx->ptr+3 >= ctx->end ||
 187         memcmp(ctx->ptr, html_commentW, sizeof(WCHAR)*4))
 188         return FALSE;
 189
 190     ctx->nl = TRUE;
 191     while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr++));
 192
 193     return TRUE;
 194 }
 195
 196 static BOOL skip_comment(parser_ctx_t *ctx)
 197 {
 198     if(ctx->ptr+1 >= ctx->end || *ctx->ptr != '/')
 199         return FALSE;
 200
 201     switch(ctx->ptr[1]) {
 202     case '*':
 203         ctx->ptr += 2;
 204         while(ctx->ptr+1 < ctx->end && (ctx->ptr[0] != '*' || ctx->ptr[1] != '/'))
 205             ctx->ptr++;
 206
 207         if(ctx->ptr[0] == '*' && ctx->ptr[1] == '/') {
 208             ctx->ptr += 2;
 209         }else {
 210             WARN("unexpected end of file (missing end of comment)\n");
 211             ctx->ptr = ctx->end;
 212         }
 213         break;
 214     case '/':
 215         ctx->ptr += 2;
 216         while(ctx->ptr < ctx->end && !is_endline(*ctx->ptr))
 217             ctx->ptr++;
 218         break;
 219     default:
 220         return FALSE;
 221     }
 222
 223     return TRUE;
 224 }
 225
 226 static BOOL unescape(WCHAR *str)
 227 {
 228     WCHAR *pd, *p, c;
 229     int i;
 230
 231     pd = p = str;
 232     while(*p) {
 233         if(*p != '\\') {
 234             *pd++ = *p++;
 235             continue;
 236         }
 237
 238         p++;
 239         c = 0;
 240
 241         switch(*p) {
 242         case '\'':
 243         case '\"':
 244         case '\\':
 245             c = *p;
 246             break;
 247         case 'b':
 248             c = '\b';
 249             break;
 250         case 't':
 251             c = '\t';
 252             break;
 253         case 'n':
 254             c = '\n';
 255             break;
 256         case 'v':
 257             c = '\v';
 258             break;
 259         case 'f':
 260             c = '\f';
 261             break;
 262         case 'r':
 263             c = '\r';
 264             break;
 265         case 'x':
 266             i = hex_to_int(*++p);
 267             if(i == -1)
 268                 return FALSE;
 269             c = i << 4;
 270
 271             i = hex_to_int(*++p);
 272             if(i == -1)
 273                 return FALSE;
 274             c += i;
 275             break;
 276         case 'u':
 277             i = hex_to_int(*++p);
 278             if(i == -1)
 279                 return FALSE;
 280             c = i << 12;
 281
 282             i = hex_to_int(*++p);
 283             if(i == -1)
 284                 return FALSE;
 285             c += i << 8;
 286
 287             i = hex_to_int(*++p);
 288             if(i == -1)
 289                 return FALSE;
 290             c += i << 4;
 291
 292             i = hex_to_int(*++p);
 293             if(i == -1)
 294                 return FALSE;
 295             c += i;
 296             break;
 297         default:
 298             if(isdigitW(*p)) {
 299                 c = *p++ - '0';
 300                 if(isdigitW(*p)) {
 301                     c = c*8 + (*p++ - '0');
 302                     if(isdigitW(*p))
 303                         c = c*8 + (*p++ - '0');
 304                 }
 305                 p--;
 306             }
 307             else
 308                 c = *p;
 309         }
 310
 311         *pd++ = c;
 312         p++;
 313     }
 314
 315     *pd = 0;
 316     return TRUE;
 317 }
 318
 319 static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
 320 {
 321     const WCHAR *ptr = ctx->ptr++;
 322     WCHAR *wstr;
 323     int len;
 324
 325     while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr))
 326         ctx->ptr++;
 327
 328     len = ctx->ptr-ptr;
 329
 330     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 331     memcpy(wstr, ptr, (len+1)*sizeof(WCHAR));
 332     wstr[len] = 0;
 333
 334     /* FIXME: unescape */
 335     return tIdentifier;
 336 }
 337
 338 static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret, WCHAR endch)
 339 {
 340     const WCHAR *ptr = ++ctx->ptr;
 341     WCHAR *wstr;
 342     int len;
 343
 344     while(ctx->ptr < ctx->end && *ctx->ptr != endch) {
 345         if(*ctx->ptr++ == '\\')
 346             ctx->ptr++;
 347     }
 348
 349     if(ctx->ptr == ctx->end)
 350         return lex_error(ctx, IDS_UNTERMINATED_STR);
 351
 352     len = ctx->ptr-ptr;
 353
 354     *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
 355     memcpy(wstr, ptr, (len+1)*sizeof(WCHAR));
 356     wstr[len] = 0;
 357
 358     ctx->ptr++;
 359
 360     if(!unescape(wstr)) {
 361         WARN("unescape failed\n");
 362         return lex_error(ctx, E_FAIL);
 363     }
 364
 365     return tStringLiteral;
 366 }
 367
 368 static literal_t *alloc_int_literal(parser_ctx_t *ctx, LONG l)
 369 {
 370     literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
 371
 372     ret->type = LT_INT;
 373     ret->u.lval = l;
 374
 375     return ret;
 376 }
 377
 378 static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **literal)
 379 {
 380     LONGLONG d, hlp;
 381     int exp = 0;
 382
 383     if(ctx->ptr == ctx->end || (!isdigitW(*ctx->ptr) &&
 384         *ctx->ptr!='.' && *ctx->ptr!='e' && *ctx->ptr!='E')) {
 385         ERR("Illegal character\n");
 386         return 0;
 387     }
 388
 389     d = int_part;
 390     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 391         hlp = d*10 + *(ctx->ptr++) - '0';
 392         if(d>LONGLONG_MAX/10 || hlp<0) {
 393             exp++;
 394             break;
 395         }
 396         else
 397             d = hlp;
 398     }
 399     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 400         exp++;
 401         ctx->ptr++;
 402     }
 403
 404     if(*ctx->ptr == '.') ctx->ptr++;
 405
 406     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 407         hlp = d*10 + *(ctx->ptr++) - '0';
 408         if(d>LONGLONG_MAX/10 || hlp<0)
 409             break;
 410
 411         d = hlp;
 412         exp--;
 413     }
 414     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
 415         ctx->ptr++;
 416
 417     if(ctx->ptr < ctx->end && (*ctx->ptr == 'e' || *ctx->ptr == 'E')) {
 418         int sign = 1, e = 0;
 419
 420         ctx->ptr++;
 421         if(ctx->ptr < ctx->end) {
 422             if(*ctx->ptr == '+') {
 423                 ctx->ptr++;
 424             }else if(*ctx->ptr == '-') {
 425                 sign = -1;
 426                 ctx->ptr++;
 427             }else if(!isdigitW(*ctx->ptr)) {
 428                 WARN("Expected exponent part\n");
 429                 return lex_error(ctx, E_FAIL);
 430             }
 431         }
 432
 433         if(ctx->ptr == ctx->end) {
 434             WARN("unexpected end of file\n");
 435             return lex_error(ctx, E_FAIL);
 436         }
 437
 438         while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
 439             if(e > INT_MAX/10 || (e = e*10 + *ctx->ptr++ - '0')<0)
 440                 e = INT_MAX;
 441         }
 442         e *= sign;
 443
 444         if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
 445         else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
 446         else exp += e;
 447     }
 448
 449     *literal = parser_alloc(ctx, sizeof(literal_t));
 450     (*literal)->type = LT_DOUBLE;
 451     (*literal)->u.dval = (double)d*pow(10, exp);
 452
 453     return tNumericLiteral;
 454 }
 455
 456 static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal)
 457 {
 458     LONG l, d;
 459
 460     l = *ctx->ptr++ - '0';
 461     if(ctx->ptr == ctx->end) {
 462         *literal = alloc_int_literal(ctx, l);
 463         return tNumericLiteral;
 464     }
 465
 466     if(!l) {
 467         if(*ctx->ptr == 'x' || *ctx->ptr == 'X') {
 468             if(++ctx->ptr == ctx->end) {
 469                 ERR("unexpexted end of file\n");
 470                 return 0;
 471             }
 472
 473             while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) {
 474                 l = l*16 + d;
 475                 ctx->ptr++;
 476             }
 477
 478             if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) {
 479                 WARN("unexpected identifier char\n");
 480                 return lex_error(ctx, E_FAIL);
 481             }
 482
 483             *literal = alloc_int_literal(ctx, l);
 484             return tNumericLiteral;
 485         }
 486
 487         if(isdigitW(*ctx->ptr) || is_identifier_char(*ctx->ptr)) {
 488             WARN("wrong char after zero\n");
 489             return lex_error(ctx, E_FAIL);
 490         }
 491
 492         *literal = alloc_int_literal(ctx, 0);
 493     }
 494
 495     while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
 496     {
 497         d = l*10 + *(ctx->ptr)-'0';
 498
 499         /* Check for integer overflow */
 500         if (l > INT_MAX/10 || d < 0)
 501             return parse_double_literal(ctx, l, literal);
 502
 503         l = d;
 504         ctx->ptr++;
 505     }
 506
 507     if(ctx->ptr < ctx->end) {
 508         if(*ctx->ptr == '.' || *ctx->ptr == 'e' || *ctx->ptr == 'E')
 509             return parse_double_literal(ctx, l, literal);
 510
 511         if(is_identifier_char(*ctx->ptr)) {
 512             WARN("unexpected identifier char\n");
 513             return lex_error(ctx, E_FAIL);
 514         }
 515     }
 516
 517     *literal = alloc_int_literal(ctx, l);
 518     return tNumericLiteral;
 519 }
 520
 521 int parser_lex(void *lval, parser_ctx_t *ctx)
 522 {
 523     int ret;
 524
 525     ctx->nl = ctx->ptr == ctx->begin;
 526
 527     do {
 528         skip_spaces(ctx);
 529         if(ctx->ptr == ctx->end)
 530             return 0;
 531     }while(skip_comment(ctx) || skip_html_comment(ctx));
 532
 533     if(isalphaW(*ctx->ptr)) {
 534         ret = check_keywords(ctx, lval);
 535         if(ret)
 536             return ret;
 537
 538         return parse_identifier(ctx, lval);
 539     }
 540
 541     if(isdigitW(*ctx->ptr))
 542         return parse_numeric_literal(ctx, lval);
 543
 544     switch(*ctx->ptr) {
 545     case '{':
 546     case '(':
 547     case ')':
 548     case '[':
 549     case ']':
 550     case ';':
 551     case ',':
 552     case '~':
 553     case '?':
 554     case ':':
 555         return *ctx->ptr++;
 556
 557     case '}':
 558         *(const WCHAR**)lval = ctx->ptr++;
 559         return '}';
 560
 561     case '.':
 562         if(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
 563             return parse_double_literal(ctx, 0, lval);
 564         return '.';
 565
 566     case '<':
 567         if(++ctx->ptr == ctx->end) {
 568             *(int*)lval = EXPR_LESS;
 569             return tRelOper;
 570         }
 571
 572         switch(*ctx->ptr) {
 573         case '=':  /* <= */
 574             ctx->ptr++;
 575             *(int*)lval = EXPR_LESSEQ;
 576             return tRelOper;
 577         case '<':  /* << */
 578             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* <<= */
 579                 ctx->ptr++;
 580                 *(int*)lval = EXPR_ASSIGNLSHIFT;
 581                 return tAssignOper;
 582             }
 583             *(int*)lval = EXPR_LSHIFT;
 584             return tShiftOper;
 585         default: /* < */
 586             *(int*)lval = EXPR_LESS;
 587             return tRelOper;
 588         }
 589
 590     case '>':
 591         if(++ctx->ptr == ctx->end) { /* > */
 592             *(int*)lval = EXPR_GREATER;
 593             return tRelOper;
 594         }
 595
 596         switch(*ctx->ptr) {
 597         case '=':  /* >= */
 598             ctx->ptr++;
 599             *(int*)lval = EXPR_GREATEREQ;
 600             return tRelOper;
 601         case '>':  /* >> */
 602             if(++ctx->ptr < ctx->end) {
 603                 if(*ctx->ptr == '=') {  /* >>= */
 604                     ctx->ptr++;
 605                     *(int*)lval = EXPR_ASSIGNRSHIFT;
 606                     return tAssignOper;
 607                 }
 608                 if(*ctx->ptr == '>') {  /* >>> */
 609                     if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* >>>= */
 610                         ctx->ptr++;
 611                         *(int*)lval = EXPR_ASSIGNRRSHIFT;
 612                         return tAssignOper;
 613                     }
 614                     *(int*)lval = EXPR_RRSHIFT;
 615                     return tRelOper;
 616                 }
 617             }
 618             *(int*)lval = EXPR_RSHIFT;
 619             return tShiftOper;
 620         default:
 621             *(int*)lval = EXPR_GREATER;
 622             return tRelOper;
 623         }
 624
 625     case '+':
 626         ctx->ptr++;
 627         if(ctx->ptr < ctx->end) {
 628             switch(*ctx->ptr) {
 629             case '+':  /* ++ */
 630                 ctx->ptr++;
 631                 return tINC;
 632             case '=':  /* += */
 633                 ctx->ptr++;
 634                 *(int*)lval = EXPR_ASSIGNADD;
 635                 return tAssignOper;
 636             }
 637         }
 638         return '+';
 639
 640     case '-':
 641         ctx->ptr++;
 642         if(ctx->ptr < ctx->end) {
 643             switch(*ctx->ptr) {
 644             case '-':  /* -- or --> */
 645                 ctx->ptr++;
 646                 if(ctx->is_html && ctx->nl && ctx->ptr < ctx->end && *ctx->ptr == '>') {
 647                     ctx->ptr++;
 648                     return tHTMLCOMMENT;
 649                 }
 650                 return tDEC;
 651             case '=':  /* -= */
 652                 ctx->ptr++;
 653                 *(int*)lval = EXPR_ASSIGNSUB;
 654                 return tAssignOper;
 655             }
 656         }
 657         return '-';
 658
 659     case '*':
 660         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* *= */
 661             ctx->ptr++;
 662             *(int*)lval = EXPR_ASSIGNMUL;
 663             return tAssignOper;
 664         }
 665         return '*';
 666
 667     case '%':
 668         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* %= */
 669             ctx->ptr++;
 670             *(int*)lval = EXPR_ASSIGNMOD;
 671             return tAssignOper;
 672         }
 673         return '%';
 674
 675     case '&':
 676         if(++ctx->ptr < ctx->end) {
 677             switch(*ctx->ptr) {
 678             case '=':  /* &= */
 679                 ctx->ptr++;
 680                 *(int*)lval = EXPR_ASSIGNAND;
 681                 return tAssignOper;
 682             case '&':  /* && */
 683                 ctx->ptr++;
 684                 return tANDAND;
 685             }
 686         }
 687         return '&';
 688
 689     case '|':
 690         if(++ctx->ptr < ctx->end) {
 691             switch(*ctx->ptr) {
 692             case '=':  /* |= */
 693                 ctx->ptr++;
 694                 *(int*)lval = EXPR_ASSIGNOR;
 695                 return tAssignOper;
 696             case '|':  /* || */
 697                 ctx->ptr++;
 698                 return tOROR;
 699             }
 700         }
 701         return '|';
 702
 703     case '^':
 704         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* ^= */
 705             ctx->ptr++;
 706             *(int*)lval = EXPR_ASSIGNXOR;
 707             return tAssignOper;
 708         }
 709         return '^';
 710
 711     case '!':
 712         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* != */
 713             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* !== */
 714                 ctx->ptr++;
 715                 *(int*)lval = EXPR_NOTEQEQ;
 716                 return tEqOper;
 717             }
 718             *(int*)lval = EXPR_NOTEQ;
 719             return tEqOper;
 720         }
 721         return '!';
 722
 723     case '=':
 724         if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* == */
 725             if(++ctx->ptr < ctx->end && *ctx->ptr == '=') {  /* === */
 726                 ctx->ptr++;
 727                 *(int*)lval = EXPR_EQEQ;
 728                 return tEqOper;
 729             }
 730             *(int*)lval = EXPR_EQ;
 731             return tEqOper;
 732         }
 733         return '=';
 734
 735     case '/':
 736         if(++ctx->ptr < ctx->end) {
 737             if(*ctx->ptr == '=') {  /* /= */
 738                 ctx->ptr++;
 739                 *(int*)lval = EXPR_ASSIGNDIV;
 740                 return kDIVEQ;
 741             }
 742         }
 743         return '/';
 744
 745     case '\"':
 746     case '\'':
 747         return parse_string_literal(ctx, lval, *ctx->ptr);
 748
 749     case '_':
 750     case '$':
 751         return parse_identifier(ctx, lval);
 752     }
 753
 754     WARN("unexpected char '%c' %d\n", *ctx->ptr, *ctx->ptr);
 755     return 0;
 756 }
 757
 758 literal_t *parse_regexp(parser_ctx_t *ctx)
 759 {
 760     const WCHAR *re, *flags_ptr;
 761     DWORD re_len, flags;
 762     literal_t *ret;
 763     HRESULT hres;
 764
 765     TRACE("\n");
 766
 767     while(*ctx->ptr != '/')
 768         ctx->ptr--;
 769
 770     re = ++ctx->ptr;
 771     while(ctx->ptr < ctx->end && *ctx->ptr != '/') {
 772         if(*ctx->ptr++ == '\\' && ctx->ptr < ctx->end)
 773             ctx->ptr++;
 774     }
 775
 776     if(ctx->ptr == ctx->end) {
 777         WARN("unexpected end of file\n");
 778         return NULL;
 779     }
 780
 781     re_len = ctx->ptr-re;
 782
 783     flags_ptr = ++ctx->ptr;
 784     while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr))
 785         ctx->ptr++;
 786
 787     hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
 788     if(FAILED(hres))
 789         return NULL;
 790
 791     ret = parser_alloc(ctx, sizeof(literal_t));
 792     ret->type = LT_REGEXP;
 793     ret->u.regexp.str = re;
 794     ret->u.regexp.str_len = re_len;
 795     ret->u.regexp.flags = flags;
 796     return ret;
 797 }