a54777d33f2aacf73e431995e0061a42807694c5
[WebKit-https.git] / JavaScriptCore / pcre / pcre_internal.h
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.
6
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
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
14
15     * Redistributions of source code must retain the above copyright notice,
16       this list of conditions and the following disclaimer.
17
18     * Redistributions in binary form must reproduce the above copyright
19       notice, this list of conditions and the following disclaimer in the
20       documentation and/or other materials provided with the distribution.
21
22     * Neither the name of the University of Cambridge nor the names of its
23       contributors may be used to endorse or promote products derived from
24       this software without specific prior written permission.
25
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 POSSIBILITY OF SUCH DAMAGE.
37 -----------------------------------------------------------------------------
38 */
39
40 /* This header contains definitions that are shared between the different
41 modules, but which are not relevant to the exported API. This includes some
42 functions whose names all begin with "_pcre_". */
43
44 #ifndef PCRE_INTERNAL_H
45 #define PCRE_INTERNAL_H
46
47 /* Bit definitions for entries in the pcre_ctypes table. */
48
49 #define ctype_space   0x01
50 #define ctype_xdigit  0x08
51 #define ctype_word    0x10   /* alphameric or '_' */
52
53 /* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
54 of bits for a class map. Some classes are built by combining these tables. */
55
56 #define cbit_space     0      /* \s */
57 #define cbit_digit    32      /* \d */
58 #define cbit_word     64      /* \w */
59 #define cbit_length   96      /* Length of the cbits table */
60
61 /* Offsets of the various tables from the base tables pointer, and
62 total length. */
63
64 #define lcc_offset      0
65 #define fcc_offset    128
66 #define cbits_offset  256
67 #define ctypes_offset (cbits_offset + cbit_length)
68 #define tables_length (ctypes_offset + 128)
69
70 #ifndef DFTABLES
71
72 #include "Assertions.h"
73
74 #if COMPILER(MSVC)
75 #pragma warning(disable: 4232)
76 #pragma warning(disable: 4244)
77 #endif
78
79 /* The value of LINK_SIZE determines the number of bytes used to store links as
80 offsets within the compiled regex. The default is 2, which allows for compiled
81 patterns up to 64K long. This covers the vast majority of cases. However, PCRE
82 can also be compiled to use 3 or 4 bytes instead. This allows for longer
83 patterns in extreme cases. On systems that support it, "configure" can be used
84 to override this default. */
85
86 #define LINK_SIZE   2
87
88 /* The below limit restricts the number of recursive match calls in order to
89 limit the maximum amount of stack (or heap, if NO_RECURSE is defined) that is used. The
90 value of MATCH_LIMIT_RECURSION applies only to recursive calls of match().
91  
92  This limit is tied to the size of MatchFrame.  Right now we allow PCRE to allocate up
93  to MATCH_LIMIT_RECURSION - 16 * sizeof(MatchFrame) bytes of "stack" space before we give up.
94  Currently that's 100000 - 16 * (23 * 4)  ~ 90MB
95  */
96
97 #define MATCH_LIMIT_RECURSION 100000
98
99 #define _pcre_default_tables kjs_pcre_default_tables
100 #define _pcre_ord2utf8 kjs_pcre_ord2utf8
101 #define _pcre_utf8_table1 kjs_pcre_utf8_table1
102 #define _pcre_utf8_table2 kjs_pcre_utf8_table2
103 #define _pcre_utf8_table3 kjs_pcre_utf8_table3
104 #define _pcre_utf8_table4 kjs_pcre_utf8_table4
105 #define _pcre_xclass kjs_pcre_xclass
106
107 /* Define DEBUG to get debugging output on stdout. */
108
109 #if 0
110 #define DEBUG
111 #endif
112
113 /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
114 inline, and there are *still* stupid compilers about that don't like indented
115 pre-processor statements, or at least there were when I first wrote this. After
116 all, it had only been about 10 years then... */
117
118 #ifdef DEBUG
119 #define DPRINTF(p) printf p
120 #else
121 #define DPRINTF(p) /*nothing*/
122 #endif
123
124 /* Standard C headers plus the external interface definition. The only time
125 setjmp and stdarg are used is when NO_RECURSE is set. */
126
127 #include <ctype.h>
128 #include <limits.h>
129 #include <setjmp.h>
130 #include <stdarg.h>
131 #include <stddef.h>
132 #include <stdio.h>
133 #include <stdlib.h>
134 #include <string.h>
135
136 /* Include the public PCRE header and the definitions of UCP character property
137 values. */
138
139 #include "pcre.h"
140
141 typedef unsigned short pcre_uint16;
142 typedef unsigned pcre_uint32;
143 typedef unsigned char uschar;
144
145 /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
146 in big-endian order) by default. These are used, for example, to link from the
147 start of a subpattern to its alternatives and its end. The use of 2 bytes per
148 offset limits the size of the compiled regex to around 64K, which is big enough
149 for almost everybody. However, I received a request for an even bigger limit.
150 For this reason, and also to make the code easier to maintain, the storing and
151 loading of offsets from the byte string is now handled by the macros that are
152 defined here.
153
154 The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
155 the config.h file, but can be overridden by using -D on the command line. This
156 is automated on Unix systems via the "configure" command. */
157
158 #if LINK_SIZE == 2
159
160 static inline void putOpcodeValueAtOffset(uschar* opcodePtr, size_t offset, unsigned short value)
161 {
162     opcodePtr[offset] = value >> 8;
163     opcodePtr[offset + 1] = value & 255;
164 }
165
166 static inline short getOpcodeValueAtOffset(const uschar* opcodePtr, size_t offset)
167 {
168     return ((opcodePtr[offset] << 8) | opcodePtr[offset + 1]);
169 }
170
171 #define MAX_PATTERN_SIZE (1 << 16)
172
173 #elif LINK_SIZE == 3
174
175 static inline void putOpcodeValueAtOffset(uschar* opcodePtr, size_t offset, unsigned value)
176 {
177     ASSERT(!(value & 0xFF000000)); // This function only allows values < 2^24
178     opcodePtr[offset] = value >> 16;
179     opcodePtr[offset + 1] = value >> 8;
180     opcodePtr[offset + 2] = value & 255;
181 }
182
183 static inline int getOpcodeValueAtOffset(const uschar* opcodePtr, size_t offset)
184 {
185     return ((opcodePtr[offset] << 16) | (opcodePtr[offset + 1] << 8) | opcodePtr[offset + 2]);
186 }
187
188 #define MAX_PATTERN_SIZE (1 << 24)
189
190 #elif LINK_SIZE == 4
191
192 static inline void putOpcodeValueAtOffset(uschar* opcodePtr, size_t offset, unsigned value)
193 {
194     opcodePtr[offset] = value >> 24;
195     opcodePtr[offset + 1] = value >> 16;
196     opcodePtr[offset + 2] = value >> 8;
197     opcodePtr[offset + 3] = value & 255;
198 }
199
200 static inline int getOpcodeValueAtOffset(const uschar* opcodePtr, size_t offset)
201 {
202     return ((opcodePtr[offset] << 24) | (opcodePtr[offset + 1] << 16) | (opcodePtr[offset + 2] << 8) | opcodePtr[offset + 3]);
203 }
204
205 #define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */
206
207 #else
208 #error LINK_SIZE must be either 2, 3, or 4
209 #endif
210
211 static inline void putOpcodeValueAtOffsetAndAdvance(uschar*& opcodePtr, size_t offset, unsigned short value)
212 {
213     putOpcodeValueAtOffset(opcodePtr, offset, value);
214     opcodePtr += LINK_SIZE;
215 }
216
217 /* PCRE uses some other 2-byte quantities that do not change when the size of
218 offsets changes. There are used for repeat counts and for other things such as
219 capturing parenthesis numbers in back references. */
220
221 static inline void put2ByteOpcodeValueAtOffset(uschar* opcodePtr, size_t offset, unsigned short value)
222 {
223     opcodePtr[offset] = value >> 8;
224     opcodePtr[offset + 1] = value & 255;
225 }
226
227 static inline short get2ByteOpcodeValueAtOffset(const uschar* opcodePtr, size_t offset)
228 {
229     return ((opcodePtr[offset] << 8) | opcodePtr[offset + 1]);
230 }
231
232 static inline void put2ByteOpcodeValueAtOffsetAndAdvance(uschar*& opcodePtr, size_t offset, unsigned short value)
233 {
234     put2ByteOpcodeValueAtOffset(opcodePtr, offset, value);
235     opcodePtr += 2;
236 }
237
238 #define LEAD_OFFSET (0xd800 - (0x10000 >> 10))
239 #define SURROGATE_OFFSET (0x10000 - (0xd800 << 10) - 0xdc00)
240
241 static inline bool isLeadingSurrogate(int c)
242 {
243     return ((c & ~0x3ff) == 0xd800);
244 }
245
246 static inline bool isTrailingSurrogate(int c)
247 {
248     return ((c & ~0x3ff) == 0xdc00);
249 }
250
251 static inline int decodeSurrogatePair(int leadingSurrogate, int trailingSurrogate)
252 {
253     return ((leadingSurrogate << 10) + trailingSurrogate + SURROGATE_OFFSET);
254 }
255
256 static inline int getChar(const UChar* subjectPtr)
257 {
258     int c = subjectPtr[0];
259     if (isLeadingSurrogate(c))
260         c = decodeSurrogatePair(c, subjectPtr[1]);
261     return c;
262 }
263
264 static inline int getCharAndAdvance(const UChar*& subjectPtr)
265 {
266     int c = *subjectPtr++;
267     if (isLeadingSurrogate(c))
268         c = decodeSurrogatePair(c, *subjectPtr++);
269     return c;
270 }
271
272 static inline int getCharAndLength(const UChar*& subjectPtr, int& length)
273 {
274     int c = subjectPtr[0];
275     if (isLeadingSurrogate(c)) {
276         c = decodeSurrogatePair(c, subjectPtr[1]);
277         length = 2;
278     } else
279         length = 1;
280     return c;
281 }
282
283 // FIXME: All (2) calls to this funtion should be removed and replaced with
284 // calls to getCharAndAdvance
285 static inline int getCharAndAdvanceIfSurrogate(const UChar*& subjectPtr)
286 {
287     int c = subjectPtr[0];
288     if (isLeadingSurrogate(c)) {
289         c = decodeSurrogatePair(c, subjectPtr[1]);
290         subjectPtr++;
291     }
292     return c;
293 }
294
295 // This flavor checks to make sure we don't walk off the end
296 // FIXME: This could also be removed and an end-aware getCharAndAdvance added instead.
297 static inline int getCharAndAdvanceIfSurrogate(const UChar*& subjectPtr, const UChar* end)
298 {
299     int c = subjectPtr[0];
300     if (isLeadingSurrogate(c)) {
301         if (subjectPtr + 1 < end)
302             c = decodeSurrogatePair(c, subjectPtr[1]);
303         else
304             c = decodeSurrogatePair(c, 0);
305         subjectPtr++;
306     }
307     return c;
308 }
309
310 static inline int getPreviousChar(const UChar* subjectPtr)
311 {
312     int valueAtSubjectMinusOne = subjectPtr[-1];
313     if (isTrailingSurrogate(valueAtSubjectMinusOne))
314         return decodeSurrogatePair(subjectPtr[-2], valueAtSubjectMinusOne);
315     return valueAtSubjectMinusOne;
316 }
317
318 static inline void movePtrToPreviousChar(const UChar*& subjectPtr)
319 {
320     subjectPtr--;
321     if (isTrailingSurrogate(*subjectPtr))
322         subjectPtr--;
323 }
324
325 static inline bool movePtrToNextChar(const UChar*& subjectPtr, const UChar* endSubject)
326 {
327     if (subjectPtr < endSubject) {
328         subjectPtr++;
329         if (subjectPtr < endSubject && isTrailingSurrogate(*subjectPtr)) {
330             subjectPtr++;
331             return subjectPtr < endSubject;
332         }
333         return true;
334     }
335     return false;
336 }
337
338 static inline void movePtrToStartOfCurrentChar(const UChar*& subjectPtr)
339 {
340     if (isTrailingSurrogate(*subjectPtr))
341         subjectPtr--;
342 }
343
344 // FIXME: These are really more of a "compiled regexp state" than "regexp options"
345 enum RegExpOptions {
346     UseFirstByteOptimizationOption = 0x40000000,  /* first_byte is set */
347     UseRequiredByteOptimizationOption = 0x20000000,  /* req_byte is set */
348     UseMultiLineFirstByteOptimizationOption = 0x10000000,  /* start after \n for multiline */
349     IsAnchoredOption = 0x02000000,  /* can't use partial with this regex */
350     IgnoreCaseOption = 0x00000001,
351     MatchAcrossMultipleLinesOption = 0x00000002
352 };
353
354 /* Negative values for the firstchar and reqchar variables */
355
356 #define REQ_UNSET (-2)
357 #define REQ_NONE  (-1)
358
359 /* The maximum remaining length of subject we are prepared to search for a
360 req_byte match. */
361
362 #define REQ_BYTE_MAX 1000
363
364 /* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
365 variable-length repeat, or a anything other than literal characters. */
366
367 #define REQ_IGNORE_CASE 0x0100    /* indicates should ignore case */
368 #define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
369
370 /* Miscellaneous definitions */
371
372 /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
373 contain UTF-8 characters with values greater than 255. */
374
375 #define XCL_NOT    0x01    /* Flag: this is a negative class */
376 #define XCL_MAP    0x02    /* Flag: a 32-byte map is present */
377
378 #define XCL_END       0    /* Marks end of individual items */
379 #define XCL_SINGLE    1    /* Single item (one multibyte char) follows */
380 #define XCL_RANGE     2    /* A range (two multibyte chars) follows */
381
382 /* These are escaped items that aren't just an encoding of a particular data
383 value such as \n. They must have non-zero values, as check_escape() returns
384 their negation. Also, they must appear in the same order as in the opcode
385 definitions below, up to ESC_z. There's a dummy for OP_ANY_CHAR because it
386 corresponds to "." rather than an escape sequence. The final one must be
387 ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
388 tests in the code for an escape greater than ESC_b and less than ESC_Z to
389 detect the types that may be repeated. These are the types that consume
390 characters. If any new escapes are put in between that don't consume a
391 character, that code will have to change. */
392
393 enum { ESC_B = 1, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W, ESC_w, ESC_REF };
394
395 /* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
396 that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
397 OP_EOD must correspond in order to the list of escapes immediately above.
398 Note that whenever this list is updated, the two macro definitions that follow
399 must also be updated to match. */
400
401 #define FOR_EACH_OPCODE(macro) \
402     macro(END) \
403     \
404     macro(NOT_WORD_BOUNDARY) \
405     macro(WORD_BOUNDARY) \
406     macro(NOT_DIGIT) \
407     macro(DIGIT) \
408     macro(NOT_WHITESPACE) \
409     macro(WHITESPACE) \
410     macro(NOT_WORDCHAR) \
411     macro(WORDCHAR) \
412     \
413     macro(ANY_CHAR) \
414     \
415     macro(CIRC) \
416     macro(DOLL) \
417     macro(CHAR) \
418     macro(CHAR_IGNORING_CASE) \
419     macro(ASCII_CHAR) \
420     macro(ASCII_LETTER_IGNORING_CASE) \
421     macro(NOT) \
422     \
423     macro(STAR) \
424     macro(MINSTAR) \
425     macro(PLUS) \
426     macro(MINPLUS) \
427     macro(QUERY) \
428     macro(MINQUERY) \
429     macro(UPTO) \
430     macro(MINUPTO) \
431     macro(EXACT) \
432     \
433     macro(NOTSTAR) \
434     macro(NOTMINSTAR) \
435     macro(NOTPLUS) \
436     macro(NOTMINPLUS) \
437     macro(NOTQUERY) \
438     macro(NOTMINQUERY) \
439     macro(NOTUPTO) \
440     macro(NOTMINUPTO) \
441     macro(NOTEXACT) \
442     \
443     macro(TYPESTAR) \
444     macro(TYPEMINSTAR) \
445     macro(TYPEPLUS) \
446     macro(TYPEMINPLUS) \
447     macro(TYPEQUERY) \
448     macro(TYPEMINQUERY) \
449     macro(TYPEUPTO) \
450     macro(TYPEMINUPTO) \
451     macro(TYPEEXACT) \
452     \
453     macro(CRSTAR) \
454     macro(CRMINSTAR) \
455     macro(CRPLUS) \
456     macro(CRMINPLUS) \
457     macro(CRQUERY) \
458     macro(CRMINQUERY) \
459     macro(CRRANGE) \
460     macro(CRMINRANGE) \
461     \
462     macro(CLASS) \
463     macro(NCLASS) \
464     macro(XCLASS) \
465     \
466     macro(REF) \
467     \
468     macro(ALT) \
469     macro(KET) \
470     macro(KETRMAX) \
471     macro(KETRMIN) \
472     \
473     macro(ASSERT) \
474     macro(ASSERT_NOT) \
475     \
476     macro(ONCE) \
477     \
478     macro(BRAZERO) \
479     macro(BRAMINZERO) \
480     macro(BRANUMBER) \
481     macro(BRA)
482
483 #define OPCODE_ENUM_VALUE(opcode) OP_##opcode,
484 enum { FOR_EACH_OPCODE(OPCODE_ENUM_VALUE) };
485
486 /* WARNING WARNING WARNING: There is an implicit assumption in pcre.c and
487 study.c that all opcodes are less than 128 in value. This makes handling UTF-8
488 character sequences easier. */
489
490 /* The highest extraction number before we have to start using additional
491 bytes. (Originally PCRE didn't have support for extraction counts highter than
492 this number.) The value is limited by the number of opcodes left after OP_BRA,
493 i.e. 255 - OP_BRA. We actually set it a bit lower to leave room for additional
494 opcodes. */
495
496 #define EXTRACT_BASIC_MAX  100
497
498 /* This macro defines the length of fixed length operations in the compiled
499 regex. The lengths are used when searching for specific things, and also in the
500 debugging printing of a compiled regex. We use a macro so that it can be
501 defined close to the definitions of the opcodes themselves.
502
503 As things have been extended, some of these are no longer fixed lenths, but are
504 minima instead. For example, the length of a single-character repeat may vary
505 in UTF-8 mode. The code that uses this table must know about such things. */
506
507 #define OP_LENGTHS \
508   1,                             /* End                                    */ \
509   1, 1, 1, 1, 1, 1, 1, 1,        /* \B, \b, \D, \d, \S, \s, \W, \w         */ \
510   1,                             /* Any                                    */ \
511   1, 1,                          /* ^, $                                   */ \
512   2, 2,                          /* Char, Charnc - minimum lengths         */ \
513   2, 2,                          /* ASCII char or non-cased                */ \
514   2,                             /* not                                    */ \
515   /* Positive single-char repeats                            ** These are  */ \
516   2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
517   4, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
518   /* Negative single-char repeats - only for chars < 256                   */ \
519   2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
520   4, 4, 4,                       /* NOT upto, minupto, exact               */ \
521   /* Positive type repeats                                                 */ \
522   2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
523   4, 4, 4,                       /* Type upto, minupto, exact              */ \
524   /* Character class & ref repeats                                         */ \
525   1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
526   5, 5,                          /* CRRANGE, CRMINRANGE                    */ \
527  33,                             /* CLASS                                  */ \
528  33,                             /* NCLASS                                 */ \
529   0,                             /* XCLASS - variable length               */ \
530   3,                             /* REF                                    */ \
531   1 + LINK_SIZE,                   /* Alt                                    */ \
532   1 + LINK_SIZE,                   /* Ket                                    */ \
533   1 + LINK_SIZE,                   /* KetRmax                                */ \
534   1 + LINK_SIZE,                   /* KetRmin                                */ \
535   1 + LINK_SIZE,                   /* Assert                                 */ \
536   1 + LINK_SIZE,                   /* Assert not                             */ \
537   1 + LINK_SIZE,                   /* Once                                   */ \
538   1, 1,                          /* BRAZERO, BRAMINZERO                    */ \
539   3,                             /* BRANUMBER                              */ \
540   1 + LINK_SIZE                    /* BRA                                    */ \
541
542
543 /* The index of names and the
544 code vector run on as long as necessary after the end. We store an explicit
545 offset to the name table so that if a regex is compiled on one host, saved, and
546 then run on another where the size of pointers is different, all might still
547 be well. For the case of compiled-on-4 and run-on-8, we include an extra
548 pointer that is always NULL.
549 */
550
551 struct JSRegExp {
552     pcre_uint32 size;               /* Total that was malloced */
553     pcre_uint32 options;
554
555     pcre_uint16 top_bracket;
556     pcre_uint16 top_backref;
557     
558     // jsRegExpExecute && jsRegExpCompile currently only how to handle ASCII
559     // chars for thse optimizations, however it would be trivial to add support
560     // for optimized UChar first_byte/req_byte scans
561     pcre_uint16 first_byte;
562     pcre_uint16 req_byte;
563 };
564
565 /* Internal shared data tables. These are tables that are used by more than one
566  of the exported public functions. They have to be "external" in the C sense,
567  but are not part of the PCRE public API. The data for these tables is in the
568  pcre_tables.c module. */
569
570 #define _pcre_utf8_table1_size 6
571
572 extern const int    _pcre_utf8_table1[6];
573 extern const int    _pcre_utf8_table2[6];
574 extern const int    _pcre_utf8_table3[6];
575 extern const uschar _pcre_utf8_table4[0x40];
576
577 extern const uschar _pcre_default_tables[tables_length];
578
579 static inline uschar toLowerCase(uschar c)
580 {
581     static const uschar* lowerCaseChars = _pcre_default_tables + lcc_offset;
582     return lowerCaseChars[c];
583 }
584
585 static inline uschar flipCase(uschar c)
586 {
587     static const uschar* flippedCaseChars = _pcre_default_tables + fcc_offset;
588     return flippedCaseChars[c];
589 }
590
591 static inline uschar classBitmapForChar(uschar c)
592 {
593     static const uschar* charClassBitmaps = _pcre_default_tables + cbits_offset;
594     return charClassBitmaps[c];
595 }
596
597 static inline uschar charTypeForChar(uschar c)
598 {
599     const uschar* charTypeMap = _pcre_default_tables + ctypes_offset;
600     return charTypeMap[c];
601 }
602
603 static inline bool isWordChar(UChar c)
604 {
605     /* UTF8 Characters > 128 are assumed to be "non-word" characters. */
606     return (c < 128 && (charTypeForChar(c) & ctype_word));
607 }
608
609 static inline bool isSpaceChar(UChar c)
610 {
611     return (c < 128 && (charTypeForChar(c) & ctype_space));
612 }
613
614 /* Structure for passing "static" information around between the functions
615 doing the compiling, so that they are thread-safe. */
616
617 struct CompileData {
618     CompileData() {
619         start_code = 0;
620         start_pattern = 0;
621         top_backref = 0;
622         backref_map = 0;
623         req_varyopt = 0;
624     }
625   const uschar* start_code;     /* The start of the compiled code */
626   const UChar* start_pattern;   /* The start of the pattern */
627   int  top_backref;             /* Maximum back reference */
628   unsigned backref_map;     /* Bitmap of low back refs */
629   int  req_varyopt;             /* "After variable item" flag for reqbyte */
630 };
631
632 /* Internal shared functions. These are functions that are used by more than
633 one of the exported public functions. They have to be "external" in the C
634 sense, but are not part of the PCRE public API. */
635
636 extern int         _pcre_ucp_othercase(const unsigned int);
637 extern bool        _pcre_xclass(int, const uschar*);
638
639 static inline bool isNewline(UChar nl)
640 {
641     return (nl == 0xA || nl == 0xD || nl == 0x2028 || nl == 0x2029);
642 }
643
644 // FIXME: It's unclear to me if this moves the opcode ptr to the start of all branches
645 // or to the end of all branches -- ecs
646 // FIXME: This abstraction is poor since it assumes that you want to jump based on whatever
647 // the next value in the stream is, and *then* follow any OP_ALT branches.
648 static inline void moveOpcodePtrPastAnyAlternateBranches(const uschar*& opcodePtr)
649 {
650     do {
651         opcodePtr += getOpcodeValueAtOffset(opcodePtr, 1);
652     } while (*opcodePtr == OP_ALT);
653 }
654
655 #endif
656
657 #endif
658
659 /* End of pcre_internal.h */