1
/* This is JavaScriptCore's variant of the PCRE library. While this library
2
started out as a copy of PCRE, many of the features of PCRE have been
3
removed. This library now supports only the regular expression features
4
required by the JavaScript language specification, and has only the functions
5
needed by JavaScriptCore and the rest of WebKit.
7
Originally written by Philip Hazel
8
Copyright (c) 1997-2006 University of Cambridge
9
Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
10
Copyright (C) 2007 Eric Seidel <eric@webkit.org>
12
-----------------------------------------------------------------------------
13
Redistribution and use in source and binary forms, with or without
14
modification, are permitted provided that the following conditions are met:
16
* Redistributions of source code must retain the above copyright notice,
17
this list of conditions and the following disclaimer.
19
* Redistributions in binary form must reproduce the above copyright
20
notice, this list of conditions and the following disclaimer in the
21
documentation and/or other materials provided with the distribution.
23
* Neither the name of the University of Cambridge nor the names of its
24
contributors may be used to endorse or promote products derived from
25
this software without specific prior written permission.
27
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37
POSSIBILITY OF SUCH DAMAGE.
38
-----------------------------------------------------------------------------
41
/* This module contains the external function jsRegExpExecute(), along with
42
supporting internal functions that are not used by other modules. */
46
#include "pcre_internal.h"
49
#include <wtf/ASCIICType.h>
50
#include <wtf/FastMalloc.h>
54
/* Negative values for the firstchar and reqchar variables */
56
#define REQ_UNSET (-2)
59
/*************************************************
60
* Code parameters and static tables *
61
*************************************************/
63
/* Maximum number of items on the nested bracket stacks at compile time. This
64
applies to the nesting of all kinds of parentheses. It does not limit
65
un-nested, non-capturing parentheses. This number can be made bigger if
66
necessary - it is used to dimension one int and one unsigned char vector at
69
#define BRASTACK_SIZE 200
71
/* Table for handling escaped characters in the range '0'-'z'. Positive returns
72
are simple data values; negative values are for special things like \d and so
73
on. Zero means further processing is needed (for things like \x), or the escape
76
static const short escapes[] = {
77
0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */
78
0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */
79
'@', 0, -ESC_B, 0, -ESC_D, 0, 0, 0, /* @ - G */
80
0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
81
0, 0, 0, -ESC_S, 0, 0, 0, -ESC_W, /* P - W */
82
0, 0, 0, '[', '\\', ']', '^', '_', /* X - _ */
83
'`', 7, -ESC_b, 0, -ESC_d, 0, '\f', 0, /* ` - g */
84
0, 0, 0, 0, 0, 0, '\n', 0, /* h - o */
85
0, 0, '\r', -ESC_s, '\t', 0, '\v', -ESC_w, /* p - w */
89
/* Error code numbers. They are given names so that they can more easily be
93
ERR0, ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7, ERR8, ERR9,
94
ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17
97
/* The texts of compile-time error messages. These are "char *" because they
98
are passed to the outside world. */
100
static const char* errorText(ErrorCode code)
102
static const char errorTexts[] =
104
"\\ at end of pattern\0"
105
"\\c at end of pattern\0"
106
"character value in \\x{...} sequence is too large\0"
107
"numbers out of order in {} quantifier\0"
109
"number too big in {} quantifier\0"
110
"missing terminating ] for character class\0"
111
"internal error: code overflow\0"
112
"range out of order in character class\0"
113
"nothing to repeat\0"
115
"unmatched parentheses\0"
116
"internal error: unexpected repeat\0"
117
"unrecognized character after (?\0"
118
"failed to get memory\0"
121
"reference to non-existent subpattern\0"
122
"regular expression too large\0"
123
"parentheses nested too deeply"
127
const char* text = errorTexts;
133
/* Structure for passing "static" information around between the functions
134
doing the compiling. */
141
needOuterBracket = false;
142
numCapturingBrackets = 0;
144
int topBackref; /* Maximum back reference */
145
unsigned backrefMap; /* Bitmap of low back refs */
146
int reqVaryOpt; /* "After variable item" flag for reqByte */
147
bool needOuterBracket;
148
int numCapturingBrackets;
151
/* Definitions to allow mutual recursion */
153
static bool compileBracket(int, int*, unsigned char**, const UChar**, const UChar*, ErrorCode*, int, int*, int*, CompileData&);
154
static bool bracketIsAnchored(const unsigned char* code);
155
static bool bracketNeedsLineStart(const unsigned char* code, unsigned captureMap, unsigned backrefMap);
156
static int bracketFindFirstAssertedCharacter(const unsigned char* code, bool inassert);
158
/*************************************************
160
*************************************************/
162
/* This function is called when a \ has been encountered. It either returns a
163
positive value for a simple escape such as \n, or a negative value which
164
encodes one of the more complicated things such as \d. When UTF-8 is enabled,
165
a positive value greater than 255 may be returned. On entry, ptr is pointing at
166
the \. On exit, it is on the final character of the escape sequence.
169
ptrPtr points to the pattern position pointer
170
errorCodePtr points to the errorcode variable
171
bracount number of previous extracting brackets
172
options the options bits
173
isClass true if inside a character class
175
Returns: zero or positive => a data character
176
negative => a special escape sequence
177
on error, errorPtr is set
180
static int checkEscape(const UChar** ptrPtr, const UChar* patternEnd, ErrorCode* errorCodePtr, int bracount, bool isClass)
182
const UChar* ptr = *ptrPtr + 1;
184
/* If backslash is at the end of the pattern, it's an error. */
185
if (ptr == patternEnd) {
186
*errorCodePtr = ERR1;
193
/* Non-alphamerics are literals. For digits or letters, do an initial lookup in
194
a table. A non-zero result is something that can be returned immediately.
195
Otherwise further processing may be required. */
197
if (c < '0' || c > 'z') { /* Not alphameric */
198
} else if (int escapeValue = escapes[c - '0']) {
202
c = '\b'; /* \b is backslash in a class */
203
else if (-c == ESC_B)
204
c = 'B'; /* and \B is a capital B in a class (in browsers event though ECMAScript 15.10.2.19 says it raises an error) */
206
/* Escapes that need further processing, or are illegal. */
219
/* Escape sequences starting with a non-zero digit are backreferences,
220
unless there are insufficient brackets, in which case they are octal
221
escape sequences. Those sequences end on the first non-octal character
222
or when we overflow 0-255, whichever comes first. */
225
const UChar* oldptr = ptr;
227
while ((ptr + 1 < patternEnd) && isASCIIDigit(ptr[1]) && c <= bracount)
228
c = c * 10 + *(++ptr) - '0';
233
ptr = oldptr; /* Put the pointer back and fall through */
236
/* Handle an octal number following \. If the first digit is 8 or 9,
237
this is not octal. */
239
if ((c = *ptr) >= '8')
242
/* \0 always starts an octal number, but we may drop through to here with a
243
larger first octal digit. */
248
for (i = 1; i <= 2; ++i) {
249
if (ptr + i >= patternEnd || ptr[i] < '0' || ptr[i] > '7')
251
int cc = c * 8 + ptr[i] - '0';
263
for (i = 1; i <= 2; ++i) {
264
if (ptr + i >= patternEnd || !isASCIIHexDigit(ptr[i])) {
271
cc -= 32; /* Convert to upper case */
272
c = c * 16 + cc - ((cc < 'A') ? '0' : ('A' - 10));
281
for (i = 1; i <= 4; ++i) {
282
if (ptr + i >= patternEnd || !isASCIIHexDigit(ptr[i])) {
289
cc -= 32; /* Convert to upper case */
290
c = c * 16 + cc - ((cc < 'A') ? '0' : ('A' - 10));
297
if (++ptr == patternEnd) {
298
*errorCodePtr = ERR2;
303
/* A letter is upper-cased; then the 0x40 bit is flipped. This coding
304
is ASCII-specific, but then the whole concept of \cx is ASCII-specific. */
305
c = toASCIIUpper(c) ^ 0x40;
314
/*************************************************
315
* Check for counted repeat *
316
*************************************************/
318
/* This function is called when a '{' is encountered in a place where it might
319
start a quantifier. It looks ahead to see if it really is a quantifier or not.
320
It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
321
where the ddds are digits.
324
p pointer to the first char after '{'
326
Returns: true or false
329
static bool isCountedRepeat(const UChar* p, const UChar* patternEnd)
331
if (p >= patternEnd || !isASCIIDigit(*p))
334
while (p < patternEnd && isASCIIDigit(*p))
336
if (p < patternEnd && *p == '}')
339
if (p >= patternEnd || *p++ != ',')
341
if (p < patternEnd && *p == '}')
344
if (p >= patternEnd || !isASCIIDigit(*p))
347
while (p < patternEnd && isASCIIDigit(*p))
350
return (p < patternEnd && *p == '}');
353
/*************************************************
354
* Read repeat counts *
355
*************************************************/
357
/* Read an item of the form {n,m} and return the values. This is called only
358
after isCountedRepeat() has confirmed that a repeat-count quantifier exists,
359
so the syntax is guaranteed to be correct, but we need to check the values.
362
p pointer to first char after '{'
363
minp pointer to int for min
364
maxp pointer to int for max
365
returned as -1 if no max
366
errorCodePtr points to error code variable
368
Returns: pointer to '}' on success;
369
current ptr on error, with errorCodePtr set non-zero
372
static const UChar* readRepeatCounts(const UChar* p, int* minp, int* maxp, ErrorCode* errorCodePtr)
377
/* Read the minimum value and do a paranoid check: a negative value indicates
378
an integer overflow. */
380
while (isASCIIDigit(*p))
381
min = min * 10 + *p++ - '0';
382
if (min < 0 || min > 65535) {
383
*errorCodePtr = ERR5;
387
/* Read the maximum value if there is one, and again do a paranoid on its size.
388
Also, max must not be less than min. */
395
while (isASCIIDigit(*p))
396
max = max * 10 + *p++ - '0';
397
if (max < 0 || max > 65535) {
398
*errorCodePtr = ERR5;
402
*errorCodePtr = ERR4;
408
/* Fill in the required variables, and pass back the pointer to the terminating
416
/*************************************************
417
* Find first significant op code *
418
*************************************************/
420
/* This is called by several functions that scan a compiled expression looking
421
for a fixed first character, or an anchoring op code etc. It skips over things
422
that do not influence this.
425
code pointer to the start of the group
426
Returns: pointer to the first significant opcode
429
static const unsigned char* firstSignificantOpcode(const unsigned char* code)
431
while (*code == OP_BRANUMBER)
436
static const unsigned char* firstSignificantOpcodeSkippingAssertions(const unsigned char* code)
441
advanceToEndOfBracket(code);
442
code += 1 + LINK_SIZE;
444
case OP_WORD_BOUNDARY:
445
case OP_NOT_WORD_BOUNDARY:
457
/*************************************************
458
* Get othercase range *
459
*************************************************/
461
/* This function is passed the start and end of a class range, in UTF-8 mode
462
with UCP support. It searches up the characters, looking for internal ranges of
463
characters in the "other" case. Each call returns the next one, updating the
467
cptr points to starting character value; updated
469
ocptr where to put start of othercase range
470
odptr where to put end of othercase range
472
Yield: true when range returned; false when no more
475
static bool getOthercaseRange(int* cptr, int d, int* ocptr, int* odptr)
477
int c, othercase = 0;
479
for (c = *cptr; c <= d; c++) {
480
if ((othercase = kjs_pcre_ucp_othercase(c)) >= 0)
488
int next = othercase + 1;
490
for (++c; c <= d; c++) {
491
if (kjs_pcre_ucp_othercase(c) != next)
502
/*************************************************
503
* Convert character value to UTF-8 *
504
*************************************************/
506
/* This function takes an integer value in the range 0 - 0x7fffffff
507
and encodes it as a UTF-8 character in 0 to 6 bytes.
510
cvalue the character value
511
buffer pointer to buffer for result - at least 6 bytes long
513
Returns: number of characters placed in the buffer
516
static int encodeUTF8(int cvalue, unsigned char *buffer)
519
for (i = 0; i < kjs_pcre_utf8_table1_size; i++)
520
if (cvalue <= kjs_pcre_utf8_table1[i])
523
for (int j = i; j > 0; j--) {
524
*buffer-- = 0x80 | (cvalue & 0x3f);
527
*buffer = kjs_pcre_utf8_table2[i] | cvalue;
531
/*************************************************
532
* Compile one branch *
533
*************************************************/
535
/* Scan the pattern, compiling it into the code vector.
538
options the option bits
539
brackets points to number of extracting brackets used
540
codePtr points to the pointer to the current code point
541
ptrPtr points to the current pattern pointer
542
errorCodePtr points to error code variable
543
firstbyteptr set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
544
reqbyteptr set to the last literal character required, else < 0
545
cd contains pointers to tables etc.
547
Returns: true on success
548
false, with *errorCodePtr set non-zero on error
551
static inline bool safelyCheckNextChar(const UChar* ptr, const UChar* patternEnd, UChar expected)
553
return ((ptr + 1 < patternEnd) && ptr[1] == expected);
557
compileBranch(int options, int* brackets, unsigned char** codePtr,
558
const UChar** ptrPtr, const UChar* patternEnd, ErrorCode* errorCodePtr, int *firstbyteptr,
559
int* reqbyteptr, CompileData& cd)
561
int repeatType, opType;
562
int repeatMin = 0, repeat_max = 0; /* To please picky compilers */
564
int reqvary, tempreqvary;
566
unsigned char* code = *codePtr;
567
unsigned char* tempcode;
568
bool didGroupSetFirstByte = false;
569
const UChar* ptr = *ptrPtr;
570
const UChar* tempptr;
571
unsigned char* previous = NULL;
572
unsigned char classbits[32];
575
unsigned char* class_utf8data;
576
unsigned char utf8_char[6];
578
/* Initialize no first byte, no required byte. REQ_UNSET means "no char
579
matching encountered yet". It gets changed to REQ_NONE if we hit something that
580
matches a non-fixed char first char; reqByte just remains unset if we never
583
When we hit a repeat whose minimum is zero, we may have to adjust these values
584
to take the zero repeat into account. This is implemented by setting them to
585
zeroFirstByte and zeroReqByte when such a repeat is encountered. The individual
586
item types that can be repeated set these backoff variables appropriately. */
588
int firstByte = REQ_UNSET;
589
int reqByte = REQ_UNSET;
590
int zeroReqByte = REQ_UNSET;
591
int zeroFirstByte = REQ_UNSET;
593
/* The variable reqCaseOpt contains either the REQ_IGNORE_CASE value or zero,
594
according to the current setting of the ignores-case flag. REQ_IGNORE_CASE is a bit
595
value > 255. It is added into the firstByte or reqByte variables to record the
596
case status of the value. This is used only for ASCII characters. */
598
int reqCaseOpt = (options & IgnoreCaseOption) ? REQ_IGNORE_CASE : 0;
600
/* Switch on next character until the end of the branch */
604
bool shouldFlipNegation; /* If a negative special such as \S is used, we should negate the whole class to properly support Unicode. */
611
unsigned char mcbuffer[8];
613
/* Next byte in the pattern */
615
c = ptr < patternEnd ? *ptr : 0;
617
/* Fill in length of a previous callout, except when the next thing is
620
bool isQuantifier = c == '*' || c == '+' || c == '?' || (c == '{' && isCountedRepeat(ptr + 1, patternEnd));
623
/* The branch terminates at end of string, |, or ). */
626
if (ptr < patternEnd)
628
// End of string; fall through
631
*firstbyteptr = firstByte;
632
*reqbyteptr = reqByte;
637
/* Handle single-character metacharacters. In multiline mode, ^ disables
638
the setting of any following char as a first character. */
641
if (options & MatchAcrossMultipleLinesOption) {
642
if (firstByte == REQ_UNSET)
643
firstByte = REQ_NONE;
652
if (options & MatchAcrossMultipleLinesOption)
658
/* There can never be a first char if '.' is first, whatever happens about
659
repeats. The value of reqByte doesn't change either. */
662
if (firstByte == REQ_UNSET)
663
firstByte = REQ_NONE;
664
zeroFirstByte = firstByte;
665
zeroReqByte = reqByte;
667
*code++ = OP_NOT_NEWLINE;
670
/* Character classes. If the included characters are all < 256, we build a
671
32-byte bitmap of the permitted characters, except in the special case
672
where there is only one such character. For negated classes, we build the
673
map as usual, then invert it at the end. However, we use a different opcode
674
so that data characters > 255 can be handled correctly.
676
If the class contains characters outside the 0-255 range, a different
677
opcode is compiled. It may optionally have a bit map for characters < 256,
678
but those above are are explicitly listed afterwards. A flag byte tells
679
whether the bitmap is present, and whether this is a negated class or not.
684
shouldFlipNegation = false;
686
/* PCRE supports POSIX class stuff inside a class. Perl gives an error if
687
they are encountered at the top level, so we'll do that too. */
689
/* If the first character is '^', set the negation flag and skip it. */
691
if (ptr + 1 >= patternEnd) {
692
*errorCodePtr = ERR6;
702
/* Keep a count of chars with values < 256 so that we can optimize the case
703
of just a single character (as long as it's < 256). For higher valued UTF-8
704
characters, we don't yet do any optimization. */
709
class_utf8 = false; /* No chars >= 256 */
710
class_utf8data = code + LINK_SIZE + 34; /* For UTF-8 items */
712
/* Initialize the 32-char bit map to all zeros. We have to build the
713
map in a temporary bit of store, in case the class contains only 1
714
character (< 256), because in that case the compiled code doesn't use the
717
memset(classbits, 0, 32 * sizeof(unsigned char));
719
/* Process characters until ] is reached. The first pass
720
through the regex checked the overall syntax, so we don't need to be very
721
strict here. At the start of the loop, c contains the first byte of the
724
while ((++ptr < patternEnd) && (c = *ptr) != ']') {
725
/* Backslash may introduce a single character, or it may introduce one
726
of the specials, which just set a flag. Escaped items are checked for
727
validity in the pre-compiling pass. The sequence \b is a special case.
728
Inside a class (and only there) it is treated as backspace. Elsewhere
729
it marks a word boundary. Other escapes have preset maps ready to
730
or into the one we are building. We assume they have more than one
731
character in them, so set classCharCount bigger than one. */
734
c = checkEscape(&ptr, patternEnd, errorCodePtr, cd.numCapturingBrackets, true);
736
classCharCount += 2; /* Greater than 1 is what matters */
739
for (c = 0; c < 32; c++)
740
classbits[c] |= classBitmapForChar(c + cbit_digit);
744
shouldFlipNegation = true;
745
for (c = 0; c < 32; c++)
746
classbits[c] |= ~classBitmapForChar(c + cbit_digit);
750
for (c = 0; c < 32; c++)
751
classbits[c] |= classBitmapForChar(c + cbit_word);
755
shouldFlipNegation = true;
756
for (c = 0; c < 32; c++)
757
classbits[c] |= ~classBitmapForChar(c + cbit_word);
761
for (c = 0; c < 32; c++)
762
classbits[c] |= classBitmapForChar(c + cbit_space);
766
shouldFlipNegation = true;
767
for (c = 0; c < 32; c++)
768
classbits[c] |= ~classBitmapForChar(c + cbit_space);
771
/* Unrecognized escapes are faulted if PCRE is running in its
772
strict mode. By default, for compatibility with Perl, they are
773
treated as literals. */
776
c = *ptr; /* The final character */
777
classCharCount -= 2; /* Undo the default count from above */
781
/* Fall through if we have a single character (c >= 0). This may be
782
> 256 in UTF-8 mode. */
784
} /* End of backslash handling */
786
/* A single character may be followed by '-' to form a range. However,
787
Perl does not permit ']' to be the end of the range. A '-' character
788
here is treated as a literal. */
790
if ((ptr + 2 < patternEnd) && ptr[1] == '-' && ptr[2] != ']') {
795
/* The second part of a range can be a single-character escape, but
796
not any of the other escapes. Perl 5.6 treats a hyphen as a literal
797
in such circumstances. */
800
const UChar* oldptr = ptr;
801
d = checkEscape(&ptr, patternEnd, errorCodePtr, cd.numCapturingBrackets, true);
803
/* \X is literal X; any other special means the '-' was literal */
806
goto LONE_SINGLE_CHARACTER; /* A few lines below */
810
/* The check that the two values are in the correct order happens in
811
the pre-pass. Optimize one-character ranges */
814
goto LONE_SINGLE_CHARACTER; /* A few lines below */
816
/* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
817
matching, we have to use an XCLASS with extra data items. Caseless
818
matching for characters > 127 is available only if UCP support is
821
if ((d > 255 || ((options & IgnoreCaseOption) && d > 127))) {
824
/* With UCP support, we can find the other case equivalents of
825
the relevant characters. There may be several ranges. Optimize how
826
they fit with the basic range. */
828
if (options & IgnoreCaseOption) {
832
while (getOthercaseRange(&cc, origd, &occ, &ocd)) {
833
if (occ >= c && ocd <= d)
834
continue; /* Skip embedded ranges */
836
if (occ < c && ocd >= c - 1) /* Extend the basic range */
837
{ /* if there is overlap, */
838
c = occ; /* noting that if occ < c */
839
continue; /* we can't have ocd > d */
840
} /* because a subrange is */
841
if (ocd > d && occ <= d + 1) /* always shorter than */
842
{ /* the basic range. */
848
*class_utf8data++ = XCL_SINGLE;
850
*class_utf8data++ = XCL_RANGE;
851
class_utf8data += encodeUTF8(occ, class_utf8data);
853
class_utf8data += encodeUTF8(ocd, class_utf8data);
857
/* Now record the original range, possibly modified for UCP caseless
858
overlapping ranges. */
860
*class_utf8data++ = XCL_RANGE;
861
class_utf8data += encodeUTF8(c, class_utf8data);
862
class_utf8data += encodeUTF8(d, class_utf8data);
864
/* With UCP support, we are done. Without UCP support, there is no
865
caseless matching for UTF-8 characters > 127; we can use the bit map
866
for the smaller ones. */
868
continue; /* With next character in the class */
871
/* We use the bit map for all cases when not in UTF-8 mode; else
872
ranges that lie entirely within 0-127 when there is UCP support; else
873
for partial ranges without UCP support. */
875
for (; c <= d; c++) {
876
classbits[c/8] |= (1 << (c&7));
877
if (options & IgnoreCaseOption) {
878
int uc = flipCase(c);
879
classbits[uc/8] |= (1 << (uc&7));
881
classCharCount++; /* in case a one-char range */
885
continue; /* Go get the next char in the class */
888
/* Handle a lone single character - we can get here for a normal
889
non-escape char, or after \ that introduces a single character or for an
890
apparent range that isn't. */
892
LONE_SINGLE_CHARACTER:
894
/* Handle a character that cannot go in the bit map */
896
if ((c > 255 || ((options & IgnoreCaseOption) && c > 127))) {
898
*class_utf8data++ = XCL_SINGLE;
899
class_utf8data += encodeUTF8(c, class_utf8data);
901
if (options & IgnoreCaseOption) {
903
if ((othercase = kjs_pcre_ucp_othercase(c)) >= 0) {
904
*class_utf8data++ = XCL_SINGLE;
905
class_utf8data += encodeUTF8(othercase, class_utf8data);
909
/* Handle a single-byte character */
910
classbits[c/8] |= (1 << (c&7));
911
if (options & IgnoreCaseOption) {
913
classbits[c/8] |= (1 << (c&7));
920
/* If classCharCount is 1, we saw precisely one character whose value is
921
less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
922
can optimize the negative case only if there were no characters >= 128
923
because OP_NOT and the related opcodes like OP_NOTSTAR operate on
924
single-bytes only. This is an historical hangover. Maybe one day we can
925
tidy these opcodes to handle multi-byte characters.
927
The optimization throws away the bit map. We turn the item into a
928
1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
929
that OP_NOT does not support multibyte characters. In the positive case, it
930
can cause firstByte to be set. Otherwise, there can be no first char if
931
this item is first, whatever repeat count may follow. In the case of
932
reqByte, save the previous value for reinstating. */
934
if (classCharCount == 1 && (!class_utf8 && (!negateClass || classLastChar < 128))) {
935
zeroReqByte = reqByte;
937
/* The OP_NOT opcode works on one-byte characters only. */
940
if (firstByte == REQ_UNSET)
941
firstByte = REQ_NONE;
942
zeroFirstByte = firstByte;
944
*code++ = classLastChar;
948
/* For a single, positive character, get the value into c, and
949
then we can handle this with the normal one-character code. */
953
} /* End of 1-char optimization */
955
/* The general case - not the one-char optimization. If this is the first
956
thing in the branch, there can be no first char setting, whatever the
957
repeat count. Any reqByte setting must remain unchanged after any kind of
960
if (firstByte == REQ_UNSET) firstByte = REQ_NONE;
961
zeroFirstByte = firstByte;
962
zeroReqByte = reqByte;
964
/* If there are characters with values > 255, we have to compile an
965
extended class, with its own opcode. If there are no characters < 256,
966
we can omit the bitmap. */
968
if (class_utf8 && !shouldFlipNegation) {
969
*class_utf8data++ = XCL_END; /* Marks the end of extra data */
972
*code = negateClass? XCL_NOT : 0;
974
/* If the map is required, install it, and move on to the end of
977
if (classCharCount > 0) {
979
memcpy(code, classbits, 32);
980
code = class_utf8data;
983
/* If the map is not required, slide down the extra data. */
986
int len = class_utf8data - (code + 33);
987
memmove(code + 1, code + 33, len);
991
/* Now fill in the complete length of the item */
993
putLinkValue(previous + 1, code - previous);
994
break; /* End of class handling */
997
/* If there are no characters > 255, negate the 32-byte map if necessary,
998
and copy it into the code vector. If this is the first thing in the branch,
999
there can be no first char setting, whatever the repeat count. Any reqByte
1000
setting must remain unchanged after any kind of repeat. */
1002
*code++ = (negateClass == shouldFlipNegation) ? OP_CLASS : OP_NCLASS;
1004
for (c = 0; c < 32; c++)
1005
code[c] = ~classbits[c];
1007
memcpy(code, classbits, 32);
1012
/* Various kinds of repeat; '{' is not necessarily a quantifier, but this
1013
has been tested above. */
1018
ptr = readRepeatCounts(ptr + 1, &repeatMin, &repeat_max, errorCodePtr);
1039
*errorCodePtr = ERR9;
1043
if (repeatMin == 0) {
1044
firstByte = zeroFirstByte; /* Adjust for zero repeat */
1045
reqByte = zeroReqByte; /* Ditto */
1048
/* Remember whether this is a variable length repeat */
1050
reqvary = (repeatMin == repeat_max) ? 0 : REQ_VARY;
1052
opType = 0; /* Default single-char op codes */
1054
/* Save start of previous item, in case we have to move it up to make space
1055
for an inserted OP_ONCE for the additional '+' extension. */
1056
/* FIXME: Probably don't need this because we don't use OP_ONCE. */
1058
tempcode = previous;
1060
/* If the next character is '+', we have a possessive quantifier. This
1061
implies greediness, whatever the setting of the PCRE_UNGREEDY option.
1062
If the next character is '?' this is a minimizing repeat, by default,
1063
but if PCRE_UNGREEDY is set, it works the other way round. We change the
1064
repeat type to the non-default. */
1066
if (safelyCheckNextChar(ptr, patternEnd, '?')) {
1072
/* If previous was a character match, abolish the item and generate a
1073
repeat item instead. If a char item has a minumum of more than one, ensure
1074
that it is set in reqByte - it might not be if a sequence such as x{3} is
1075
the first thing in a branch because the x will have gone into firstByte
1078
if (*previous == OP_CHAR || *previous == OP_CHAR_IGNORING_CASE) {
1079
/* Deal with UTF-8 characters that take up more than one byte. It's
1080
easier to write this out separately than try to macrify it. Use c to
1081
hold the length of the character in bytes, plus 0x80 to flag that it's a
1082
length rather than a small character. */
1084
if (code[-1] & 0x80) {
1085
unsigned char *lastchar = code - 1;
1086
while((*lastchar & 0xc0) == 0x80)
1088
c = code - lastchar; /* Length of UTF-8 character */
1089
memcpy(utf8_char, lastchar, c); /* Save the char */
1090
c |= 0x80; /* Flag c as a length */
1095
reqByte = c | reqCaseOpt | cd.reqVaryOpt;
1098
goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
1101
else if (*previous == OP_ASCII_CHAR || *previous == OP_ASCII_LETTER_IGNORING_CASE) {
1104
reqByte = c | reqCaseOpt | cd.reqVaryOpt;
1105
goto OUTPUT_SINGLE_REPEAT;
1108
/* If previous was a single negated character ([^a] or similar), we use
1109
one of the special opcodes, replacing it. The code is shared with single-
1110
character repeats by setting opt_type to add a suitable offset into
1111
repeatType. OP_NOT is currently used only for single-byte chars. */
1113
else if (*previous == OP_NOT) {
1114
opType = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
1116
goto OUTPUT_SINGLE_REPEAT;
1119
/* If previous was a character type match (\d or similar), abolish it and
1120
create a suitable repeat item. The code is shared with single-character
1121
repeats by setting opType to add a suitable offset into repeatType. */
1123
else if (*previous <= OP_NOT_NEWLINE) {
1124
opType = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
1127
OUTPUT_SINGLE_REPEAT:
1129
int prop_value = -1;
1131
unsigned char* oldcode = code;
1132
code = previous; /* Usually overwrite previous item */
1134
/* If the maximum is zero then the minimum must also be zero; Perl allows
1135
this case, so we do too - by simply omitting the item altogether. */
1137
if (repeat_max == 0)
1140
/* Combine the opType with the repeatType */
1142
repeatType += opType;
1144
/* A minimum of zero is handled either as the special case * or ?, or as
1145
an UPTO, with the maximum given. */
1147
if (repeatMin == 0) {
1148
if (repeat_max == -1)
1149
*code++ = OP_STAR + repeatType;
1150
else if (repeat_max == 1)
1151
*code++ = OP_QUERY + repeatType;
1153
*code++ = OP_UPTO + repeatType;
1154
put2ByteValueAndAdvance(code, repeat_max);
1158
/* A repeat minimum of 1 is optimized into some special cases. If the
1159
maximum is unlimited, we use OP_PLUS. Otherwise, the original item it
1160
left in place and, if the maximum is greater than 1, we use OP_UPTO with
1161
one less than the maximum. */
1163
else if (repeatMin == 1) {
1164
if (repeat_max == -1)
1165
*code++ = OP_PLUS + repeatType;
1167
code = oldcode; /* leave previous item in place */
1168
if (repeat_max == 1)
1170
*code++ = OP_UPTO + repeatType;
1171
put2ByteValueAndAdvance(code, repeat_max - 1);
1175
/* The case {n,n} is just an EXACT, while the general case {n,m} is
1176
handled as an EXACT followed by an UPTO. */
1179
*code++ = OP_EXACT + opType; /* NB EXACT doesn't have repeatType */
1180
put2ByteValueAndAdvance(code, repeatMin);
1182
/* If the maximum is unlimited, insert an OP_STAR. Before doing so,
1183
we have to insert the character for the previous code. For a repeated
1184
Unicode property match, there are two extra bytes that define the
1185
required property. In UTF-8 mode, long characters have their length in
1186
c, with the 0x80 bit as a flag. */
1188
if (repeat_max < 0) {
1190
memcpy(code, utf8_char, c & 7);
1194
if (prop_type >= 0) {
1195
*code++ = prop_type;
1196
*code++ = prop_value;
1199
*code++ = OP_STAR + repeatType;
1202
/* Else insert an UPTO if the max is greater than the min, again
1203
preceded by the character, for the previously inserted code. */
1205
else if (repeat_max != repeatMin) {
1207
memcpy(code, utf8_char, c & 7);
1211
if (prop_type >= 0) {
1212
*code++ = prop_type;
1213
*code++ = prop_value;
1215
repeat_max -= repeatMin;
1216
*code++ = OP_UPTO + repeatType;
1217
put2ByteValueAndAdvance(code, repeat_max);
1221
/* The character or character type itself comes last in all cases. */
1224
memcpy(code, utf8_char, c & 7);
1229
/* For a repeated Unicode property match, there are two extra bytes that
1230
define the required property. */
1232
if (prop_type >= 0) {
1233
*code++ = prop_type;
1234
*code++ = prop_value;
1238
/* If previous was a character class or a back reference, we put the repeat
1239
stuff after it, but just skip the item if the repeat was {0,0}. */
1241
else if (*previous == OP_CLASS ||
1242
*previous == OP_NCLASS ||
1243
*previous == OP_XCLASS ||
1244
*previous == OP_REF)
1246
if (repeat_max == 0) {
1251
if (repeatMin == 0 && repeat_max == -1)
1252
*code++ = OP_CRSTAR + repeatType;
1253
else if (repeatMin == 1 && repeat_max == -1)
1254
*code++ = OP_CRPLUS + repeatType;
1255
else if (repeatMin == 0 && repeat_max == 1)
1256
*code++ = OP_CRQUERY + repeatType;
1258
*code++ = OP_CRRANGE + repeatType;
1259
put2ByteValueAndAdvance(code, repeatMin);
1260
if (repeat_max == -1)
1261
repeat_max = 0; /* 2-byte encoding for max */
1262
put2ByteValueAndAdvance(code, repeat_max);
1266
/* If previous was a bracket group, we may have to replicate it in certain
1269
else if (*previous >= OP_BRA) {
1271
int len = code - previous;
1272
unsigned char* bralink = NULL;
1274
/* If the maximum repeat count is unlimited, find the end of the bracket
1275
by scanning through from the start, and compute the offset back to it
1276
from the current code pointer. There may be an OP_OPT setting following
1277
the final KET, so we can't find the end just by going back from the code
1280
if (repeat_max == -1) {
1281
const unsigned char* ket = previous;
1282
advanceToEndOfBracket(ket);
1283
ketoffset = code - ket;
1286
/* The case of a zero minimum is special because of the need to stick
1287
OP_BRAZERO in front of it, and because the group appears once in the
1288
data, whereas in other cases it appears the minimum number of times. For
1289
this reason, it is simplest to treat this case separately, as otherwise
1290
the code gets far too messy. There are several special subcases when the
1293
if (repeatMin == 0) {
1294
/* If the maximum is also zero, we just omit the group from the output
1297
if (repeat_max == 0) {
1302
/* If the maximum is 1 or unlimited, we just have to stick in the
1303
BRAZERO and do no more at this point. However, we do need to adjust
1304
any OP_RECURSE calls inside the group that refer to the group itself or
1305
any internal group, because the offset is from the start of the whole
1306
regex. Temporarily terminate the pattern while doing this. */
1308
if (repeat_max <= 1) {
1310
memmove(previous+1, previous, len);
1312
*previous++ = OP_BRAZERO + repeatType;
1315
/* If the maximum is greater than 1 and limited, we have to replicate
1316
in a nested fashion, sticking OP_BRAZERO before each set of brackets.
1317
The first one has to be handled carefully because it's the original
1318
copy, which has to be moved up. The remainder can be handled by code
1319
that is common with the non-zero minimum case below. We have to
1320
adjust the value of repeat_max, since one less copy is required. */
1324
memmove(previous + 2 + LINK_SIZE, previous, len);
1325
code += 2 + LINK_SIZE;
1326
*previous++ = OP_BRAZERO + repeatType;
1327
*previous++ = OP_BRA;
1329
/* We chain together the bracket offset fields that have to be
1330
filled in later when the ends of the brackets are reached. */
1332
int offset = (!bralink) ? 0 : previous - bralink;
1334
putLinkValueAllowZeroAndAdvance(previous, offset);
1340
/* If the minimum is greater than zero, replicate the group as many
1341
times as necessary, and adjust the maximum to the number of subsequent
1342
copies that we need. If we set a first char from the group, and didn't
1343
set a required char, copy the latter from the former. */
1346
if (repeatMin > 1) {
1347
if (didGroupSetFirstByte && reqByte < 0)
1348
reqByte = firstByte;
1349
for (int i = 1; i < repeatMin; i++) {
1350
memcpy(code, previous, len);
1355
repeat_max -= repeatMin;
1358
/* This code is common to both the zero and non-zero minimum cases. If
1359
the maximum is limited, it replicates the group in a nested fashion,
1360
remembering the bracket starts on a stack. In the case of a zero minimum,
1361
the first one was set up above. In all cases the repeat_max now specifies
1362
the number of additional copies needed. */
1364
if (repeat_max >= 0) {
1365
for (int i = repeat_max - 1; i >= 0; i--) {
1366
*code++ = OP_BRAZERO + repeatType;
1368
/* All but the final copy start a new nesting, maintaining the
1369
chain of brackets outstanding. */
1373
int offset = (!bralink) ? 0 : code - bralink;
1375
putLinkValueAllowZeroAndAdvance(code, offset);
1378
memcpy(code, previous, len);
1382
/* Now chain through the pending brackets, and fill in their length
1383
fields (which are holding the chain links pro tem). */
1386
int offset = code - bralink + 1;
1387
unsigned char* bra = code - offset;
1388
int oldlinkoffset = getLinkValueAllowZero(bra + 1);
1389
bralink = (!oldlinkoffset) ? 0 : bralink - oldlinkoffset;
1391
putLinkValueAndAdvance(code, offset);
1392
putLinkValue(bra + 1, offset);
1396
/* If the maximum is unlimited, set a repeater in the final copy. We
1397
can't just offset backwards from the current code point, because we
1398
don't know if there's been an options resetting after the ket. The
1399
correct offset was computed above. */
1402
code[-ketoffset] = OP_KETRMAX + repeatType;
1405
/* Else there's some kind of shambles */
1408
*errorCodePtr = ERR11;
1412
/* In all case we no longer have a previous item. We also set the
1413
"follows varying string" flag for subsequently encountered reqbytes if
1414
it isn't already set and we have just passed a varying length item. */
1418
cd.reqVaryOpt |= reqvary;
1421
/* Start of nested bracket sub-expression, or comment or lookahead or
1422
lookbehind or option setting or condition. First deal with special things
1423
that can come after a bracket; all are introduced by ?, and the appearance
1424
of any of them means that this is not a referencing group. They were
1425
checked for validity in the first pass over the string, so we don't have to
1426
check for syntax errors here. */
1431
if (*(++ptr) == '?') {
1433
case ':': /* Non-extracting bracket */
1438
case '=': /* Positive lookahead */
1439
bravalue = OP_ASSERT;
1443
case '!': /* Negative lookahead */
1444
bravalue = OP_ASSERT_NOT;
1448
/* Character after (? not specially recognized */
1451
*errorCodePtr = ERR12;
1456
/* Else we have a referencing group; adjust the opcode. If the bracket
1457
number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
1458
arrange for the true number to follow later, in an OP_BRANUMBER item. */
1461
if (++(*brackets) > EXTRACT_BASIC_MAX) {
1462
bravalue = OP_BRA + EXTRACT_BASIC_MAX + 1;
1463
code[1 + LINK_SIZE] = OP_BRANUMBER;
1464
put2ByteValue(code + 2 + LINK_SIZE, *brackets);
1468
bravalue = OP_BRA + *brackets;
1471
/* Process nested bracketed re. Assertions may not be repeated, but other
1472
kinds can be. We copy code into a non-variable in order to be able
1473
to pass its address because some compilers complain otherwise. Pass in a
1474
new setting for the ims options if they have changed. */
1476
previous = (bravalue >= OP_BRAZERO) ? code : 0;
1479
tempreqvary = cd.reqVaryOpt; /* Save value before bracket */
1481
if (!compileBracket(
1483
brackets, /* Extracting bracket count */
1484
&tempcode, /* Where to put code (updated) */
1485
&ptr, /* Input pointer (updated) */
1487
errorCodePtr, /* Where to put an error message */
1488
skipBytes, /* Skip over OP_BRANUMBER */
1489
&subFirstByte, /* For possible first char */
1490
&subReqByte, /* For possible last char */
1491
cd)) /* Tables block */
1494
/* At the end of compiling, code is still pointing to the start of the
1495
group, while tempcode has been updated to point past the end of the group
1496
and any option resetting that may follow it. The pattern pointer (ptr)
1497
is on the bracket. */
1499
/* Handle updating of the required and first characters. Update for normal
1500
brackets of all kinds, and conditions with two branches (see code above).
1501
If the bracket is followed by a quantifier with zero repeat, we have to
1502
back off. Hence the definition of zeroReqByte and zeroFirstByte outside the
1503
main loop so that they can be accessed for the back off. */
1505
zeroReqByte = reqByte;
1506
zeroFirstByte = firstByte;
1507
didGroupSetFirstByte = false;
1509
if (bravalue >= OP_BRA) {
1510
/* If we have not yet set a firstByte in this branch, take it from the
1511
subpattern, remembering that it was set here so that a repeat of more
1512
than one can replicate it as reqByte if necessary. If the subpattern has
1513
no firstByte, set "none" for the whole branch. In both cases, a zero
1514
repeat forces firstByte to "none". */
1516
if (firstByte == REQ_UNSET) {
1517
if (subFirstByte >= 0) {
1518
firstByte = subFirstByte;
1519
didGroupSetFirstByte = true;
1522
firstByte = REQ_NONE;
1523
zeroFirstByte = REQ_NONE;
1526
/* If firstByte was previously set, convert the subpattern's firstByte
1527
into reqByte if there wasn't one, using the vary flag that was in
1528
existence beforehand. */
1530
else if (subFirstByte >= 0 && subReqByte < 0)
1531
subReqByte = subFirstByte | tempreqvary;
1533
/* If the subpattern set a required byte (or set a first byte that isn't
1534
really the first byte - see above), set it. */
1536
if (subReqByte >= 0)
1537
reqByte = subReqByte;
1540
/* For a forward assertion, we take the reqByte, if set. This can be
1541
helpful if the pattern that follows the assertion doesn't set a different
1542
char. For example, it's useful for /(?=abcde).+/. We can't set firstByte
1543
for an assertion, however because it leads to incorrect effect for patterns
1544
such as /(?=a)a.+/ when the "real" "a" would then become a reqByte instead
1545
of a firstByte. This is overcome by a scan at the end if there's no
1546
firstByte, looking for an asserted first char. */
1548
else if (bravalue == OP_ASSERT && subReqByte >= 0)
1549
reqByte = subReqByte;
1551
/* Now update the main code pointer to the end of the group. */
1555
/* Error if hit end of pattern */
1557
if (ptr >= patternEnd || *ptr != ')') {
1558
*errorCodePtr = ERR14;
1563
/* Check \ for being a real metacharacter; if not, fall through and handle
1564
it as a data character at the start of a string. Escape items are checked
1565
for validity in the pre-compiling pass. */
1569
c = checkEscape(&ptr, patternEnd, errorCodePtr, cd.numCapturingBrackets, false);
1571
/* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
1572
are arranged to be the negation of the corresponding OP_values. For the
1573
back references, the values are ESC_REF plus the reference number. Only
1574
back references and those types that consume a character may be repeated.
1575
We can test for values between ESC_b and ESC_w for the latter; this may
1576
have to change if any new ones are ever created. */
1579
/* For metasequences that actually match a character, we disable the
1580
setting of a first character if it hasn't already been set. */
1582
if (firstByte == REQ_UNSET && -c > ESC_b && -c <= ESC_w)
1583
firstByte = REQ_NONE;
1585
/* Set values to reset to if this is followed by a zero repeat. */
1587
zeroFirstByte = firstByte;
1588
zeroReqByte = reqByte;
1590
/* Back references are handled specially */
1592
if (-c >= ESC_REF) {
1593
int number = -c - ESC_REF;
1596
put2ByteValueAndAdvance(code, number);
1599
/* For the rest, we can obtain the OP value by negating the escape
1603
previous = (-c > ESC_b && -c <= ESC_w) ? code : NULL;
1611
/* Handle a literal character. It is guaranteed not to be whitespace or #
1612
when the extended flag is set. If we are in UTF-8 mode, it may be a
1613
multi-byte literal character. */
1624
if ((options & IgnoreCaseOption) && (c | 0x20) >= 'a' && (c | 0x20) <= 'z') {
1625
*code++ = OP_ASCII_LETTER_IGNORING_CASE;
1628
*code++ = OP_ASCII_CHAR;
1632
mcLength = encodeUTF8(c, mcbuffer);
1634
*code++ = (options & IgnoreCaseOption) ? OP_CHAR_IGNORING_CASE : OP_CHAR;
1635
for (c = 0; c < mcLength; c++)
1636
*code++ = mcbuffer[c];
1639
/* Set the first and required bytes appropriately. If no previous first
1640
byte, set it from this character, but revert to none on a zero repeat.
1641
Otherwise, leave the firstByte value alone, and don't change it on a zero
1644
if (firstByte == REQ_UNSET) {
1645
zeroFirstByte = REQ_NONE;
1646
zeroReqByte = reqByte;
1648
/* If the character is more than one byte long, we can set firstByte
1649
only if it is not to be matched caselessly. */
1651
if (mcLength == 1 || reqCaseOpt == 0) {
1652
firstByte = mcbuffer[0] | reqCaseOpt;
1654
reqByte = code[-1] | cd.reqVaryOpt;
1657
firstByte = reqByte = REQ_NONE;
1660
/* firstByte was previously set; we can set reqByte only the length is
1661
1 or the matching is caseful. */
1664
zeroFirstByte = firstByte;
1665
zeroReqByte = reqByte;
1666
if (mcLength == 1 || reqCaseOpt == 0)
1667
reqByte = code[-1] | reqCaseOpt | cd.reqVaryOpt;
1670
break; /* End of literal character handling */
1672
} /* end of big loop */
1674
/* Control never reaches here by falling through, only by a goto for all the
1675
error states. Pass back the position in the pattern so that it can be displayed
1676
to the user for diagnosing the error. */
1683
/*************************************************
1684
* Compile sequence of alternatives *
1685
*************************************************/
1687
/* On entry, ptr is pointing past the bracket character, but on return
1688
it points to the closing bracket, or vertical bar, or end of string.
1689
The code variable is pointing at the byte into which the BRA operator has been
1690
stored. If the ims options are changed at the start (for a (?ims: group) or
1691
during any branch, we need to insert an OP_OPT item at the start of every
1692
following branch to ensure they get set correctly at run time, and also pass
1693
the new options into every subsequent branch compile.
1696
options option bits, including any changes for this subpattern
1697
brackets -> int containing the number of extracting brackets used
1698
codePtr -> the address of the current code pointer
1699
ptrPtr -> the address of the current pattern pointer
1700
errorCodePtr -> pointer to error code variable
1701
skipBytes skip this many bytes at start (for OP_BRANUMBER)
1702
firstbyteptr place to put the first required character, or a negative number
1703
reqbyteptr place to put the last required character, or a negative number
1704
cd points to the data block with tables pointers etc.
1706
Returns: true on success
1710
compileBracket(int options, int* brackets, unsigned char** codePtr,
1711
const UChar** ptrPtr, const UChar* patternEnd, ErrorCode* errorCodePtr, int skipBytes,
1712
int* firstbyteptr, int* reqbyteptr, CompileData& cd)
1714
const UChar* ptr = *ptrPtr;
1715
unsigned char* code = *codePtr;
1716
unsigned char* lastBranch = code;
1717
unsigned char* start_bracket = code;
1718
int firstByte = REQ_UNSET;
1719
int reqByte = REQ_UNSET;
1721
/* Offset is set zero to mark that this bracket is still open */
1723
putLinkValueAllowZero(code + 1, 0);
1724
code += 1 + LINK_SIZE + skipBytes;
1726
/* Loop for each alternative branch */
1729
/* Now compile the branch */
1731
int branchFirstByte;
1733
if (!compileBranch(options, brackets, &code, &ptr, patternEnd, errorCodePtr,
1734
&branchFirstByte, &branchReqByte, cd)) {
1739
/* If this is the first branch, the firstByte and reqByte values for the
1740
branch become the values for the regex. */
1742
if (*lastBranch != OP_ALT) {
1743
firstByte = branchFirstByte;
1744
reqByte = branchReqByte;
1747
/* If this is not the first branch, the first char and reqByte have to
1748
match the values from all the previous branches, except that if the previous
1749
value for reqByte didn't have REQ_VARY set, it can still match, and we set
1750
REQ_VARY for the regex. */
1753
/* If we previously had a firstByte, but it doesn't match the new branch,
1754
we have to abandon the firstByte for the regex, but if there was previously
1755
no reqByte, it takes on the value of the old firstByte. */
1757
if (firstByte >= 0 && firstByte != branchFirstByte) {
1759
reqByte = firstByte;
1760
firstByte = REQ_NONE;
1763
/* If we (now or from before) have no firstByte, a firstByte from the
1764
branch becomes a reqByte if there isn't a branch reqByte. */
1766
if (firstByte < 0 && branchFirstByte >= 0 && branchReqByte < 0)
1767
branchReqByte = branchFirstByte;
1769
/* Now ensure that the reqbytes match */
1771
if ((reqByte & ~REQ_VARY) != (branchReqByte & ~REQ_VARY))
1774
reqByte |= branchReqByte; /* To "or" REQ_VARY */
1777
/* Reached end of expression, either ')' or end of pattern. Go back through
1778
the alternative branches and reverse the chain of offsets, with the field in
1779
the BRA item now becoming an offset to the first alternative. If there are
1780
no alternatives, it points to the end of the group. The length in the
1781
terminating ket is always the length of the whole bracketed item. If any of
1782
the ims options were changed inside the group, compile a resetting op-code
1783
following, except at the very end of the pattern. Return leaving the pointer
1784
at the terminating char. */
1786
if (ptr >= patternEnd || *ptr != '|') {
1787
int length = code - lastBranch;
1789
int prevLength = getLinkValueAllowZero(lastBranch + 1);
1790
putLinkValue(lastBranch + 1, length);
1791
length = prevLength;
1792
lastBranch -= length;
1793
} while (length > 0);
1795
/* Fill in the ket */
1798
putLinkValue(code + 1, code - start_bracket);
1799
code += 1 + LINK_SIZE;
1801
/* Set values to pass back */
1805
*firstbyteptr = firstByte;
1806
*reqbyteptr = reqByte;
1810
/* Another branch follows; insert an "or" node. Its length field points back
1811
to the previous branch while the bracket remains open. At the end the chain
1812
is reversed. It's done like this so that the start of the bracket has a
1813
zero offset until it is closed, making it possible to detect recursion. */
1816
putLinkValue(code + 1, code - lastBranch);
1818
code += 1 + LINK_SIZE;
1821
ASSERT_NOT_REACHED();
1824
/*************************************************
1825
* Check for anchored expression *
1826
*************************************************/
1828
/* Try to find out if this is an anchored regular expression. Consider each
1829
alternative branch. If they all start OP_CIRC, or with a bracket
1830
all of whose alternatives start OP_CIRC (recurse ad lib), then
1834
code points to start of expression (the bracket)
1835
captureMap a bitmap of which brackets we are inside while testing; this
1836
handles up to substring 31; all brackets after that share
1838
backrefMap the back reference bitmap
1841
static bool branchIsAnchored(const unsigned char* code)
1843
const unsigned char* scode = firstSignificantOpcode(code);
1847
if (op >= OP_BRA || op == OP_ASSERT)
1848
return bracketIsAnchored(scode);
1850
/* Check for explicit anchoring */
1851
return op == OP_CIRC;
1854
static bool bracketIsAnchored(const unsigned char* code)
1857
if (!branchIsAnchored(code + 1 + LINK_SIZE))
1859
code += getLinkValue(code + 1);
1860
} while (*code == OP_ALT); /* Loop for each alternative */
1864
/*************************************************
1865
* Check for starting with ^ or .* *
1866
*************************************************/
1868
/* This is called to find out if every branch starts with ^ or .* so that
1869
"first char" processing can be done to speed things up in multiline
1870
matching and for non-DOTALL patterns that start with .* (which must start at
1871
the beginning or after \n)
1873
Except when the .* appears inside capturing parentheses, and there is a
1874
subsequent back reference to those parentheses. By keeping a bitmap of the
1875
first 31 back references, we can catch some of the more common cases more
1876
precisely; all the greater back references share a single bit.
1879
code points to start of expression (the bracket)
1880
captureMap a bitmap of which brackets we are inside while testing; this
1881
handles up to substring 31; all brackets after that share
1883
backrefMap the back reference bitmap
1886
static bool branchNeedsLineStart(const unsigned char* code, unsigned captureMap, unsigned backrefMap)
1888
const unsigned char* scode = firstSignificantOpcode(code);
1891
/* Capturing brackets */
1893
int captureNum = op - OP_BRA;
1894
if (captureNum > EXTRACT_BASIC_MAX)
1895
captureNum = get2ByteValue(scode + 2 + LINK_SIZE);
1896
int bracketMask = (captureNum < 32) ? (1 << captureNum) : 1;
1897
return bracketNeedsLineStart(scode, captureMap | bracketMask, backrefMap);
1900
/* Other brackets */
1901
if (op == OP_BRA || op == OP_ASSERT)
1902
return bracketNeedsLineStart(scode, captureMap, backrefMap);
1904
/* .* means "start at start or after \n" if it isn't in brackets that
1905
may be referenced. */
1907
if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
1908
return scode[1] == OP_NOT_NEWLINE && !(captureMap & backrefMap);
1911
return op == OP_CIRC || op == OP_BOL;
1914
static bool bracketNeedsLineStart(const unsigned char* code, unsigned captureMap, unsigned backrefMap)
1917
if (!branchNeedsLineStart(code + 1 + LINK_SIZE, captureMap, backrefMap))
1919
code += getLinkValue(code + 1);
1920
} while (*code == OP_ALT); /* Loop for each alternative */
1924
/*************************************************
1925
* Check for asserted fixed first char *
1926
*************************************************/
1928
/* During compilation, the "first char" settings from forward assertions are
1929
discarded, because they can cause conflicts with actual literals that follow.
1930
However, if we end up without a first char setting for an unanchored pattern,
1931
it is worth scanning the regex to see if there is an initial asserted first
1932
char. If all branches start with the same asserted char, or with a bracket all
1933
of whose alternatives start with the same asserted char (recurse ad lib), then
1934
we return that char, otherwise -1.
1937
code points to start of expression (the bracket)
1938
options pointer to the options (used to check casing changes)
1939
inassert true if in an assertion
1941
Returns: -1 or the fixed first char
1944
static int branchFindFirstAssertedCharacter(const unsigned char* code, bool inassert)
1946
const unsigned char* scode = firstSignificantOpcodeSkippingAssertions(code);
1958
return bracketFindFirstAssertedCharacter(scode, op == OP_ASSERT);
1965
case OP_CHAR_IGNORING_CASE:
1967
case OP_ASCII_LETTER_IGNORING_CASE:
1976
static int bracketFindFirstAssertedCharacter(const unsigned char* code, bool inassert)
1980
int d = branchFindFirstAssertedCharacter(code + 1 + LINK_SIZE, inassert);
1987
code += getLinkValue(code + 1);
1988
} while (*code == OP_ALT);
1992
static inline int multiplyWithOverflowCheck(int a, int b)
1996
if (a > MAX_PATTERN_SIZE / b)
2001
static int calculateCompiledPatternLength(const UChar* pattern, int patternLength, JSRegExpIgnoreCaseOption ignoreCase,
2002
CompileData& cd, ErrorCode& errorcode)
2004
/* Make a pass over the pattern to compute the
2005
amount of store required to hold the compiled code. This does not have to be
2006
perfect as long as errors are overestimates. */
2008
if (patternLength > MAX_PATTERN_SIZE) {
2013
int length = 1 + LINK_SIZE; /* For initial BRA plus length */
2014
int branch_extra = 0;
2015
int lastitemlength = 0;
2016
unsigned brastackptr = 0;
2017
int brastack[BRASTACK_SIZE];
2018
unsigned char bralenstack[BRASTACK_SIZE];
2021
const UChar* ptr = (const UChar*)(pattern - 1);
2022
const UChar* patternEnd = (const UChar*)(pattern + patternLength);
2024
while (++ptr < patternEnd) {
2025
int minRepeats = 0, maxRepeats = 0;
2029
/* A backslashed item may be an escaped data character or it may be a
2033
c = checkEscape(&ptr, patternEnd, &errorcode, cd.numCapturingBrackets, false);
2037
lastitemlength = 1; /* Default length of last item for repeats */
2039
if (c >= 0) { /* Data character */
2040
length += 2; /* For a one-byte character */
2044
for (i = 0; i < kjs_pcre_utf8_table1_size; i++)
2045
if (c <= kjs_pcre_utf8_table1[i]) break;
2047
lastitemlength += i;
2053
/* Other escapes need one byte */
2057
/* A back reference needs an additional 2 bytes, plus either one or 5
2058
bytes for a repeat. We also need to keep the value of the highest
2061
if (c <= -ESC_REF) {
2062
int refnum = -c - ESC_REF;
2063
cd.backrefMap |= (refnum < 32) ? (1 << refnum) : 1;
2064
if (refnum > cd.topBackref)
2065
cd.topBackref = refnum;
2066
length += 2; /* For single back reference */
2067
if (safelyCheckNextChar(ptr, patternEnd, '{') && isCountedRepeat(ptr + 2, patternEnd)) {
2068
ptr = readRepeatCounts(ptr + 2, &minRepeats, &maxRepeats, &errorcode);
2071
if ((minRepeats == 0 && (maxRepeats == 1 || maxRepeats == -1)) ||
2072
(minRepeats == 1 && maxRepeats == -1))
2076
if (safelyCheckNextChar(ptr, patternEnd, '?'))
2082
case '^': /* Single-byte metacharacters */
2089
case '*': /* These repeats won't be after brackets; */
2090
case '+': /* those are handled separately */
2095
/* This covers the cases of braced repeats after a single char, metachar,
2096
class, or back reference. */
2099
if (!isCountedRepeat(ptr + 1, patternEnd))
2101
ptr = readRepeatCounts(ptr + 1, &minRepeats, &maxRepeats, &errorcode);
2105
/* These special cases just insert one extra opcode */
2107
if ((minRepeats == 0 && (maxRepeats == 1 || maxRepeats == -1)) ||
2108
(minRepeats == 1 && maxRepeats == -1))
2111
/* These cases might insert additional copies of a preceding character. */
2114
if (minRepeats != 1) {
2115
length -= lastitemlength; /* Uncount the original char or metachar */
2117
length += 3 + lastitemlength;
2119
length += lastitemlength + ((maxRepeats > 0) ? 3 : 1);
2122
if (safelyCheckNextChar(ptr, patternEnd, '?'))
2123
ptr++; /* Needs no extra length */
2125
POSSESSIVE: /* Test for possessive quantifier */
2126
if (safelyCheckNextChar(ptr, patternEnd, '+')) {
2128
length += 2 + 2 * LINK_SIZE; /* Allow for atomic brackets */
2132
/* An alternation contains an offset to the next branch or ket. If any ims
2133
options changed in the previous branch(es), and/or if we are in a
2134
lookbehind assertion, extra space will be needed at the start of the
2135
branch. This is handled by branch_extra. */
2138
if (brastackptr == 0)
2139
cd.needOuterBracket = true;
2140
length += 1 + LINK_SIZE + branch_extra;
2143
/* A character class uses 33 characters provided that all the character
2144
values are less than 256. Otherwise, it uses a bit map for low valued
2145
characters, and individual items for others. Don't worry about character
2146
types that aren't allowed in classes - they'll get picked up during the
2147
compile. A character class that contains only one single-byte character
2148
uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
2149
where we can. (In UTF-8 mode we can do this only for chars < 128.) */
2153
if (*(++ptr) == '^') {
2154
class_optcount = 10; /* Greater than one */
2160
bool class_utf8 = false;
2162
for (; ptr < patternEnd && *ptr != ']'; ++ptr) {
2163
/* Check for escapes */
2166
c = checkEscape(&ptr, patternEnd, &errorcode, cd.numCapturingBrackets, true);
2170
/* Handle escapes that turn into characters */
2173
goto NON_SPECIAL_CHARACTER;
2175
/* Escapes that are meta-things. The normal ones just affect the
2176
bit map, but Unicode properties require an XCLASS extended item. */
2179
class_optcount = 10; /* \d, \s etc; make sure > 1 */
2182
/* Anything else increments the possible optimization count. We have to
2183
detect ranges here so that we can compute the number of extra ranges for
2184
caseless wide characters when UCP support is available. If there are wide
2185
characters, we are going to have to use an XCLASS, even for single
2191
/* Come here from handling \ above when it escapes to a char value */
2193
NON_SPECIAL_CHARACTER:
2197
if (safelyCheckNextChar(ptr, patternEnd, '-')) {
2198
UChar const *hyptr = ptr++;
2199
if (safelyCheckNextChar(ptr, patternEnd, '\\')) {
2201
d = checkEscape(&ptr, patternEnd, &errorcode, cd.numCapturingBrackets, true);
2205
else if ((ptr + 1 < patternEnd) && ptr[1] != ']')
2208
ptr = hyptr; /* go back to hyphen as data */
2211
/* If d >= 0 we have a range. In UTF-8 mode, if the end is > 255, or >
2212
127 for caseless matching, we will need to use an XCLASS. */
2215
class_optcount = 10; /* Ensure > 1 */
2221
if ((d > 255 || (ignoreCase && d > 127))) {
2222
unsigned char buffer[6];
2223
if (!class_utf8) /* Allow for XCLASS overhead */
2226
length += LINK_SIZE + 2;
2229
/* If we have UCP support, find out how many extra ranges are
2230
needed to map the other case of characters within this range. We
2231
have to mimic the range optimization here, because extending the
2232
range upwards might push d over a boundary that makes it use
2233
another byte in the UTF-8 representation. */
2239
while (getOthercaseRange(&cc, origd, &occ, &ocd)) {
2240
if (occ >= c && ocd <= d)
2241
continue; /* Skip embedded */
2243
if (occ < c && ocd >= c - 1) /* Extend the basic range */
2244
{ /* if there is overlap, */
2245
c = occ; /* noting that if occ < c */
2246
continue; /* we can't have ocd > d */
2247
} /* because a subrange is */
2248
if (ocd > d && occ <= d + 1) /* always shorter than */
2249
{ /* the basic range. */
2254
/* An extra item is needed */
2256
length += 1 + encodeUTF8(occ, buffer) +
2257
((occ == ocd) ? 0 : encodeUTF8(ocd, buffer));
2261
/* The length of the (possibly extended) range */
2263
length += 1 + encodeUTF8(c, buffer) + encodeUTF8(d, buffer);
2268
/* We have a single character. There is nothing to be done unless we
2269
are in UTF-8 mode. If the char is > 255, or 127 when caseless, we must
2270
allow for an XCL_SINGLE item, doubled for caselessness if there is UCP
2274
if ((c > 255 || (ignoreCase && c > 127))) {
2275
unsigned char buffer[6];
2276
class_optcount = 10; /* Ensure > 1 */
2277
if (!class_utf8) /* Allow for XCLASS overhead */
2280
length += LINK_SIZE + 2;
2282
length += (ignoreCase ? 2 : 1) * (1 + encodeUTF8(c, buffer));
2288
if (ptr >= patternEnd) { /* Missing terminating ']' */
2293
/* We can optimize when there was only one optimizable character.
2294
Note that this does not detect the case of a negated single character.
2295
In that case we do an incorrect length computation, but it's not a serious
2296
problem because the computed length is too large rather than too small. */
2298
if (class_optcount == 1)
2301
/* Here, we handle repeats for the class opcodes. */
2305
/* A repeat needs either 1 or 5 bytes. If it is a possessive quantifier,
2306
we also need extra for wrapping the whole thing in a sub-pattern. */
2308
if (safelyCheckNextChar(ptr, patternEnd, '{') && isCountedRepeat(ptr + 2, patternEnd)) {
2309
ptr = readRepeatCounts(ptr + 2, &minRepeats, &maxRepeats, &errorcode);
2312
if ((minRepeats == 0 && (maxRepeats == 1 || maxRepeats == -1)) ||
2313
(minRepeats == 1 && maxRepeats == -1))
2317
if (safelyCheckNextChar(ptr, patternEnd, '+')) {
2319
length += 2 + 2 * LINK_SIZE;
2320
} else if (safelyCheckNextChar(ptr, patternEnd, '?'))
2327
/* Brackets may be genuine groups or special things */
2330
int branch_newextra = 0;
2331
int bracket_length = 1 + LINK_SIZE;
2332
bool capturing = false;
2334
/* Handle special forms of bracket, which all start (? */
2336
if (safelyCheckNextChar(ptr, patternEnd, '?')) {
2337
switch (c = (ptr + 2 < patternEnd ? ptr[2] : 0)) {
2338
/* Non-referencing groups and lookaheads just move the pointer on, and
2339
then behave like a non-special bracket, except that they don't increment
2340
the count of extracting brackets. Ditto for the "once only" bracket,
2341
which is in Perl from version 5.005. */
2349
/* Else loop checking valid options until ) is met. Anything else is an
2350
error. If we are without any brackets, i.e. at top level, the settings
2351
act as if specified in the options, so massage the options immediately.
2352
This is for backward compatibility with Perl 5.004. */
2361
/* Capturing brackets must be counted so we can process escapes in a
2362
Perlish way. If the number exceeds EXTRACT_BASIC_MAX we are going to need
2363
an additional 3 bytes of memory per capturing bracket. */
2367
if (bracount > EXTRACT_BASIC_MAX)
2368
bracket_length += 3;
2371
/* Save length for computing whole length at end if there's a repeat that
2372
requires duplication of the group. Also save the current value of
2373
branch_extra, and start the new group with the new value. If non-zero, this
2374
will either be 2 for a (?imsx: group, or 3 for a lookbehind assertion. */
2376
if (brastackptr >= sizeof(brastack)/sizeof(int)) {
2381
bralenstack[brastackptr] = branch_extra;
2382
branch_extra = branch_newextra;
2384
brastack[brastackptr++] = length;
2385
length += bracket_length;
2389
/* Handle ket. Look for subsequent maxRepeats/minRepeats; for certain sets of values we
2390
have to replicate this bracket up to that many times. If brastackptr is
2391
0 this is an unmatched bracket which will generate an error, but take care
2392
not to try to access brastack[-1] when computing the length and restoring
2393
the branch_extra value. */
2397
length += 1 + LINK_SIZE;
2398
if (brastackptr > 0) {
2399
duplength = length - brastack[--brastackptr];
2400
branch_extra = bralenstack[brastackptr];
2405
/* Leave ptr at the final char; for readRepeatCounts this happens
2406
automatically; for the others we need an increment. */
2408
if ((ptr + 1 < patternEnd) && (c = ptr[1]) == '{' && isCountedRepeat(ptr + 2, patternEnd)) {
2409
ptr = readRepeatCounts(ptr + 2, &minRepeats, &maxRepeats, &errorcode);
2412
} else if (c == '*') {
2416
} else if (c == '+') {
2420
} else if (c == '?') {
2429
/* If the minimum is zero, we have to allow for an OP_BRAZERO before the
2430
group, and if the maximum is greater than zero, we have to replicate
2431
maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
2435
if (minRepeats == 0) {
2437
if (maxRepeats > 0) {
2438
repeatsLength = multiplyWithOverflowCheck(maxRepeats - 1, duplength + 3 + 2 * LINK_SIZE);
2439
if (repeatsLength < 0) {
2443
length += repeatsLength;
2444
if (length > MAX_PATTERN_SIZE) {
2451
/* When the minimum is greater than zero, we have to replicate up to
2452
minval-1 times, with no additions required in the copies. Then, if there
2453
is a limited maximum we have to replicate up to maxval-1 times allowing
2454
for a BRAZERO item before each optional copy and nesting brackets for all
2455
but one of the optional copies. */
2458
repeatsLength = multiplyWithOverflowCheck(minRepeats - 1, duplength);
2459
if (repeatsLength < 0) {
2463
length += repeatsLength;
2464
if (maxRepeats > minRepeats) { /* Need this test as maxRepeats=-1 means no limit */
2465
repeatsLength = multiplyWithOverflowCheck(maxRepeats - minRepeats, duplength + 3 + 2 * LINK_SIZE);
2466
if (repeatsLength < 0) {
2470
length += repeatsLength - (2 + 2 * LINK_SIZE);
2472
if (length > MAX_PATTERN_SIZE) {
2478
/* Allow space for once brackets for "possessive quantifier" */
2480
if (safelyCheckNextChar(ptr, patternEnd, '+')) {
2482
length += 2 + 2 * LINK_SIZE;
2487
/* Non-special character. It won't be space or # in extended mode, so it is
2488
always a genuine character. If we are in a \Q...\E sequence, check for the
2489
end; if not, we have a literal. */
2493
length += 2; /* For a one-byte character */
2494
lastitemlength = 1; /* Default length of last item for repeats */
2498
for (i = 0; i < kjs_pcre_utf8_table1_size; i++)
2499
if (c <= kjs_pcre_utf8_table1[i])
2502
lastitemlength += i;
2509
length += 2 + LINK_SIZE; /* For final KET and END */
2511
cd.numCapturingBrackets = bracount;
2515
/*************************************************
2516
* Compile a Regular Expression *
2517
*************************************************/
2519
/* This function takes a string and returns a pointer to a block of store
2520
holding a compiled version of the expression. The original API for this
2521
function had no error code return variable; it is retained for backwards
2522
compatibility. The new function is given a new name.
2525
pattern the regular expression
2526
options various option bits
2527
errorCodePtr pointer to error code variable (pcre_compile2() only)
2528
can be NULL if you don't want a code value
2529
errorPtr pointer to pointer to error text
2530
erroroffset ptr offset in pattern where error was detected
2531
tables pointer to character tables or NULL
2533
Returns: pointer to compiled data block, or NULL on error,
2534
with errorPtr and erroroffset set
2537
static inline JSRegExp* returnError(ErrorCode errorcode, const char** errorPtr)
2539
*errorPtr = errorText(errorcode);
2543
JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
2544
JSRegExpIgnoreCaseOption ignoreCase, JSRegExpMultilineOption multiline,
2545
unsigned* numSubpatterns, const char** errorPtr)
2547
/* We can't pass back an error message if errorPtr is NULL; I guess the best we
2548
can do is just return NULL, but we can set a code value if there is a code pointer. */
2555
ErrorCode errorcode = ERR0;
2556
/* Call this once just to count the brackets. */
2557
calculateCompiledPatternLength(pattern, patternLength, ignoreCase, cd, errorcode);
2558
/* Call it again to compute the length. */
2559
int length = calculateCompiledPatternLength(pattern, patternLength, ignoreCase, cd, errorcode);
2561
return returnError(errorcode, errorPtr);
2563
if (length > MAX_PATTERN_SIZE)
2564
return returnError(ERR16, errorPtr);
2566
size_t size = length + sizeof(JSRegExp);
2567
JSRegExp* re = reinterpret_cast<JSRegExp*>(new char[size]);
2570
return returnError(ERR13, errorPtr);
2572
re->options = (ignoreCase ? IgnoreCaseOption : 0) | (multiline ? MatchAcrossMultipleLinesOption : 0);
2574
/* The starting points of the name/number translation table and of the code are
2575
passed around in the compile data block. */
2577
const unsigned char* codeStart = (const unsigned char*)(re + 1);
2579
/* Set up a starting, non-extracting bracket, then compile the expression. On
2580
error, errorcode will be set non-zero, so we don't need to look at the result
2581
of the function here. */
2583
const UChar* ptr = (const UChar*)pattern;
2584
const UChar* patternEnd = pattern + patternLength;
2585
unsigned char* code = (unsigned char*)codeStart;
2586
int firstByte, reqByte;
2587
int bracketCount = 0;
2588
if (!cd.needOuterBracket)
2589
compileBranch(re->options, &bracketCount, &code, &ptr, patternEnd, &errorcode, &firstByte, &reqByte, cd);
2592
compileBracket(re->options, &bracketCount, &code, &ptr, patternEnd, &errorcode, 0, &firstByte, &reqByte, cd);
2594
re->topBracket = bracketCount;
2595
re->topBackref = cd.topBackref;
2597
/* If not reached end of pattern on success, there's an excess bracket. */
2599
if (errorcode == 0 && ptr < patternEnd)
2602
/* Fill in the terminating state and check for disastrous overflow, but
2603
if debugging, leave the test till after things are printed out. */
2607
ASSERT(code - codeStart <= length);
2608
if (code - codeStart > length)
2611
/* Give an error if there's back reference to a non-existent capturing
2614
if (re->topBackref > re->topBracket)
2617
/* Failed to compile, or error while post-processing */
2619
if (errorcode != ERR0) {
2620
delete [] reinterpret_cast<char*>(re);
2621
return returnError(errorcode, errorPtr);
2624
/* If the anchored option was not passed, set the flag if we can determine that
2625
the pattern is anchored by virtue of ^ characters or \A or anything else (such
2626
as starting with .* when DOTALL is set).
2628
Otherwise, if we know what the first character has to be, save it, because that
2629
speeds up unanchored matches no end. If not, see if we can set the
2630
UseMultiLineFirstByteOptimizationOption flag. This is helpful for multiline matches when all branches
2631
start with ^. and also when all branches start with .* for non-DOTALL matches.
2634
if (cd.needOuterBracket ? bracketIsAnchored(codeStart) : branchIsAnchored(codeStart))
2635
re->options |= IsAnchoredOption;
2637
if (firstByte < 0) {
2638
firstByte = (cd.needOuterBracket
2639
? bracketFindFirstAssertedCharacter(codeStart, false)
2640
: branchFindFirstAssertedCharacter(codeStart, false))
2641
| ((re->options & IgnoreCaseOption) ? REQ_IGNORE_CASE : 0);
2643
if (firstByte >= 0) {
2644
int ch = firstByte & 255;
2646
re->firstByte = ((firstByte & REQ_IGNORE_CASE) && flipCase(ch) == ch) ? ch : firstByte;
2647
re->options |= UseFirstByteOptimizationOption;
2650
if (cd.needOuterBracket ? bracketNeedsLineStart(codeStart, 0, cd.backrefMap) : branchNeedsLineStart(codeStart, 0, cd.backrefMap))
2651
re->options |= UseMultiLineFirstByteOptimizationOption;
2655
/* For an anchored pattern, we use the "required byte" only if it follows a
2656
variable length item in the regex. Remove the caseless flag for non-caseable
2659
if (reqByte >= 0 && (!(re->options & IsAnchoredOption) || (reqByte & REQ_VARY))) {
2660
int ch = reqByte & 255;
2662
re->reqByte = ((reqByte & REQ_IGNORE_CASE) && flipCase(ch) == ch) ? (reqByte & ~REQ_IGNORE_CASE) : reqByte;
2663
re->options |= UseRequiredByteOptimizationOption;
2668
*numSubpatterns = re->topBracket;
2672
void jsRegExpFree(JSRegExp* re)
2674
delete [] reinterpret_cast<char*>(re);
added
removed
JavaScriptCore/pcre/pcre_compile.cpp
