?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Separate fetching the window icon bits and setting the WM hints.
[wine.git] / dlls / jscript / regexp.c
blobb53b8487437582348a2b981138a0bc95916218cc
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 /*
20 * Code in this file is based on files:
21 * js/src/jsregexp.h
22 * js/src/jsregexp.c
23 * from Mozilla project, released under LGPL 2.1 or later.
24 *
25 * The Original Code is Mozilla Communicator client code, released
26 * March 31, 1998.
27 *
28 * The Initial Developer of the Original Code is
29 * Netscape Communications Corporation.
30 * Portions created by the Initial Developer are Copyright (C) 1998
31 * the Initial Developer. All Rights Reserved.
32 */
33
34 #include <assert.h>
35 #include <math.h>
36
37 #include "jscript.h"
38
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
42
43 #define JSREG_FOLD 0x01 /* fold uppercase to lowercase */
44 #define JSREG_GLOB 0x02 /* global exec, creates array of matches */
45 #define JSREG_MULTILINE 0x04 /* treat ^ and $ as begin and end of line */
46 #define JSREG_STICKY 0x08 /* only match starting at lastIndex */
47
48 typedef BYTE JSPackedBool;
49 typedef BYTE jsbytecode;
50
51 /*
52 * This struct holds a bitmap representation of a class from a regexp.
53 * There's a list of these referenced by the classList field in the JSRegExp
54 * struct below. The initial state has startIndex set to the offset in the
55 * original regexp source of the beginning of the class contents. The first
56 * use of the class converts the source representation into a bitmap.
57 *
58 */
59 typedef struct RECharSet {
60 JSPackedBool converted;
61 JSPackedBool sense;
62 WORD length;
63 union {
64 BYTE *bits;
65 struct {
66 size_t startIndex;
67 size_t length;
68 } src;
69 } u;
70 } RECharSet;
71
72 typedef struct {
73 WORD flags; /* flags, see jsapi.h's JSREG_* defines */
74 size_t parenCount; /* number of parenthesized submatches */
75 size_t classCount; /* count [...] bitmaps */
76 RECharSet *classList; /* list of [...] bitmaps */
77 BSTR source; /* locked source string, sans // */
78 jsbytecode program[1]; /* regular expression bytecode */
79 } JSRegExp;
80
81 typedef struct {
82 jsdisp_t dispex;
83
84 JSRegExp *jsregexp;
85 BSTR str;
86 INT last_index;
87 jsval_t last_index_val;
88 } RegExpInstance;
89
90 static const WCHAR sourceW[] = {'s','o','u','r','c','e',0};
91 static const WCHAR globalW[] = {'g','l','o','b','a','l',0};
92 static const WCHAR ignoreCaseW[] = {'i','g','n','o','r','e','C','a','s','e',0};
93 static const WCHAR multilineW[] = {'m','u','l','t','i','l','i','n','e',0};
94 static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
95 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
96 static const WCHAR execW[] = {'e','x','e','c',0};
97 static const WCHAR testW[] = {'t','e','s','t',0};
98
99 static const WCHAR leftContextW[] =
100 {'l','e','f','t','C','o','n','t','e','x','t',0};
101 static const WCHAR rightContextW[] =
102 {'r','i','g','h','t','C','o','n','t','e','x','t',0};
103
104 static const WCHAR idx1W[] = {'$','1',0};
105 static const WCHAR idx2W[] = {'$','2',0};
106 static const WCHAR idx3W[] = {'$','3',0};
107 static const WCHAR idx4W[] = {'$','4',0};
108 static const WCHAR idx5W[] = {'$','5',0};
109 static const WCHAR idx6W[] = {'$','6',0};
110 static const WCHAR idx7W[] = {'$','7',0};
111 static const WCHAR idx8W[] = {'$','8',0};
112 static const WCHAR idx9W[] = {'$','9',0};
113
114 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
115 static const WCHAR emptyW[] = {0};
116
117 /* FIXME: Better error handling */
118 #define ReportRegExpError(a,b,c)
119 #define ReportRegExpErrorHelper(a,b,c,d)
120 #define JS_ReportErrorNumber(a,b,c,d)
121 #define JS_ReportErrorFlagsAndNumber(a,b,c,d,e,f)
122 #define js_ReportOutOfScriptQuota(a)
123 #define JS_ReportOutOfMemory(a)
124 #define JS_COUNT_OPERATION(a,b)
125
126 #define JSMSG_MIN_TOO_BIG 47
127 #define JSMSG_MAX_TOO_BIG 48
128 #define JSMSG_OUT_OF_ORDER 49
129 #define JSMSG_OUT_OF_MEMORY 137
130
131 #define LINE_SEPARATOR 0x2028
132 #define PARA_SEPARATOR 0x2029
133
134 #define RE_IS_LETTER(c) (((c >= 'A') && (c <= 'Z')) || \
135 ((c >= 'a') && (c <= 'z')) )
136 #define RE_IS_LINE_TERM(c) ((c == '\n') || (c == '\r') || \
137 (c == LINE_SEPARATOR) || (c == PARA_SEPARATOR))
138
139 #define JS_ISWORD(c) ((c) < 128 && (isalnum(c) || (c) == '_'))
140
141 #define JS7_ISDEC(c) ((((unsigned)(c)) - '0') <= 9)
142 #define JS7_UNDEC(c) ((c) - '0')
143
144 typedef enum REOp {
145 REOP_EMPTY,
146 REOP_BOL,
147 REOP_EOL,
148 REOP_WBDRY,
149 REOP_WNONBDRY,
150 REOP_DOT,
151 REOP_DIGIT,
152 REOP_NONDIGIT,
153 REOP_ALNUM,
154 REOP_NONALNUM,
155 REOP_SPACE,
156 REOP_NONSPACE,
157 REOP_BACKREF,
158 REOP_FLAT,
159 REOP_FLAT1,
160 REOP_FLATi,
161 REOP_FLAT1i,
162 REOP_UCFLAT1,
163 REOP_UCFLAT1i,
164 REOP_UCFLAT,
165 REOP_UCFLATi,
166 REOP_CLASS,
167 REOP_NCLASS,
168 REOP_ALT,
169 REOP_QUANT,
170 REOP_STAR,
171 REOP_PLUS,
172 REOP_OPT,
173 REOP_LPAREN,
174 REOP_RPAREN,
175 REOP_JUMP,
176 REOP_DOTSTAR,
177 REOP_LPARENNON,
178 REOP_ASSERT,
179 REOP_ASSERT_NOT,
180 REOP_ASSERTTEST,
181 REOP_ASSERTNOTTEST,
182 REOP_MINIMALSTAR,
183 REOP_MINIMALPLUS,
184 REOP_MINIMALOPT,
185 REOP_MINIMALQUANT,
186 REOP_ENDCHILD,
187 REOP_REPEAT,
188 REOP_MINIMALREPEAT,
189 REOP_ALTPREREQ,
190 REOP_ALTPREREQ2,
191 REOP_ENDALT,
192 REOP_CONCAT,
193 REOP_END,
194 REOP_LIMIT /* META: no operator >= to this */
195 } REOp;
196
197 #define REOP_IS_SIMPLE(op) ((op) <= REOP_NCLASS)
198
199 static const char *reop_names[] = {
200 "empty",
201 "bol",
202 "eol",
203 "wbdry",
204 "wnonbdry",
205 "dot",
206 "digit",
207 "nondigit",
208 "alnum",
209 "nonalnum",
210 "space",
211 "nonspace",
212 "backref",
213 "flat",
214 "flat1",
215 "flati",
216 "flat1i",
217 "ucflat1",
218 "ucflat1i",
219 "ucflat",
220 "ucflati",
221 "class",
222 "nclass",
223 "alt",
224 "quant",
225 "star",
226 "plus",
227 "opt",
228 "lparen",
229 "rparen",
230 "jump",
231 "dotstar",
232 "lparennon",
233 "assert",
234 "assert_not",
235 "asserttest",
236 "assertnottest",
237 "minimalstar",
238 "minimalplus",
239 "minimalopt",
240 "minimalquant",
241 "endchild",
242 "repeat",
243 "minimalrepeat",
244 "altprereq",
245 "alrprereq2",
246 "endalt",
247 "concat",
248 "end",
249 NULL
250 };
251
252 typedef struct RECapture {
253 ptrdiff_t index; /* start of contents, -1 for empty */
254 size_t length; /* length of capture */
255 } RECapture;
256
257 typedef struct REMatchState {
258 const WCHAR *cp;
259 RECapture parens[1]; /* first of 're->parenCount' captures,
260 allocated at end of this struct */
261 } REMatchState;
262
263 typedef struct REProgState {
264 jsbytecode *continue_pc; /* current continuation data */
265 jsbytecode continue_op;
266 ptrdiff_t index; /* progress in text */
267 size_t parenSoFar; /* highest indexed paren started */
268 union {
269 struct {
270 UINT min; /* current quantifier limits */
271 UINT max;
272 } quantifier;
273 struct {
274 size_t top; /* backtrack stack state */
275 size_t sz;
276 } assertion;
277 } u;
278 } REProgState;
279
280 typedef struct REBackTrackData {
281 size_t sz; /* size of previous stack entry */
282 jsbytecode *backtrack_pc; /* where to backtrack to */
283 jsbytecode backtrack_op;
284 const WCHAR *cp; /* index in text of match at backtrack */
285 size_t parenIndex; /* start index of saved paren contents */
286 size_t parenCount; /* # of saved paren contents */
287 size_t saveStateStackTop; /* number of parent states */
288 /* saved parent states follow */
289 /* saved paren contents follow */
290 } REBackTrackData;
291
292 #define INITIAL_STATESTACK 100
293 #define INITIAL_BACKTRACK 8000
294
295 typedef struct REGlobalData {
296 script_ctx_t *cx;
297 JSRegExp *regexp; /* the RE in execution */
298 BOOL ok; /* runtime error (out_of_memory only?) */
299 size_t start; /* offset to start at */
300 ptrdiff_t skipped; /* chars skipped anchoring this r.e. */
301 const WCHAR *cpbegin; /* text base address */
302 const WCHAR *cpend; /* text limit address */
303
304 REProgState *stateStack; /* stack of state of current parents */
305 size_t stateStackTop;
306 size_t stateStackLimit;
307
308 REBackTrackData *backTrackStack;/* stack of matched-so-far positions */
309 REBackTrackData *backTrackSP;
310 size_t backTrackStackSize;
311 size_t cursz; /* size of current stack entry */
312 size_t backTrackCount; /* how many times we've backtracked */
313 size_t backTrackLimit; /* upper limit on backtrack states */
314
315 jsheap_t *pool; /* It's faster to use one malloc'd pool
316 than to malloc/free the three items
317 that are allocated from this pool */
318 } REGlobalData;
319
320 typedef struct RENode RENode;
321 struct RENode {
322 REOp op; /* r.e. op bytecode */
323 RENode *next; /* next in concatenation order */
324 void *kid; /* first operand */
325 union {
326 void *kid2; /* second operand */
327 INT num; /* could be a number */
328 size_t parenIndex; /* or a parenthesis index */
329 struct { /* or a quantifier range */
330 UINT min;
331 UINT max;
332 JSPackedBool greedy;
333 } range;
334 struct { /* or a character class */
335 size_t startIndex;
336 size_t kidlen; /* length of string at kid, in jschars */
337 size_t index; /* index into class list */
338 WORD bmsize; /* bitmap size, based on max char code */
339 JSPackedBool sense;
340 } ucclass;
341 struct { /* or a literal sequence */
342 WCHAR chr; /* of one character */
343 size_t length; /* or many (via the kid) */
344 } flat;
345 struct {
346 RENode *kid2; /* second operand from ALT */
347 WCHAR ch1; /* match char for ALTPREREQ */
348 WCHAR ch2; /* ditto, or class index for ALTPREREQ2 */
349 } altprereq;
350 } u;
351 };
352
353 #define CLASS_CACHE_SIZE 4
354
355 typedef struct CompilerState {
356 script_ctx_t *context;
357 const WCHAR *cpbegin;
358 const WCHAR *cpend;
359 const WCHAR *cp;
360 size_t parenCount;
361 size_t classCount; /* number of [] encountered */
362 size_t treeDepth; /* maximum depth of parse tree */
363 size_t progLength; /* estimated bytecode length */
364 RENode *result;
365 size_t classBitmapsMem; /* memory to hold all class bitmaps */
366 struct {
367 const WCHAR *start; /* small cache of class strings */
368 size_t length; /* since they're often the same */
369 size_t index;
370 } classCache[CLASS_CACHE_SIZE];
371 WORD flags;
372 } CompilerState;
373
374 typedef struct EmitStateStackEntry {
375 jsbytecode *altHead; /* start of REOP_ALT* opcode */
376 jsbytecode *nextAltFixup; /* fixup pointer to next-alt offset */
377 jsbytecode *nextTermFixup; /* fixup ptr. to REOP_JUMP offset */
378 jsbytecode *endTermFixup; /* fixup ptr. to REOPT_ALTPREREQ* offset */
379 RENode *continueNode; /* original REOP_ALT* node being stacked */
380 jsbytecode continueOp; /* REOP_JUMP or REOP_ENDALT continuation */
381 JSPackedBool jumpToJumpFlag; /* true if we've patched jump-to-jump to
382 avoid 16-bit unsigned offset overflow */
383 } EmitStateStackEntry;
384
385 /*
386 * Immediate operand sizes and getter/setters. Unlike the ones in jsopcode.h,
387 * the getters and setters take the pc of the offset, not of the opcode before
388 * the offset.
389 */
390 #define ARG_LEN 2
391 #define GET_ARG(pc) ((WORD)(((pc)[0] << 8) | (pc)[1]))
392 #define SET_ARG(pc, arg) ((pc)[0] = (jsbytecode) ((arg) >> 8), \
393 (pc)[1] = (jsbytecode) (arg))
394
395 #define OFFSET_LEN ARG_LEN
396 #define OFFSET_MAX ((1 << (ARG_LEN * 8)) - 1)
397 #define GET_OFFSET(pc) GET_ARG(pc)
398
399 static BOOL ParseRegExp(CompilerState*);
400
401 /*
402 * Maximum supported tree depth is maximum size of EmitStateStackEntry stack.
403 * For sanity, we limit it to 2^24 bytes.
404 */
405 #define TREE_DEPTH_MAX ((1 << 24) / sizeof(EmitStateStackEntry))
406
407 /*
408 * The maximum memory that can be allocated for class bitmaps.
409 * For sanity, we limit it to 2^24 bytes.
410 */
411 #define CLASS_BITMAPS_MEM_LIMIT (1 << 24)
412
413 /*
414 * Functions to get size and write/read bytecode that represent small indexes
415 * compactly.
416 * Each byte in the code represent 7-bit chunk of the index. 8th bit when set
417 * indicates that the following byte brings more bits to the index. Otherwise
418 * this is the last byte in the index bytecode representing highest index bits.
419 */
420 static size_t
421 GetCompactIndexWidth(size_t index)
422 {
423 size_t width;
424
425 for (width = 1; (index >>= 7) != 0; ++width) { }
426 return width;
427 }
428
429 static inline jsbytecode *
430 WriteCompactIndex(jsbytecode *pc, size_t index)
431 {
432 size_t next;
433
434 while ((next = index >> 7) != 0) {
435 *pc++ = (jsbytecode)(index | 0x80);
436 index = next;
437 }
438 *pc++ = (jsbytecode)index;
439 return pc;
440 }
441
442 static inline jsbytecode *
443 ReadCompactIndex(jsbytecode *pc, size_t *result)
444 {
445 size_t nextByte;
446
447 nextByte = *pc++;
448 if ((nextByte & 0x80) == 0) {
449 /*
450 * Short-circuit the most common case when compact index <= 127.
451 */
452 *result = nextByte;
453 } else {
454 size_t shift = 7;
455 *result = 0x7F & nextByte;
456 do {
457 nextByte = *pc++;
458 *result |= (nextByte & 0x7F) << shift;
459 shift += 7;
460 } while ((nextByte & 0x80) != 0);
461 }
462 return pc;
463 }
464
465 /* Construct and initialize an RENode, returning NULL for out-of-memory */
466 static RENode *
467 NewRENode(CompilerState *state, REOp op)
468 {
469 RENode *ren;
470
471 ren = jsheap_alloc(&state->context->tmp_heap, sizeof(*ren));
472 if (!ren) {
473 /* js_ReportOutOfScriptQuota(cx); */
474 return NULL;
475 }
476 ren->op = op;
477 ren->next = NULL;
478 ren->kid = NULL;
479 return ren;
480 }
481
482 /*
483 * Validates and converts hex ascii value.
484 */
485 static BOOL
486 isASCIIHexDigit(WCHAR c, UINT *digit)
487 {
488 UINT cv = c;
489
490 if (cv < '0')
491 return FALSE;
492 if (cv <= '9') {
493 *digit = cv - '0';
494 return TRUE;
495 }
496 cv |= 0x20;
497 if (cv >= 'a' && cv <= 'f') {
498 *digit = cv - 'a' + 10;
499 return TRUE;
500 }
501 return FALSE;
502 }
503
504 typedef struct {
505 REOp op;
506 const WCHAR *errPos;
507 size_t parenIndex;
508 } REOpData;
509
510 #define JUMP_OFFSET_HI(off) ((jsbytecode)((off) >> 8))
511 #define JUMP_OFFSET_LO(off) ((jsbytecode)(off))
512
513 static BOOL
514 SetForwardJumpOffset(jsbytecode *jump, jsbytecode *target)
515 {
516 ptrdiff_t offset = target - jump;
517
518 /* Check that target really points forward. */
519 assert(offset >= 2);
520 if ((size_t)offset > OFFSET_MAX)
521 return FALSE;
522
523 jump[0] = JUMP_OFFSET_HI(offset);
524 jump[1] = JUMP_OFFSET_LO(offset);
525 return TRUE;
526 }
527
528 /*
529 * Generate bytecode for the tree rooted at t using an explicit stack instead
530 * of recursion.
531 */
532 static jsbytecode *
533 EmitREBytecode(CompilerState *state, JSRegExp *re, size_t treeDepth,
534 jsbytecode *pc, RENode *t)
535 {
536 EmitStateStackEntry *emitStateSP, *emitStateStack;
537 RECharSet *charSet;
538 REOp op;
539
540 if (treeDepth == 0) {
541 emitStateStack = NULL;
542 } else {
543 emitStateStack = heap_alloc(sizeof(EmitStateStackEntry) * treeDepth);
544 if (!emitStateStack)
545 return NULL;
546 }
547 emitStateSP = emitStateStack;
548 op = t->op;
549 assert(op < REOP_LIMIT);
550
551 for (;;) {
552 *pc++ = op;
553 switch (op) {
554 case REOP_EMPTY:
555 --pc;
556 break;
557
558 case REOP_ALTPREREQ2:
559 case REOP_ALTPREREQ:
560 assert(emitStateSP);
561 emitStateSP->altHead = pc - 1;
562 emitStateSP->endTermFixup = pc;
563 pc += OFFSET_LEN;
564 SET_ARG(pc, t->u.altprereq.ch1);
565 pc += ARG_LEN;
566 SET_ARG(pc, t->u.altprereq.ch2);
567 pc += ARG_LEN;
568
569 emitStateSP->nextAltFixup = pc; /* offset to next alternate */
570 pc += OFFSET_LEN;
571
572 emitStateSP->continueNode = t;
573 emitStateSP->continueOp = REOP_JUMP;
574 emitStateSP->jumpToJumpFlag = FALSE;
575 ++emitStateSP;
576 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
577 t = t->kid;
578 op = t->op;
579 assert(op < REOP_LIMIT);
580 continue;
581
582 case REOP_JUMP:
583 emitStateSP->nextTermFixup = pc; /* offset to following term */
584 pc += OFFSET_LEN;
585 if (!SetForwardJumpOffset(emitStateSP->nextAltFixup, pc))
586 goto jump_too_big;
587 emitStateSP->continueOp = REOP_ENDALT;
588 ++emitStateSP;
589 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
590 t = t->u.kid2;
591 op = t->op;
592 assert(op < REOP_LIMIT);
593 continue;
594
595 case REOP_ENDALT:
596 /*
597 * If we already patched emitStateSP->nextTermFixup to jump to
598 * a nearer jump, to avoid 16-bit immediate offset overflow, we
599 * are done here.
600 */
601 if (emitStateSP->jumpToJumpFlag)
602 break;
603
604 /*
605 * Fix up the REOP_JUMP offset to go to the op after REOP_ENDALT.
606 * REOP_ENDALT is executed only on successful match of the last
607 * alternate in a group.
608 */
609 if (!SetForwardJumpOffset(emitStateSP->nextTermFixup, pc))
610 goto jump_too_big;
611 if (t->op != REOP_ALT) {
612 if (!SetForwardJumpOffset(emitStateSP->endTermFixup, pc))
613 goto jump_too_big;
614 }
615
616 /*
617 * If the program is bigger than the REOP_JUMP offset range, then
618 * we must check for alternates before this one that are part of
619 * the same group, and fix up their jump offsets to target jumps
620 * close enough to fit in a 16-bit unsigned offset immediate.
621 */
622 if ((size_t)(pc - re->program) > OFFSET_MAX &&
623 emitStateSP > emitStateStack) {
624 EmitStateStackEntry *esp, *esp2;
625 jsbytecode *alt, *jump;
626 ptrdiff_t span, header;
627
628 esp2 = emitStateSP;
629 alt = esp2->altHead;
630 for (esp = esp2 - 1; esp >= emitStateStack; --esp) {
631 if (esp->continueOp == REOP_ENDALT &&
632 !esp->jumpToJumpFlag &&
633 esp->nextTermFixup + OFFSET_LEN == alt &&
634 (size_t)(pc - ((esp->continueNode->op != REOP_ALT)
635 ? esp->endTermFixup
636 : esp->nextTermFixup)) > OFFSET_MAX) {
637 alt = esp->altHead;
638 jump = esp->nextTermFixup;
639
640 /*
641 * The span must be 1 less than the distance from
642 * jump offset to jump offset, so we actually jump
643 * to a REOP_JUMP bytecode, not to its offset!
644 */
645 for (;;) {
646 assert(jump < esp2->nextTermFixup);
647 span = esp2->nextTermFixup - jump - 1;
648 if ((size_t)span <= OFFSET_MAX)
649 break;
650 do {
651 if (--esp2 == esp)
652 goto jump_too_big;
653 } while (esp2->continueOp != REOP_ENDALT);
654 }
655
656 jump[0] = JUMP_OFFSET_HI(span);
657 jump[1] = JUMP_OFFSET_LO(span);
658
659 if (esp->continueNode->op != REOP_ALT) {
660 /*
661 * We must patch the offset at esp->endTermFixup
662 * as well, for the REOP_ALTPREREQ{,2} opcodes.
663 * If we're unlucky and endTermFixup is more than
664 * OFFSET_MAX bytes from its target, we cheat by
665 * jumping 6 bytes to the jump whose offset is at
666 * esp->nextTermFixup, which has the same target.
667 */
668 jump = esp->endTermFixup;
669 header = esp->nextTermFixup - jump;
670 span += header;
671 if ((size_t)span > OFFSET_MAX)
672 span = header;
673
674 jump[0] = JUMP_OFFSET_HI(span);
675 jump[1] = JUMP_OFFSET_LO(span);
676 }
677
678 esp->jumpToJumpFlag = TRUE;
679 }
680 }
681 }
682 break;
683
684 case REOP_ALT:
685 assert(emitStateSP);
686 emitStateSP->altHead = pc - 1;
687 emitStateSP->nextAltFixup = pc; /* offset to next alternate */
688 pc += OFFSET_LEN;
689 emitStateSP->continueNode = t;
690 emitStateSP->continueOp = REOP_JUMP;
691 emitStateSP->jumpToJumpFlag = FALSE;
692 ++emitStateSP;
693 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
694 t = t->kid;
695 op = t->op;
696 assert(op < REOP_LIMIT);
697 continue;
698
699 case REOP_FLAT:
700 /*
701 * Coalesce FLATs if possible and if it would not increase bytecode
702 * beyond preallocated limit. The latter happens only when bytecode
703 * size for coalesced string with offset p and length 2 exceeds 6
704 * bytes preallocated for 2 single char nodes, i.e. when
705 * 1 + GetCompactIndexWidth(p) + GetCompactIndexWidth(2) > 6 or
706 * GetCompactIndexWidth(p) > 4.
707 * Since when GetCompactIndexWidth(p) <= 4 coalescing of 3 or more
708 * nodes strictly decreases bytecode size, the check has to be
709 * done only for the first coalescing.
710 */
711 if (t->kid &&
712 GetCompactIndexWidth((WCHAR*)t->kid - state->cpbegin) <= 4)
713 {
714 while (t->next &&
715 t->next->op == REOP_FLAT &&
716 (WCHAR*)t->kid + t->u.flat.length ==
717 t->next->kid) {
718 t->u.flat.length += t->next->u.flat.length;
719 t->next = t->next->next;
720 }
721 }
722 if (t->kid && t->u.flat.length > 1) {
723 pc[-1] = (state->flags & JSREG_FOLD) ? REOP_FLATi : REOP_FLAT;
724 pc = WriteCompactIndex(pc, (WCHAR*)t->kid - state->cpbegin);
725 pc = WriteCompactIndex(pc, t->u.flat.length);
726 } else if (t->u.flat.chr < 256) {
727 pc[-1] = (state->flags & JSREG_FOLD) ? REOP_FLAT1i : REOP_FLAT1;
728 *pc++ = (jsbytecode) t->u.flat.chr;
729 } else {
730 pc[-1] = (state->flags & JSREG_FOLD)
731 ? REOP_UCFLAT1i
732 : REOP_UCFLAT1;
733 SET_ARG(pc, t->u.flat.chr);
734 pc += ARG_LEN;
735 }
736 break;
737
738 case REOP_LPAREN:
739 assert(emitStateSP);
740 pc = WriteCompactIndex(pc, t->u.parenIndex);
741 emitStateSP->continueNode = t;
742 emitStateSP->continueOp = REOP_RPAREN;
743 ++emitStateSP;
744 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
745 t = t->kid;
746 op = t->op;
747 continue;
748
749 case REOP_RPAREN:
750 pc = WriteCompactIndex(pc, t->u.parenIndex);
751 break;
752
753 case REOP_BACKREF:
754 pc = WriteCompactIndex(pc, t->u.parenIndex);
755 break;
756
757 case REOP_ASSERT:
758 assert(emitStateSP);
759 emitStateSP->nextTermFixup = pc;
760 pc += OFFSET_LEN;
761 emitStateSP->continueNode = t;
762 emitStateSP->continueOp = REOP_ASSERTTEST;
763 ++emitStateSP;
764 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
765 t = t->kid;
766 op = t->op;
767 continue;
768
769 case REOP_ASSERTTEST:
770 case REOP_ASSERTNOTTEST:
771 if (!SetForwardJumpOffset(emitStateSP->nextTermFixup, pc))
772 goto jump_too_big;
773 break;
774
775 case REOP_ASSERT_NOT:
776 assert(emitStateSP);
777 emitStateSP->nextTermFixup = pc;
778 pc += OFFSET_LEN;
779 emitStateSP->continueNode = t;
780 emitStateSP->continueOp = REOP_ASSERTNOTTEST;
781 ++emitStateSP;
782 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
783 t = t->kid;
784 op = t->op;
785 continue;
786
787 case REOP_QUANT:
788 assert(emitStateSP);
789 if (t->u.range.min == 0 && t->u.range.max == (UINT)-1) {
790 pc[-1] = (t->u.range.greedy) ? REOP_STAR : REOP_MINIMALSTAR;
791 } else if (t->u.range.min == 0 && t->u.range.max == 1) {
792 pc[-1] = (t->u.range.greedy) ? REOP_OPT : REOP_MINIMALOPT;
793 } else if (t->u.range.min == 1 && t->u.range.max == (UINT) -1) {
794 pc[-1] = (t->u.range.greedy) ? REOP_PLUS : REOP_MINIMALPLUS;
795 } else {
796 if (!t->u.range.greedy)
797 pc[-1] = REOP_MINIMALQUANT;
798 pc = WriteCompactIndex(pc, t->u.range.min);
799 /*
800 * Write max + 1 to avoid using size_t(max) + 1 bytes
801 * for (UINT)-1 sentinel.
802 */
803 pc = WriteCompactIndex(pc, t->u.range.max + 1);
804 }
805 emitStateSP->nextTermFixup = pc;
806 pc += OFFSET_LEN;
807 emitStateSP->continueNode = t;
808 emitStateSP->continueOp = REOP_ENDCHILD;
809 ++emitStateSP;
810 assert((size_t)(emitStateSP - emitStateStack) <= treeDepth);
811 t = t->kid;
812 op = t->op;
813 continue;
814
815 case REOP_ENDCHILD:
816 if (!SetForwardJumpOffset(emitStateSP->nextTermFixup, pc))
817 goto jump_too_big;
818 break;
819
820 case REOP_CLASS:
821 if (!t->u.ucclass.sense)
822 pc[-1] = REOP_NCLASS;
823 pc = WriteCompactIndex(pc, t->u.ucclass.index);
824 charSet = &re->classList[t->u.ucclass.index];
825 charSet->converted = FALSE;
826 charSet->length = t->u.ucclass.bmsize;
827 charSet->u.src.startIndex = t->u.ucclass.startIndex;
828 charSet->u.src.length = t->u.ucclass.kidlen;
829 charSet->sense = t->u.ucclass.sense;
830 break;
831
832 default:
833 break;
834 }
835
836 t = t->next;
837 if (t) {
838 op = t->op;
839 } else {
840 if (emitStateSP == emitStateStack)
841 break;
842 --emitStateSP;
843 t = emitStateSP->continueNode;
844 op = (REOp) emitStateSP->continueOp;
845 }
846 }
847
848 cleanup:
849 heap_free(emitStateStack);
850 return pc;
851
852 jump_too_big:
853 ReportRegExpError(state, JSREPORT_ERROR, JSMSG_REGEXP_TOO_COMPLEX);
854 pc = NULL;
855 goto cleanup;
856 }
857
858 /*
859 * Process the op against the two top operands, reducing them to a single
860 * operand in the penultimate slot. Update progLength and treeDepth.
861 */
862 static BOOL
863 ProcessOp(CompilerState *state, REOpData *opData, RENode **operandStack,
864 INT operandSP)
865 {
866 RENode *result;
867
868 switch (opData->op) {
869 case REOP_ALT:
870 result = NewRENode(state, REOP_ALT);
871 if (!result)
872 return FALSE;
873 result->kid = operandStack[operandSP - 2];
874 result->u.kid2 = operandStack[operandSP - 1];
875 operandStack[operandSP - 2] = result;
876
877 if (state->treeDepth == TREE_DEPTH_MAX) {
878 ReportRegExpError(state, JSREPORT_ERROR, JSMSG_REGEXP_TOO_COMPLEX);
879 return FALSE;
880 }
881 ++state->treeDepth;
882
883 /*
884 * Look at both alternates to see if there's a FLAT or a CLASS at
885 * the start of each. If so, use a prerequisite match.
886 */
887 if (((RENode *) result->kid)->op == REOP_FLAT &&
888 ((RENode *) result->u.kid2)->op == REOP_FLAT &&
889 (state->flags & JSREG_FOLD) == 0) {
890 result->op = REOP_ALTPREREQ;
891 result->u.altprereq.ch1 = ((RENode *) result->kid)->u.flat.chr;
892 result->u.altprereq.ch2 = ((RENode *) result->u.kid2)->u.flat.chr;
893 /* ALTPREREQ, <end>, uch1, uch2, <next>, ...,
894 JUMP, <end> ... ENDALT */
895 state->progLength += 13;
896 }
897 else
898 if (((RENode *) result->kid)->op == REOP_CLASS &&
899 ((RENode *) result->kid)->u.ucclass.index < 256 &&
900 ((RENode *) result->u.kid2)->op == REOP_FLAT &&
901 (state->flags & JSREG_FOLD) == 0) {
902 result->op = REOP_ALTPREREQ2;
903 result->u.altprereq.ch1 = ((RENode *) result->u.kid2)->u.flat.chr;
904 result->u.altprereq.ch2 = ((RENode *) result->kid)->u.ucclass.index;
905 /* ALTPREREQ2, <end>, uch1, uch2, <next>, ...,
906 JUMP, <end> ... ENDALT */
907 state->progLength += 13;
908 }
909 else
910 if (((RENode *) result->kid)->op == REOP_FLAT &&
911 ((RENode *) result->u.kid2)->op == REOP_CLASS &&
912 ((RENode *) result->u.kid2)->u.ucclass.index < 256 &&
913 (state->flags & JSREG_FOLD) == 0) {
914 result->op = REOP_ALTPREREQ2;
915 result->u.altprereq.ch1 = ((RENode *) result->kid)->u.flat.chr;
916 result->u.altprereq.ch2 =
917 ((RENode *) result->u.kid2)->u.ucclass.index;
918 /* ALTPREREQ2, <end>, uch1, uch2, <next>, ...,
919 JUMP, <end> ... ENDALT */
920 state->progLength += 13;
921 }
922 else {
923 /* ALT, <next>, ..., JUMP, <end> ... ENDALT */
924 state->progLength += 7;
925 }
926 break;
927
928 case REOP_CONCAT:
929 result = operandStack[operandSP - 2];
930 while (result->next)
931 result = result->next;
932 result->next = operandStack[operandSP - 1];
933 break;
934
935 case REOP_ASSERT:
936 case REOP_ASSERT_NOT:
937 case REOP_LPARENNON:
938 case REOP_LPAREN:
939 /* These should have been processed by a close paren. */
940 ReportRegExpErrorHelper(state, JSREPORT_ERROR, JSMSG_MISSING_PAREN,
941 opData->errPos);
942 return FALSE;
943
944 default:;
945 }
946 return TRUE;
947 }
948
949 /*
950 * Hack two bits in CompilerState.flags, for use within FindParenCount to flag
951 * its being on the stack, and to propagate errors to its callers.
952 */
953 #define JSREG_FIND_PAREN_COUNT 0x8000
954 #define JSREG_FIND_PAREN_ERROR 0x4000
955
956 /*
957 * Magic return value from FindParenCount and GetDecimalValue, to indicate
958 * overflow beyond GetDecimalValue's max parameter, or a computed maximum if
959 * its findMax parameter is non-null.
960 */
961 #define OVERFLOW_VALUE ((UINT)-1)
962
963 static UINT
964 FindParenCount(CompilerState *state)
965 {
966 CompilerState temp;
967 int i;
968
969 if (state->flags & JSREG_FIND_PAREN_COUNT)
970 return OVERFLOW_VALUE;
971
972 /*
973 * Copy state into temp, flag it so we never report an invalid backref,
974 * and reset its members to parse the entire regexp. This is obviously
975 * suboptimal, but GetDecimalValue calls us only if a backref appears to
976 * refer to a forward parenthetical, which is rare.
977 */
978 temp = *state;
979 temp.flags |= JSREG_FIND_PAREN_COUNT;
980 temp.cp = temp.cpbegin;
981 temp.parenCount = 0;
982 temp.classCount = 0;
983 temp.progLength = 0;
984 temp.treeDepth = 0;
985 temp.classBitmapsMem = 0;
986 for (i = 0; i < CLASS_CACHE_SIZE; i++)
987 temp.classCache[i].start = NULL;
988
989 if (!ParseRegExp(&temp)) {
990 state->flags |= JSREG_FIND_PAREN_ERROR;
991 return OVERFLOW_VALUE;
992 }
993 return temp.parenCount;
994 }
995
996 /*
997 * Extract and return a decimal value at state->cp. The initial character c
998 * has already been read. Return OVERFLOW_VALUE if the result exceeds max.
999 * Callers who pass a non-null findMax should test JSREG_FIND_PAREN_ERROR in
1000 * state->flags to discover whether an error occurred under findMax.
1001 */
1002 static UINT
1003 GetDecimalValue(WCHAR c, UINT max, UINT (*findMax)(CompilerState *state),
1004 CompilerState *state)
1005 {
1006 UINT value = JS7_UNDEC(c);
1007 BOOL overflow = (value > max && (!findMax || value > findMax(state)));
1008
1009 /* The following restriction allows simpler overflow checks. */
1010 assert(max <= ((UINT)-1 - 9) / 10);
1011 while (state->cp < state->cpend) {
1012 c = *state->cp;
1013 if (!JS7_ISDEC(c))
1014 break;
1015 value = 10 * value + JS7_UNDEC(c);
1016 if (!overflow && value > max && (!findMax || value > findMax(state)))
1017 overflow = TRUE;
1018 ++state->cp;
1019 }
1020 return overflow ? OVERFLOW_VALUE : value;
1021 }
1022
1023 /*
1024 * Calculate the total size of the bitmap required for a class expression.
1025 */
1026 static BOOL
1027 CalculateBitmapSize(CompilerState *state, RENode *target, const WCHAR *src,
1028 const WCHAR *end)
1029 {
1030 UINT max = 0;
1031 BOOL inRange = FALSE;
1032 WCHAR c, rangeStart = 0;
1033 UINT n, digit, nDigits, i;
1034
1035 target->u.ucclass.bmsize = 0;
1036 target->u.ucclass.sense = TRUE;
1037
1038 if (src == end)
1039 return TRUE;
1040
1041 if (*src == '^') {
1042 ++src;
1043 target->u.ucclass.sense = FALSE;
1044 }
1045
1046 while (src != end) {
1047 BOOL canStartRange = TRUE;
1048 UINT localMax = 0;
1049
1050 switch (*src) {
1051 case '\\':
1052 ++src;
1053 c = *src++;
1054 switch (c) {
1055 case 'b':
1056 localMax = 0x8;
1057 break;
1058 case 'f':
1059 localMax = 0xC;
1060 break;
1061 case 'n':
1062 localMax = 0xA;
1063 break;
1064 case 'r':
1065 localMax = 0xD;
1066 break;
1067 case 't':
1068 localMax = 0x9;
1069 break;
1070 case 'v':
1071 localMax = 0xB;
1072 break;
1073 case 'c':
1074 if (src < end && RE_IS_LETTER(*src)) {
1075 localMax = (UINT) (*src++) & 0x1F;
1076 } else {
1077 --src;
1078 localMax = '\\';
1079 }
1080 break;
1081 case 'x':
1082 nDigits = 2;
1083 goto lexHex;
1084 case 'u':
1085 nDigits = 4;
1086 lexHex:
1087 n = 0;
1088 for (i = 0; (i < nDigits) && (src < end); i++) {
1089 c = *src++;
1090 if (!isASCIIHexDigit(c, &digit)) {
1091 /*
1092 * Back off to accepting the original
1093 *'\' as a literal.
1094 */
1095 src -= i + 1;
1096 n = '\\';
1097 break;
1098 }
1099 n = (n << 4) | digit;
1100 }
1101 localMax = n;
1102 break;
1103 case 'd':
1104 canStartRange = FALSE;
1105 if (inRange) {
1106 JS_ReportErrorNumber(state->context,
1107 js_GetErrorMessage, NULL,
1108 JSMSG_BAD_CLASS_RANGE);
1109 return FALSE;
1110 }
1111 localMax = '9';
1112 break;
1113 case 'D':
1114 case 's':
1115 case 'S':
1116 case 'w':
1117 case 'W':
1118 canStartRange = FALSE;
1119 if (inRange) {
1120 JS_ReportErrorNumber(state->context,
1121 js_GetErrorMessage, NULL,
1122 JSMSG_BAD_CLASS_RANGE);
1123 return FALSE;
1124 }
1125 max = 65535;
1126
1127 /*
1128 * If this is the start of a range, ensure that it's less than
1129 * the end.
1130 */
1131 localMax = 0;
1132 break;
1133 case '0':
1134 case '1':
1135 case '2':
1136 case '3':
1137 case '4':
1138 case '5':
1139 case '6':
1140 case '7':
1141 /*
1142 * This is a non-ECMA extension - decimal escapes (in this
1143 * case, octal!) are supposed to be an error inside class
1144 * ranges, but supported here for backwards compatibility.
1145 *
1146 */
1147 n = JS7_UNDEC(c);
1148 c = *src;
1149 if ('0' <= c && c <= '7') {
1150 src++;
1151 n = 8 * n + JS7_UNDEC(c);
1152 c = *src;
1153 if ('0' <= c && c <= '7') {
1154 src++;
1155 i = 8 * n + JS7_UNDEC(c);
1156 if (i <= 0377)
1157 n = i;
1158 else
1159 src--;
1160 }
1161 }
1162 localMax = n;
1163 break;
1164
1165 default:
1166 localMax = c;
1167 break;
1168 }
1169 break;
1170 default:
1171 localMax = *src++;
1172 break;
1173 }
1174
1175 if (inRange) {
1176 /* Throw a SyntaxError here, per ECMA-262, 15.10.2.15. */
1177 if (rangeStart > localMax) {
1178 JS_ReportErrorNumber(state->context,
1179 js_GetErrorMessage, NULL,
1180 JSMSG_BAD_CLASS_RANGE);
1181 return FALSE;
1182 }
1183 inRange = FALSE;
1184 } else {
1185 if (canStartRange && src < end - 1) {
1186 if (*src == '-') {
1187 ++src;
1188 inRange = TRUE;
1189 rangeStart = (WCHAR)localMax;
1190 continue;
1191 }
1192 }
1193 if (state->flags & JSREG_FOLD)
1194 rangeStart = localMax; /* one run of the uc/dc loop below */
1195 }
1196
1197 if (state->flags & JSREG_FOLD) {
1198 WCHAR maxch = localMax;
1199
1200 for (i = rangeStart; i <= localMax; i++) {
1201 WCHAR uch, dch;
1202
1203 uch = toupperW(i);
1204 dch = tolowerW(i);
1205 if(maxch < uch)
1206 maxch = uch;
1207 if(maxch < dch)
1208 maxch = dch;
1209 }
1210 localMax = maxch;
1211 }
1212
1213 if (localMax > max)
1214 max = localMax;
1215 }
1216 target->u.ucclass.bmsize = max;
1217 return TRUE;
1218 }
1219
1220 static INT
1221 ParseMinMaxQuantifier(CompilerState *state, BOOL ignoreValues)
1222 {
1223 UINT min, max;
1224 WCHAR c;
1225 const WCHAR *errp = state->cp++;
1226
1227 c = *state->cp;
1228 if (JS7_ISDEC(c)) {
1229 ++state->cp;
1230 min = GetDecimalValue(c, 0xFFFF, NULL, state);
1231 c = *state->cp;
1232
1233 if (!ignoreValues && min == OVERFLOW_VALUE)
1234 return JSMSG_MIN_TOO_BIG;
1235
1236 if (c == ',') {
1237 c = *++state->cp;
1238 if (JS7_ISDEC(c)) {
1239 ++state->cp;
1240 max = GetDecimalValue(c, 0xFFFF, NULL, state);
1241 c = *state->cp;
1242 if (!ignoreValues && max == OVERFLOW_VALUE)
1243 return JSMSG_MAX_TOO_BIG;
1244 if (!ignoreValues && min > max)
1245 return JSMSG_OUT_OF_ORDER;
1246 } else {
1247 max = (UINT)-1;
1248 }
1249 } else {
1250 max = min;
1251 }
1252 if (c == '}') {
1253 state->result = NewRENode(state, REOP_QUANT);
1254 if (!state->result)
1255 return JSMSG_OUT_OF_MEMORY;
1256 state->result->u.range.min = min;
1257 state->result->u.range.max = max;
1258 /*
1259 * QUANT, <min>, <max>, <next> ... <ENDCHILD>
1260 * where <max> is written as compact(max+1) to make
1261 * (UINT)-1 sentinel to occupy 1 byte, not width_of(max)+1.
1262 */
1263 state->progLength += (1 + GetCompactIndexWidth(min)
1264 + GetCompactIndexWidth(max + 1)
1265 +3);
1266 return 0;
1267 }
1268 }
1269
1270 state->cp = errp;
1271 return -1;
1272 }
1273
1274 static BOOL
1275 ParseQuantifier(CompilerState *state)
1276 {
1277 RENode *term;
1278 term = state->result;
1279 if (state->cp < state->cpend) {
1280 switch (*state->cp) {
1281 case '+':
1282 state->result = NewRENode(state, REOP_QUANT);
1283 if (!state->result)
1284 return FALSE;
1285 state->result->u.range.min = 1;
1286 state->result->u.range.max = (UINT)-1;
1287 /* <PLUS>, <next> ... <ENDCHILD> */
1288 state->progLength += 4;
1289 goto quantifier;
1290 case '*':
1291 state->result = NewRENode(state, REOP_QUANT);
1292 if (!state->result)
1293 return FALSE;
1294 state->result->u.range.min = 0;
1295 state->result->u.range.max = (UINT)-1;
1296 /* <STAR>, <next> ... <ENDCHILD> */
1297 state->progLength += 4;
1298 goto quantifier;
1299 case '?':
1300 state->result = NewRENode(state, REOP_QUANT);
1301 if (!state->result)
1302 return FALSE;
1303 state->result->u.range.min = 0;
1304 state->result->u.range.max = 1;
1305 /* <OPT>, <next> ... <ENDCHILD> */
1306 state->progLength += 4;
1307 goto quantifier;
1308 case '{': /* balance '}' */
1309 {
1310 INT err;
1311
1312 err = ParseMinMaxQuantifier(state, FALSE);
1313 if (err == 0)
1314 goto quantifier;
1315 if (err == -1)
1316 return TRUE;
1317
1318 ReportRegExpErrorHelper(state, JSREPORT_ERROR, err, errp);
1319 return FALSE;
1320 }
1321 default:;
1322 }
1323 }
1324 return TRUE;
1325
1326 quantifier:
1327 if (state->treeDepth == TREE_DEPTH_MAX) {
1328 ReportRegExpError(state, JSREPORT_ERROR, JSMSG_REGEXP_TOO_COMPLEX);
1329 return FALSE;
1330 }
1331
1332 ++state->treeDepth;
1333 ++state->cp;
1334 state->result->kid = term;
1335 if (state->cp < state->cpend && *state->cp == '?') {
1336 ++state->cp;
1337 state->result->u.range.greedy = FALSE;
1338 } else {
1339 state->result->u.range.greedy = TRUE;
1340 }
1341 return TRUE;
1342 }
1343
1344 /*
1345 * item: assertion An item is either an assertion or
1346 * quantatom a quantified atom.
1347 *
1348 * assertion: '^' Assertions match beginning of string
1349 * (or line if the class static property
1350 * RegExp.multiline is true).
1351 * '$' End of string (or line if the class
1352 * static property RegExp.multiline is
1353 * true).
1354 * '\b' Word boundary (between \w and \W).
1355 * '\B' Word non-boundary.
1356 *
1357 * quantatom: atom An unquantified atom.
1358 * quantatom '{' n ',' m '}'
1359 * Atom must occur between n and m times.
1360 * quantatom '{' n ',' '}' Atom must occur at least n times.
1361 * quantatom '{' n '}' Atom must occur exactly n times.
1362 * quantatom '*' Zero or more times (same as {0,}).
1363 * quantatom '+' One or more times (same as {1,}).
1364 * quantatom '?' Zero or one time (same as {0,1}).
1365 *
1366 * any of which can be optionally followed by '?' for ungreedy
1367 *
1368 * atom: '(' regexp ')' A parenthesized regexp (what matched
1369 * can be addressed using a backreference,
1370 * see '\' n below).
1371 * '.' Matches any char except '\n'.
1372 * '[' classlist ']' A character class.
1373 * '[' '^' classlist ']' A negated character class.
1374 * '\f' Form Feed.
1375 * '\n' Newline (Line Feed).
1376 * '\r' Carriage Return.
1377 * '\t' Horizontal Tab.
1378 * '\v' Vertical Tab.
1379 * '\d' A digit (same as [0-9]).
1380 * '\D' A non-digit.
1381 * '\w' A word character, [0-9a-z_A-Z].
1382 * '\W' A non-word character.
1383 * '\s' A whitespace character, [ \b\f\n\r\t\v].
1384 * '\S' A non-whitespace character.
1385 * '\' n A backreference to the nth (n decimal
1386 * and positive) parenthesized expression.
1387 * '\' octal An octal escape sequence (octal must be
1388 * two or three digits long, unless it is
1389 * 0 for the null character).
1390 * '\x' hex A hex escape (hex must be two digits).
1391 * '\u' unicode A unicode escape (must be four digits).
1392 * '\c' ctrl A control character, ctrl is a letter.
1393 * '\' literalatomchar Any character except one of the above
1394 * that follow '\' in an atom.
1395 * otheratomchar Any character not first among the other
1396 * atom right-hand sides.
1397 */
1398 static BOOL
1399 ParseTerm(CompilerState *state)
1400 {
1401 WCHAR c = *state->cp++;
1402 UINT nDigits;
1403 UINT num, tmp, n, i;
1404 const WCHAR *termStart;
1405
1406 switch (c) {
1407 /* assertions and atoms */
1408 case '^':
1409 state->result = NewRENode(state, REOP_BOL);
1410 if (!state->result)
1411 return FALSE;
1412 state->progLength++;
1413 return TRUE;
1414 case '$':
1415 state->result = NewRENode(state, REOP_EOL);
1416 if (!state->result)
1417 return FALSE;
1418 state->progLength++;
1419 return TRUE;
1420 case '\\':
1421 if (state->cp >= state->cpend) {
1422 /* a trailing '\' is an error */
1423 ReportRegExpError(state, JSREPORT_ERROR, JSMSG_TRAILING_SLASH);
1424 return FALSE;
1425 }
1426 c = *state->cp++;
1427 switch (c) {
1428 /* assertion escapes */
1429 case 'b' :
1430 state->result = NewRENode(state, REOP_WBDRY);
1431 if (!state->result)
1432 return FALSE;
1433 state->progLength++;
1434 return TRUE;
1435 case 'B':
1436 state->result = NewRENode(state, REOP_WNONBDRY);
1437 if (!state->result)
1438 return FALSE;
1439 state->progLength++;
1440 return TRUE;
1441 /* Decimal escape */
1442 case '0':
1443 /* Give a strict warning. See also the note below. */
1444 WARN("non-octal digit in an escape sequence that doesn't match a back-reference\n");
1445 doOctal:
1446 num = 0;
1447 while (state->cp < state->cpend) {
1448 c = *state->cp;
1449 if (c < '0' || '7' < c)
1450 break;
1451 state->cp++;
1452 tmp = 8 * num + (UINT)JS7_UNDEC(c);
1453 if (tmp > 0377)
1454 break;
1455 num = tmp;
1456 }
1457 c = (WCHAR)num;
1458 doFlat:
1459 state->result = NewRENode(state, REOP_FLAT);
1460 if (!state->result)
1461 return FALSE;
1462 state->result->u.flat.chr = c;
1463 state->result->u.flat.length = 1;
1464 state->progLength += 3;
1465 break;
1466 case '1':
1467 case '2':
1468 case '3':
1469 case '4':
1470 case '5':
1471 case '6':
1472 case '7':
1473 case '8':
1474 case '9':
1475 termStart = state->cp - 1;
1476 num = GetDecimalValue(c, state->parenCount, FindParenCount, state);
1477 if (state->flags & JSREG_FIND_PAREN_ERROR)
1478 return FALSE;
1479 if (num == OVERFLOW_VALUE) {
1480 /* Give a strict mode warning. */
1481 WARN("back-reference exceeds number of capturing parentheses\n");
1482
1483 /*
1484 * Note: ECMA 262, 15.10.2.9 says that we should throw a syntax
1485 * error here. However, for compatibility with IE, we treat the
1486 * whole backref as flat if the first character in it is not a
1487 * valid octal character, and as an octal escape otherwise.
1488 */
1489 state->cp = termStart;
1490 if (c >= '8') {
1491 /* Treat this as flat. termStart - 1 is the \. */
1492 c = '\\';
1493 goto asFlat;
1494 }
1495
1496 /* Treat this as an octal escape. */
1497 goto doOctal;
1498 }
1499 assert(1 <= num && num <= 0x10000);
1500 state->result = NewRENode(state, REOP_BACKREF);
1501 if (!state->result)
1502 return FALSE;
1503 state->result->u.parenIndex = num - 1;
1504 state->progLength
1505 += 1 + GetCompactIndexWidth(state->result->u.parenIndex);
1506 break;
1507 /* Control escape */
1508 case 'f':
1509 c = 0xC;
1510 goto doFlat;
1511 case 'n':
1512 c = 0xA;
1513 goto doFlat;
1514 case 'r':
1515 c = 0xD;
1516 goto doFlat;
1517 case 't':
1518 c = 0x9;
1519 goto doFlat;
1520 case 'v':
1521 c = 0xB;
1522 goto doFlat;
1523 /* Control letter */
1524 case 'c':
1525 if (state->cp < state->cpend && RE_IS_LETTER(*state->cp)) {
1526 c = (WCHAR) (*state->cp++ & 0x1F);
1527 } else {
1528 /* back off to accepting the original '\' as a literal */
1529 --state->cp;
1530 c = '\\';
1531 }
1532 goto doFlat;
1533 /* HexEscapeSequence */
1534 case 'x':
1535 nDigits = 2;
1536 goto lexHex;
1537 /* UnicodeEscapeSequence */
1538 case 'u':
1539 nDigits = 4;
1540 lexHex:
1541 n = 0;
1542 for (i = 0; i < nDigits && state->cp < state->cpend; i++) {
1543 UINT digit;
1544 c = *state->cp++;
1545 if (!isASCIIHexDigit(c, &digit)) {
1546 /*
1547 * Back off to accepting the original 'u' or 'x' as a
1548 * literal.
1549 */
1550 state->cp -= i + 2;
1551 n = *state->cp++;
1552 break;
1553 }
1554 n = (n << 4) | digit;
1555 }
1556 c = (WCHAR) n;
1557 goto doFlat;
1558 /* Character class escapes */
1559 case 'd':
1560 state->result = NewRENode(state, REOP_DIGIT);
1561 doSimple:
1562 if (!state->result)
1563 return FALSE;
1564 state->progLength++;
1565 break;
1566 case 'D':
1567 state->result = NewRENode(state, REOP_NONDIGIT);
1568 goto doSimple;
1569 case 's':
1570 state->result = NewRENode(state, REOP_SPACE);
1571 goto doSimple;
1572 case 'S':
1573 state->result = NewRENode(state, REOP_NONSPACE);
1574 goto doSimple;
1575 case 'w':
1576 state->result = NewRENode(state, REOP_ALNUM);
1577 goto doSimple;
1578 case 'W':
1579 state->result = NewRENode(state, REOP_NONALNUM);
1580 goto doSimple;
1581 /* IdentityEscape */
1582 default:
1583 state->result = NewRENode(state, REOP_FLAT);
1584 if (!state->result)
1585 return FALSE;
1586 state->result->u.flat.chr = c;
1587 state->result->u.flat.length = 1;
1588 state->result->kid = (void *) (state->cp - 1);
1589 state->progLength += 3;
1590 break;
1591 }
1592 break;
1593 case '[':
1594 state->result = NewRENode(state, REOP_CLASS);
1595 if (!state->result)
1596 return FALSE;
1597 termStart = state->cp;
1598 state->result->u.ucclass.startIndex = termStart - state->cpbegin;
1599 for (;;) {
1600 if (state->cp == state->cpend) {
1601 ReportRegExpErrorHelper(state, JSREPORT_ERROR,
1602 JSMSG_UNTERM_CLASS, termStart);
1603
1604 return FALSE;
1605 }
1606 if (*state->cp == '\\') {
1607 state->cp++;
1608 if (state->cp != state->cpend)
1609 state->cp++;
1610 continue;
1611 }
1612 if (*state->cp == ']') {
1613 state->result->u.ucclass.kidlen = state->cp - termStart;
1614 break;
1615 }
1616 state->cp++;
1617 }
1618 for (i = 0; i < CLASS_CACHE_SIZE; i++) {
1619 if (!state->classCache[i].start) {
1620 state->classCache[i].start = termStart;
1621 state->classCache[i].length = state->result->u.ucclass.kidlen;
1622 state->classCache[i].index = state->classCount;
1623 break;
1624 }
1625 if (state->classCache[i].length ==
1626 state->result->u.ucclass.kidlen) {
1627 for (n = 0; ; n++) {
1628 if (n == state->classCache[i].length) {
1629 state->result->u.ucclass.index
1630 = state->classCache[i].index;
1631 goto claim;
1632 }
1633 if (state->classCache[i].start[n] != termStart[n])
1634 break;
1635 }
1636 }
1637 }
1638 state->result->u.ucclass.index = state->classCount++;
1639
1640 claim:
1641 /*
1642 * Call CalculateBitmapSize now as we want any errors it finds
1643 * to be reported during the parse phase, not at execution.
1644 */
1645 if (!CalculateBitmapSize(state, state->result, termStart, state->cp++))
1646 return FALSE;
1647 /*
1648 * Update classBitmapsMem with number of bytes to hold bmsize bits,
1649 * which is (bitsCount + 7) / 8 or (highest_bit + 1 + 7) / 8
1650 * or highest_bit / 8 + 1 where highest_bit is u.ucclass.bmsize.
1651 */
1652 n = (state->result->u.ucclass.bmsize >> 3) + 1;
1653 if (n > CLASS_BITMAPS_MEM_LIMIT - state->classBitmapsMem) {
1654 ReportRegExpError(state, JSREPORT_ERROR, JSMSG_REGEXP_TOO_COMPLEX);
1655 return FALSE;
1656 }
1657 state->classBitmapsMem += n;
1658 /* CLASS, <index> */
1659 state->progLength
1660 += 1 + GetCompactIndexWidth(state->result->u.ucclass.index);
1661 break;
1662
1663 case '.':
1664 state->result = NewRENode(state, REOP_DOT);
1665 goto doSimple;
1666
1667 case '{':
1668 {
1669 const WCHAR *errp = state->cp--;
1670 INT err;
1671
1672 err = ParseMinMaxQuantifier(state, TRUE);
1673 state->cp = errp;
1674
1675 if (err < 0)
1676 goto asFlat;
1677
1678 /* FALL THROUGH */
1679 }
1680 case '*':
1681 case '+':
1682 case '?':
1683 ReportRegExpErrorHelper(state, JSREPORT_ERROR,
1684 JSMSG_BAD_QUANTIFIER, state->cp - 1);
1685 return FALSE;
1686 default:
1687 asFlat:
1688 state->result = NewRENode(state, REOP_FLAT);
1689 if (!state->result)
1690 return FALSE;
1691 state->result->u.flat.chr = c;
1692 state->result->u.flat.length = 1;
1693 state->result->kid = (void *) (state->cp - 1);
1694 state->progLength += 3;
1695 break;
1696 }
1697 return ParseQuantifier(state);
1698 }
1699
1700 /*
1701 * Top-down regular expression grammar, based closely on Perl4.
1702 *
1703 * regexp: altern A regular expression is one or more
1704 * altern '|' regexp alternatives separated by vertical bar.
1705 */
1706 #define INITIAL_STACK_SIZE 128
1707
1708 static BOOL
1709 ParseRegExp(CompilerState *state)
1710 {
1711 size_t parenIndex;
1712 RENode *operand;
1713 REOpData *operatorStack;
1714 RENode **operandStack;
1715 REOp op;
1716 INT i;
1717 BOOL result = FALSE;
1718
1719 INT operatorSP = 0, operatorStackSize = INITIAL_STACK_SIZE;
1720 INT operandSP = 0, operandStackSize = INITIAL_STACK_SIZE;
1721
1722 /* Watch out for empty regexp */
1723 if (state->cp == state->cpend) {
1724 state->result = NewRENode(state, REOP_EMPTY);
1725 return (state->result != NULL);
1726 }
1727
1728 operatorStack = heap_alloc(sizeof(REOpData) * operatorStackSize);
1729 if (!operatorStack)
1730 return FALSE;
1731
1732 operandStack = heap_alloc(sizeof(RENode *) * operandStackSize);
1733 if (!operandStack)
1734 goto out;
1735
1736 for (;;) {
1737 parenIndex = state->parenCount;
1738 if (state->cp == state->cpend) {
1739 /*
1740 * If we are at the end of the regexp and we're short one or more
1741 * operands, the regexp must have the form /x|/ or some such, with
1742 * left parentheses making us short more than one operand.
1743 */
1744 if (operatorSP >= operandSP) {
1745 operand = NewRENode(state, REOP_EMPTY);
1746 if (!operand)
1747 goto out;
1748 goto pushOperand;
1749 }
1750 } else {
1751 switch (*state->cp) {
1752 case '(':
1753 ++state->cp;
1754 if (state->cp + 1 < state->cpend &&
1755 *state->cp == '?' &&
1756 (state->cp[1] == '=' ||
1757 state->cp[1] == '!' ||
1758 state->cp[1] == ':')) {
1759 switch (state->cp[1]) {
1760 case '=':
1761 op = REOP_ASSERT;
1762 /* ASSERT, <next>, ... ASSERTTEST */
1763 state->progLength += 4;
1764 break;
1765 case '!':
1766 op = REOP_ASSERT_NOT;
1767 /* ASSERTNOT, <next>, ... ASSERTNOTTEST */
1768 state->progLength += 4;
1769 break;
1770 default:
1771 op = REOP_LPARENNON;
1772 break;
1773 }
1774 state->cp += 2;
1775 } else {
1776 op = REOP_LPAREN;
1777 /* LPAREN, <index>, ... RPAREN, <index> */
1778 state->progLength
1779 += 2 * (1 + GetCompactIndexWidth(parenIndex));
1780 state->parenCount++;
1781 if (state->parenCount == 65535) {
1782 ReportRegExpError(state, JSREPORT_ERROR,
1783 JSMSG_TOO_MANY_PARENS);
1784 goto out;
1785 }
1786 }
1787 goto pushOperator;
1788
1789 case ')':
1790 /*
1791 * If there's no stacked open parenthesis, throw syntax error.
1792 */
1793 for (i = operatorSP - 1; ; i--) {
1794 if (i < 0) {
1795 ReportRegExpError(state, JSREPORT_ERROR,
1796 JSMSG_UNMATCHED_RIGHT_PAREN);
1797 goto out;
1798 }
1799 if (operatorStack[i].op == REOP_ASSERT ||
1800 operatorStack[i].op == REOP_ASSERT_NOT ||
1801 operatorStack[i].op == REOP_LPARENNON ||
1802 operatorStack[i].op == REOP_LPAREN) {
1803 break;
1804 }
1805 }
1806 /* FALL THROUGH */
1807
1808 case '|':
1809 /* Expected an operand before these, so make an empty one */
1810 operand = NewRENode(state, REOP_EMPTY);
1811 if (!operand)
1812 goto out;
1813 goto pushOperand;
1814
1815 default:
1816 if (!ParseTerm(state))
1817 goto out;
1818 operand = state->result;
1819 pushOperand:
1820 if (operandSP == operandStackSize) {
1821 RENode **tmp;
1822 operandStackSize += operandStackSize;
1823 tmp = heap_realloc(operandStack, sizeof(RENode *) * operandStackSize);
1824 if (!tmp)
1825 goto out;
1826 operandStack = tmp;
1827 }
1828 operandStack[operandSP++] = operand;
1829 break;
1830 }
1831 }
1832
1833 /* At the end; process remaining operators. */
1834 restartOperator:
1835 if (state->cp == state->cpend) {
1836 while (operatorSP) {
1837 --operatorSP;
1838 if (!ProcessOp(state, &operatorStack[operatorSP],
1839 operandStack, operandSP))
1840 goto out;
1841 --operandSP;
1842 }
1843 assert(operandSP == 1);
1844 state->result = operandStack[0];
1845 result = TRUE;
1846 goto out;
1847 }
1848
1849 switch (*state->cp) {
1850 case '|':
1851 /* Process any stacked 'concat' operators */
1852 ++state->cp;
1853 while (operatorSP &&
1854 operatorStack[operatorSP - 1].op == REOP_CONCAT) {
1855 --operatorSP;
1856 if (!ProcessOp(state, &operatorStack[operatorSP],
1857 operandStack, operandSP)) {
1858 goto out;
1859 }
1860 --operandSP;
1861 }
1862 op = REOP_ALT;
1863 goto pushOperator;
1864
1865 case ')':
1866 /*
1867 * If there's no stacked open parenthesis, throw syntax error.
1868 */
1869 for (i = operatorSP - 1; ; i--) {
1870 if (i < 0) {
1871 ReportRegExpError(state, JSREPORT_ERROR,
1872 JSMSG_UNMATCHED_RIGHT_PAREN);
1873 goto out;
1874 }
1875 if (operatorStack[i].op == REOP_ASSERT ||
1876 operatorStack[i].op == REOP_ASSERT_NOT ||
1877 operatorStack[i].op == REOP_LPARENNON ||
1878 operatorStack[i].op == REOP_LPAREN) {
1879 break;
1880 }
1881 }
1882 ++state->cp;
1883
1884 /* Process everything on the stack until the open parenthesis. */
1885 for (;;) {
1886 assert(operatorSP);
1887 --operatorSP;
1888 switch (operatorStack[operatorSP].op) {
1889 case REOP_ASSERT:
1890 case REOP_ASSERT_NOT:
1891 case REOP_LPAREN:
1892 operand = NewRENode(state, operatorStack[operatorSP].op);
1893 if (!operand)
1894 goto out;
1895 operand->u.parenIndex =
1896 operatorStack[operatorSP].parenIndex;
1897 assert(operandSP);
1898 operand->kid = operandStack[operandSP - 1];
1899 operandStack[operandSP - 1] = operand;
1900 if (state->treeDepth == TREE_DEPTH_MAX) {
1901 ReportRegExpError(state, JSREPORT_ERROR,
1902 JSMSG_REGEXP_TOO_COMPLEX);
1903 goto out;
1904 }
1905 ++state->treeDepth;
1906 /* FALL THROUGH */
1907
1908 case REOP_LPARENNON:
1909 state->result = operandStack[operandSP - 1];
1910 if (!ParseQuantifier(state))
1911 goto out;
1912 operandStack[operandSP - 1] = state->result;
1913 goto restartOperator;
1914 default:
1915 if (!ProcessOp(state, &operatorStack[operatorSP],
1916 operandStack, operandSP))
1917 goto out;
1918 --operandSP;
1919 break;
1920 }
1921 }
1922 break;
1923
1924 case '{':
1925 {
1926 const WCHAR *errp = state->cp;
1927
1928 if (ParseMinMaxQuantifier(state, TRUE) < 0) {
1929 /*
1930 * This didn't even scan correctly as a quantifier, so we should
1931 * treat it as flat.
1932 */
1933 op = REOP_CONCAT;
1934 goto pushOperator;
1935 }
1936
1937 state->cp = errp;
1938 /* FALL THROUGH */
1939 }
1940
1941 case '+':
1942 case '*':
1943 case '?':
1944 ReportRegExpErrorHelper(state, JSREPORT_ERROR, JSMSG_BAD_QUANTIFIER,
1945 state->cp);
1946 result = FALSE;
1947 goto out;
1948
1949 default:
1950 /* Anything else is the start of the next term. */
1951 op = REOP_CONCAT;
1952 pushOperator:
1953 if (operatorSP == operatorStackSize) {
1954 REOpData *tmp;
1955 operatorStackSize += operatorStackSize;
1956 tmp = heap_realloc(operatorStack, sizeof(REOpData) * operatorStackSize);
1957 if (!tmp)
1958 goto out;
1959 operatorStack = tmp;
1960 }
1961 operatorStack[operatorSP].op = op;
1962 operatorStack[operatorSP].errPos = state->cp;
1963 operatorStack[operatorSP++].parenIndex = parenIndex;
1964 break;
1965 }
1966 }
1967 out:
1968 heap_free(operatorStack);
1969 heap_free(operandStack);
1970 return result;
1971 }
1972
1973 /*
1974 * Save the current state of the match - the position in the input
1975 * text as well as the position in the bytecode. The state of any
1976 * parent expressions is also saved (preceding state).
1977 * Contents of parenCount parentheses from parenIndex are also saved.
1978 */
1979 static REBackTrackData *
1980 PushBackTrackState(REGlobalData *gData, REOp op,
1981 jsbytecode *target, REMatchState *x, const WCHAR *cp,
1982 size_t parenIndex, size_t parenCount)
1983 {
1984 size_t i;
1985 REBackTrackData *result =
1986 (REBackTrackData *) ((char *)gData->backTrackSP + gData->cursz);
1987
1988 size_t sz = sizeof(REBackTrackData) +
1989 gData->stateStackTop * sizeof(REProgState) +
1990 parenCount * sizeof(RECapture);
1991
1992 ptrdiff_t btsize = gData->backTrackStackSize;
1993 ptrdiff_t btincr = ((char *)result + sz) -
1994 ((char *)gData->backTrackStack + btsize);
1995
1996 TRACE("\tBT_Push: %lu,%lu\n", (ULONG_PTR)parenIndex, (ULONG_PTR)parenCount);
1997
1998 JS_COUNT_OPERATION(gData->cx, JSOW_JUMP * (1 + parenCount));
1999 if (btincr > 0) {
2000 ptrdiff_t offset = (char *)result - (char *)gData->backTrackStack;
2001
2002 JS_COUNT_OPERATION(gData->cx, JSOW_ALLOCATION);
2003 btincr = ((btincr+btsize-1)/btsize)*btsize;
2004 gData->backTrackStack = jsheap_grow(gData->pool, gData->backTrackStack, btsize, btincr);
2005 if (!gData->backTrackStack) {
2006 js_ReportOutOfScriptQuota(gData->cx);
2007 gData->ok = FALSE;
2008 return NULL;
2009 }
2010 gData->backTrackStackSize = btsize + btincr;
2011 result = (REBackTrackData *) ((char *)gData->backTrackStack + offset);
2012 }
2013 gData->backTrackSP = result;
2014 result->sz = gData->cursz;
2015 gData->cursz = sz;
2016
2017 result->backtrack_op = op;
2018 result->backtrack_pc = target;
2019 result->cp = cp;
2020 result->parenCount = parenCount;
2021 result->parenIndex = parenIndex;
2022
2023 result->saveStateStackTop = gData->stateStackTop;
2024 assert(gData->stateStackTop);
2025 memcpy(result + 1, gData->stateStack,
2026 sizeof(REProgState) * result->saveStateStackTop);
2027
2028 if (parenCount != 0) {
2029 memcpy((char *)(result + 1) +
2030 sizeof(REProgState) * result->saveStateStackTop,
2031 &x->parens[parenIndex],
2032 sizeof(RECapture) * parenCount);
2033 for (i = 0; i != parenCount; i++)
2034 x->parens[parenIndex + i].index = -1;
2035 }
2036
2037 return result;
2038 }
2039
2040 static inline REMatchState *
2041 FlatNIMatcher(REGlobalData *gData, REMatchState *x, WCHAR *matchChars,
2042 size_t length)
2043 {
2044 size_t i;
2045 assert(gData->cpend >= x->cp);
2046 if (length > (size_t)(gData->cpend - x->cp))
2047 return NULL;
2048 for (i = 0; i != length; i++) {
2049 if (toupperW(matchChars[i]) != toupperW(x->cp[i]))
2050 return NULL;
2051 }
2052 x->cp += length;
2053 return x;
2054 }
2055
2056 /*
2057 * 1. Evaluate DecimalEscape to obtain an EscapeValue E.
2058 * 2. If E is not a character then go to step 6.
2059 * 3. Let ch be E's character.
2060 * 4. Let A be a one-element RECharSet containing the character ch.
2061 * 5. Call CharacterSetMatcher(A, false) and return its Matcher result.
2062 * 6. E must be an integer. Let n be that integer.
2063 * 7. If n=0 or n>NCapturingParens then throw a SyntaxError exception.
2064 * 8. Return an internal Matcher closure that takes two arguments, a State x
2065 * and a Continuation c, and performs the following:
2066 * 1. Let cap be x's captures internal array.
2067 * 2. Let s be cap[n].
2068 * 3. If s is undefined, then call c(x) and return its result.
2069 * 4. Let e be x's endIndex.
2070 * 5. Let len be s's length.
2071 * 6. Let f be e+len.
2072 * 7. If f>InputLength, return failure.
2073 * 8. If there exists an integer i between 0 (inclusive) and len (exclusive)
2074 * such that Canonicalize(s[i]) is not the same character as
2075 * Canonicalize(Input [e+i]), then return failure.
2076 * 9. Let y be the State (f, cap).
2077 * 10. Call c(y) and return its result.
2078 */
2079 static REMatchState *
2080 BackrefMatcher(REGlobalData *gData, REMatchState *x, size_t parenIndex)
2081 {
2082 size_t len, i;
2083 const WCHAR *parenContent;
2084 RECapture *cap = &x->parens[parenIndex];
2085
2086 if (cap->index == -1)
2087 return x;
2088
2089 len = cap->length;
2090 if (x->cp + len > gData->cpend)
2091 return NULL;
2092
2093 parenContent = &gData->cpbegin[cap->index];
2094 if (gData->regexp->flags & JSREG_FOLD) {
2095 for (i = 0; i < len; i++) {
2096 if (toupperW(parenContent[i]) != toupperW(x->cp[i]))
2097 return NULL;
2098 }
2099 } else {
2100 for (i = 0; i < len; i++) {
2101 if (parenContent[i] != x->cp[i])
2102 return NULL;
2103 }
2104 }
2105 x->cp += len;
2106 return x;
2107 }
2108
2109 /* Add a single character to the RECharSet */
2110 static void
2111 AddCharacterToCharSet(RECharSet *cs, WCHAR c)
2112 {
2113 UINT byteIndex = (UINT)(c >> 3);
2114 assert(c <= cs->length);
2115 cs->u.bits[byteIndex] |= 1 << (c & 0x7);
2116 }
2117
2118
2119 /* Add a character range, c1 to c2 (inclusive) to the RECharSet */
2120 static void
2121 AddCharacterRangeToCharSet(RECharSet *cs, UINT c1, UINT c2)
2122 {
2123 UINT i;
2124
2125 UINT byteIndex1 = c1 >> 3;
2126 UINT byteIndex2 = c2 >> 3;
2127
2128 assert(c2 <= cs->length && c1 <= c2);
2129
2130 c1 &= 0x7;
2131 c2 &= 0x7;
2132
2133 if (byteIndex1 == byteIndex2) {
2134 cs->u.bits[byteIndex1] |= ((BYTE)0xFF >> (7 - (c2 - c1))) << c1;
2135 } else {
2136 cs->u.bits[byteIndex1] |= 0xFF << c1;
2137 for (i = byteIndex1 + 1; i < byteIndex2; i++)
2138 cs->u.bits[i] = 0xFF;
2139 cs->u.bits[byteIndex2] |= (BYTE)0xFF >> (7 - c2);
2140 }
2141 }
2142
2143 /* Compile the source of the class into a RECharSet */
2144 static BOOL
2145 ProcessCharSet(REGlobalData *gData, RECharSet *charSet)
2146 {
2147 const WCHAR *src, *end;
2148 BOOL inRange = FALSE;
2149 WCHAR rangeStart = 0;
2150 UINT byteLength, n;
2151 WCHAR c, thisCh;
2152 INT nDigits, i;
2153
2154 assert(!charSet->converted);
2155 /*
2156 * Assert that startIndex and length points to chars inside [] inside
2157 * source string.
2158 */
2159 assert(1 <= charSet->u.src.startIndex);
2160 assert(charSet->u.src.startIndex
2161 < SysStringLen(gData->regexp->source));
2162 assert(charSet->u.src.length <= SysStringLen(gData->regexp->source)
2163 - 1 - charSet->u.src.startIndex);
2164
2165 charSet->converted = TRUE;
2166 src = gData->regexp->source + charSet->u.src.startIndex;
2167
2168 end = src + charSet->u.src.length;
2169
2170 assert(src[-1] == '[' && end[0] == ']');
2171
2172 byteLength = (charSet->length >> 3) + 1;
2173 charSet->u.bits = heap_alloc(byteLength);
2174 if (!charSet->u.bits) {
2175 JS_ReportOutOfMemory(gData->cx);
2176 gData->ok = FALSE;
2177 return FALSE;
2178 }
2179 memset(charSet->u.bits, 0, byteLength);
2180
2181 if (src == end)
2182 return TRUE;
2183
2184 if (*src == '^') {
2185 assert(charSet->sense == FALSE);
2186 ++src;
2187 } else {
2188 assert(charSet->sense == TRUE);
2189 }
2190
2191 while (src != end) {
2192 switch (*src) {
2193 case '\\':
2194 ++src;
2195 c = *src++;
2196 switch (c) {
2197 case 'b':
2198 thisCh = 0x8;
2199 break;
2200 case 'f':
2201 thisCh = 0xC;
2202 break;
2203 case 'n':
2204 thisCh = 0xA;
2205 break;
2206 case 'r':
2207 thisCh = 0xD;
2208 break;
2209 case 't':
2210 thisCh = 0x9;
2211 break;
2212 case 'v':
2213 thisCh = 0xB;
2214 break;
2215 case 'c':
2216 if (src < end && JS_ISWORD(*src)) {
2217 thisCh = (WCHAR)(*src++ & 0x1F);
2218 } else {
2219 --src;
2220 thisCh = '\\';
2221 }
2222 break;
2223 case 'x':
2224 nDigits = 2;
2225 goto lexHex;
2226 case 'u':
2227 nDigits = 4;
2228 lexHex:
2229 n = 0;
2230 for (i = 0; (i < nDigits) && (src < end); i++) {
2231 UINT digit;
2232 c = *src++;
2233 if (!isASCIIHexDigit(c, &digit)) {
2234 /*
2235 * Back off to accepting the original '\'
2236 * as a literal
2237 */
2238 src -= i + 1;
2239 n = '\\';
2240 break;
2241 }
2242 n = (n << 4) | digit;
2243 }
2244 thisCh = (WCHAR)n;
2245 break;
2246 case '0':
2247 case '1':
2248 case '2':
2249 case '3':
2250 case '4':
2251 case '5':
2252 case '6':
2253 case '7':
2254 /*
2255 * This is a non-ECMA extension - decimal escapes (in this
2256 * case, octal!) are supposed to be an error inside class
2257 * ranges, but supported here for backwards compatibility.
2258 */
2259 n = JS7_UNDEC(c);
2260 c = *src;
2261 if ('0' <= c && c <= '7') {
2262 src++;
2263 n = 8 * n + JS7_UNDEC(c);
2264 c = *src;
2265 if ('0' <= c && c <= '7') {
2266 src++;
2267 i = 8 * n + JS7_UNDEC(c);
2268 if (i <= 0377)
2269 n = i;
2270 else
2271 src--;
2272 }
2273 }
2274 thisCh = (WCHAR)n;
2275 break;
2276
2277 case 'd':
2278 AddCharacterRangeToCharSet(charSet, '0', '9');
2279 continue; /* don't need range processing */
2280 case 'D':
2281 AddCharacterRangeToCharSet(charSet, 0, '0' - 1);
2282 AddCharacterRangeToCharSet(charSet,
2283 (WCHAR)('9' + 1),
2284 (WCHAR)charSet->length);
2285 continue;
2286 case 's':
2287 for (i = (INT)charSet->length; i >= 0; i--)
2288 if (isspaceW(i))
2289 AddCharacterToCharSet(charSet, (WCHAR)i);
2290 continue;
2291 case 'S':
2292 for (i = (INT)charSet->length; i >= 0; i--)
2293 if (!isspaceW(i))
2294 AddCharacterToCharSet(charSet, (WCHAR)i);
2295 continue;
2296 case 'w':
2297 for (i = (INT)charSet->length; i >= 0; i--)
2298 if (JS_ISWORD(i))
2299 AddCharacterToCharSet(charSet, (WCHAR)i);
2300 continue;
2301 case 'W':
2302 for (i = (INT)charSet->length; i >= 0; i--)
2303 if (!JS_ISWORD(i))
2304 AddCharacterToCharSet(charSet, (WCHAR)i);
2305 continue;
2306 default:
2307 thisCh = c;
2308 break;
2309
2310 }
2311 break;
2312
2313 default:
2314 thisCh = *src++;
2315 break;
2316
2317 }
2318 if (inRange) {
2319 if (gData->regexp->flags & JSREG_FOLD) {
2320 assert(rangeStart <= thisCh);
2321 for (i = rangeStart; i <= thisCh; i++) {
2322 WCHAR uch, dch;
2323
2324 AddCharacterToCharSet(charSet, i);
2325 uch = toupperW(i);
2326 dch = tolowerW(i);
2327 if (i != uch)
2328 AddCharacterToCharSet(charSet, uch);
2329 if (i != dch)
2330 AddCharacterToCharSet(charSet, dch);
2331 }
2332 } else {
2333 AddCharacterRangeToCharSet(charSet, rangeStart, thisCh);
2334 }
2335 inRange = FALSE;
2336 } else {
2337 if (gData->regexp->flags & JSREG_FOLD) {
2338 AddCharacterToCharSet(charSet, toupperW(thisCh));
2339 AddCharacterToCharSet(charSet, tolowerW(thisCh));
2340 } else {
2341 AddCharacterToCharSet(charSet, thisCh);
2342 }
2343 if (src < end - 1) {
2344 if (*src == '-') {
2345 ++src;
2346 inRange = TRUE;
2347 rangeStart = thisCh;
2348 }
2349 }
2350 }
2351 }
2352 return TRUE;
2353 }
2354
2355 static BOOL
2356 ReallocStateStack(REGlobalData *gData)
2357 {
2358 size_t limit = gData->stateStackLimit;
2359 size_t sz = sizeof(REProgState) * limit;
2360
2361 gData->stateStack = jsheap_grow(gData->pool, gData->stateStack, sz, sz);
2362 if (!gData->stateStack) {
2363 js_ReportOutOfScriptQuota(gData->cx);
2364 gData->ok = FALSE;
2365 return FALSE;
2366 }
2367 gData->stateStackLimit = limit + limit;
2368 return TRUE;
2369 }
2370
2371 #define PUSH_STATE_STACK(data) \
2372 do { \
2373 ++(data)->stateStackTop; \
2374 if ((data)->stateStackTop == (data)->stateStackLimit && \
2375 !ReallocStateStack((data))) { \
2376 return NULL; \
2377 } \
2378 }while(0)
2379
2380 /*
2381 * Apply the current op against the given input to see if it's going to match
2382 * or fail. Return false if we don't get a match, true if we do. If updatecp is
2383 * true, then update the current state's cp. Always update startpc to the next
2384 * op.
2385 */
2386 static inline REMatchState *
2387 SimpleMatch(REGlobalData *gData, REMatchState *x, REOp op,
2388 jsbytecode **startpc, BOOL updatecp)
2389 {
2390 REMatchState *result = NULL;
2391 WCHAR matchCh;
2392 size_t parenIndex;
2393 size_t offset, length, index;
2394 jsbytecode *pc = *startpc; /* pc has already been incremented past op */
2395 WCHAR *source;
2396 const WCHAR *startcp = x->cp;
2397 WCHAR ch;
2398 RECharSet *charSet;
2399
2400 const char *opname = reop_names[op];
2401 TRACE("\n%06d: %*s%s\n", (int)(pc - gData->regexp->program),
2402 (int)gData->stateStackTop * 2, "", opname);
2403
2404 switch (op) {
2405 case REOP_EMPTY:
2406 result = x;
2407 break;
2408 case REOP_BOL:
2409 if (x->cp != gData->cpbegin) {
2410 if (/*!gData->cx->regExpStatics.multiline && FIXME !!! */
2411 !(gData->regexp->flags & JSREG_MULTILINE)) {
2412 break;
2413 }
2414 if (!RE_IS_LINE_TERM(x->cp[-1]))
2415 break;
2416 }
2417 result = x;
2418 break;
2419 case REOP_EOL:
2420 if (x->cp != gData->cpend) {
2421 if (/*!gData->cx->regExpStatics.multiline &&*/
2422 !(gData->regexp->flags & JSREG_MULTILINE)) {
2423 break;
2424 }
2425 if (!RE_IS_LINE_TERM(*x->cp))
2426 break;
2427 }
2428 result = x;
2429 break;
2430 case REOP_WBDRY:
2431 if ((x->cp == gData->cpbegin || !JS_ISWORD(x->cp[-1])) ^
2432 !(x->cp != gData->cpend && JS_ISWORD(*x->cp))) {
2433 result = x;
2434 }
2435 break;
2436 case REOP_WNONBDRY:
2437 if ((x->cp == gData->cpbegin || !JS_ISWORD(x->cp[-1])) ^
2438 (x->cp != gData->cpend && JS_ISWORD(*x->cp))) {
2439 result = x;
2440 }
2441 break;
2442 case REOP_DOT:
2443 if (x->cp != gData->cpend && !RE_IS_LINE_TERM(*x->cp)) {
2444 result = x;
2445 result->cp++;
2446 }
2447 break;
2448 case REOP_DIGIT:
2449 if (x->cp != gData->cpend && JS7_ISDEC(*x->cp)) {
2450 result = x;
2451 result->cp++;
2452 }
2453 break;
2454 case REOP_NONDIGIT:
2455 if (x->cp != gData->cpend && !JS7_ISDEC(*x->cp)) {
2456 result = x;
2457 result->cp++;
2458 }
2459 break;
2460 case REOP_ALNUM:
2461 if (x->cp != gData->cpend && JS_ISWORD(*x->cp)) {
2462 result = x;
2463 result->cp++;
2464 }
2465 break;
2466 case REOP_NONALNUM:
2467 if (x->cp != gData->cpend && !JS_ISWORD(*x->cp)) {
2468 result = x;
2469 result->cp++;
2470 }
2471 break;
2472 case REOP_SPACE:
2473 if (x->cp != gData->cpend && isspaceW(*x->cp)) {
2474 result = x;
2475 result->cp++;
2476 }
2477 break;
2478 case REOP_NONSPACE:
2479 if (x->cp != gData->cpend && !isspaceW(*x->cp)) {
2480 result = x;
2481 result->cp++;
2482 }
2483 break;
2484 case REOP_BACKREF:
2485 pc = ReadCompactIndex(pc, &parenIndex);
2486 assert(parenIndex < gData->regexp->parenCount);
2487 result = BackrefMatcher(gData, x, parenIndex);
2488 break;
2489 case REOP_FLAT:
2490 pc = ReadCompactIndex(pc, &offset);
2491 assert(offset < SysStringLen(gData->regexp->source));
2492 pc = ReadCompactIndex(pc, &length);
2493 assert(1 <= length);
2494 assert(length <= SysStringLen(gData->regexp->source) - offset);
2495 if (length <= (size_t)(gData->cpend - x->cp)) {
2496 source = gData->regexp->source + offset;
2497 TRACE("%s\n", debugstr_wn(source, length));
2498 for (index = 0; index != length; index++) {
2499 if (source[index] != x->cp[index])
2500 return NULL;
2501 }
2502 x->cp += length;
2503 result = x;
2504 }
2505 break;
2506 case REOP_FLAT1:
2507 matchCh = *pc++;
2508 TRACE(" '%c' == '%c'\n", (char)matchCh, (char)*x->cp);
2509 if (x->cp != gData->cpend && *x->cp == matchCh) {
2510 result = x;
2511 result->cp++;
2512 }
2513 break;
2514 case REOP_FLATi:
2515 pc = ReadCompactIndex(pc, &offset);
2516 assert(offset < SysStringLen(gData->regexp->source));
2517 pc = ReadCompactIndex(pc, &length);
2518 assert(1 <= length);
2519 assert(length <= SysStringLen(gData->regexp->source) - offset);
2520 source = gData->regexp->source;
2521 result = FlatNIMatcher(gData, x, source + offset, length);
2522 break;
2523 case REOP_FLAT1i:
2524 matchCh = *pc++;
2525 if (x->cp != gData->cpend && toupperW(*x->cp) == toupperW(matchCh)) {
2526 result = x;
2527 result->cp++;
2528 }
2529 break;
2530 case REOP_UCFLAT1:
2531 matchCh = GET_ARG(pc);
2532 TRACE(" '%c' == '%c'\n", (char)matchCh, (char)*x->cp);
2533 pc += ARG_LEN;
2534 if (x->cp != gData->cpend && *x->cp == matchCh) {
2535 result = x;
2536 result->cp++;
2537 }
2538 break;
2539 case REOP_UCFLAT1i:
2540 matchCh = GET_ARG(pc);
2541 pc += ARG_LEN;
2542 if (x->cp != gData->cpend && toupperW(*x->cp) == toupperW(matchCh)) {
2543 result = x;
2544 result->cp++;
2545 }
2546 break;
2547 case REOP_CLASS:
2548 pc = ReadCompactIndex(pc, &index);
2549 assert(index < gData->regexp->classCount);
2550 if (x->cp != gData->cpend) {
2551 charSet = &gData->regexp->classList[index];
2552 assert(charSet->converted);
2553 ch = *x->cp;
2554 index = ch >> 3;
2555 if (charSet->length != 0 &&
2556 ch <= charSet->length &&
2557 (charSet->u.bits[index] & (1 << (ch & 0x7)))) {
2558 result = x;
2559 result->cp++;
2560 }
2561 }
2562 break;
2563 case REOP_NCLASS:
2564 pc = ReadCompactIndex(pc, &index);
2565 assert(index < gData->regexp->classCount);
2566 if (x->cp != gData->cpend) {
2567 charSet = &gData->regexp->classList[index];
2568 assert(charSet->converted);
2569 ch = *x->cp;
2570 index = ch >> 3;
2571 if (charSet->length == 0 ||
2572 ch > charSet->length ||
2573 !(charSet->u.bits[index] & (1 << (ch & 0x7)))) {
2574 result = x;
2575 result->cp++;
2576 }
2577 }
2578 break;
2579
2580 default:
2581 assert(FALSE);
2582 }
2583 if (result) {
2584 if (!updatecp)
2585 x->cp = startcp;
2586 *startpc = pc;
2587 TRACE(" *\n");
2588 return result;
2589 }
2590 x->cp = startcp;
2591 return NULL;
2592 }
2593
2594 static inline REMatchState *
2595 ExecuteREBytecode(REGlobalData *gData, REMatchState *x)
2596 {
2597 REMatchState *result = NULL;
2598 REBackTrackData *backTrackData;
2599 jsbytecode *nextpc, *testpc;
2600 REOp nextop;
2601 RECapture *cap;
2602 REProgState *curState;
2603 const WCHAR *startcp;
2604 size_t parenIndex, k;
2605 size_t parenSoFar = 0;
2606
2607 WCHAR matchCh1, matchCh2;
2608 RECharSet *charSet;
2609
2610 BOOL anchor;
2611 jsbytecode *pc = gData->regexp->program;
2612 REOp op = (REOp) *pc++;
2613
2614 /*
2615 * If the first node is a simple match, step the index into the string
2616 * until that match is made, or fail if it can't be found at all.
2617 */
2618 if (REOP_IS_SIMPLE(op) && !(gData->regexp->flags & JSREG_STICKY)) {
2619 anchor = FALSE;
2620 while (x->cp <= gData->cpend) {
2621 nextpc = pc; /* reset back to start each time */
2622 result = SimpleMatch(gData, x, op, &nextpc, TRUE);
2623 if (result) {
2624 anchor = TRUE;
2625 x = result;
2626 pc = nextpc; /* accept skip to next opcode */
2627 op = (REOp) *pc++;
2628 assert(op < REOP_LIMIT);
2629 break;
2630 }
2631 gData->skipped++;
2632 x->cp++;
2633 }
2634 if (!anchor)
2635 goto bad;
2636 }
2637
2638 for (;;) {
2639 const char *opname = reop_names[op];
2640 TRACE("\n%06d: %*s%s\n", (int)(pc - gData->regexp->program),
2641 (int)gData->stateStackTop * 2, "", opname);
2642
2643 if (REOP_IS_SIMPLE(op)) {
2644 result = SimpleMatch(gData, x, op, &pc, TRUE);
2645 } else {
2646 curState = &gData->stateStack[gData->stateStackTop];
2647 switch (op) {
2648 case REOP_END:
2649 goto good;
2650 case REOP_ALTPREREQ2:
2651 nextpc = pc + GET_OFFSET(pc); /* start of next op */
2652 pc += ARG_LEN;
2653 matchCh2 = GET_ARG(pc);
2654 pc += ARG_LEN;
2655 k = GET_ARG(pc);
2656 pc += ARG_LEN;
2657
2658 if (x->cp != gData->cpend) {
2659 if (*x->cp == matchCh2)
2660 goto doAlt;
2661
2662 charSet = &gData->regexp->classList[k];
2663 if (!charSet->converted && !ProcessCharSet(gData, charSet))
2664 goto bad;
2665 matchCh1 = *x->cp;
2666 k = matchCh1 >> 3;
2667 if ((charSet->length == 0 ||
2668 matchCh1 > charSet->length ||
2669 !(charSet->u.bits[k] & (1 << (matchCh1 & 0x7)))) ^
2670 charSet->sense) {
2671 goto doAlt;
2672 }
2673 }
2674 result = NULL;
2675 break;
2676
2677 case REOP_ALTPREREQ:
2678 nextpc = pc + GET_OFFSET(pc); /* start of next op */
2679 pc += ARG_LEN;
2680 matchCh1 = GET_ARG(pc);
2681 pc += ARG_LEN;
2682 matchCh2 = GET_ARG(pc);
2683 pc += ARG_LEN;
2684 if (x->cp == gData->cpend ||
2685 (*x->cp != matchCh1 && *x->cp != matchCh2)) {
2686 result = NULL;
2687 break;
2688 }
2689 /* else fall through... */
2690
2691 case REOP_ALT:
2692 doAlt:
2693 nextpc = pc + GET_OFFSET(pc); /* start of next alternate */
2694 pc += ARG_LEN; /* start of this alternate */
2695 curState->parenSoFar = parenSoFar;
2696 PUSH_STATE_STACK(gData);
2697 op = (REOp) *pc++;
2698 startcp = x->cp;
2699 if (REOP_IS_SIMPLE(op)) {
2700 if (!SimpleMatch(gData, x, op, &pc, TRUE)) {
2701 op = (REOp) *nextpc++;
2702 pc = nextpc;
2703 continue;
2704 }
2705 result = x;
2706 op = (REOp) *pc++;
2707 }
2708 nextop = (REOp) *nextpc++;
2709 if (!PushBackTrackState(gData, nextop, nextpc, x, startcp, 0, 0))
2710 goto bad;
2711 continue;
2712
2713 /*
2714 * Occurs at (successful) end of REOP_ALT,
2715 */
2716 case REOP_JUMP:
2717 /*
2718 * If we have not gotten a result here, it is because of an
2719 * empty match. Do the same thing REOP_EMPTY would do.
2720 */
2721 if (!result)
2722 result = x;
2723
2724 --gData->stateStackTop;
2725 pc += GET_OFFSET(pc);
2726 op = (REOp) *pc++;
2727 continue;
2728
2729 /*
2730 * Occurs at last (successful) end of REOP_ALT,
2731 */
2732 case REOP_ENDALT:
2733 /*
2734 * If we have not gotten a result here, it is because of an
2735 * empty match. Do the same thing REOP_EMPTY would do.
2736 */
2737 if (!result)
2738 result = x;
2739
2740 --gData->stateStackTop;
2741 op = (REOp) *pc++;
2742 continue;
2743
2744 case REOP_LPAREN:
2745 pc = ReadCompactIndex(pc, &parenIndex);
2746 TRACE("[ %lu ]\n", (ULONG_PTR)parenIndex);
2747 assert(parenIndex < gData->regexp->parenCount);
2748 if (parenIndex + 1 > parenSoFar)
2749 parenSoFar = parenIndex + 1;
2750 x->parens[parenIndex].index = x->cp - gData->cpbegin;
2751 x->parens[parenIndex].length = 0;
2752 op = (REOp) *pc++;
2753 continue;
2754
2755 case REOP_RPAREN:
2756 {
2757 ptrdiff_t delta;
2758
2759 pc = ReadCompactIndex(pc, &parenIndex);
2760 assert(parenIndex < gData->regexp->parenCount);
2761 cap = &x->parens[parenIndex];
2762 delta = x->cp - (gData->cpbegin + cap->index);
2763 cap->length = (delta < 0) ? 0 : (size_t) delta;
2764 op = (REOp) *pc++;
2765
2766 if (!result)
2767 result = x;
2768 continue;
2769 }
2770 case REOP_ASSERT:
2771 nextpc = pc + GET_OFFSET(pc); /* start of term after ASSERT */
2772 pc += ARG_LEN; /* start of ASSERT child */
2773 op = (REOp) *pc++;
2774 testpc = pc;
2775 if (REOP_IS_SIMPLE(op) &&
2776 !SimpleMatch(gData, x, op, &testpc, FALSE)) {
2777 result = NULL;
2778 break;
2779 }
2780 curState->u.assertion.top =
2781 (char *)gData->backTrackSP - (char *)gData->backTrackStack;
2782 curState->u.assertion.sz = gData->cursz;
2783 curState->index = x->cp - gData->cpbegin;
2784 curState->parenSoFar = parenSoFar;
2785 PUSH_STATE_STACK(gData);
2786 if (!PushBackTrackState(gData, REOP_ASSERTTEST,
2787 nextpc, x, x->cp, 0, 0)) {
2788 goto bad;
2789 }
2790 continue;
2791
2792 case REOP_ASSERT_NOT:
2793 nextpc = pc + GET_OFFSET(pc);
2794 pc += ARG_LEN;
2795 op = (REOp) *pc++;
2796 testpc = pc;
2797 if (REOP_IS_SIMPLE(op) /* Note - fail to fail! */ &&
2798 SimpleMatch(gData, x, op, &testpc, FALSE) &&
2799 *testpc == REOP_ASSERTNOTTEST) {
2800 result = NULL;
2801 break;
2802 }
2803 curState->u.assertion.top
2804 = (char *)gData->backTrackSP -
2805 (char *)gData->backTrackStack;
2806 curState->u.assertion.sz = gData->cursz;
2807 curState->index = x->cp - gData->cpbegin;
2808 curState->parenSoFar = parenSoFar;
2809 PUSH_STATE_STACK(gData);
2810 if (!PushBackTrackState(gData, REOP_ASSERTNOTTEST,
2811 nextpc, x, x->cp, 0, 0)) {
2812 goto bad;
2813 }
2814 continue;
2815
2816 case REOP_ASSERTTEST:
2817 --gData->stateStackTop;
2818 --curState;
2819 x->cp = gData->cpbegin + curState->index;
2820 gData->backTrackSP =
2821 (REBackTrackData *) ((char *)gData->backTrackStack +
2822 curState->u.assertion.top);
2823 gData->cursz = curState->u.assertion.sz;
2824 if (result)
2825 result = x;
2826 break;
2827
2828 case REOP_ASSERTNOTTEST:
2829 --gData->stateStackTop;
2830 --curState;
2831 x->cp = gData->cpbegin + curState->index;
2832 gData->backTrackSP =
2833 (REBackTrackData *) ((char *)gData->backTrackStack +
2834 curState->u.assertion.top);
2835 gData->cursz = curState->u.assertion.sz;
2836 result = (!result) ? x : NULL;
2837 break;
2838 case REOP_STAR:
2839 curState->u.quantifier.min = 0;
2840 curState->u.quantifier.max = (UINT)-1;
2841 goto quantcommon;
2842 case REOP_PLUS:
2843 curState->u.quantifier.min = 1;
2844 curState->u.quantifier.max = (UINT)-1;
2845 goto quantcommon;
2846 case REOP_OPT:
2847 curState->u.quantifier.min = 0;
2848 curState->u.quantifier.max = 1;
2849 goto quantcommon;
2850 case REOP_QUANT:
2851 pc = ReadCompactIndex(pc, &k);
2852 curState->u.quantifier.min = k;
2853 pc = ReadCompactIndex(pc, &k);
2854 /* max is k - 1 to use one byte for (UINT)-1 sentinel. */
2855 curState->u.quantifier.max = k - 1;
2856 assert(curState->u.quantifier.min <= curState->u.quantifier.max);
2857 quantcommon:
2858 if (curState->u.quantifier.max == 0) {
2859 pc = pc + GET_OFFSET(pc);
2860 op = (REOp) *pc++;
2861 result = x;
2862 continue;
2863 }
2864 /* Step over <next> */
2865 nextpc = pc + ARG_LEN;
2866 op = (REOp) *nextpc++;
2867 startcp = x->cp;
2868 if (REOP_IS_SIMPLE(op)) {
2869 if (!SimpleMatch(gData, x, op, &nextpc, TRUE)) {
2870 if (curState->u.quantifier.min == 0)
2871 result = x;
2872 else
2873 result = NULL;
2874 pc = pc + GET_OFFSET(pc);
2875 break;
2876 }
2877 op = (REOp) *nextpc++;
2878 result = x;
2879 }
2880 curState->index = startcp - gData->cpbegin;
2881 curState->continue_op = REOP_REPEAT;
2882 curState->continue_pc = pc;
2883 curState->parenSoFar = parenSoFar;
2884 PUSH_STATE_STACK(gData);
2885 if (curState->u.quantifier.min == 0 &&
2886 !PushBackTrackState(gData, REOP_REPEAT, pc, x, startcp,
2887 0, 0)) {
2888 goto bad;
2889 }
2890 pc = nextpc;
2891 continue;
2892
2893 case REOP_ENDCHILD: /* marks the end of a quantifier child */
2894 pc = curState[-1].continue_pc;
2895 op = (REOp) curState[-1].continue_op;
2896
2897 if (!result)
2898 result = x;
2899 continue;
2900
2901 case REOP_REPEAT:
2902 --curState;
2903 do {
2904 --gData->stateStackTop;
2905 if (!result) {
2906 /* Failed, see if we have enough children. */
2907 if (curState->u.quantifier.min == 0)
2908 goto repeatDone;
2909 goto break_switch;
2910 }
2911 if (curState->u.quantifier.min == 0 &&
2912 x->cp == gData->cpbegin + curState->index) {
2913 /* matched an empty string, that'll get us nowhere */
2914 result = NULL;
2915 goto break_switch;
2916 }
2917 if (curState->u.quantifier.min != 0)
2918 curState->u.quantifier.min--;
2919 if (curState->u.quantifier.max != (UINT) -1)
2920 curState->u.quantifier.max--;
2921 if (curState->u.quantifier.max == 0)
2922 goto repeatDone;
2923 nextpc = pc + ARG_LEN;
2924 nextop = (REOp) *nextpc;
2925 startcp = x->cp;
2926 if (REOP_IS_SIMPLE(nextop)) {
2927 nextpc++;
2928 if (!SimpleMatch(gData, x, nextop, &nextpc, TRUE)) {
2929 if (curState->u.quantifier.min == 0)
2930 goto repeatDone;
2931 result = NULL;
2932 goto break_switch;
2933 }
2934 result = x;
2935 }
2936 curState->index = startcp - gData->cpbegin;
2937 PUSH_STATE_STACK(gData);
2938 if (curState->u.quantifier.min == 0 &&
2939 !PushBackTrackState(gData, REOP_REPEAT,
2940 pc, x, startcp,
2941 curState->parenSoFar,
2942 parenSoFar -
2943 curState->parenSoFar)) {
2944 goto bad;
2945 }
2946 } while (*nextpc == REOP_ENDCHILD);
2947 pc = nextpc;
2948 op = (REOp) *pc++;
2949 parenSoFar = curState->parenSoFar;
2950 continue;
2951
2952 repeatDone:
2953 result = x;
2954 pc += GET_OFFSET(pc);
2955 goto break_switch;
2956
2957 case REOP_MINIMALSTAR:
2958 curState->u.quantifier.min = 0;
2959 curState->u.quantifier.max = (UINT)-1;
2960 goto minimalquantcommon;
2961 case REOP_MINIMALPLUS:
2962 curState->u.quantifier.min = 1;
2963 curState->u.quantifier.max = (UINT)-1;
2964 goto minimalquantcommon;
2965 case REOP_MINIMALOPT:
2966 curState->u.quantifier.min = 0;
2967 curState->u.quantifier.max = 1;
2968 goto minimalquantcommon;
2969 case REOP_MINIMALQUANT:
2970 pc = ReadCompactIndex(pc, &k);
2971 curState->u.quantifier.min = k;
2972 pc = ReadCompactIndex(pc, &k);
2973 /* See REOP_QUANT comments about k - 1. */
2974 curState->u.quantifier.max = k - 1;
2975 assert(curState->u.quantifier.min
2976 <= curState->u.quantifier.max);
2977 minimalquantcommon:
2978 curState->index = x->cp - gData->cpbegin;
2979 curState->parenSoFar = parenSoFar;
2980 PUSH_STATE_STACK(gData);
2981 if (curState->u.quantifier.min != 0) {
2982 curState->continue_op = REOP_MINIMALREPEAT;
2983 curState->continue_pc = pc;
2984 /* step over <next> */
2985 pc += OFFSET_LEN;
2986 op = (REOp) *pc++;
2987 } else {
2988 if (!PushBackTrackState(gData, REOP_MINIMALREPEAT,
2989 pc, x, x->cp, 0, 0)) {
2990 goto bad;
2991 }
2992 --gData->stateStackTop;
2993 pc = pc + GET_OFFSET(pc);
2994 op = (REOp) *pc++;
2995 }
2996 continue;
2997
2998 case REOP_MINIMALREPEAT:
2999 --gData->stateStackTop;
3000 --curState;
3001
3002 TRACE("{%d,%d}\n", curState->u.quantifier.min, curState->u.quantifier.max);
3003 #define PREPARE_REPEAT() \
3004 do { \
3005 curState->index = x->cp - gData->cpbegin; \
3006 curState->continue_op = REOP_MINIMALREPEAT; \
3007 curState->continue_pc = pc; \
3008 pc += ARG_LEN; \
3009 for (k = curState->parenSoFar; k < parenSoFar; k++) \
3010 x->parens[k].index = -1; \
3011 PUSH_STATE_STACK(gData); \
3012 op = (REOp) *pc++; \
3013 assert(op < REOP_LIMIT); \
3014 }while(0)
3015
3016 if (!result) {
3017 TRACE(" -\n");
3018 /*
3019 * Non-greedy failure - try to consume another child.
3020 */
3021 if (curState->u.quantifier.max == (UINT) -1 ||
3022 curState->u.quantifier.max > 0) {
3023 PREPARE_REPEAT();
3024 continue;
3025 }
3026 /* Don't need to adjust pc since we're going to pop. */
3027 break;
3028 }
3029 if (curState->u.quantifier.min == 0 &&
3030 x->cp == gData->cpbegin + curState->index) {
3031 /* Matched an empty string, that'll get us nowhere. */
3032 result = NULL;
3033 break;
3034 }
3035 if (curState->u.quantifier.min != 0)
3036 curState->u.quantifier.min--;
3037 if (curState->u.quantifier.max != (UINT) -1)
3038 curState->u.quantifier.max--;
3039 if (curState->u.quantifier.min != 0) {
3040 PREPARE_REPEAT();
3041 continue;
3042 }
3043 curState->index = x->cp - gData->cpbegin;
3044 curState->parenSoFar = parenSoFar;
3045 PUSH_STATE_STACK(gData);
3046 if (!PushBackTrackState(gData, REOP_MINIMALREPEAT,
3047 pc, x, x->cp,
3048 curState->parenSoFar,
3049 parenSoFar - curState->parenSoFar)) {
3050 goto bad;
3051 }
3052 --gData->stateStackTop;
3053 pc = pc + GET_OFFSET(pc);
3054 op = (REOp) *pc++;
3055 assert(op < REOP_LIMIT);
3056 continue;
3057 default:
3058 assert(FALSE);
3059 result = NULL;
3060 }
3061 break_switch:;
3062 }
3063
3064 /*
3065 * If the match failed and there's a backtrack option, take it.
3066 * Otherwise this is a complete and utter failure.
3067 */
3068 if (!result) {
3069 if (gData->cursz == 0)
3070 return NULL;
3071
3072 /* Potentially detect explosive regex here. */
3073 gData->backTrackCount++;
3074 if (gData->backTrackLimit &&
3075 gData->backTrackCount >= gData->backTrackLimit) {
3076 JS_ReportErrorNumber(gData->cx, js_GetErrorMessage, NULL,
3077 JSMSG_REGEXP_TOO_COMPLEX);
3078 gData->ok = FALSE;
3079 return NULL;
3080 }
3081
3082 backTrackData = gData->backTrackSP;
3083 gData->cursz = backTrackData->sz;
3084 gData->backTrackSP =
3085 (REBackTrackData *) ((char *)backTrackData - backTrackData->sz);
3086 x->cp = backTrackData->cp;
3087 pc = backTrackData->backtrack_pc;
3088 op = (REOp) backTrackData->backtrack_op;
3089 assert(op < REOP_LIMIT);
3090 gData->stateStackTop = backTrackData->saveStateStackTop;
3091 assert(gData->stateStackTop);
3092
3093 memcpy(gData->stateStack, backTrackData + 1,
3094 sizeof(REProgState) * backTrackData->saveStateStackTop);
3095 curState = &gData->stateStack[gData->stateStackTop - 1];
3096
3097 if (backTrackData->parenCount) {
3098 memcpy(&x->parens[backTrackData->parenIndex],
3099 (char *)(backTrackData + 1) +
3100 sizeof(REProgState) * backTrackData->saveStateStackTop,
3101 sizeof(RECapture) * backTrackData->parenCount);
3102 parenSoFar = backTrackData->parenIndex + backTrackData->parenCount;
3103 } else {
3104 for (k = curState->parenSoFar; k < parenSoFar; k++)
3105 x->parens[k].index = -1;
3106 parenSoFar = curState->parenSoFar;
3107 }
3108
3109 TRACE("\tBT_Pop: %ld,%ld\n",
3110 (ULONG_PTR)backTrackData->parenIndex,
3111 (ULONG_PTR)backTrackData->parenCount);
3112 continue;
3113 }
3114 x = result;
3115
3116 /*
3117 * Continue with the expression.
3118 */
3119 op = (REOp)*pc++;
3120 assert(op < REOP_LIMIT);
3121 }
3122
3123 bad:
3124 TRACE("\n");
3125 return NULL;
3126
3127 good:
3128 TRACE("\n");
3129 return x;
3130 }
3131
3132 static REMatchState *MatchRegExp(REGlobalData *gData, REMatchState *x)
3133 {
3134 REMatchState *result;
3135 const WCHAR *cp = x->cp;
3136 const WCHAR *cp2;
3137 UINT j;
3138
3139 /*
3140 * Have to include the position beyond the last character
3141 * in order to detect end-of-input/line condition.
3142 */
3143 for (cp2 = cp; cp2 <= gData->cpend; cp2++) {
3144 gData->skipped = cp2 - cp;
3145 x->cp = cp2;
3146 for (j = 0; j < gData->regexp->parenCount; j++)
3147 x->parens[j].index = -1;
3148 result = ExecuteREBytecode(gData, x);
3149 if (!gData->ok || result || (gData->regexp->flags & JSREG_STICKY))
3150 return result;
3151 gData->backTrackSP = gData->backTrackStack;
3152 gData->cursz = 0;
3153 gData->stateStackTop = 0;
3154 cp2 = cp + gData->skipped;
3155 }
3156 return NULL;
3157 }
3158
3159 #define MIN_BACKTRACK_LIMIT 400000
3160
3161 static REMatchState *InitMatch(script_ctx_t *cx, REGlobalData *gData, JSRegExp *re, size_t length)
3162 {
3163 REMatchState *result;
3164 UINT i;
3165
3166 gData->backTrackStackSize = INITIAL_BACKTRACK;
3167 gData->backTrackStack = jsheap_alloc(gData->pool, INITIAL_BACKTRACK);
3168 if (!gData->backTrackStack)
3169 goto bad;
3170
3171 gData->backTrackSP = gData->backTrackStack;
3172 gData->cursz = 0;
3173 gData->backTrackCount = 0;
3174 gData->backTrackLimit = 0;
3175
3176 gData->stateStackLimit = INITIAL_STATESTACK;
3177 gData->stateStack = jsheap_alloc(gData->pool, sizeof(REProgState) * INITIAL_STATESTACK);
3178 if (!gData->stateStack)
3179 goto bad;
3180
3181 gData->stateStackTop = 0;
3182 gData->cx = cx;
3183 gData->regexp = re;
3184 gData->ok = TRUE;
3185
3186 result = jsheap_alloc(gData->pool, offsetof(REMatchState, parens) + re->parenCount * sizeof(RECapture));
3187 if (!result)
3188 goto bad;
3189
3190 for (i = 0; i < re->classCount; i++) {
3191 if (!re->classList[i].converted &&
3192 !ProcessCharSet(gData, &re->classList[i])) {
3193 return NULL;
3194 }
3195 }
3196
3197 return result;
3198
3199 bad:
3200 js_ReportOutOfScriptQuota(cx);
3201 gData->ok = FALSE;
3202 return NULL;
3203 }
3204
3205 static void
3206 js_DestroyRegExp(JSRegExp *re)
3207 {
3208 if (re->classList) {
3209 UINT i;
3210 for (i = 0; i < re->classCount; i++) {
3211 if (re->classList[i].converted)
3212 heap_free(re->classList[i].u.bits);
3213 re->classList[i].u.bits = NULL;
3214 }
3215 heap_free(re->classList);
3216 }
3217 heap_free(re);
3218 }
3219
3220 static JSRegExp *
3221 js_NewRegExp(script_ctx_t *cx, BSTR str, UINT flags, BOOL flat)
3222 {
3223 JSRegExp *re;
3224 jsheap_t *mark;
3225 CompilerState state;
3226 size_t resize;
3227 jsbytecode *endPC;
3228 UINT i;
3229 size_t len;
3230
3231 re = NULL;
3232 mark = jsheap_mark(&cx->tmp_heap);
3233 len = SysStringLen(str);
3234
3235 state.context = cx;
3236 state.cp = str;
3237 if (!state.cp)
3238 goto out;
3239 state.cpbegin = state.cp;
3240 state.cpend = state.cp + len;
3241 state.flags = flags;
3242 state.parenCount = 0;
3243 state.classCount = 0;
3244 state.progLength = 0;
3245 state.treeDepth = 0;
3246 state.classBitmapsMem = 0;
3247 for (i = 0; i < CLASS_CACHE_SIZE; i++)
3248 state.classCache[i].start = NULL;
3249
3250 if (len != 0 && flat) {
3251 state.result = NewRENode(&state, REOP_FLAT);
3252 if (!state.result)
3253 goto out;
3254 state.result->u.flat.chr = *state.cpbegin;
3255 state.result->u.flat.length = len;
3256 state.result->kid = (void *) state.cpbegin;
3257 /* Flat bytecode: REOP_FLAT compact(string_offset) compact(len). */
3258 state.progLength += 1 + GetCompactIndexWidth(0)
3259 + GetCompactIndexWidth(len);
3260 } else {
3261 if (!ParseRegExp(&state))
3262 goto out;
3263 }
3264 resize = offsetof(JSRegExp, program) + state.progLength + 1;
3265 re = heap_alloc(resize);
3266 if (!re)
3267 goto out;
3268
3269 assert(state.classBitmapsMem <= CLASS_BITMAPS_MEM_LIMIT);
3270 re->classCount = state.classCount;
3271 if (re->classCount) {
3272 re->classList = heap_alloc(re->classCount * sizeof(RECharSet));
3273 if (!re->classList) {
3274 js_DestroyRegExp(re);
3275 re = NULL;
3276 goto out;
3277 }
3278 for (i = 0; i < re->classCount; i++)
3279 re->classList[i].converted = FALSE;
3280 } else {
3281 re->classList = NULL;
3282 }
3283 endPC = EmitREBytecode(&state, re, state.treeDepth, re->program, state.result);
3284 if (!endPC) {
3285 js_DestroyRegExp(re);
3286 re = NULL;
3287 goto out;
3288 }
3289 *endPC++ = REOP_END;
3290 /*
3291 * Check whether size was overestimated and shrink using realloc.
3292 * This is safe since no pointers to newly parsed regexp or its parts
3293 * besides re exist here.
3294 */
3295 if ((size_t)(endPC - re->program) != state.progLength + 1) {
3296 JSRegExp *tmp;
3297 assert((size_t)(endPC - re->program) < state.progLength + 1);
3298 resize = offsetof(JSRegExp, program) + (endPC - re->program);
3299 tmp = heap_realloc(re, resize);
3300 if (tmp)
3301 re = tmp;
3302 }
3303
3304 re->flags = flags;
3305 re->parenCount = state.parenCount;
3306 re->source = str;
3307
3308 out:
3309 jsheap_clear(mark);
3310 return re;
3311 }
3312
3313 static inline RegExpInstance *regexp_from_vdisp(vdisp_t *vdisp)
3314 {
3315 return (RegExpInstance*)vdisp->u.jsdisp;
3316 }
3317
3318 static void set_last_index(RegExpInstance *This, DWORD last_index)
3319 {
3320 This->last_index = last_index;
3321 jsval_release(This->last_index_val);
3322 This->last_index_val = jsval_number(last_index);
3323 }
3324
3325 static HRESULT do_regexp_match_next(script_ctx_t *ctx, RegExpInstance *regexp, DWORD rem_flags,
3326 const WCHAR *str, DWORD len, const WCHAR **cp, match_result_t **parens, DWORD *parens_size,
3327 DWORD *parens_cnt, match_result_t *ret)
3328 {
3329 REMatchState *x, *result;
3330 REGlobalData gData;
3331 DWORD matchlen;
3332
3333 gData.cpbegin = str;
3334 gData.cpend = str + len;
3335 gData.start = *cp-str;
3336 gData.skipped = 0;
3337 gData.pool = &ctx->tmp_heap;
3338
3339 x = InitMatch(NULL, &gData, regexp->jsregexp, gData.cpend - gData.cpbegin);
3340 if(!x) {
3341 WARN("InitMatch failed\n");
3342 return E_FAIL;
3343 }
3344
3345 x->cp = *cp;
3346 result = MatchRegExp(&gData, x);
3347 if(!gData.ok) {
3348 WARN("MatchRegExp failed\n");
3349 return E_FAIL;
3350 }
3351
3352 if(!result) {
3353 if(rem_flags & REM_RESET_INDEX)
3354 set_last_index(regexp, 0);
3355 return S_FALSE;
3356 }
3357
3358 if(parens) {
3359 if(regexp->jsregexp->parenCount > *parens_size) {
3360 match_result_t *new_parens;
3361
3362 if(*parens)
3363 new_parens = heap_realloc(*parens, sizeof(match_result_t)*regexp->jsregexp->parenCount);
3364 else
3365 new_parens = heap_alloc(sizeof(match_result_t)*regexp->jsregexp->parenCount);
3366 if(!new_parens)
3367 return E_OUTOFMEMORY;
3368
3369 *parens = new_parens;
3370 }
3371 }
3372
3373 /* FIXME: We often already have a copy of input string that we could use to store last match */
3374 if(!(rem_flags & REM_NO_CTX_UPDATE) &&
3375 (!ctx->last_match || len != SysStringLen(ctx->last_match) || strncmpW(ctx->last_match, str, len))) {
3376 BSTR last_match;
3377
3378 last_match = SysAllocStringLen(str, len);
3379 if(!last_match)
3380 return E_OUTOFMEMORY;
3381 SysFreeString(ctx->last_match);
3382 ctx->last_match = last_match;
3383 }
3384
3385 if(parens) {
3386 DWORD i;
3387
3388 *parens_cnt = regexp->jsregexp->parenCount;
3389
3390 for(i=0; i < regexp->jsregexp->parenCount; i++) {
3391 if(result->parens[i].index == -1) {
3392 (*parens)[i].str = NULL;
3393 (*parens)[i].len = 0;
3394 }else {
3395 (*parens)[i].str = str + result->parens[i].index;
3396 (*parens)[i].len = result->parens[i].length;
3397 }
3398 }
3399 }
3400
3401 if(!(rem_flags & REM_NO_CTX_UPDATE)) {
3402 DWORD i, n = min(sizeof(ctx->match_parens)/sizeof(ctx->match_parens[0]), regexp->jsregexp->parenCount);
3403
3404 for(i=0; i < n; i++) {
3405 if(result->parens[i].index == -1) {
3406 ctx->match_parens[i].str = NULL;
3407 ctx->match_parens[i].len = 0;
3408 }else {
3409 ctx->match_parens[i].str = ctx->last_match + result->parens[i].index;
3410 ctx->match_parens[i].len = result->parens[i].length;
3411 }
3412 }
3413
3414 if(n < sizeof(ctx->match_parens)/sizeof(ctx->match_parens[0]))
3415 memset(ctx->match_parens+n, 0, sizeof(ctx->match_parens) - n*sizeof(ctx->match_parens[0]));
3416 }
3417
3418 matchlen = (result->cp-*cp) - gData.skipped;
3419 *cp = result->cp;
3420 ret->str = result->cp-matchlen;
3421 ret->len = matchlen;
3422 set_last_index(regexp, result->cp-str);
3423
3424 if(!(rem_flags & REM_NO_CTX_UPDATE)) {
3425 ctx->last_match_index = ret->str-str;
3426 ctx->last_match_length = matchlen;
3427 }
3428
3429 return S_OK;
3430 }
3431
3432 HRESULT regexp_match_next(script_ctx_t *ctx, jsdisp_t *dispex, DWORD rem_flags, const WCHAR *str,
3433 DWORD len, const WCHAR **cp, match_result_t **parens, DWORD *parens_size, DWORD *parens_cnt,
3434 match_result_t *ret)
3435 {
3436 RegExpInstance *regexp = (RegExpInstance*)dispex;
3437 jsheap_t *mark;
3438 HRESULT hres;
3439
3440 if((rem_flags & REM_CHECK_GLOBAL) && !(regexp->jsregexp->flags & JSREG_GLOB))
3441 return S_FALSE;
3442
3443 mark = jsheap_mark(&ctx->tmp_heap);
3444
3445 hres = do_regexp_match_next(ctx, regexp, rem_flags, str, len, cp, parens, parens_size, parens_cnt, ret);
3446
3447 jsheap_clear(mark);
3448 return hres;
3449 }
3450
3451 HRESULT regexp_match(script_ctx_t *ctx, jsdisp_t *dispex, const WCHAR *str, DWORD len, BOOL gflag,
3452 match_result_t **match_result, DWORD *result_cnt)
3453 {
3454 RegExpInstance *This = (RegExpInstance*)dispex;
3455 match_result_t *ret = NULL, cres;
3456 const WCHAR *cp = str;
3457 DWORD i=0, ret_size = 0;
3458 jsheap_t *mark;
3459 HRESULT hres;
3460
3461 mark = jsheap_mark(&ctx->tmp_heap);
3462
3463 while(1) {
3464 hres = do_regexp_match_next(ctx, This, 0, str, len, &cp, NULL, NULL, NULL, &cres);
3465 if(hres == S_FALSE) {
3466 hres = S_OK;
3467 break;
3468 }
3469
3470 if(FAILED(hres))
3471 break;
3472
3473 if(ret_size == i) {
3474 if(ret)
3475 ret = heap_realloc(ret, (ret_size <<= 1) * sizeof(match_result_t));
3476 else
3477 ret = heap_alloc((ret_size=4) * sizeof(match_result_t));
3478 if(!ret) {
3479 hres = E_OUTOFMEMORY;
3480 break;
3481 }
3482 }
3483
3484 ret[i++] = cres;
3485
3486 if(!gflag && !(This->jsregexp->flags & JSREG_GLOB)) {
3487 hres = S_OK;
3488 break;
3489 }
3490 }
3491
3492 jsheap_clear(mark);
3493 if(FAILED(hres)) {
3494 heap_free(ret);
3495 return hres;
3496 }
3497
3498 *match_result = ret;
3499 *result_cnt = i;
3500 return S_OK;
3501 }
3502
3503 static HRESULT RegExp_source(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3504 jsval_t *r)
3505 {
3506 TRACE("\n");
3507
3508 switch(flags) {
3509 case DISPATCH_PROPERTYGET: {
3510 RegExpInstance *This = regexp_from_vdisp(jsthis);
3511 BSTR ret = SysAllocString(This->str);
3512 if(!ret)
3513 return E_OUTOFMEMORY;
3514 *r = jsval_string(ret);
3515 break;
3516 }
3517 default:
3518 FIXME("Unimplemented flags %x\n", flags);
3519 return E_NOTIMPL;
3520 }
3521
3522 return S_OK;
3523 }
3524
3525 static HRESULT RegExp_global(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3526 jsval_t *r)
3527 {
3528 FIXME("\n");
3529 return E_NOTIMPL;
3530 }
3531
3532 static HRESULT RegExp_ignoreCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3533 jsval_t *r)
3534 {
3535 FIXME("\n");
3536 return E_NOTIMPL;
3537 }
3538
3539 static HRESULT RegExp_multiline(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3540 jsval_t *r)
3541 {
3542 FIXME("\n");
3543 return E_NOTIMPL;
3544 }
3545
3546 static INT index_from_val(script_ctx_t *ctx, jsval_t v)
3547 {
3548 double n;
3549 HRESULT hres;
3550
3551 hres = to_number(ctx, v, &n);
3552 if(FAILED(hres)) {
3553 clear_ei(ctx); /* FIXME: Move ignoring exceptions to to_primitive */
3554 return 0;
3555 }
3556
3557 n = floor(n);
3558 return is_int32(n) ? n : 0;
3559 }
3560
3561 static HRESULT RegExp_lastIndex(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3562 jsval_t *r)
3563 {
3564 TRACE("\n");
3565
3566 switch(flags) {
3567 case DISPATCH_PROPERTYGET: {
3568 RegExpInstance *regexp = regexp_from_vdisp(jsthis);
3569
3570 return jsval_copy(regexp->last_index_val, r);
3571 }
3572 case DISPATCH_PROPERTYPUT: {
3573 RegExpInstance *regexp = regexp_from_vdisp(jsthis);
3574 HRESULT hres;
3575
3576 hres = jsval_copy(argv[0], &regexp->last_index_val);
3577 if(FAILED(hres))
3578 return hres;
3579
3580 regexp->last_index = index_from_val(ctx, argv[0]);
3581 break;
3582 }
3583 default:
3584 FIXME("unimplemented flags: %x\n", flags);
3585 return E_NOTIMPL;
3586 }
3587
3588 return S_OK;
3589 }
3590
3591 static HRESULT RegExp_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3592 jsval_t *r)
3593 {
3594 FIXME("\n");
3595 return E_NOTIMPL;
3596 }
3597
3598 static HRESULT create_match_array(script_ctx_t *ctx, BSTR input, const match_result_t *result,
3599 const match_result_t *parens, DWORD parens_cnt, IDispatch **ret)
3600 {
3601 jsdisp_t *array;
3602 BSTR str;
3603 int i;
3604 HRESULT hres = S_OK;
3605
3606 static const WCHAR indexW[] = {'i','n','d','e','x',0};
3607 static const WCHAR inputW[] = {'i','n','p','u','t',0};
3608 static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
3609 static const WCHAR zeroW[] = {'0',0};
3610
3611 hres = create_array(ctx, parens_cnt+1, &array);
3612 if(FAILED(hres))
3613 return hres;
3614
3615 for(i=0; i < parens_cnt; i++) {
3616 str = SysAllocStringLen(parens[i].str, parens[i].len);
3617 if(!str) {
3618 hres = E_OUTOFMEMORY;
3619 break;
3620 }
3621
3622 hres = jsdisp_propput_idx(array, i+1, jsval_string(str));
3623 SysFreeString(str);
3624 if(FAILED(hres))
3625 break;
3626 }
3627
3628 while(SUCCEEDED(hres)) {
3629 hres = jsdisp_propput_name(array, indexW, jsval_number(result->str-input));
3630 if(FAILED(hres))
3631 break;
3632
3633 hres = jsdisp_propput_name(array, lastIndexW, jsval_number(result->str-input+result->len));
3634 if(FAILED(hres))
3635 break;
3636
3637 hres = jsdisp_propput_name(array, inputW, jsval_string(input));
3638 if(FAILED(hres))
3639 break;
3640
3641 str = SysAllocStringLen(result->str, result->len);
3642 if(!str) {
3643 hres = E_OUTOFMEMORY;
3644 break;
3645 }
3646 hres = jsdisp_propput_name(array, zeroW, jsval_string(str));
3647 SysFreeString(str);
3648 break;
3649 }
3650
3651 if(FAILED(hres)) {
3652 jsdisp_release(array);
3653 return hres;
3654 }
3655
3656 *ret = to_disp(array);
3657 return S_OK;
3658 }
3659
3660 static HRESULT run_exec(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t arg, BSTR *input,
3661 match_result_t *match, match_result_t **parens, DWORD *parens_cnt, BOOL *ret)
3662 {
3663 RegExpInstance *regexp;
3664 DWORD parens_size = 0, last_index = 0, length;
3665 const WCHAR *cp;
3666 BSTR string;
3667 HRESULT hres;
3668
3669 if(!is_vclass(jsthis, JSCLASS_REGEXP)) {
3670 FIXME("Not a RegExp\n");
3671 return E_NOTIMPL;
3672 }
3673
3674 regexp = regexp_from_vdisp(jsthis);
3675
3676 hres = to_string(ctx, arg, &string);
3677 if(FAILED(hres))
3678 return hres;
3679 length = SysStringLen(string);
3680
3681 if(regexp->jsregexp->flags & JSREG_GLOB) {
3682 if(regexp->last_index < 0) {
3683 SysFreeString(string);
3684 set_last_index(regexp, 0);
3685 *ret = FALSE;
3686 if(input) {
3687 *input = NULL;
3688 }
3689 return S_OK;
3690 }
3691
3692 last_index = regexp->last_index;
3693 }
3694
3695 cp = string + last_index;
3696 hres = regexp_match_next(ctx, &regexp->dispex, REM_RESET_INDEX, string, length, &cp, parens,
3697 parens ? &parens_size : NULL, parens_cnt, match);
3698 if(FAILED(hres)) {
3699 SysFreeString(string);
3700 return hres;
3701 }
3702
3703 *ret = hres == S_OK;
3704 if(input) {
3705 *input = string;
3706 }else {
3707 SysFreeString(string);
3708 }
3709 return S_OK;
3710 }
3711
3712 static HRESULT RegExp_exec(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3713 jsval_t *r)
3714 {
3715 match_result_t *parens = NULL, match;
3716 DWORD parens_cnt = 0;
3717 BOOL b;
3718 BSTR string;
3719 HRESULT hres;
3720
3721 TRACE("\n");
3722
3723 hres = run_exec(ctx, jsthis, argc ? argv[0] : jsval_string(NULL), &string, &match, &parens, &parens_cnt, &b);
3724 if(FAILED(hres))
3725 return hres;
3726
3727 if(r) {
3728 if(b) {
3729 IDispatch *ret;
3730
3731 hres = create_match_array(ctx, string, &match, parens, parens_cnt, &ret);
3732 if(SUCCEEDED(hres))
3733 *r = jsval_disp(ret);
3734 }else {
3735 *r = jsval_null();
3736 }
3737 }
3738
3739 heap_free(parens);
3740 SysFreeString(string);
3741 return hres;
3742 }
3743
3744 static HRESULT RegExp_test(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3745 jsval_t *r)
3746 {
3747 match_result_t match;
3748 BSTR undef_str;
3749 BOOL b;
3750 HRESULT hres;
3751
3752 TRACE("\n");
3753
3754 if(!argc) {
3755 undef_str = SysAllocString(undefinedW);
3756 if(!undef_str)
3757 return E_OUTOFMEMORY;
3758 }
3759
3760 hres = run_exec(ctx, jsthis, argc ? argv[0] : jsval_string(undef_str), NULL, &match, NULL, NULL, &b);
3761 if(!argc)
3762 SysFreeString(undef_str);
3763 if(FAILED(hres))
3764 return hres;
3765
3766 if(r)
3767 *r = jsval_bool(b);
3768 return S_OK;
3769 }
3770
3771 static HRESULT RegExp_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
3772 jsval_t *r)
3773 {
3774 TRACE("\n");
3775
3776 switch(flags) {
3777 case INVOKE_FUNC:
3778 return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
3779 default:
3780 FIXME("unimplemented flags %x\n", flags);
3781 return E_NOTIMPL;
3782 }
3783
3784 return S_OK;
3785 }
3786
3787 static void RegExp_destructor(jsdisp_t *dispex)
3788 {
3789 RegExpInstance *This = (RegExpInstance*)dispex;
3790
3791 if(This->jsregexp)
3792 js_DestroyRegExp(This->jsregexp);
3793 jsval_release(This->last_index_val);
3794 SysFreeString(This->str);
3795 heap_free(This);
3796 }
3797
3798 static const builtin_prop_t RegExp_props[] = {
3799 {execW, RegExp_exec, PROPF_METHOD|1},
3800 {globalW, RegExp_global, 0},
3801 {ignoreCaseW, RegExp_ignoreCase, 0},
3802 {lastIndexW, RegExp_lastIndex, 0},
3803 {multilineW, RegExp_multiline, 0},
3804 {sourceW, RegExp_source, 0},
3805 {testW, RegExp_test, PROPF_METHOD|1},
3806 {toStringW, RegExp_toString, PROPF_METHOD}
3807 };
3808
3809 static const builtin_info_t RegExp_info = {
3810 JSCLASS_REGEXP,
3811 {NULL, RegExp_value, 0},
3812 sizeof(RegExp_props)/sizeof(*RegExp_props),
3813 RegExp_props,
3814 RegExp_destructor,
3815 NULL
3816 };
3817
3818 static const builtin_prop_t RegExpInst_props[] = {
3819 {globalW, RegExp_global, 0},
3820 {ignoreCaseW, RegExp_ignoreCase, 0},
3821 {lastIndexW, RegExp_lastIndex, 0},
3822 {multilineW, RegExp_multiline, 0},
3823 {sourceW, RegExp_source, 0}
3824 };
3825
3826 static const builtin_info_t RegExpInst_info = {
3827 JSCLASS_REGEXP,
3828 {NULL, RegExp_value, 0},
3829 sizeof(RegExpInst_props)/sizeof(*RegExpInst_props),
3830 RegExpInst_props,
3831 RegExp_destructor,
3832 NULL
3833 };
3834
3835 static HRESULT alloc_regexp(script_ctx_t *ctx, jsdisp_t *object_prototype, RegExpInstance **ret)
3836 {
3837 RegExpInstance *regexp;
3838 HRESULT hres;
3839
3840 regexp = heap_alloc_zero(sizeof(RegExpInstance));
3841 if(!regexp)
3842 return E_OUTOFMEMORY;
3843
3844 if(object_prototype)
3845 hres = init_dispex(&regexp->dispex, ctx, &RegExp_info, object_prototype);
3846 else
3847 hres = init_dispex_from_constr(&regexp->dispex, ctx, &RegExpInst_info, ctx->regexp_constr);
3848
3849 if(FAILED(hres)) {
3850 heap_free(regexp);
3851 return hres;
3852 }
3853
3854 *ret = regexp;
3855 return S_OK;
3856 }
3857
3858 HRESULT create_regexp(script_ctx_t *ctx, const WCHAR *exp, int len, DWORD flags, jsdisp_t **ret)
3859 {
3860 RegExpInstance *regexp;
3861 HRESULT hres;
3862
3863 TRACE("%s %x\n", debugstr_wn(exp, len), flags);
3864
3865 hres = alloc_regexp(ctx, NULL, &regexp);
3866 if(FAILED(hres))
3867 return hres;
3868
3869 if(len == -1)
3870 regexp->str = SysAllocString(exp);
3871 else
3872 regexp->str = SysAllocStringLen(exp, len);
3873 if(!regexp->str) {
3874 jsdisp_release(&regexp->dispex);
3875 return E_OUTOFMEMORY;
3876 }
3877
3878 regexp->jsregexp = js_NewRegExp(ctx, regexp->str, flags, FALSE);
3879 if(!regexp->jsregexp) {
3880 WARN("js_NewRegExp failed\n");
3881 jsdisp_release(&regexp->dispex);
3882 return E_FAIL;
3883 }
3884
3885 regexp->last_index_val = jsval_number(0);
3886
3887 *ret = &regexp->dispex;
3888 return S_OK;
3889 }
3890
3891 HRESULT create_regexp_var(script_ctx_t *ctx, jsval_t src_arg, jsval_t *flags_arg, jsdisp_t **ret)
3892 {
3893 const WCHAR *opt = emptyW, *src;
3894 DWORD flags;
3895 HRESULT hres;
3896
3897 if(is_object_instance(src_arg)) {
3898 jsdisp_t *obj;
3899
3900 obj = iface_to_jsdisp((IUnknown*)get_object(src_arg));
3901 if(obj) {
3902 if(is_class(obj, JSCLASS_REGEXP)) {
3903 RegExpInstance *regexp = (RegExpInstance*)obj;
3904
3905 hres = create_regexp(ctx, regexp->str, -1, regexp->jsregexp->flags, ret);
3906 jsdisp_release(obj);
3907 return hres;
3908 }
3909
3910 jsdisp_release(obj);
3911 }
3912 }
3913
3914 if(!is_string(src_arg)) {
3915 FIXME("src_arg = %s\n", debugstr_jsval(src_arg));
3916 return E_NOTIMPL;
3917 }
3918
3919 src = get_string(src_arg);
3920
3921 if(flags_arg) {
3922 if(!is_string(*flags_arg)) {
3923 FIXME("unimplemented for %s\n", debugstr_jsval(*flags_arg));
3924 return E_NOTIMPL;
3925 }
3926
3927 opt = get_string(*flags_arg);
3928 }
3929
3930 hres = parse_regexp_flags(opt, strlenW(opt), &flags);
3931 if(FAILED(hres))
3932 return hres;
3933
3934 return create_regexp(ctx, src, -1, flags, ret);
3935 }
3936
3937 HRESULT regexp_string_match(script_ctx_t *ctx, jsdisp_t *re, BSTR str, jsval_t *r)
3938 {
3939 static const WCHAR indexW[] = {'i','n','d','e','x',0};
3940 static const WCHAR inputW[] = {'i','n','p','u','t',0};
3941 static const WCHAR lastIndexW[] = {'l','a','s','t','I','n','d','e','x',0};
3942
3943 RegExpInstance *regexp = (RegExpInstance*)re;
3944 match_result_t *match_result;
3945 DWORD match_cnt, i, length;
3946 jsdisp_t *array;
3947 HRESULT hres;
3948
3949 length = SysStringLen(str);
3950
3951 if(!(regexp->jsregexp->flags & JSREG_GLOB)) {
3952 match_result_t match, *parens = NULL;
3953 DWORD parens_cnt, parens_size = 0;
3954 const WCHAR *cp = str;
3955
3956 hres = regexp_match_next(ctx, &regexp->dispex, 0, str, length, &cp, &parens, &parens_size, &parens_cnt, &match);
3957 if(FAILED(hres))
3958 return hres;
3959
3960 if(r) {
3961 if(hres == S_OK) {
3962 IDispatch *ret;
3963
3964 hres = create_match_array(ctx, str, &match, parens, parens_cnt, &ret);
3965 if(SUCCEEDED(hres))
3966 *r = jsval_disp(ret);
3967 }else {
3968 *r = jsval_null();
3969 }
3970 }
3971
3972 heap_free(parens);
3973 return S_OK;
3974 }
3975
3976 hres = regexp_match(ctx, &regexp->dispex, str, length, FALSE, &match_result, &match_cnt);
3977 if(FAILED(hres))
3978 return hres;
3979
3980 if(!match_cnt) {
3981 TRACE("no match\n");
3982
3983 if(r)
3984 *r = jsval_null();
3985 return S_OK;
3986 }
3987
3988 hres = create_array(ctx, match_cnt, &array);
3989 if(FAILED(hres))
3990 return hres;
3991
3992 for(i=0; i < match_cnt; i++) {
3993 BSTR tmp_str;
3994
3995 tmp_str = SysAllocStringLen(match_result[i].str, match_result[i].len);
3996 if(!tmp_str) {
3997 hres = E_OUTOFMEMORY;
3998 break;
3999 }
4000
4001 hres = jsdisp_propput_idx(array, i, jsval_string(tmp_str));
4002 SysFreeString(tmp_str);
4003 if(FAILED(hres))
4004 break;
4005 }
4006
4007 while(SUCCEEDED(hres)) {
4008 hres = jsdisp_propput_name(array, indexW, jsval_number(match_result[match_cnt-1].str-str));
4009 if(FAILED(hres))
4010 break;
4011
4012 hres = jsdisp_propput_name(array, lastIndexW,
4013 jsval_number(match_result[match_cnt-1].str-str+match_result[match_cnt-1].len));
4014 if(FAILED(hres))
4015 break;
4016
4017 hres = jsdisp_propput_name(array, inputW, jsval_string(str));
4018 break;
4019 }
4020
4021 heap_free(match_result);
4022
4023 if(SUCCEEDED(hres) && r)
4024 *r = jsval_obj(array);
4025 else
4026 jsdisp_release(array);
4027 return hres;
4028 }
4029
4030 static HRESULT global_idx(script_ctx_t *ctx, DWORD flags, DWORD idx, jsval_t *r)
4031 {
4032 switch(flags) {
4033 case DISPATCH_PROPERTYGET: {
4034 BSTR ret = NULL;
4035
4036 ret = SysAllocStringLen(ctx->match_parens[idx].str, ctx->match_parens[idx].len);
4037 if(!ret)
4038 return E_OUTOFMEMORY;
4039
4040 *r = jsval_string(ret);
4041 break;
4042 }
4043 case DISPATCH_PROPERTYPUT:
4044 break;
4045 default:
4046 FIXME("unsupported flags\n");
4047 return E_NOTIMPL;
4048 }
4049
4050 return S_OK;
4051 }
4052
4053 static HRESULT RegExpConstr_idx1(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4054 unsigned argc, jsval_t *argv, jsval_t *r)
4055 {
4056 TRACE("\n");
4057 return global_idx(ctx, flags, 0, r);
4058 }
4059
4060 static HRESULT RegExpConstr_idx2(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4061 unsigned argc, jsval_t *argv, jsval_t *r)
4062 {
4063 TRACE("\n");
4064 return global_idx(ctx, flags, 1, r);
4065 }
4066
4067 static HRESULT RegExpConstr_idx3(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4068 unsigned argc, jsval_t *argv, jsval_t *r)
4069 {
4070 TRACE("\n");
4071 return global_idx(ctx, flags, 2, r);
4072 }
4073
4074 static HRESULT RegExpConstr_idx4(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4075 unsigned argc, jsval_t *argv, jsval_t *r)
4076 {
4077 TRACE("\n");
4078 return global_idx(ctx, flags, 3, r);
4079 }
4080
4081 static HRESULT RegExpConstr_idx5(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4082 unsigned argc, jsval_t *argv, jsval_t *r)
4083 {
4084 TRACE("\n");
4085 return global_idx(ctx, flags, 4, r);
4086 }
4087
4088 static HRESULT RegExpConstr_idx6(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4089 unsigned argc, jsval_t *argv, jsval_t *r)
4090 {
4091 TRACE("\n");
4092 return global_idx(ctx, flags, 5, r);
4093 }
4094
4095 static HRESULT RegExpConstr_idx7(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4096 unsigned argc, jsval_t *argv, jsval_t *r)
4097 {
4098 TRACE("\n");
4099 return global_idx(ctx, flags, 6, r);
4100 }
4101
4102 static HRESULT RegExpConstr_idx8(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4103 unsigned argc, jsval_t *argv, jsval_t *r)
4104 {
4105 TRACE("\n");
4106 return global_idx(ctx, flags, 7, r);
4107 }
4108
4109 static HRESULT RegExpConstr_idx9(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4110 unsigned argc, jsval_t *argv, jsval_t *r)
4111 {
4112 TRACE("\n");
4113 return global_idx(ctx, flags, 8, r);
4114 }
4115
4116 static HRESULT RegExpConstr_leftContext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4117 unsigned argc, jsval_t *argv, jsval_t *r)
4118 {
4119 TRACE("\n");
4120
4121 switch(flags) {
4122 case DISPATCH_PROPERTYGET: {
4123 BSTR ret;
4124
4125 ret = SysAllocStringLen(ctx->last_match, ctx->last_match_index);
4126 if(!ret)
4127 return E_OUTOFMEMORY;
4128
4129 *r = jsval_string(ret);
4130 break;
4131 }
4132 case DISPATCH_PROPERTYPUT:
4133 break;
4134 default:
4135 FIXME("unsupported flags\n");
4136 return E_NOTIMPL;
4137 }
4138
4139 return S_OK;
4140 }
4141
4142 static HRESULT RegExpConstr_rightContext(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
4143 unsigned argc, jsval_t *argv, jsval_t *r)
4144 {
4145 TRACE("\n");
4146
4147 switch(flags) {
4148 case DISPATCH_PROPERTYGET: {
4149 BSTR ret;
4150
4151 ret = SysAllocString(ctx->last_match+ctx->last_match_index+ctx->last_match_length);
4152 if(!ret)
4153 return E_OUTOFMEMORY;
4154
4155 *r = jsval_string(ret);
4156 break;
4157 }
4158 case DISPATCH_PROPERTYPUT:
4159 break;
4160 default:
4161 FIXME("unsupported flags\n");
4162 return E_NOTIMPL;
4163 }
4164
4165 return S_OK;
4166 }
4167
4168 static HRESULT RegExpConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
4169 jsval_t *r)
4170 {
4171 TRACE("\n");
4172
4173 switch(flags) {
4174 case DISPATCH_METHOD:
4175 if(argc) {
4176 if(is_object_instance(argv[0])) {
4177 jsdisp_t *jsdisp = iface_to_jsdisp((IUnknown*)get_object(argv[0]));
4178 if(jsdisp) {
4179 if(is_class(jsdisp, JSCLASS_REGEXP)) {
4180 if(argc > 1 && !is_undefined(argv[1])) {
4181 jsdisp_release(jsdisp);
4182 return throw_regexp_error(ctx, JS_E_REGEXP_SYNTAX, NULL);
4183 }
4184
4185 if(r)
4186 *r = jsval_obj(jsdisp);
4187 else
4188 jsdisp_release(jsdisp);
4189 return S_OK;
4190 }
4191 jsdisp_release(jsdisp);
4192 }
4193 }
4194 }
4195 /* fall through */
4196 case DISPATCH_CONSTRUCT: {
4197 jsdisp_t *ret;
4198 HRESULT hres;
4199
4200 if(!argc) {
4201 FIXME("no args\n");
4202 return E_NOTIMPL;
4203 }
4204
4205 hres = create_regexp_var(ctx, argv[0], argc > 1 ? argv+1 : NULL, &ret);
4206 if(FAILED(hres))
4207 return hres;
4208
4209 if(r)
4210 *r = jsval_obj(ret);
4211 else
4212 jsdisp_release(ret);
4213 return S_OK;
4214 }
4215 default:
4216 FIXME("unimplemented flags: %x\n", flags);
4217 return E_NOTIMPL;
4218 }
4219
4220 return S_OK;
4221 }
4222
4223 static const builtin_prop_t RegExpConstr_props[] = {
4224 {idx1W, RegExpConstr_idx1, 0},
4225 {idx2W, RegExpConstr_idx2, 0},
4226 {idx3W, RegExpConstr_idx3, 0},
4227 {idx4W, RegExpConstr_idx4, 0},
4228 {idx5W, RegExpConstr_idx5, 0},
4229 {idx6W, RegExpConstr_idx6, 0},
4230 {idx7W, RegExpConstr_idx7, 0},
4231 {idx8W, RegExpConstr_idx8, 0},
4232 {idx9W, RegExpConstr_idx9, 0},
4233 {leftContextW, RegExpConstr_leftContext, 0},
4234 {rightContextW, RegExpConstr_rightContext, 0}
4235 };
4236
4237 static const builtin_info_t RegExpConstr_info = {
4238 JSCLASS_FUNCTION,
4239 {NULL, Function_value, 0},
4240 sizeof(RegExpConstr_props)/sizeof(*RegExpConstr_props),
4241 RegExpConstr_props,
4242 NULL,
4243 NULL
4244 };
4245
4246 HRESULT create_regexp_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
4247 {
4248 RegExpInstance *regexp;
4249 HRESULT hres;
4250
4251 static const WCHAR RegExpW[] = {'R','e','g','E','x','p',0};
4252
4253 hres = alloc_regexp(ctx, object_prototype, &regexp);
4254 if(FAILED(hres))
4255 return hres;
4256
4257 hres = create_builtin_constructor(ctx, RegExpConstr_value, RegExpW, &RegExpConstr_info,
4258 PROPF_CONSTR|2, &regexp->dispex, ret);
4259
4260 jsdisp_release(&regexp->dispex);
4261 return hres;
4262 }
4263
4264 HRESULT parse_regexp_flags(const WCHAR *str, DWORD str_len, DWORD *ret)
4265 {
4266 const WCHAR *p;
4267 DWORD flags = 0;
4268
4269 for (p = str; p < str+str_len; p++) {
4270 switch (*p) {
4271 case 'g':
4272 flags |= JSREG_GLOB;
4273 break;
4274 case 'i':
4275 flags |= JSREG_FOLD;
4276 break;
4277 case 'm':
4278 flags |= JSREG_MULTILINE;
4279 break;
4280 case 'y':
4281 flags |= JSREG_STICKY;
4282 break;
4283 default:
4284 WARN("wrong flag %c\n", *p);
4285 return E_FAIL;
4286 }
4287 }
4288
4289 *ret = flags;
4290 return S_OK;
4291 }
Windows API implementation