2007-11-14 Eric Seidel <eric@webkit.org>
[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 value of MATCH_LIMIT determines the default number of times the internal
89 match() function can be called during a single execution of pcre_exec(). There
90 is a runtime interface for setting a different limit. The limit exists in order
91 to catch runaway regular expressions that take for ever to determine that they
92 do not match. The default is set very large so that it does not accidentally
93 catch legitimate cases. On systems that support it, "configure" can be used to
94 override this default default. */
95
96 #define MATCH_LIMIT 10000000
97
98 /* The above limit applies to all calls of match(), whether or not they
99 increase the recursion depth. In some environments it is desirable to limit the
100 depth of recursive calls of match() more strictly, in order to restrict the
101 maximum amount of stack (or heap, if NO_RECURSE is defined) that is used. The
102 value of MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
103 have any useful effect, it must be less than the value of MATCH_LIMIT. There is
104 a runtime method for setting a different limit. On systems that support it,
105 "configure" can be used to override this default default. */
106
107 #define MATCH_LIMIT_RECURSION MATCH_LIMIT
108
109 #define _pcre_default_tables kjs_pcre_default_tables
110 #define _pcre_ord2utf8 kjs_pcre_ord2utf8
111 #define _pcre_utf8_table1 kjs_pcre_utf8_table1
112 #define _pcre_utf8_table2 kjs_pcre_utf8_table2
113 #define _pcre_utf8_table3 kjs_pcre_utf8_table3
114 #define _pcre_utf8_table4 kjs_pcre_utf8_table4
115 #define _pcre_xclass kjs_pcre_xclass
116
117 /* Define DEBUG to get debugging output on stdout. */
118
119 #if 0
120 #define DEBUG
121 #endif
122
123 /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
124 inline, and there are *still* stupid compilers about that don't like indented
125 pre-processor statements, or at least there were when I first wrote this. After
126 all, it had only been about 10 years then... */
127
128 #ifdef DEBUG
129 #define DPRINTF(p) printf p
130 #else
131 #define DPRINTF(p) /*nothing*/
132 #endif
133
134 /* Standard C headers plus the external interface definition. The only time
135 setjmp and stdarg are used is when NO_RECURSE is set. */
136
137 #include <ctype.h>
138 #include <limits.h>
139 #include <setjmp.h>
140 #include <stdarg.h>
141 #include <stddef.h>
142 #include <stdio.h>
143 #include <stdlib.h>
144 #include <string.h>
145
146 /* Include the public PCRE header and the definitions of UCP character property
147 values. */
148
149 #include "pcre.h"
150
151 typedef unsigned short pcre_uint16;
152 typedef unsigned pcre_uint32;
153 typedef unsigned char uschar;
154
155 typedef JSRegExp pcre;
156
157 typedef UChar pcre_char;
158 typedef UChar pcre_uchar;
159 typedef const UChar* USPTR;
160
161 /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
162 in big-endian order) by default. These are used, for example, to link from the
163 start of a subpattern to its alternatives and its end. The use of 2 bytes per
164 offset limits the size of the compiled regex to around 64K, which is big enough
165 for almost everybody. However, I received a request for an even bigger limit.
166 For this reason, and also to make the code easier to maintain, the storing and
167 loading of offsets from the byte string is now handled by the macros that are
168 defined here.
169
170 The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
171 the config.h file, but can be overridden by using -D on the command line. This
172 is automated on Unix systems via the "configure" command. */
173
174 #if LINK_SIZE == 2
175
176 static inline void PUT(uschar* a, size_t n, unsigned short d)
177 {
178     a[n] = d >> 8;
179     a[n+1] = d & 255;
180 }
181
182 static inline short GET(const uschar* a, size_t n)
183 {
184     return ((a[n] << 8) | a[n + 1]);
185 }
186
187 #define MAX_PATTERN_SIZE (1 << 16)
188
189 #elif LINK_SIZE == 3
190
191 static inline void PUT(uschar* a, size_t n, unsigned d)
192 {
193     a[n] = d >> 16;
194     a[n+1] = d >> 8;
195     a[n+2] = d & 255;
196 }
197
198 static inline int GET(const uschar* a, size_t n)
199 {
200     return ((a[n] << 16) | (a[n+1] << 8) | a[n+2]);
201 }
202
203 #define MAX_PATTERN_SIZE (1 << 24)
204
205 #elif LINK_SIZE == 4
206
207 static inline void PUT(uschar* a, size_t n, unsigned d)
208 {
209     a[n] = d >> 24;
210     a[n+1] = d >> 16;
211     a[n+2] = d >> 8;
212     a[n+3] = d & 255;
213 }
214
215 static inline int GET(const uschar* a, size_t n)
216 {
217     return ((a[n] << 24) | (a[n+1] << 16) | (a[n+2] << 8) | a[n+3]);
218 }
219
220 #define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */
221
222 #else
223 #error LINK_SIZE must be either 2, 3, or 4
224 #endif
225
226
227 /* Convenience macro defined in terms of the others */
228
229 #define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE
230
231
232 /* PCRE uses some other 2-byte quantities that do not change when the size of
233 offsets changes. There are used for repeat counts and for other things such as
234 capturing parenthesis numbers in back references. */
235
236 static inline void PUT2(uschar* a, size_t n, unsigned short d)
237 {
238     a[n] = d >> 8;
239     a[n+1] = d & 255;
240 }
241
242 static inline short GET2(const uschar* a, size_t n)
243 {
244     return ((a[n] << 8) | a[n + 1]);
245 }
246
247 // FIXME: This can't be a static inline yet, because it's passed register values by some callers
248 // you can't take the address of a register
249 #define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2
250
251 /* When UTF-8 encoding is being used, a character is no longer just a single
252 byte. The macros for character handling generate simple sequences when used in
253 byte-mode, and more complicated ones for UTF-8 characters. */
254
255 /* Get the next UTF-8 character, not advancing the pointer, incrementing length
256 if there are extra bytes. This is called when we know we are in UTF-8 mode. */
257
258 #define GETUTF8CHARLEN(c, eptr, len) \
259   c = *eptr; \
260   if ((c & 0xc0) == 0xc0) \
261     { \
262     int gcii; \
263     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
264     int gcss = 6*gcaa; \
265     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
266     for (gcii = 1; gcii <= gcaa; gcii++) \
267       { \
268       gcss -= 6; \
269       c |= (eptr[gcii] & 0x3f) << gcss; \
270       } \
271     len += gcaa; \
272     }
273
274 /* Get the next UTF-8 character, advancing the pointer. This is called when we
275 know we are in UTF-8 mode. */
276
277 #define GETUTF8CHARINC(c, eptr) \
278 c = *eptr++; \
279 if ((c & 0xc0) == 0xc0) \
280 { \
281   int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
282     int gcss = 6*gcaa; \
283       c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
284         while (gcaa-- > 0) \
285         { \
286           gcss -= 6; \
287             c |= (*eptr++ & 0x3f) << gcss; \
288         } \
289 }
290
291 #define LEAD_OFFSET (0xd800 - (0x10000 >> 10))
292 #define SURROGATE_OFFSET (0x10000 - (0xd800 << 10) - 0xdc00)
293
294 #define IS_LEADING_SURROGATE(c) (((c) & ~0x3ff) == 0xd800)
295 #define IS_TRAILING_SURROGATE(c) (((c) & ~0x3ff) == 0xdc00)
296
297 #define DECODE_SURROGATE_PAIR(l, t) (((l) << 10) + (t) + SURROGATE_OFFSET)
298 #define LEADING_SURROGATE(c) (LEAD_OFFSET + ((c) >> 10))
299 #define TRAILING_SURROGATE(c) (0xdc00 + ((c) & 0x3FF))
300
301 #define GETCHAR(c, eptr) \
302   c = eptr[0]; \
303   if (IS_LEADING_SURROGATE(c)) \
304     c = DECODE_SURROGATE_PAIR(c, eptr[1])
305
306 #define GETCHARTEST(c, eptr) GETCHAR(c, eptr)
307
308 #define GETCHARINC(c, eptr) \
309   c = *eptr++; \
310   if (IS_LEADING_SURROGATE(c)) \
311     c = DECODE_SURROGATE_PAIR(c, *eptr++)
312
313 #define GETCHARINCTEST(c, eptr) GETCHARINC(c, eptr)
314
315 #define GETCHARLEN(c, eptr, len) \
316   c = eptr[0]; \
317   if (IS_LEADING_SURROGATE(c)) \
318     { \
319     c = DECODE_SURROGATE_PAIR(c, eptr[1]); \
320     ++len; \
321     }
322
323 #define GETCHARLENEND(c, eptr, end, len) \
324   c = eptr[0]; \
325   if (IS_LEADING_SURROGATE(c)) \
326     { \
327     c = DECODE_SURROGATE_PAIR(c, eptr + 1 < end ? eptr[1] : 0); \
328     ++len; \
329     }
330
331 #define ISMIDCHAR(c) IS_TRAILING_SURROGATE(c)
332
333 #define BACKCHAR(eptr) while(ISMIDCHAR(*eptr)) eptr--;
334
335 #define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
336 #define PCRE_REQCHSET      0x20000000  /* req_byte is set */
337 #define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
338 #define PCRE_ANCHORED      0x02000000  /* can't use partial with this regex */
339 #define PCRE_CASELESS      0x00000001
340 #define PCRE_MULTILINE     0x00000002
341
342 /* Negative values for the firstchar and reqchar variables */
343
344 #define REQ_UNSET (-2)
345 #define REQ_NONE  (-1)
346
347 /* The maximum remaining length of subject we are prepared to search for a
348 req_byte match. */
349
350 #define REQ_BYTE_MAX 1000
351
352 /* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
353 variable-length repeat, or a anything other than literal characters. */
354
355 #define REQ_CASELESS 0x0100    /* indicates caselessness */
356 #define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
357
358 /* Miscellaneous definitions */
359
360 typedef int BOOL;
361
362 /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
363 contain UTF-8 characters with values greater than 255. */
364
365 #define XCL_NOT    0x01    /* Flag: this is a negative class */
366 #define XCL_MAP    0x02    /* Flag: a 32-byte map is present */
367
368 #define XCL_END       0    /* Marks end of individual items */
369 #define XCL_SINGLE    1    /* Single item (one multibyte char) follows */
370 #define XCL_RANGE     2    /* A range (two multibyte chars) follows */
371
372 /* These are escaped items that aren't just an encoding of a particular data
373 value such as \n. They must have non-zero values, as check_escape() returns
374 their negation. Also, they must appear in the same order as in the opcode
375 definitions below, up to ESC_z. There's a dummy for OP_ANY because it
376 corresponds to "." rather than an escape sequence. The final one must be
377 ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
378 tests in the code for an escape greater than ESC_b and less than ESC_Z to
379 detect the types that may be repeated. These are the types that consume
380 characters. If any new escapes are put in between that don't consume a
381 character, that code will have to change. */
382
383 enum { ESC_B = 1, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W, ESC_w, ESC_REF };
384
385 /* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
386 that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
387 OP_EOD must correspond in order to the list of escapes immediately above.
388 Note that whenever this list is updated, the two macro definitions that follow
389 must also be updated to match. */
390
391 #define FOR_EACH_OPCODE(macro) \
392     macro(END) \
393     \
394     macro(NOT_WORD_BOUNDARY) \
395     macro(WORD_BOUNDARY) \
396     macro(NOT_DIGIT) \
397     macro(DIGIT) \
398     macro(NOT_WHITESPACE) \
399     macro(WHITESPACE) \
400     macro(NOT_WORDCHAR) \
401     macro(WORDCHAR) \
402     \
403     macro(ANY) \
404     \
405     macro(CIRC) \
406     macro(DOLL) \
407     macro(CHAR) \
408     macro(CHARNC) \
409     macro(ASCII_CHAR) \
410     macro(ASCII_LETTER_NC) \
411     macro(NOT) \
412     \
413     macro(STAR) \
414     macro(MINSTAR) \
415     macro(PLUS) \
416     macro(MINPLUS) \
417     macro(QUERY) \
418     macro(MINQUERY) \
419     macro(UPTO) \
420     macro(MINUPTO) \
421     macro(EXACT) \
422     \
423     macro(NOTSTAR) \
424     macro(NOTMINSTAR) \
425     macro(NOTPLUS) \
426     macro(NOTMINPLUS) \
427     macro(NOTQUERY) \
428     macro(NOTMINQUERY) \
429     macro(NOTUPTO) \
430     macro(NOTMINUPTO) \
431     macro(NOTEXACT) \
432     \
433     macro(TYPESTAR) \
434     macro(TYPEMINSTAR) \
435     macro(TYPEPLUS) \
436     macro(TYPEMINPLUS) \
437     macro(TYPEQUERY) \
438     macro(TYPEMINQUERY) \
439     macro(TYPEUPTO) \
440     macro(TYPEMINUPTO) \
441     macro(TYPEEXACT) \
442     \
443     macro(CRSTAR) \
444     macro(CRMINSTAR) \
445     macro(CRPLUS) \
446     macro(CRMINPLUS) \
447     macro(CRQUERY) \
448     macro(CRMINQUERY) \
449     macro(CRRANGE) \
450     macro(CRMINRANGE) \
451     \
452     macro(CLASS) \
453     macro(NCLASS) \
454     macro(XCLASS) \
455     \
456     macro(REF) \
457     \
458     macro(ALT) \
459     macro(KET) \
460     macro(KETRMAX) \
461     macro(KETRMIN) \
462     \
463     macro(ASSERT) \
464     macro(ASSERT_NOT) \
465     \
466     macro(ONCE) \
467     \
468     macro(BRAZERO) \
469     macro(BRAMINZERO) \
470     macro(BRANUMBER) \
471     macro(BRA)
472
473 #define OPCODE_ENUM_VALUE(opcode) OP_##opcode,
474 enum { FOR_EACH_OPCODE(OPCODE_ENUM_VALUE) };
475
476 /* WARNING WARNING WARNING: There is an implicit assumption in pcre.c and
477 study.c that all opcodes are less than 128 in value. This makes handling UTF-8
478 character sequences easier. */
479
480 /* The highest extraction number before we have to start using additional
481 bytes. (Originally PCRE didn't have support for extraction counts highter than
482 this number.) The value is limited by the number of opcodes left after OP_BRA,
483 i.e. 255 - OP_BRA. We actually set it a bit lower to leave room for additional
484 opcodes. */
485
486 #define EXTRACT_BASIC_MAX  100
487
488 /* This macro defines the length of fixed length operations in the compiled
489 regex. The lengths are used when searching for specific things, and also in the
490 debugging printing of a compiled regex. We use a macro so that it can be
491 defined close to the definitions of the opcodes themselves.
492
493 As things have been extended, some of these are no longer fixed lenths, but are
494 minima instead. For example, the length of a single-character repeat may vary
495 in UTF-8 mode. The code that uses this table must know about such things. */
496
497 #define OP_LENGTHS \
498   1,                             /* End                                    */ \
499   1, 1, 1, 1, 1, 1, 1, 1,        /* \B, \b, \D, \d, \S, \s, \W, \w         */ \
500   1,                             /* Any                                    */ \
501   1, 1,                          /* ^, $                                   */ \
502   2, 2,                          /* Char, Charnc - minimum lengths         */ \
503   2, 2,                          /* ASCII char or non-cased                */ \
504   2,                             /* not                                    */ \
505   /* Positive single-char repeats                            ** These are  */ \
506   2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
507   4, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
508   /* Negative single-char repeats - only for chars < 256                   */ \
509   2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
510   4, 4, 4,                       /* NOT upto, minupto, exact               */ \
511   /* Positive type repeats                                                 */ \
512   2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
513   4, 4, 4,                       /* Type upto, minupto, exact              */ \
514   /* Character class & ref repeats                                         */ \
515   1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
516   5, 5,                          /* CRRANGE, CRMINRANGE                    */ \
517  33,                             /* CLASS                                  */ \
518  33,                             /* NCLASS                                 */ \
519   0,                             /* XCLASS - variable length               */ \
520   3,                             /* REF                                    */ \
521   1+LINK_SIZE,                   /* Alt                                    */ \
522   1+LINK_SIZE,                   /* Ket                                    */ \
523   1+LINK_SIZE,                   /* KetRmax                                */ \
524   1+LINK_SIZE,                   /* KetRmin                                */ \
525   1+LINK_SIZE,                   /* Assert                                 */ \
526   1+LINK_SIZE,                   /* Assert not                             */ \
527   1+LINK_SIZE,                   /* Once                                   */ \
528   1, 1,                          /* BRAZERO, BRAMINZERO                    */ \
529   3,                             /* BRANUMBER                              */ \
530   1+LINK_SIZE                    /* BRA                                    */ \
531
532
533 /* The real format of the start of the pcre block; the index of names and the
534 code vector run on as long as necessary after the end. We store an explicit
535 offset to the name table so that if a regex is compiled on one host, saved, and
536 then run on another where the size of pointers is different, all might still
537 be well. For the case of compiled-on-4 and run-on-8, we include an extra
538 pointer that is always NULL. For future-proofing, a few dummy fields were
539 originally included - even though you can never get this planning right - but
540 there is only one left now.
541
542 NOTE NOTE NOTE:
543 Because people can now save and re-use compiled patterns, any additions to this
544 structure should be made at the end, and something earlier (e.g. a new
545 flag in the options or one of the dummy fields) should indicate that the new
546 fields are present. Currently PCRE always sets the dummy fields to zero.
547 NOTE NOTE NOTE:
548 */
549
550 typedef struct real_pcre {
551   pcre_uint32 size;               /* Total that was malloced */
552   pcre_uint32 options;
553
554   pcre_uint16 top_bracket;
555   pcre_uint16 top_backref;
556   pcre_uint16 first_byte;
557   pcre_uint16 req_byte;
558 } real_pcre;
559
560 /* Internal shared data tables. These are tables that are used by more than one
561  of the exported public functions. They have to be "external" in the C sense,
562  but are not part of the PCRE public API. The data for these tables is in the
563  pcre_tables.c module. */
564
565 #define _pcre_utf8_table1_size 6
566
567 extern const int    _pcre_utf8_table1[6];
568 extern const int    _pcre_utf8_table2[6];
569 extern const int    _pcre_utf8_table3[6];
570 extern const uschar _pcre_utf8_table4[0x40];
571
572 extern const uschar _pcre_default_tables[tables_length];
573
574 /* Structure for passing "static" information around between the functions
575 doing the compiling, so that they are thread-safe. */
576
577 typedef struct compile_data {
578     compile_data() {
579         lcc = _pcre_default_tables + lcc_offset;
580         fcc = _pcre_default_tables + fcc_offset;
581         cbits = _pcre_default_tables + cbits_offset;
582         ctypes = _pcre_default_tables + ctypes_offset;
583         start_code = 0;
584         start_pattern = 0;
585         top_backref = 0;
586         backref_map = 0;
587         req_varyopt = 0;
588     }
589     
590   const uschar *lcc;            /* Points to lower casing table */
591   const uschar *fcc;            /* Points to case-flipping table */
592   const uschar *cbits;          /* Points to character type table */
593   const uschar *ctypes;         /* Points to table of type maps */
594   const uschar *start_code;     /* The start of the compiled code */
595   const pcre_uchar *start_pattern;   /* The start of the pattern */
596   int  top_backref;             /* Maximum back reference */
597   unsigned int backref_map;     /* Bitmap of low back refs */
598   int  req_varyopt;             /* "After variable item" flag for reqbyte */
599 } compile_data;
600
601 /* Internal shared functions. These are functions that are used by more than
602 one of the exported public functions. They have to be "external" in the C
603 sense, but are not part of the PCRE public API. */
604
605 extern int         _pcre_ord2utf8(int, uschar *);
606 extern int         _pcre_ucp_othercase(const int);
607 extern BOOL        _pcre_xclass(int, const uschar *);
608
609 static inline bool isNewline(pcre_uchar nl)
610 {
611     return (nl == 0xA || nl == 0xD || nl == 0x2028 || nl == 0x2029);
612 }
613
614 #endif
615
616 #endif
617
618 /* End of pcre_internal.h */