chiark / gitweb /
Patch from Graham Inggs to add symbols support (Closes: #767374)
[pcre3.git] / pcretest.c
1 /*************************************************
2 *             PCRE testing program               *
3 *************************************************/
4
5 /* This program was hacked up as a tester for PCRE. I really should have
6 written it more tidily in the first place. Will I ever learn? It has grown and
7 been extended and consequently is now rather, er, *very* untidy in places. The
8 addition of 16-bit support has made it even worse. :-(
9
10 -----------------------------------------------------------------------------
11 Redistribution and use in source and binary forms, with or without
12 modification, are permitted provided that the following conditions are met:
13
14     * Redistributions of source code must retain the above copyright notice,
15       this list of conditions and the following disclaimer.
16
17     * Redistributions in binary form must reproduce the above copyright
18       notice, this list of conditions and the following disclaimer in the
19       documentation and/or other materials provided with the distribution.
20
21     * Neither the name of the University of Cambridge nor the names of its
22       contributors may be used to endorse or promote products derived from
23       this software without specific prior written permission.
24
25 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
29 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 POSSIBILITY OF SUCH DAMAGE.
36 -----------------------------------------------------------------------------
37 */
38
39 /* This program now supports the testing of all of the 8-bit, 16-bit, and
40 32-bit PCRE libraries in a single program. This is different from the modules
41 such as pcre_compile.c in the library itself, which are compiled separately for
42 each mode. If two modes are enabled, for example, pcre_compile.c is compiled
43 twice. By contrast, pcretest.c is compiled only once. Therefore, it must not
44 make use of any of the macros from pcre_internal.h that depend on
45 COMPILE_PCRE8, COMPILE_PCRE16, or COMPILE_PCRE32. It does, however, make use of
46 SUPPORT_PCRE8, SUPPORT_PCRE16, and SUPPORT_PCRE32 to ensure that it calls only
47 supported library functions. */
48
49 #ifdef HAVE_CONFIG_H
50 #include "config.h"
51 #endif
52
53 #include <ctype.h>
54 #include <stdio.h>
55 #include <string.h>
56 #include <stdlib.h>
57 #include <time.h>
58 #include <locale.h>
59 #include <errno.h>
60
61 /* Both libreadline and libedit are optionally supported. The user-supplied
62 original patch uses readline/readline.h for libedit, but in at least one system
63 it is installed as editline/readline.h, so the configuration code now looks for
64 that first, falling back to readline/readline.h. */
65
66 #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT)
67 #ifdef HAVE_UNISTD_H
68 #include <unistd.h>
69 #endif
70 #if defined(SUPPORT_LIBREADLINE)
71 #include <readline/readline.h>
72 #include <readline/history.h>
73 #else
74 #if defined(HAVE_EDITLINE_READLINE_H)
75 #include <editline/readline.h>
76 #else
77 #include <readline/readline.h>
78 #endif
79 #endif
80 #endif
81
82 /* A number of things vary for Windows builds. Originally, pcretest opened its
83 input and output without "b"; then I was told that "b" was needed in some
84 environments, so it was added for release 5.0 to both the input and output. (It
85 makes no difference on Unix-like systems.) Later I was told that it is wrong
86 for the input on Windows. I've now abstracted the modes into two macros that
87 are set here, to make it easier to fiddle with them, and removed "b" from the
88 input mode under Windows. */
89
90 #if defined(_WIN32) || defined(WIN32)
91 #include <io.h>                /* For _setmode() */
92 #include <fcntl.h>             /* For _O_BINARY */
93 #define INPUT_MODE   "r"
94 #define OUTPUT_MODE  "wb"
95
96 #ifndef isatty
97 #define isatty _isatty         /* This is what Windows calls them, I'm told, */
98 #endif                         /* though in some environments they seem to   */
99                                /* be already defined, hence the #ifndefs.    */
100 #ifndef fileno
101 #define fileno _fileno
102 #endif
103
104 /* A user sent this fix for Borland Builder 5 under Windows. */
105
106 #ifdef __BORLANDC__
107 #define _setmode(handle, mode) setmode(handle, mode)
108 #endif
109
110 /* Not Windows */
111
112 #else
113 #include <sys/time.h>          /* These two includes are needed */
114 #include <sys/resource.h>      /* for setrlimit(). */
115 #if defined NATIVE_ZOS         /* z/OS uses non-binary I/O */
116 #define INPUT_MODE   "r"
117 #define OUTPUT_MODE  "w"
118 #else
119 #define INPUT_MODE   "rb"
120 #define OUTPUT_MODE  "wb"
121 #endif
122 #endif
123
124 #ifdef __VMS
125 #include <ssdef.h>
126 void vms_setsymbol( char *, char *, int );
127 #endif
128
129
130 #define PRIV(name) name
131
132 /* We have to include pcre_internal.h because we need the internal info for
133 displaying the results of pcre_study() and we also need to know about the
134 internal macros, structures, and other internal data values; pcretest has
135 "inside information" compared to a program that strictly follows the PCRE API.
136
137 Although pcre_internal.h does itself include pcre.h, we explicitly include it
138 here before pcre_internal.h so that the PCRE_EXP_xxx macros get set
139 appropriately for an application, not for building PCRE. */
140
141 #include "pcre.h"
142 #include "pcre_internal.h"
143
144 /* The pcre_printint() function, which prints the internal form of a compiled
145 regex, is held in a separate file so that (a) it can be compiled in either
146 8-, 16- or 32-bit mode, and (b) it can be #included directly in pcre_compile.c
147 when that is compiled in debug mode. */
148
149 #ifdef SUPPORT_PCRE8
150 void pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths);
151 #endif
152 #ifdef SUPPORT_PCRE16
153 void pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths);
154 #endif
155 #ifdef SUPPORT_PCRE32
156 void pcre32_printint(pcre *external_re, FILE *f, BOOL print_lengths);
157 #endif
158
159 /* We need access to some of the data tables that PCRE uses. So as not to have
160 to keep two copies, we include the source files here, changing the names of the
161 external symbols to prevent clashes. */
162
163 #define PCRE_INCLUDED
164
165 #include "pcre_tables.c"
166 #include "pcre_ucd.c"
167
168 /* The definition of the macro PRINTABLE, which determines whether to print an
169 output character as-is or as a hex value when showing compiled patterns, is
170 the same as in the printint.src file. We uses it here in cases when the locale
171 has not been explicitly changed, so as to get consistent output from systems
172 that differ in their output from isprint() even in the "C" locale. */
173
174 #ifdef EBCDIC
175 #define PRINTABLE(c) ((c) >= 64 && (c) < 255)
176 #else
177 #define PRINTABLE(c) ((c) >= 32 && (c) < 127)
178 #endif
179
180 #define PRINTOK(c) (locale_set? isprint(c) : PRINTABLE(c))
181
182 /* Posix support is disabled in 16 or 32 bit only mode. */
183 #if !defined SUPPORT_PCRE8 && !defined NOPOSIX
184 #define NOPOSIX
185 #endif
186
187 /* It is possible to compile this test program without including support for
188 testing the POSIX interface, though this is not available via the standard
189 Makefile. */
190
191 #if !defined NOPOSIX
192 #include "pcreposix.h"
193 #endif
194
195 /* It is also possible, originally for the benefit of a version that was
196 imported into Exim, to build pcretest without support for UTF8 or UTF16 (define
197 NOUTF), without the interface to the DFA matcher (NODFA). In fact, we
198 automatically cut out the UTF support if PCRE is built without it. */
199
200 #ifndef SUPPORT_UTF
201 #ifndef NOUTF
202 #define NOUTF
203 #endif
204 #endif
205
206 /* To make the code a bit tidier for 8/16/32-bit support, we define macros
207 for all the pcre[16]_xxx functions (except pcre16_fullinfo, which is called
208 only from one place and is handled differently). I couldn't dream up any way of
209 using a single macro to do this in a generic way, because of the many different
210 argument requirements. We know that at least one of SUPPORT_PCRE8 and
211 SUPPORT_PCRE16 must be set. First define macros for each individual mode; then
212 use these in the definitions of generic macros.
213
214 **** Special note about the PCHARSxxx macros: the address of the string to be
215 printed is always given as two arguments: a base address followed by an offset.
216 The base address is cast to the correct data size for 8 or 16 bit data; the
217 offset is in units of this size. If the string were given as base+offset in one
218 argument, the casting might be incorrectly applied. */
219
220 #ifdef SUPPORT_PCRE8
221
222 #define PCHARS8(lv, p, offset, len, f) \
223   lv = pchars((pcre_uint8 *)(p) + offset, len, f)
224
225 #define PCHARSV8(p, offset, len, f) \
226   (void)pchars((pcre_uint8 *)(p) + offset, len, f)
227
228 #define READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re) \
229   p = read_capture_name8(p, cn8, re)
230
231 #define STRLEN8(p) ((int)strlen((char *)p))
232
233 #define SET_PCRE_CALLOUT8(callout) \
234   pcre_callout = callout
235
236 #define SET_PCRE_STACK_GUARD8(stack_guard) \
237   pcre_stack_guard = stack_guard
238
239 #define PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata) \
240    pcre_assign_jit_stack(extra, callback, userdata)
241
242 #define PCRE_COMPILE8(re, pat, options, error, erroffset, tables) \
243   re = pcre_compile((char *)pat, options, error, erroffset, tables)
244
245 #define PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \
246     namesptr, cbuffer, size) \
247   rc = pcre_copy_named_substring(re, (char *)bptr, offsets, count, \
248     (char *)namesptr, cbuffer, size)
249
250 #define PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size) \
251   rc = pcre_copy_substring((char *)bptr, offsets, count, i, cbuffer, size)
252
253 #define PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \
254     offsets, size_offsets, workspace, size_workspace) \
255   count = pcre_dfa_exec(re, extra, (char *)bptr, len, start_offset, options, \
256     offsets, size_offsets, workspace, size_workspace)
257
258 #define PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \
259     offsets, size_offsets) \
260   count = pcre_exec(re, extra, (char *)bptr, len, start_offset, options, \
261     offsets, size_offsets)
262
263 #define PCRE_FREE_STUDY8(extra) \
264   pcre_free_study(extra)
265
266 #define PCRE_FREE_SUBSTRING8(substring) \
267   pcre_free_substring(substring)
268
269 #define PCRE_FREE_SUBSTRING_LIST8(listptr) \
270   pcre_free_substring_list(listptr)
271
272 #define PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \
273     getnamesptr, subsptr) \
274   rc = pcre_get_named_substring(re, (char *)bptr, offsets, count, \
275     (char *)getnamesptr, subsptr)
276
277 #define PCRE_GET_STRINGNUMBER8(n, rc, ptr) \
278   n = pcre_get_stringnumber(re, (char *)ptr)
279
280 #define PCRE_GET_SUBSTRING8(rc, bptr, offsets, count, i, subsptr) \
281   rc = pcre_get_substring((char *)bptr, offsets, count, i, subsptr)
282
283 #define PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr) \
284   rc = pcre_get_substring_list((const char *)bptr, offsets, count, listptr)
285
286 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables) \
287   rc = pcre_pattern_to_host_byte_order(re, extra, tables)
288
289 #define PCRE_PRINTINT8(re, outfile, debug_lengths) \
290   pcre_printint(re, outfile, debug_lengths)
291
292 #define PCRE_STUDY8(extra, re, options, error) \
293   extra = pcre_study(re, options, error)
294
295 #define PCRE_JIT_STACK_ALLOC8(startsize, maxsize) \
296   pcre_jit_stack_alloc(startsize, maxsize)
297
298 #define PCRE_JIT_STACK_FREE8(stack) \
299   pcre_jit_stack_free(stack)
300
301 #define pcre8_maketables pcre_maketables
302
303 #endif /* SUPPORT_PCRE8 */
304
305 /* -----------------------------------------------------------*/
306
307 #ifdef SUPPORT_PCRE16
308
309 #define PCHARS16(lv, p, offset, len, f) \
310   lv = pchars16((PCRE_SPTR16)(p) + offset, len, f)
311
312 #define PCHARSV16(p, offset, len, f) \
313   (void)pchars16((PCRE_SPTR16)(p) + offset, len, f)
314
315 #define READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re) \
316   p = read_capture_name16(p, cn16, re)
317
318 #define STRLEN16(p) ((int)strlen16((PCRE_SPTR16)p))
319
320 #define SET_PCRE_CALLOUT16(callout) \
321   pcre16_callout = (int (*)(pcre16_callout_block *))callout
322
323 #define SET_PCRE_STACK_GUARD16(stack_guard) \
324   pcre16_stack_guard = (int (*)(void))stack_guard
325
326 #define PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata) \
327   pcre16_assign_jit_stack((pcre16_extra *)extra, \
328     (pcre16_jit_callback)callback, userdata)
329
330 #define PCRE_COMPILE16(re, pat, options, error, erroffset, tables) \
331   re = (pcre *)pcre16_compile((PCRE_SPTR16)pat, options, error, erroffset, \
332     tables)
333
334 #define PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \
335     namesptr, cbuffer, size) \
336   rc = pcre16_copy_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \
337     count, (PCRE_SPTR16)namesptr, (PCRE_UCHAR16 *)cbuffer, size/2)
338
339 #define PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size) \
340   rc = pcre16_copy_substring((PCRE_SPTR16)bptr, offsets, count, i, \
341     (PCRE_UCHAR16 *)cbuffer, size/2)
342
343 #define PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \
344     offsets, size_offsets, workspace, size_workspace) \
345   count = pcre16_dfa_exec((pcre16 *)re, (pcre16_extra *)extra, \
346     (PCRE_SPTR16)bptr, len, start_offset, options, offsets, size_offsets, \
347     workspace, size_workspace)
348
349 #define PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \
350     offsets, size_offsets) \
351   count = pcre16_exec((pcre16 *)re, (pcre16_extra *)extra, (PCRE_SPTR16)bptr, \
352     len, start_offset, options, offsets, size_offsets)
353
354 #define PCRE_FREE_STUDY16(extra) \
355   pcre16_free_study((pcre16_extra *)extra)
356
357 #define PCRE_FREE_SUBSTRING16(substring) \
358   pcre16_free_substring((PCRE_SPTR16)substring)
359
360 #define PCRE_FREE_SUBSTRING_LIST16(listptr) \
361   pcre16_free_substring_list((PCRE_SPTR16 *)listptr)
362
363 #define PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \
364     getnamesptr, subsptr) \
365   rc = pcre16_get_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \
366     count, (PCRE_SPTR16)getnamesptr, (PCRE_SPTR16 *)(void*)subsptr)
367
368 #define PCRE_GET_STRINGNUMBER16(n, rc, ptr) \
369   n = pcre16_get_stringnumber(re, (PCRE_SPTR16)ptr)
370
371 #define PCRE_GET_SUBSTRING16(rc, bptr, offsets, count, i, subsptr) \
372   rc = pcre16_get_substring((PCRE_SPTR16)bptr, offsets, count, i, \
373     (PCRE_SPTR16 *)(void*)subsptr)
374
375 #define PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr) \
376   rc = pcre16_get_substring_list((PCRE_SPTR16)bptr, offsets, count, \
377     (PCRE_SPTR16 **)(void*)listptr)
378
379 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables) \
380   rc = pcre16_pattern_to_host_byte_order((pcre16 *)re, (pcre16_extra *)extra, \
381     tables)
382
383 #define PCRE_PRINTINT16(re, outfile, debug_lengths) \
384   pcre16_printint(re, outfile, debug_lengths)
385
386 #define PCRE_STUDY16(extra, re, options, error) \
387   extra = (pcre_extra *)pcre16_study((pcre16 *)re, options, error)
388
389 #define PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \
390   (pcre_jit_stack *)pcre16_jit_stack_alloc(startsize, maxsize)
391
392 #define PCRE_JIT_STACK_FREE16(stack) \
393   pcre16_jit_stack_free((pcre16_jit_stack *)stack)
394
395 #endif /* SUPPORT_PCRE16 */
396
397 /* -----------------------------------------------------------*/
398
399 #ifdef SUPPORT_PCRE32
400
401 #define PCHARS32(lv, p, offset, len, f) \
402   lv = pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f)
403
404 #define PCHARSV32(p, offset, len, f)                \
405   (void)pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f)
406
407 #define READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re) \
408   p = read_capture_name32(p, cn32, re)
409
410 #define STRLEN32(p) ((int)strlen32((PCRE_SPTR32)p))
411
412 #define SET_PCRE_CALLOUT32(callout) \
413   pcre32_callout = (int (*)(pcre32_callout_block *))callout
414
415 #define SET_PCRE_STACK_GUARD32(stack_guard) \
416   pcre32_stack_guard = (int (*)(void))stack_guard
417
418 #define PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata) \
419   pcre32_assign_jit_stack((pcre32_extra *)extra, \
420     (pcre32_jit_callback)callback, userdata)
421
422 #define PCRE_COMPILE32(re, pat, options, error, erroffset, tables) \
423   re = (pcre *)pcre32_compile((PCRE_SPTR32)pat, options, error, erroffset, \
424     tables)
425
426 #define PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \
427     namesptr, cbuffer, size) \
428   rc = pcre32_copy_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \
429     count, (PCRE_SPTR32)namesptr, (PCRE_UCHAR32 *)cbuffer, size/2)
430
431 #define PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size) \
432   rc = pcre32_copy_substring((PCRE_SPTR32)bptr, offsets, count, i, \
433     (PCRE_UCHAR32 *)cbuffer, size/2)
434
435 #define PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \
436     offsets, size_offsets, workspace, size_workspace) \
437   count = pcre32_dfa_exec((pcre32 *)re, (pcre32_extra *)extra, \
438     (PCRE_SPTR32)bptr, len, start_offset, options, offsets, size_offsets, \
439     workspace, size_workspace)
440
441 #define PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \
442     offsets, size_offsets) \
443   count = pcre32_exec((pcre32 *)re, (pcre32_extra *)extra, (PCRE_SPTR32)bptr, \
444     len, start_offset, options, offsets, size_offsets)
445
446 #define PCRE_FREE_STUDY32(extra) \
447   pcre32_free_study((pcre32_extra *)extra)
448
449 #define PCRE_FREE_SUBSTRING32(substring) \
450   pcre32_free_substring((PCRE_SPTR32)substring)
451
452 #define PCRE_FREE_SUBSTRING_LIST32(listptr) \
453   pcre32_free_substring_list((PCRE_SPTR32 *)listptr)
454
455 #define PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \
456     getnamesptr, subsptr) \
457   rc = pcre32_get_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \
458     count, (PCRE_SPTR32)getnamesptr, (PCRE_SPTR32 *)(void*)subsptr)
459
460 #define PCRE_GET_STRINGNUMBER32(n, rc, ptr) \
461   n = pcre32_get_stringnumber(re, (PCRE_SPTR32)ptr)
462
463 #define PCRE_GET_SUBSTRING32(rc, bptr, offsets, count, i, subsptr) \
464   rc = pcre32_get_substring((PCRE_SPTR32)bptr, offsets, count, i, \
465     (PCRE_SPTR32 *)(void*)subsptr)
466
467 #define PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr) \
468   rc = pcre32_get_substring_list((PCRE_SPTR32)bptr, offsets, count, \
469     (PCRE_SPTR32 **)(void*)listptr)
470
471 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables) \
472   rc = pcre32_pattern_to_host_byte_order((pcre32 *)re, (pcre32_extra *)extra, \
473     tables)
474
475 #define PCRE_PRINTINT32(re, outfile, debug_lengths) \
476   pcre32_printint(re, outfile, debug_lengths)
477
478 #define PCRE_STUDY32(extra, re, options, error) \
479   extra = (pcre_extra *)pcre32_study((pcre32 *)re, options, error)
480
481 #define PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \
482   (pcre_jit_stack *)pcre32_jit_stack_alloc(startsize, maxsize)
483
484 #define PCRE_JIT_STACK_FREE32(stack) \
485   pcre32_jit_stack_free((pcre32_jit_stack *)stack)
486
487 #endif /* SUPPORT_PCRE32 */
488
489
490 /* ----- More than one mode is supported; a runtime test is needed, except for
491 pcre_config(), and the JIT stack functions, when it doesn't matter which
492 available version is called. ----- */
493
494 enum {
495   PCRE8_MODE,
496   PCRE16_MODE,
497   PCRE32_MODE
498 };
499
500 #if (defined (SUPPORT_PCRE8) + defined (SUPPORT_PCRE16) + \
501      defined (SUPPORT_PCRE32)) >= 2
502
503 #define CHAR_SIZE (1 << pcre_mode)
504
505 /* There doesn't seem to be an easy way of writing these macros that can cope
506 with the 3 pairs of bit sizes plus all three bit sizes. So just handle all the
507 cases separately. */
508
509 /* ----- All three modes supported ----- */
510
511 #if defined(SUPPORT_PCRE8) && defined(SUPPORT_PCRE16) && defined(SUPPORT_PCRE32)
512
513 #define PCHARS(lv, p, offset, len, f) \
514   if (pcre_mode == PCRE32_MODE) \
515     PCHARS32(lv, p, offset, len, f); \
516   else if (pcre_mode == PCRE16_MODE) \
517     PCHARS16(lv, p, offset, len, f); \
518   else \
519     PCHARS8(lv, p, offset, len, f)
520
521 #define PCHARSV(p, offset, len, f) \
522   if (pcre_mode == PCRE32_MODE) \
523     PCHARSV32(p, offset, len, f); \
524   else if (pcre_mode == PCRE16_MODE) \
525     PCHARSV16(p, offset, len, f); \
526   else \
527     PCHARSV8(p, offset, len, f)
528
529 #define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \
530   if (pcre_mode == PCRE32_MODE) \
531     READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re); \
532   else if (pcre_mode == PCRE16_MODE) \
533     READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re); \
534   else \
535     READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re)
536
537 #define SET_PCRE_CALLOUT(callout) \
538   if (pcre_mode == PCRE32_MODE) \
539     SET_PCRE_CALLOUT32(callout); \
540   else if (pcre_mode == PCRE16_MODE) \
541     SET_PCRE_CALLOUT16(callout); \
542   else \
543     SET_PCRE_CALLOUT8(callout)
544
545 #define SET_PCRE_STACK_GUARD(stack_guard) \
546   if (pcre_mode == PCRE32_MODE) \
547     SET_PCRE_STACK_GUARD32(stack_guard); \
548   else if (pcre_mode == PCRE16_MODE) \
549     SET_PCRE_STACK_GUARD16(stack_guard); \
550   else \
551     SET_PCRE_STACK_GUARD8(stack_guard)
552
553 #define STRLEN(p) (pcre_mode == PCRE32_MODE ? STRLEN32(p) : pcre_mode == PCRE16_MODE ? STRLEN16(p) : STRLEN8(p))
554
555 #define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \
556   if (pcre_mode == PCRE32_MODE) \
557     PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata); \
558   else if (pcre_mode == PCRE16_MODE) \
559     PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata); \
560   else \
561     PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata)
562
563 #define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \
564   if (pcre_mode == PCRE32_MODE) \
565     PCRE_COMPILE32(re, pat, options, error, erroffset, tables); \
566   else if (pcre_mode == PCRE16_MODE) \
567     PCRE_COMPILE16(re, pat, options, error, erroffset, tables); \
568   else \
569     PCRE_COMPILE8(re, pat, options, error, erroffset, tables)
570
571 #define PCRE_CONFIG pcre_config
572
573 #define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \
574     namesptr, cbuffer, size) \
575   if (pcre_mode == PCRE32_MODE) \
576     PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \
577       namesptr, cbuffer, size); \
578   else if (pcre_mode == PCRE16_MODE) \
579     PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \
580       namesptr, cbuffer, size); \
581   else \
582     PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \
583       namesptr, cbuffer, size)
584
585 #define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \
586   if (pcre_mode == PCRE32_MODE) \
587     PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size); \
588   else if (pcre_mode == PCRE16_MODE) \
589     PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size); \
590   else \
591     PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size)
592
593 #define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \
594     offsets, size_offsets, workspace, size_workspace) \
595   if (pcre_mode == PCRE32_MODE) \
596     PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \
597       offsets, size_offsets, workspace, size_workspace); \
598   else if (pcre_mode == PCRE16_MODE) \
599     PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \
600       offsets, size_offsets, workspace, size_workspace); \
601   else \
602     PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \
603       offsets, size_offsets, workspace, size_workspace)
604
605 #define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \
606     offsets, size_offsets) \
607   if (pcre_mode == PCRE32_MODE) \
608     PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \
609       offsets, size_offsets); \
610   else if (pcre_mode == PCRE16_MODE) \
611     PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \
612       offsets, size_offsets); \
613   else \
614     PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \
615       offsets, size_offsets)
616
617 #define PCRE_FREE_STUDY(extra) \
618   if (pcre_mode == PCRE32_MODE) \
619     PCRE_FREE_STUDY32(extra); \
620   else if (pcre_mode == PCRE16_MODE) \
621     PCRE_FREE_STUDY16(extra); \
622   else \
623     PCRE_FREE_STUDY8(extra)
624
625 #define PCRE_FREE_SUBSTRING(substring) \
626   if (pcre_mode == PCRE32_MODE) \
627     PCRE_FREE_SUBSTRING32(substring); \
628   else if (pcre_mode == PCRE16_MODE) \
629     PCRE_FREE_SUBSTRING16(substring); \
630   else \
631     PCRE_FREE_SUBSTRING8(substring)
632
633 #define PCRE_FREE_SUBSTRING_LIST(listptr) \
634   if (pcre_mode == PCRE32_MODE) \
635     PCRE_FREE_SUBSTRING_LIST32(listptr); \
636   else if (pcre_mode == PCRE16_MODE) \
637     PCRE_FREE_SUBSTRING_LIST16(listptr); \
638   else \
639     PCRE_FREE_SUBSTRING_LIST8(listptr)
640
641 #define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \
642     getnamesptr, subsptr) \
643   if (pcre_mode == PCRE32_MODE) \
644     PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \
645       getnamesptr, subsptr); \
646   else if (pcre_mode == PCRE16_MODE) \
647     PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \
648       getnamesptr, subsptr); \
649   else \
650     PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \
651       getnamesptr, subsptr)
652
653 #define PCRE_GET_STRINGNUMBER(n, rc, ptr) \
654   if (pcre_mode == PCRE32_MODE) \
655     PCRE_GET_STRINGNUMBER32(n, rc, ptr); \
656   else if (pcre_mode == PCRE16_MODE) \
657     PCRE_GET_STRINGNUMBER16(n, rc, ptr); \
658   else \
659     PCRE_GET_STRINGNUMBER8(n, rc, ptr)
660
661 #define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \
662   if (pcre_mode == PCRE32_MODE) \
663     PCRE_GET_SUBSTRING32(rc, bptr, use_offsets, count, i, subsptr); \
664   else if (pcre_mode == PCRE16_MODE) \
665     PCRE_GET_SUBSTRING16(rc, bptr, use_offsets, count, i, subsptr); \
666   else \
667     PCRE_GET_SUBSTRING8(rc, bptr, use_offsets, count, i, subsptr)
668
669 #define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \
670   if (pcre_mode == PCRE32_MODE) \
671     PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr); \
672   else if (pcre_mode == PCRE16_MODE) \
673     PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr); \
674   else \
675     PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr)
676
677 #define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \
678   (pcre_mode == PCRE32_MODE ? \
679      PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \
680     : pcre_mode == PCRE16_MODE ? \
681       PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \
682       : PCRE_JIT_STACK_ALLOC8(startsize, maxsize))
683
684 #define PCRE_JIT_STACK_FREE(stack) \
685   if (pcre_mode == PCRE32_MODE) \
686     PCRE_JIT_STACK_FREE32(stack); \
687   else if (pcre_mode == PCRE16_MODE) \
688     PCRE_JIT_STACK_FREE16(stack); \
689   else \
690     PCRE_JIT_STACK_FREE8(stack)
691
692 #define PCRE_MAKETABLES \
693   (pcre_mode == PCRE32_MODE ? pcre32_maketables() : pcre_mode == PCRE16_MODE ? pcre16_maketables() : pcre_maketables())
694
695 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \
696   if (pcre_mode == PCRE32_MODE) \
697     PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables); \
698   else if (pcre_mode == PCRE16_MODE) \
699     PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables); \
700   else \
701     PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables)
702
703 #define PCRE_PRINTINT(re, outfile, debug_lengths) \
704   if (pcre_mode == PCRE32_MODE) \
705     PCRE_PRINTINT32(re, outfile, debug_lengths); \
706   else if (pcre_mode == PCRE16_MODE) \
707     PCRE_PRINTINT16(re, outfile, debug_lengths); \
708   else \
709     PCRE_PRINTINT8(re, outfile, debug_lengths)
710
711 #define PCRE_STUDY(extra, re, options, error) \
712   if (pcre_mode == PCRE32_MODE) \
713     PCRE_STUDY32(extra, re, options, error); \
714   else if (pcre_mode == PCRE16_MODE) \
715     PCRE_STUDY16(extra, re, options, error); \
716   else \
717     PCRE_STUDY8(extra, re, options, error)
718
719
720 /* ----- Two out of three modes are supported ----- */
721
722 #else
723
724 /* We can use some macro trickery to make a single set of definitions work in
725 the three different cases. */
726
727 /* ----- 32-bit and 16-bit but not 8-bit supported ----- */
728
729 #if defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE16)
730 #define BITONE 32
731 #define BITTWO 16
732
733 /* ----- 32-bit and 8-bit but not 16-bit supported ----- */
734
735 #elif defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE8)
736 #define BITONE 32
737 #define BITTWO 8
738
739 /* ----- 16-bit and 8-bit but not 32-bit supported ----- */
740
741 #else
742 #define BITONE 16
743 #define BITTWO 8
744 #endif
745
746 #define glue(a,b) a##b
747 #define G(a,b) glue(a,b)
748
749
750 /* ----- Common macros for two-mode cases ----- */
751
752 #define PCHARS(lv, p, offset, len, f) \
753   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
754     G(PCHARS,BITONE)(lv, p, offset, len, f); \
755   else \
756     G(PCHARS,BITTWO)(lv, p, offset, len, f)
757
758 #define PCHARSV(p, offset, len, f) \
759   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
760     G(PCHARSV,BITONE)(p, offset, len, f); \
761   else \
762     G(PCHARSV,BITTWO)(p, offset, len, f)
763
764 #define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \
765   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
766     G(READ_CAPTURE_NAME,BITONE)(p, cn8, cn16, cn32, re); \
767   else \
768     G(READ_CAPTURE_NAME,BITTWO)(p, cn8, cn16, cn32, re)
769
770 #define SET_PCRE_CALLOUT(callout) \
771   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
772     G(SET_PCRE_CALLOUT,BITONE)(callout); \
773   else \
774     G(SET_PCRE_CALLOUT,BITTWO)(callout)
775
776 #define SET_PCRE_STACK_GUARD(stack_guard) \
777   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
778     G(SET_PCRE_STACK_GUARD,BITONE)(stack_guard); \
779   else \
780     G(SET_PCRE_STACK_GUARD,BITTWO)(stack_guard)
781
782 #define STRLEN(p) ((pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \
783   G(STRLEN,BITONE)(p) : G(STRLEN,BITTWO)(p))
784
785 #define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \
786   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
787     G(PCRE_ASSIGN_JIT_STACK,BITONE)(extra, callback, userdata); \
788   else \
789     G(PCRE_ASSIGN_JIT_STACK,BITTWO)(extra, callback, userdata)
790
791 #define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \
792   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
793     G(PCRE_COMPILE,BITONE)(re, pat, options, error, erroffset, tables); \
794   else \
795     G(PCRE_COMPILE,BITTWO)(re, pat, options, error, erroffset, tables)
796
797 #define PCRE_CONFIG G(G(pcre,BITONE),_config)
798
799 #define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \
800     namesptr, cbuffer, size) \
801   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
802     G(PCRE_COPY_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \
803       namesptr, cbuffer, size); \
804   else \
805     G(PCRE_COPY_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \
806       namesptr, cbuffer, size)
807
808 #define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \
809   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
810     G(PCRE_COPY_SUBSTRING,BITONE)(rc, bptr, offsets, count, i, cbuffer, size); \
811   else \
812     G(PCRE_COPY_SUBSTRING,BITTWO)(rc, bptr, offsets, count, i, cbuffer, size)
813
814 #define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \
815     offsets, size_offsets, workspace, size_workspace) \
816   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
817     G(PCRE_DFA_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \
818       offsets, size_offsets, workspace, size_workspace); \
819   else \
820     G(PCRE_DFA_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \
821       offsets, size_offsets, workspace, size_workspace)
822
823 #define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \
824     offsets, size_offsets) \
825   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
826     G(PCRE_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \
827       offsets, size_offsets); \
828   else \
829     G(PCRE_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \
830       offsets, size_offsets)
831
832 #define PCRE_FREE_STUDY(extra) \
833   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
834     G(PCRE_FREE_STUDY,BITONE)(extra); \
835   else \
836     G(PCRE_FREE_STUDY,BITTWO)(extra)
837
838 #define PCRE_FREE_SUBSTRING(substring) \
839   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
840     G(PCRE_FREE_SUBSTRING,BITONE)(substring); \
841   else \
842     G(PCRE_FREE_SUBSTRING,BITTWO)(substring)
843
844 #define PCRE_FREE_SUBSTRING_LIST(listptr) \
845   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
846     G(PCRE_FREE_SUBSTRING_LIST,BITONE)(listptr); \
847   else \
848     G(PCRE_FREE_SUBSTRING_LIST,BITTWO)(listptr)
849
850 #define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \
851     getnamesptr, subsptr) \
852   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
853     G(PCRE_GET_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \
854       getnamesptr, subsptr); \
855   else \
856     G(PCRE_GET_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \
857       getnamesptr, subsptr)
858
859 #define PCRE_GET_STRINGNUMBER(n, rc, ptr) \
860   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
861     G(PCRE_GET_STRINGNUMBER,BITONE)(n, rc, ptr); \
862   else \
863     G(PCRE_GET_STRINGNUMBER,BITTWO)(n, rc, ptr)
864
865 #define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \
866   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
867     G(PCRE_GET_SUBSTRING,BITONE)(rc, bptr, use_offsets, count, i, subsptr); \
868   else \
869     G(PCRE_GET_SUBSTRING,BITTWO)(rc, bptr, use_offsets, count, i, subsptr)
870
871 #define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \
872   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
873     G(PCRE_GET_SUBSTRING_LIST,BITONE)(rc, bptr, offsets, count, listptr); \
874   else \
875     G(PCRE_GET_SUBSTRING_LIST,BITTWO)(rc, bptr, offsets, count, listptr)
876
877 #define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \
878   (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \
879      G(PCRE_JIT_STACK_ALLOC,BITONE)(startsize, maxsize) \
880     : G(PCRE_JIT_STACK_ALLOC,BITTWO)(startsize, maxsize)
881
882 #define PCRE_JIT_STACK_FREE(stack) \
883   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
884     G(PCRE_JIT_STACK_FREE,BITONE)(stack); \
885   else \
886     G(PCRE_JIT_STACK_FREE,BITTWO)(stack)
887
888 #define PCRE_MAKETABLES \
889   (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \
890     G(G(pcre,BITONE),_maketables)() : G(G(pcre,BITTWO),_maketables)()
891
892 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \
893   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
894     G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITONE)(rc, re, extra, tables); \
895   else \
896     G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITTWO)(rc, re, extra, tables)
897
898 #define PCRE_PRINTINT(re, outfile, debug_lengths) \
899   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
900     G(PCRE_PRINTINT,BITONE)(re, outfile, debug_lengths); \
901   else \
902     G(PCRE_PRINTINT,BITTWO)(re, outfile, debug_lengths)
903
904 #define PCRE_STUDY(extra, re, options, error) \
905   if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \
906     G(PCRE_STUDY,BITONE)(extra, re, options, error); \
907   else \
908     G(PCRE_STUDY,BITTWO)(extra, re, options, error)
909
910 #endif  /* Two out of three modes */
911
912 /* ----- End of cases where more than one mode is supported ----- */
913
914
915 /* ----- Only 8-bit mode is supported ----- */
916
917 #elif defined SUPPORT_PCRE8
918 #define CHAR_SIZE                 1
919 #define PCHARS                    PCHARS8
920 #define PCHARSV                   PCHARSV8
921 #define READ_CAPTURE_NAME         READ_CAPTURE_NAME8
922 #define SET_PCRE_CALLOUT          SET_PCRE_CALLOUT8
923 #define SET_PCRE_STACK_GUARD      SET_PCRE_STACK_GUARD8
924 #define STRLEN                    STRLEN8
925 #define PCRE_ASSIGN_JIT_STACK     PCRE_ASSIGN_JIT_STACK8
926 #define PCRE_COMPILE              PCRE_COMPILE8
927 #define PCRE_CONFIG               pcre_config
928 #define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING8
929 #define PCRE_COPY_SUBSTRING       PCRE_COPY_SUBSTRING8
930 #define PCRE_DFA_EXEC             PCRE_DFA_EXEC8
931 #define PCRE_EXEC                 PCRE_EXEC8
932 #define PCRE_FREE_STUDY           PCRE_FREE_STUDY8
933 #define PCRE_FREE_SUBSTRING       PCRE_FREE_SUBSTRING8
934 #define PCRE_FREE_SUBSTRING_LIST  PCRE_FREE_SUBSTRING_LIST8
935 #define PCRE_GET_NAMED_SUBSTRING  PCRE_GET_NAMED_SUBSTRING8
936 #define PCRE_GET_STRINGNUMBER     PCRE_GET_STRINGNUMBER8
937 #define PCRE_GET_SUBSTRING        PCRE_GET_SUBSTRING8
938 #define PCRE_GET_SUBSTRING_LIST   PCRE_GET_SUBSTRING_LIST8
939 #define PCRE_JIT_STACK_ALLOC      PCRE_JIT_STACK_ALLOC8
940 #define PCRE_JIT_STACK_FREE       PCRE_JIT_STACK_FREE8
941 #define PCRE_MAKETABLES           pcre_maketables()
942 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER8
943 #define PCRE_PRINTINT             PCRE_PRINTINT8
944 #define PCRE_STUDY                PCRE_STUDY8
945
946 /* ----- Only 16-bit mode is supported ----- */
947
948 #elif defined SUPPORT_PCRE16
949 #define CHAR_SIZE                 2
950 #define PCHARS                    PCHARS16
951 #define PCHARSV                   PCHARSV16
952 #define READ_CAPTURE_NAME         READ_CAPTURE_NAME16
953 #define SET_PCRE_CALLOUT          SET_PCRE_CALLOUT16
954 #define SET_PCRE_STACK_GUARD      SET_PCRE_STACK_GUARD16
955 #define STRLEN                    STRLEN16
956 #define PCRE_ASSIGN_JIT_STACK     PCRE_ASSIGN_JIT_STACK16
957 #define PCRE_COMPILE              PCRE_COMPILE16
958 #define PCRE_CONFIG               pcre16_config
959 #define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING16
960 #define PCRE_COPY_SUBSTRING       PCRE_COPY_SUBSTRING16
961 #define PCRE_DFA_EXEC             PCRE_DFA_EXEC16
962 #define PCRE_EXEC                 PCRE_EXEC16
963 #define PCRE_FREE_STUDY           PCRE_FREE_STUDY16
964 #define PCRE_FREE_SUBSTRING       PCRE_FREE_SUBSTRING16
965 #define PCRE_FREE_SUBSTRING_LIST  PCRE_FREE_SUBSTRING_LIST16
966 #define PCRE_GET_NAMED_SUBSTRING  PCRE_GET_NAMED_SUBSTRING16
967 #define PCRE_GET_STRINGNUMBER     PCRE_GET_STRINGNUMBER16
968 #define PCRE_GET_SUBSTRING        PCRE_GET_SUBSTRING16
969 #define PCRE_GET_SUBSTRING_LIST   PCRE_GET_SUBSTRING_LIST16
970 #define PCRE_JIT_STACK_ALLOC      PCRE_JIT_STACK_ALLOC16
971 #define PCRE_JIT_STACK_FREE       PCRE_JIT_STACK_FREE16
972 #define PCRE_MAKETABLES           pcre16_maketables()
973 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER16
974 #define PCRE_PRINTINT             PCRE_PRINTINT16
975 #define PCRE_STUDY                PCRE_STUDY16
976
977 /* ----- Only 32-bit mode is supported ----- */
978
979 #elif defined SUPPORT_PCRE32
980 #define CHAR_SIZE                 4
981 #define PCHARS                    PCHARS32
982 #define PCHARSV                   PCHARSV32
983 #define READ_CAPTURE_NAME         READ_CAPTURE_NAME32
984 #define SET_PCRE_CALLOUT          SET_PCRE_CALLOUT32
985 #define SET_PCRE_STACK_GUARD      SET_PCRE_STACK_GUARD32
986 #define STRLEN                    STRLEN32
987 #define PCRE_ASSIGN_JIT_STACK     PCRE_ASSIGN_JIT_STACK32
988 #define PCRE_COMPILE              PCRE_COMPILE32
989 #define PCRE_CONFIG               pcre32_config
990 #define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING32
991 #define PCRE_COPY_SUBSTRING       PCRE_COPY_SUBSTRING32
992 #define PCRE_DFA_EXEC             PCRE_DFA_EXEC32
993 #define PCRE_EXEC                 PCRE_EXEC32
994 #define PCRE_FREE_STUDY           PCRE_FREE_STUDY32
995 #define PCRE_FREE_SUBSTRING       PCRE_FREE_SUBSTRING32
996 #define PCRE_FREE_SUBSTRING_LIST  PCRE_FREE_SUBSTRING_LIST32
997 #define PCRE_GET_NAMED_SUBSTRING  PCRE_GET_NAMED_SUBSTRING32
998 #define PCRE_GET_STRINGNUMBER     PCRE_GET_STRINGNUMBER32
999 #define PCRE_GET_SUBSTRING        PCRE_GET_SUBSTRING32
1000 #define PCRE_GET_SUBSTRING_LIST   PCRE_GET_SUBSTRING_LIST32
1001 #define PCRE_JIT_STACK_ALLOC      PCRE_JIT_STACK_ALLOC32
1002 #define PCRE_JIT_STACK_FREE       PCRE_JIT_STACK_FREE32
1003 #define PCRE_MAKETABLES           pcre32_maketables()
1004 #define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER32
1005 #define PCRE_PRINTINT             PCRE_PRINTINT32
1006 #define PCRE_STUDY                PCRE_STUDY32
1007
1008 #endif
1009
1010 /* ----- End of mode-specific function call macros ----- */
1011
1012
1013 /* Other parameters */
1014
1015 #ifndef CLOCKS_PER_SEC
1016 #ifdef CLK_TCK
1017 #define CLOCKS_PER_SEC CLK_TCK
1018 #else
1019 #define CLOCKS_PER_SEC 100
1020 #endif
1021 #endif
1022
1023 #if !defined NODFA
1024 #define DFA_WS_DIMENSION 1000
1025 #endif
1026
1027 /* This is the default loop count for timing. */
1028
1029 #define LOOPREPEAT 500000
1030
1031 /* Static variables */
1032
1033 static FILE *outfile;
1034 static int log_store = 0;
1035 static int callout_count;
1036 static int callout_extra;
1037 static int callout_fail_count;
1038 static int callout_fail_id;
1039 static int debug_lengths;
1040 static int first_callout;
1041 static int jit_was_used;
1042 static int locale_set = 0;
1043 static int show_malloc;
1044 static int stack_guard_return;
1045 static int use_utf;
1046 static const unsigned char *last_callout_mark = NULL;
1047
1048 /* The buffers grow automatically if very long input lines are encountered. */
1049
1050 static int buffer_size = 50000;
1051 static pcre_uint8 *buffer = NULL;
1052 static pcre_uint8 *pbuffer = NULL;
1053
1054 /* Just as a safety check, make sure that COMPILE_PCRE[16|32] are *not* set. */
1055
1056 #ifdef COMPILE_PCRE16
1057 #error COMPILE_PCRE16 must not be set when compiling pcretest.c
1058 #endif
1059
1060 #ifdef COMPILE_PCRE32
1061 #error COMPILE_PCRE32 must not be set when compiling pcretest.c
1062 #endif
1063
1064 /* We need buffers for building 16/32-bit strings, and the tables of operator
1065 lengths that are used for 16/32-bit compiling, in order to swap bytes in a
1066 pattern for saving/reloading testing. Luckily, the data for these tables is
1067 defined as a macro. However, we must ensure that LINK_SIZE and IMM2_SIZE (which
1068 are used in the tables) are adjusted appropriately for the 16/32-bit world.
1069 LINK_SIZE is also used later in this program. */
1070
1071 #ifdef SUPPORT_PCRE16
1072 #undef IMM2_SIZE
1073 #define IMM2_SIZE 1
1074
1075 #if LINK_SIZE == 2
1076 #undef LINK_SIZE
1077 #define LINK_SIZE 1
1078 #elif LINK_SIZE == 3 || LINK_SIZE == 4
1079 #undef LINK_SIZE
1080 #define LINK_SIZE 2
1081 #else
1082 #error LINK_SIZE must be either 2, 3, or 4
1083 #endif
1084
1085 static int buffer16_size = 0;
1086 static pcre_uint16 *buffer16 = NULL;
1087 static const pcre_uint16 OP_lengths16[] = { OP_LENGTHS };
1088 #endif  /* SUPPORT_PCRE16 */
1089
1090 #ifdef SUPPORT_PCRE32
1091 #undef IMM2_SIZE
1092 #define IMM2_SIZE 1
1093 #undef LINK_SIZE
1094 #define LINK_SIZE 1
1095
1096 static int buffer32_size = 0;
1097 static pcre_uint32 *buffer32 = NULL;
1098 static const pcre_uint32 OP_lengths32[] = { OP_LENGTHS };
1099 #endif  /* SUPPORT_PCRE32 */
1100
1101 /* If we have 8-bit support, default to it; if there is also 16-or 32-bit
1102 support, it can be changed by an option. If there is no 8-bit support, there
1103 must be 16-or 32-bit support, so default it to 1. */
1104
1105 #if defined SUPPORT_PCRE8
1106 static int pcre_mode = PCRE8_MODE;
1107 #elif defined SUPPORT_PCRE16
1108 static int pcre_mode = PCRE16_MODE;
1109 #elif defined SUPPORT_PCRE32
1110 static int pcre_mode = PCRE32_MODE;
1111 #endif
1112
1113 /* JIT study options for -s+n and /S+n where '1' <= n <= '7'. */
1114
1115 static int jit_study_bits[] =
1116   {
1117   PCRE_STUDY_JIT_COMPILE,
1118   PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE,
1119   PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE,
1120   PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
1121   PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
1122   PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
1123   PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE +
1124     PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE
1125 };
1126
1127 #define PCRE_STUDY_ALLJIT (PCRE_STUDY_JIT_COMPILE | \
1128   PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE)
1129
1130 /* Textual explanations for runtime error codes */
1131
1132 static const char *errtexts[] = {
1133   NULL,  /* 0 is no error */
1134   NULL,  /* NOMATCH is handled specially */
1135   "NULL argument passed",
1136   "bad option value",
1137   "magic number missing",
1138   "unknown opcode - pattern overwritten?",
1139   "no more memory",
1140   NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
1141   "match limit exceeded",
1142   "callout error code",
1143   NULL,  /* BADUTF8/16 is handled specially */
1144   NULL,  /* BADUTF8/16 offset is handled specially */
1145   NULL,  /* PARTIAL is handled specially */
1146   "not used - internal error",
1147   "internal error - pattern overwritten?",
1148   "bad count value",
1149   "item unsupported for DFA matching",
1150   "backreference condition or recursion test not supported for DFA matching",
1151   "match limit not supported for DFA matching",
1152   "workspace size exceeded in DFA matching",
1153   "too much recursion for DFA matching",
1154   "recursion limit exceeded",
1155   "not used - internal error",
1156   "invalid combination of newline options",
1157   "bad offset value",
1158   NULL,  /* SHORTUTF8/16 is handled specially */
1159   "nested recursion at the same subject position",
1160   "JIT stack limit reached",
1161   "pattern compiled in wrong mode: 8-bit/16-bit error",
1162   "pattern compiled with other endianness",
1163   "invalid data in workspace for DFA restart",
1164   "bad JIT option",
1165   "bad length"
1166 };
1167
1168
1169 /*************************************************
1170 *         Alternate character tables             *
1171 *************************************************/
1172
1173 /* By default, the "tables" pointer when calling PCRE is set to NULL, thereby
1174 using the default tables of the library. However, the T option can be used to
1175 select alternate sets of tables, for different kinds of testing. Note also that
1176 the L (locale) option also adjusts the tables. */
1177
1178 /* This is the set of tables distributed as default with PCRE. It recognizes
1179 only ASCII characters. */
1180
1181 static const pcre_uint8 tables0[] = {
1182
1183 /* This table is a lower casing table. */
1184
1185     0,  1,  2,  3,  4,  5,  6,  7,
1186     8,  9, 10, 11, 12, 13, 14, 15,
1187    16, 17, 18, 19, 20, 21, 22, 23,
1188    24, 25, 26, 27, 28, 29, 30, 31,
1189    32, 33, 34, 35, 36, 37, 38, 39,
1190    40, 41, 42, 43, 44, 45, 46, 47,
1191    48, 49, 50, 51, 52, 53, 54, 55,
1192    56, 57, 58, 59, 60, 61, 62, 63,
1193    64, 97, 98, 99,100,101,102,103,
1194   104,105,106,107,108,109,110,111,
1195   112,113,114,115,116,117,118,119,
1196   120,121,122, 91, 92, 93, 94, 95,
1197    96, 97, 98, 99,100,101,102,103,
1198   104,105,106,107,108,109,110,111,
1199   112,113,114,115,116,117,118,119,
1200   120,121,122,123,124,125,126,127,
1201   128,129,130,131,132,133,134,135,
1202   136,137,138,139,140,141,142,143,
1203   144,145,146,147,148,149,150,151,
1204   152,153,154,155,156,157,158,159,
1205   160,161,162,163,164,165,166,167,
1206   168,169,170,171,172,173,174,175,
1207   176,177,178,179,180,181,182,183,
1208   184,185,186,187,188,189,190,191,
1209   192,193,194,195,196,197,198,199,
1210   200,201,202,203,204,205,206,207,
1211   208,209,210,211,212,213,214,215,
1212   216,217,218,219,220,221,222,223,
1213   224,225,226,227,228,229,230,231,
1214   232,233,234,235,236,237,238,239,
1215   240,241,242,243,244,245,246,247,
1216   248,249,250,251,252,253,254,255,
1217
1218 /* This table is a case flipping table. */
1219
1220     0,  1,  2,  3,  4,  5,  6,  7,
1221     8,  9, 10, 11, 12, 13, 14, 15,
1222    16, 17, 18, 19, 20, 21, 22, 23,
1223    24, 25, 26, 27, 28, 29, 30, 31,
1224    32, 33, 34, 35, 36, 37, 38, 39,
1225    40, 41, 42, 43, 44, 45, 46, 47,
1226    48, 49, 50, 51, 52, 53, 54, 55,
1227    56, 57, 58, 59, 60, 61, 62, 63,
1228    64, 97, 98, 99,100,101,102,103,
1229   104,105,106,107,108,109,110,111,
1230   112,113,114,115,116,117,118,119,
1231   120,121,122, 91, 92, 93, 94, 95,
1232    96, 65, 66, 67, 68, 69, 70, 71,
1233    72, 73, 74, 75, 76, 77, 78, 79,
1234    80, 81, 82, 83, 84, 85, 86, 87,
1235    88, 89, 90,123,124,125,126,127,
1236   128,129,130,131,132,133,134,135,
1237   136,137,138,139,140,141,142,143,
1238   144,145,146,147,148,149,150,151,
1239   152,153,154,155,156,157,158,159,
1240   160,161,162,163,164,165,166,167,
1241   168,169,170,171,172,173,174,175,
1242   176,177,178,179,180,181,182,183,
1243   184,185,186,187,188,189,190,191,
1244   192,193,194,195,196,197,198,199,
1245   200,201,202,203,204,205,206,207,
1246   208,209,210,211,212,213,214,215,
1247   216,217,218,219,220,221,222,223,
1248   224,225,226,227,228,229,230,231,
1249   232,233,234,235,236,237,238,239,
1250   240,241,242,243,244,245,246,247,
1251   248,249,250,251,252,253,254,255,
1252
1253 /* This table contains bit maps for various character classes. Each map is 32
1254 bytes long and the bits run from the least significant end of each byte. The
1255 classes that have their own maps are: space, xdigit, digit, upper, lower, word,
1256 graph, print, punct, and cntrl. Other classes are built from combinations. */
1257
1258   0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
1259   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1260   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1261   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1262
1263   0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1264   0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
1265   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1266   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1267
1268   0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1269   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1270   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1271   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1272
1273   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1274   0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
1275   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1276   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1277
1278   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1279   0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
1280   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1281   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1282
1283   0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1284   0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
1285   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1286   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1287
1288   0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
1289   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
1290   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1291   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1292
1293   0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
1294   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
1295   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1296   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1297
1298   0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
1299   0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
1300   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1301   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1302
1303   0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
1304   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
1305   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1306   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1307
1308 /* This table identifies various classes of character by individual bits:
1309   0x01   white space character
1310   0x02   letter
1311   0x04   decimal digit
1312   0x08   hexadecimal digit
1313   0x10   alphanumeric or '_'
1314   0x80   regular expression metacharacter or binary zero
1315 */
1316
1317   0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
1318   0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /*   8- 15 */
1319   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
1320   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
1321   0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /*    - '  */
1322   0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /*  ( - /  */
1323   0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
1324   0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /*  8 - ?  */
1325   0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  @ - G  */
1326   0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
1327   0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
1328   0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /*  X - _  */
1329   0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  ` - g  */
1330   0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  h - o  */
1331   0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  p - w  */
1332   0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /*  x -127 */
1333   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
1334   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
1335   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
1336   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
1337   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
1338   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
1339   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
1340   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
1341   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
1342   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
1343   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
1344   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
1345   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
1346   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
1347   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
1348   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
1349
1350 /* This is a set of tables that came originally from a Windows user. It seems
1351 to be at least an approximation of ISO 8859. In particular, there are
1352 characters greater than 128 that are marked as spaces, letters, etc. */
1353
1354 static const pcre_uint8 tables1[] = {
1355 0,1,2,3,4,5,6,7,
1356 8,9,10,11,12,13,14,15,
1357 16,17,18,19,20,21,22,23,
1358 24,25,26,27,28,29,30,31,
1359 32,33,34,35,36,37,38,39,
1360 40,41,42,43,44,45,46,47,
1361 48,49,50,51,52,53,54,55,
1362 56,57,58,59,60,61,62,63,
1363 64,97,98,99,100,101,102,103,
1364 104,105,106,107,108,109,110,111,
1365 112,113,114,115,116,117,118,119,
1366 120,121,122,91,92,93,94,95,
1367 96,97,98,99,100,101,102,103,
1368 104,105,106,107,108,109,110,111,
1369 112,113,114,115,116,117,118,119,
1370 120,121,122,123,124,125,126,127,
1371 128,129,130,131,132,133,134,135,
1372 136,137,138,139,140,141,142,143,
1373 144,145,146,147,148,149,150,151,
1374 152,153,154,155,156,157,158,159,
1375 160,161,162,163,164,165,166,167,
1376 168,169,170,171,172,173,174,175,
1377 176,177,178,179,180,181,182,183,
1378 184,185,186,187,188,189,190,191,
1379 224,225,226,227,228,229,230,231,
1380 232,233,234,235,236,237,238,239,
1381 240,241,242,243,244,245,246,215,
1382 248,249,250,251,252,253,254,223,
1383 224,225,226,227,228,229,230,231,
1384 232,233,234,235,236,237,238,239,
1385 240,241,242,243,244,245,246,247,
1386 248,249,250,251,252,253,254,255,
1387 0,1,2,3,4,5,6,7,
1388 8,9,10,11,12,13,14,15,
1389 16,17,18,19,20,21,22,23,
1390 24,25,26,27,28,29,30,31,
1391 32,33,34,35,36,37,38,39,
1392 40,41,42,43,44,45,46,47,
1393 48,49,50,51,52,53,54,55,
1394 56,57,58,59,60,61,62,63,
1395 64,97,98,99,100,101,102,103,
1396 104,105,106,107,108,109,110,111,
1397 112,113,114,115,116,117,118,119,
1398 120,121,122,91,92,93,94,95,
1399 96,65,66,67,68,69,70,71,
1400 72,73,74,75,76,77,78,79,
1401 80,81,82,83,84,85,86,87,
1402 88,89,90,123,124,125,126,127,
1403 128,129,130,131,132,133,134,135,
1404 136,137,138,139,140,141,142,143,
1405 144,145,146,147,148,149,150,151,
1406 152,153,154,155,156,157,158,159,
1407 160,161,162,163,164,165,166,167,
1408 168,169,170,171,172,173,174,175,
1409 176,177,178,179,180,181,182,183,
1410 184,185,186,187,188,189,190,191,
1411 224,225,226,227,228,229,230,231,
1412 232,233,234,235,236,237,238,239,
1413 240,241,242,243,244,245,246,215,
1414 248,249,250,251,252,253,254,223,
1415 192,193,194,195,196,197,198,199,
1416 200,201,202,203,204,205,206,207,
1417 208,209,210,211,212,213,214,247,
1418 216,217,218,219,220,221,222,255,
1419 0,62,0,0,1,0,0,0,
1420 0,0,0,0,0,0,0,0,
1421 32,0,0,0,1,0,0,0,
1422 0,0,0,0,0,0,0,0,
1423 0,0,0,0,0,0,255,3,
1424 126,0,0,0,126,0,0,0,
1425 0,0,0,0,0,0,0,0,
1426 0,0,0,0,0,0,0,0,
1427 0,0,0,0,0,0,255,3,
1428 0,0,0,0,0,0,0,0,
1429 0,0,0,0,0,0,12,2,
1430 0,0,0,0,0,0,0,0,
1431 0,0,0,0,0,0,0,0,
1432 254,255,255,7,0,0,0,0,
1433 0,0,0,0,0,0,0,0,
1434 255,255,127,127,0,0,0,0,
1435 0,0,0,0,0,0,0,0,
1436 0,0,0,0,254,255,255,7,
1437 0,0,0,0,0,4,32,4,
1438 0,0,0,128,255,255,127,255,
1439 0,0,0,0,0,0,255,3,
1440 254,255,255,135,254,255,255,7,
1441 0,0,0,0,0,4,44,6,
1442 255,255,127,255,255,255,127,255,
1443 0,0,0,0,254,255,255,255,
1444 255,255,255,255,255,255,255,127,
1445 0,0,0,0,254,255,255,255,
1446 255,255,255,255,255,255,255,255,
1447 0,2,0,0,255,255,255,255,
1448 255,255,255,255,255,255,255,127,
1449 0,0,0,0,255,255,255,255,
1450 255,255,255,255,255,255,255,255,
1451 0,0,0,0,254,255,0,252,
1452 1,0,0,248,1,0,0,120,
1453 0,0,0,0,254,255,255,255,
1454 0,0,128,0,0,0,128,0,
1455 255,255,255,255,0,0,0,0,
1456 0,0,0,0,0,0,0,128,
1457 255,255,255,255,0,0,0,0,
1458 0,0,0,0,0,0,0,0,
1459 128,0,0,0,0,0,0,0,
1460 0,1,1,0,1,1,0,0,
1461 0,0,0,0,0,0,0,0,
1462 0,0,0,0,0,0,0,0,
1463 1,0,0,0,128,0,0,0,
1464 128,128,128,128,0,0,128,0,
1465 28,28,28,28,28,28,28,28,
1466 28,28,0,0,0,0,0,128,
1467 0,26,26,26,26,26,26,18,
1468 18,18,18,18,18,18,18,18,
1469 18,18,18,18,18,18,18,18,
1470 18,18,18,128,128,0,128,16,
1471 0,26,26,26,26,26,26,18,
1472 18,18,18,18,18,18,18,18,
1473 18,18,18,18,18,18,18,18,
1474 18,18,18,128,128,0,0,0,
1475 0,0,0,0,0,1,0,0,
1476 0,0,0,0,0,0,0,0,
1477 0,0,0,0,0,0,0,0,
1478 0,0,0,0,0,0,0,0,
1479 1,0,0,0,0,0,0,0,
1480 0,0,18,0,0,0,0,0,
1481 0,0,20,20,0,18,0,0,
1482 0,20,18,0,0,0,0,0,
1483 18,18,18,18,18,18,18,18,
1484 18,18,18,18,18,18,18,18,
1485 18,18,18,18,18,18,18,0,
1486 18,18,18,18,18,18,18,18,
1487 18,18,18,18,18,18,18,18,
1488 18,18,18,18,18,18,18,18,
1489 18,18,18,18,18,18,18,0,
1490 18,18,18,18,18,18,18,18
1491 };
1492
1493
1494
1495
1496 #ifndef HAVE_STRERROR
1497 /*************************************************
1498 *     Provide strerror() for non-ANSI libraries  *
1499 *************************************************/
1500
1501 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
1502 in their libraries, but can provide the same facility by this simple
1503 alternative function. */
1504
1505 extern int   sys_nerr;
1506 extern char *sys_errlist[];
1507
1508 char *
1509 strerror(int n)
1510 {
1511 if (n < 0 || n >= sys_nerr) return "unknown error number";
1512 return sys_errlist[n];
1513 }
1514 #endif /* HAVE_STRERROR */
1515
1516
1517
1518 /*************************************************
1519 *       Print newline configuration              *
1520 *************************************************/
1521
1522 /*
1523 Arguments:
1524   rc         the return code from PCRE_CONFIG_NEWLINE
1525   isc        TRUE if called from "-C newline"
1526 Returns:     nothing
1527 */
1528
1529 static void
1530 print_newline_config(int rc, BOOL isc)
1531 {
1532 const char *s = NULL;
1533 if (!isc) printf("  Newline sequence is ");
1534 switch(rc)
1535   {
1536   case CHAR_CR: s = "CR"; break;
1537   case CHAR_LF: s = "LF"; break;
1538   case (CHAR_CR<<8 | CHAR_LF): s = "CRLF"; break;
1539   case -1: s = "ANY"; break;
1540   case -2: s = "ANYCRLF"; break;
1541
1542   default:
1543   printf("a non-standard value: 0x%04x\n", rc);
1544   return;
1545   }
1546
1547 printf("%s\n", s);
1548 }
1549
1550
1551
1552 /*************************************************
1553 *         JIT memory callback                    *
1554 *************************************************/
1555
1556 static pcre_jit_stack* jit_callback(void *arg)
1557 {
1558 jit_was_used = TRUE;
1559 return (pcre_jit_stack *)arg;
1560 }
1561
1562
1563 #if !defined NOUTF || defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32
1564 /*************************************************
1565 *            Convert UTF-8 string to value       *
1566 *************************************************/
1567
1568 /* This function takes one or more bytes that represents a UTF-8 character,
1569 and returns the value of the character.
1570
1571 Argument:
1572   utf8bytes   a pointer to the byte vector
1573   vptr        a pointer to an int to receive the value
1574
1575 Returns:      >  0 => the number of bytes consumed
1576               -6 to 0 => malformed UTF-8 character at offset = (-return)
1577 */
1578
1579 static int
1580 utf82ord(pcre_uint8 *utf8bytes, pcre_uint32 *vptr)
1581 {
1582 pcre_uint32 c = *utf8bytes++;
1583 pcre_uint32 d = c;
1584 int i, j, s;
1585
1586 for (i = -1; i < 6; i++)               /* i is number of additional bytes */
1587   {
1588   if ((d & 0x80) == 0) break;
1589   d <<= 1;
1590   }
1591
1592 if (i == -1) { *vptr = c; return 1; }  /* ascii character */
1593 if (i == 0 || i == 6) return 0;        /* invalid UTF-8 */
1594
1595 /* i now has a value in the range 1-5 */
1596
1597 s = 6*i;
1598 d = (c & utf8_table3[i]) << s;
1599
1600 for (j = 0; j < i; j++)
1601   {
1602   c = *utf8bytes++;
1603   if ((c & 0xc0) != 0x80) return -(j+1);
1604   s -= 6;
1605   d |= (c & 0x3f) << s;
1606   }
1607
1608 /* Check that encoding was the correct unique one */
1609
1610 for (j = 0; j < utf8_table1_size; j++)
1611   if (d <= (pcre_uint32)utf8_table1[j]) break;
1612 if (j != i) return -(i+1);
1613
1614 /* Valid value */
1615
1616 *vptr = d;
1617 return i+1;
1618 }
1619 #endif /* NOUTF || SUPPORT_PCRE16 */
1620
1621
1622
1623 #if defined SUPPORT_PCRE8 && !defined NOUTF
1624 /*************************************************
1625 *       Convert character value to UTF-8         *
1626 *************************************************/
1627
1628 /* This function takes an integer value in the range 0 - 0x7fffffff
1629 and encodes it as a UTF-8 character in 0 to 6 bytes.
1630
1631 Arguments:
1632   cvalue     the character value
1633   utf8bytes  pointer to buffer for result - at least 6 bytes long
1634
1635 Returns:     number of characters placed in the buffer
1636 */
1637
1638 static int
1639 ord2utf8(pcre_uint32 cvalue, pcre_uint8 *utf8bytes)
1640 {
1641 register int i, j;
1642 if (cvalue > 0x7fffffffu)
1643   return -1;
1644 for (i = 0; i < utf8_table1_size; i++)
1645   if (cvalue <= (pcre_uint32)utf8_table1[i]) break;
1646 utf8bytes += i;
1647 for (j = i; j > 0; j--)
1648  {
1649  *utf8bytes-- = 0x80 | (cvalue & 0x3f);
1650  cvalue >>= 6;
1651  }
1652 *utf8bytes = utf8_table2[i] | cvalue;
1653 return i + 1;
1654 }
1655 #endif
1656
1657
1658 #ifdef SUPPORT_PCRE16
1659 /*************************************************
1660 *         Convert a string to 16-bit             *
1661 *************************************************/
1662
1663 /* In non-UTF mode, the space needed for a 16-bit string is exactly double the
1664 8-bit size. For a UTF-8 string, the size needed for UTF-16 is no more than
1665 double, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4
1666 in UTF-16. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-16. The
1667 result is always left in buffer16.
1668
1669 Note that this function does not object to surrogate values. This is
1670 deliberate; it makes it possible to construct UTF-16 strings that are invalid,
1671 for the purpose of testing that they are correctly faulted.
1672
1673 Patterns to be converted are either plain ASCII or UTF-8; data lines are always
1674 in UTF-8 so that values greater than 255 can be handled.
1675
1676 Arguments:
1677   data       TRUE if converting a data line; FALSE for a regex
1678   p          points to a byte string
1679   utf        true if UTF-8 (to be converted to UTF-16)
1680   len        number of bytes in the string (excluding trailing zero)
1681
1682 Returns:     number of 16-bit data items used (excluding trailing zero)
1683              OR -1 if a UTF-8 string is malformed
1684              OR -2 if a value > 0x10ffff is encountered
1685              OR -3 if a value > 0xffff is encountered when not in UTF mode
1686 */
1687
1688 static int
1689 to16(int data, pcre_uint8 *p, int utf, int len)
1690 {
1691 pcre_uint16 *pp;
1692
1693 if (buffer16_size < 2*len + 2)
1694   {
1695   if (buffer16 != NULL) free(buffer16);
1696   buffer16_size = 2*len + 2;
1697   buffer16 = (pcre_uint16 *)malloc(buffer16_size);
1698   if (buffer16 == NULL)
1699     {
1700     fprintf(stderr, "pcretest: malloc(%d) failed for buffer16\n", buffer16_size);
1701     exit(1);
1702     }
1703   }
1704
1705 pp = buffer16;
1706
1707 if (!utf && !data)
1708   {
1709   while (len-- > 0) *pp++ = *p++;
1710   }
1711
1712 else
1713   {
1714   pcre_uint32 c = 0;
1715   while (len > 0)
1716     {
1717     int chlen = utf82ord(p, &c);
1718     if (chlen <= 0) return -1;
1719     if (c > 0x10ffff) return -2;
1720     p += chlen;
1721     len -= chlen;
1722     if (c < 0x10000) *pp++ = c; else
1723       {
1724       if (!utf) return -3;
1725       c -= 0x10000;
1726       *pp++ = 0xD800 | (c >> 10);
1727       *pp++ = 0xDC00 | (c & 0x3ff);
1728       }
1729     }
1730   }
1731
1732 *pp = 0;
1733 return pp - buffer16;
1734 }
1735 #endif
1736
1737 #ifdef SUPPORT_PCRE32
1738 /*************************************************
1739 *         Convert a string to 32-bit             *
1740 *************************************************/
1741
1742 /* In non-UTF mode, the space needed for a 32-bit string is exactly four times the
1743 8-bit size. For a UTF-8 string, the size needed for UTF-32 is no more than four
1744 times, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4
1745 in UTF-32. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-32. The
1746 result is always left in buffer32.
1747
1748 Note that this function does not object to surrogate values. This is
1749 deliberate; it makes it possible to construct UTF-32 strings that are invalid,
1750 for the purpose of testing that they are correctly faulted.
1751
1752 Patterns to be converted are either plain ASCII or UTF-8; data lines are always
1753 in UTF-8 so that values greater than 255 can be handled.
1754
1755 Arguments:
1756   data       TRUE if converting a data line; FALSE for a regex
1757   p          points to a byte string
1758   utf        true if UTF-8 (to be converted to UTF-32)
1759   len        number of bytes in the string (excluding trailing zero)
1760
1761 Returns:     number of 32-bit data items used (excluding trailing zero)
1762              OR -1 if a UTF-8 string is malformed
1763              OR -2 if a value > 0x10ffff is encountered
1764              OR -3 if an ill-formed value is encountered (i.e. a surrogate)
1765 */
1766
1767 static int
1768 to32(int data, pcre_uint8 *p, int utf, int len)
1769 {
1770 pcre_uint32 *pp;
1771
1772 if (buffer32_size < 4*len + 4)
1773   {
1774   if (buffer32 != NULL) free(buffer32);
1775   buffer32_size = 4*len + 4;
1776   buffer32 = (pcre_uint32 *)malloc(buffer32_size);
1777   if (buffer32 == NULL)
1778     {
1779     fprintf(stderr, "pcretest: malloc(%d) failed for buffer32\n", buffer32_size);
1780     exit(1);
1781     }
1782   }
1783
1784 pp = buffer32;
1785
1786 if (!utf && !data)
1787   {
1788   while (len-- > 0) *pp++ = *p++;
1789   }
1790
1791 else
1792   {
1793   pcre_uint32 c = 0;
1794   while (len > 0)
1795     {
1796     int chlen = utf82ord(p, &c);
1797     if (chlen <= 0) return -1;
1798     if (utf)
1799       {
1800       if (c > 0x10ffff) return -2;
1801       if (!data && (c & 0xfffff800u) == 0xd800u) return -3;
1802       }
1803
1804     p += chlen;
1805     len -= chlen;
1806     *pp++ = c;
1807     }
1808   }
1809
1810 *pp = 0;
1811 return pp - buffer32;
1812 }
1813
1814 /* Check that a 32-bit character string is valid UTF-32.
1815
1816 Arguments:
1817   string       points to the string
1818   length       length of string, or -1 if the string is zero-terminated
1819
1820 Returns:       TRUE  if the string is a valid UTF-32 string
1821                FALSE otherwise
1822 */
1823
1824 #ifdef NEVER   /* Not used */
1825 #ifdef SUPPORT_UTF
1826 static BOOL
1827 valid_utf32(pcre_uint32 *string, int length)
1828 {
1829 register pcre_uint32 *p;
1830 register pcre_uint32 c;
1831
1832 for (p = string; length-- > 0; p++)
1833   {
1834   c = *p;
1835   if (c > 0x10ffffu) return FALSE;                 /* Too big */
1836   if ((c & 0xfffff800u) == 0xd800u) return FALSE;  /* Surrogate */
1837   }
1838
1839 return TRUE;
1840 }
1841 #endif /* SUPPORT_UTF */
1842 #endif /* NEVER */
1843 #endif /* SUPPORT_PCRE32 */
1844
1845
1846 /*************************************************
1847 *        Read or extend an input line            *
1848 *************************************************/
1849
1850 /* Input lines are read into buffer, but both patterns and data lines can be
1851 continued over multiple input lines. In addition, if the buffer fills up, we
1852 want to automatically expand it so as to be able to handle extremely large
1853 lines that are needed for certain stress tests. When the input buffer is
1854 expanded, the other two buffers must also be expanded likewise, and the
1855 contents of pbuffer, which are a copy of the input for callouts, must be
1856 preserved (for when expansion happens for a data line). This is not the most
1857 optimal way of handling this, but hey, this is just a test program!
1858
1859 Arguments:
1860   f            the file to read
1861   start        where in buffer to start (this *must* be within buffer)
1862   prompt       for stdin or readline()
1863
1864 Returns:       pointer to the start of new data
1865                could be a copy of start, or could be moved
1866                NULL if no data read and EOF reached
1867 */
1868
1869 static pcre_uint8 *
1870 extend_inputline(FILE *f, pcre_uint8 *start, const char *prompt)
1871 {
1872 pcre_uint8 *here = start;
1873
1874 for (;;)
1875   {
1876   size_t rlen = (size_t)(buffer_size - (here - buffer));
1877
1878   if (rlen > 1000)
1879     {
1880     int dlen;
1881
1882     /* If libreadline or libedit support is required, use readline() to read a
1883     line if the input is a terminal. Note that readline() removes the trailing
1884     newline, so we must put it back again, to be compatible with fgets(). */
1885
1886 #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT)
1887     if (isatty(fileno(f)))
1888       {
1889       size_t len;
1890       char *s = readline(prompt);
1891       if (s == NULL) return (here == start)? NULL : start;
1892       len = strlen(s);
1893       if (len > 0) add_history(s);
1894       if (len > rlen - 1) len = rlen - 1;
1895       memcpy(here, s, len);
1896       here[len] = '\n';
1897       here[len+1] = 0;
1898       free(s);
1899       }
1900     else
1901 #endif
1902
1903     /* Read the next line by normal means, prompting if the file is stdin. */
1904
1905       {
1906       if (f == stdin) printf("%s", prompt);
1907       if (fgets((char *)here, rlen,  f) == NULL)
1908         return (here == start)? NULL : start;
1909       }
1910
1911     dlen = (int)strlen((char *)here);
1912     if (dlen > 0 && here[dlen - 1] == '\n') return start;
1913     here += dlen;
1914     }
1915
1916   else
1917     {
1918     int new_buffer_size = 2*buffer_size;
1919     pcre_uint8 *new_buffer = (pcre_uint8 *)malloc(new_buffer_size);
1920     pcre_uint8 *new_pbuffer = (pcre_uint8 *)malloc(new_buffer_size);
1921
1922     if (new_buffer == NULL || new_pbuffer == NULL)
1923       {
1924       fprintf(stderr, "pcretest: malloc(%d) failed\n", new_buffer_size);
1925       exit(1);
1926       }
1927
1928     memcpy(new_buffer, buffer, buffer_size);
1929     memcpy(new_pbuffer, pbuffer, buffer_size);
1930
1931     buffer_size = new_buffer_size;
1932
1933     start = new_buffer + (start - buffer);
1934     here = new_buffer + (here - buffer);
1935
1936     free(buffer);
1937     free(pbuffer);
1938
1939     buffer = new_buffer;
1940     pbuffer = new_pbuffer;
1941     }
1942   }
1943
1944 /* Control never gets here */
1945 }
1946
1947
1948
1949 /*************************************************
1950 *          Read number from string               *
1951 *************************************************/
1952
1953 /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess
1954 around with conditional compilation, just do the job by hand. It is only used
1955 for unpicking arguments, so just keep it simple.
1956
1957 Arguments:
1958   str           string to be converted
1959   endptr        where to put the end pointer
1960
1961 Returns:        the unsigned long
1962 */
1963
1964 static int
1965 get_value(pcre_uint8 *str, pcre_uint8 **endptr)
1966 {
1967 int result = 0;
1968 while(*str != 0 && isspace(*str)) str++;
1969 while (isdigit(*str)) result = result * 10 + (int)(*str++ - '0');
1970 *endptr = str;
1971 return(result);
1972 }
1973
1974
1975
1976 /*************************************************
1977 *             Print one character                *
1978 *************************************************/
1979
1980 /* Print a single character either literally, or as a hex escape. */
1981
1982 static int pchar(pcre_uint32 c, FILE *f)
1983 {
1984 int n = 0;
1985 if (PRINTOK(c))
1986   {
1987   if (f != NULL) fprintf(f, "%c", c);
1988   return 1;
1989   }
1990
1991 if (c < 0x100)
1992   {
1993   if (use_utf)
1994     {
1995     if (f != NULL) fprintf(f, "\\x{%02x}", c);
1996     return 6;
1997     }
1998   else
1999     {
2000     if (f != NULL) fprintf(f, "\\x%02x", c);
2001     return 4;
2002     }
2003   }
2004
2005 if (f != NULL) n = fprintf(f, "\\x{%02x}", c);
2006 return n >= 0 ? n : 0;
2007 }
2008
2009
2010
2011 #ifdef SUPPORT_PCRE8
2012 /*************************************************
2013 *         Print 8-bit character string           *
2014 *************************************************/
2015
2016 /* Must handle UTF-8 strings in utf8 mode. Yields number of characters printed.
2017 If handed a NULL file, just counts chars without printing. */
2018
2019 static int pchars(pcre_uint8 *p, int length, FILE *f)
2020 {
2021 pcre_uint32 c = 0;
2022 int yield = 0;
2023
2024 if (length < 0)
2025   length = strlen((char *)p);
2026
2027 while (length-- > 0)
2028   {
2029 #if !defined NOUTF
2030   if (use_utf)
2031     {
2032     int rc = utf82ord(p, &c);
2033     if (rc > 0 && rc <= length + 1)   /* Mustn't run over the end */
2034       {
2035       length -= rc - 1;
2036       p += rc;
2037       yield += pchar(c, f);
2038       continue;
2039       }
2040     }
2041 #endif
2042   c = *p++;
2043   yield += pchar(c, f);
2044   }
2045
2046 return yield;
2047 }
2048 #endif
2049
2050
2051
2052 #ifdef SUPPORT_PCRE16
2053 /*************************************************
2054 *    Find length of 0-terminated 16-bit string   *
2055 *************************************************/
2056
2057 static int strlen16(PCRE_SPTR16 p)
2058 {
2059 PCRE_SPTR16 pp = p;
2060 while (*pp != 0) pp++;
2061 return (int)(pp - p);
2062 }
2063 #endif  /* SUPPORT_PCRE16 */
2064
2065
2066
2067 #ifdef SUPPORT_PCRE32
2068 /*************************************************
2069 *    Find length of 0-terminated 32-bit string   *
2070 *************************************************/
2071
2072 static int strlen32(PCRE_SPTR32 p)
2073 {
2074 PCRE_SPTR32 pp = p;
2075 while (*pp != 0) pp++;
2076 return (int)(pp - p);
2077 }
2078 #endif  /* SUPPORT_PCRE32 */
2079
2080
2081
2082 #ifdef SUPPORT_PCRE16
2083 /*************************************************
2084 *           Print 16-bit character string        *
2085 *************************************************/
2086
2087 /* Must handle UTF-16 strings in utf mode. Yields number of characters printed.
2088 If handed a NULL file, just counts chars without printing. */
2089
2090 static int pchars16(PCRE_SPTR16 p, int length, FILE *f)
2091 {
2092 int yield = 0;
2093
2094 if (length < 0)
2095   length = strlen16(p);
2096
2097 while (length-- > 0)
2098   {
2099   pcre_uint32 c = *p++ & 0xffff;
2100 #if !defined NOUTF
2101   if (use_utf && c >= 0xD800 && c < 0xDC00 && length > 0)
2102     {
2103     int d = *p & 0xffff;
2104     if (d >= 0xDC00 && d <= 0xDFFF)
2105       {
2106       c = ((c & 0x3ff) << 10) + (d & 0x3ff) + 0x10000;
2107       length--;
2108       p++;
2109       }
2110     }
2111 #endif
2112   yield += pchar(c, f);
2113   }
2114
2115 return yield;
2116 }
2117 #endif  /* SUPPORT_PCRE16 */
2118
2119
2120
2121 #ifdef SUPPORT_PCRE32
2122 /*************************************************
2123 *           Print 32-bit character string        *
2124 *************************************************/
2125
2126 /* Must handle UTF-32 strings in utf mode. Yields number of characters printed.
2127 If handed a NULL file, just counts chars without printing. */
2128
2129 static int pchars32(PCRE_SPTR32 p, int length, BOOL utf, FILE *f)
2130 {
2131 int yield = 0;
2132
2133 (void)(utf);  /* Avoid compiler warning */
2134
2135 if (length < 0)
2136   length = strlen32(p);
2137
2138 while (length-- > 0)
2139   {
2140   pcre_uint32 c = *p++;
2141   yield += pchar(c, f);
2142   }
2143
2144 return yield;
2145 }
2146 #endif  /* SUPPORT_PCRE32 */
2147
2148
2149
2150 #ifdef SUPPORT_PCRE8
2151 /*************************************************
2152 *     Read a capture name (8-bit) and check it   *
2153 *************************************************/
2154
2155 static pcre_uint8 *
2156 read_capture_name8(pcre_uint8 *p, pcre_uint8 **pp, pcre *re)
2157 {
2158 pcre_uint8 *npp = *pp;
2159 while (isalnum(*p)) *npp++ = *p++;
2160 *npp++ = 0;
2161 *npp = 0;
2162 if (pcre_get_stringnumber(re, (char *)(*pp)) < 0)
2163   {
2164   fprintf(outfile, "no parentheses with name \"");
2165   PCHARSV(*pp, 0, -1, outfile);
2166   fprintf(outfile, "\"\n");
2167   }
2168
2169 *pp = npp;
2170 return p;
2171 }
2172 #endif  /* SUPPORT_PCRE8 */
2173
2174
2175
2176 #ifdef SUPPORT_PCRE16
2177 /*************************************************
2178 *     Read a capture name (16-bit) and check it  *
2179 *************************************************/
2180
2181 /* Note that the text being read is 8-bit. */
2182
2183 static pcre_uint8 *
2184 read_capture_name16(pcre_uint8 *p, pcre_uint16 **pp, pcre *re)
2185 {
2186 pcre_uint16 *npp = *pp;
2187 while (isalnum(*p)) *npp++ = *p++;
2188 *npp++ = 0;
2189 *npp = 0;
2190 if (pcre16_get_stringnumber((pcre16 *)re, (PCRE_SPTR16)(*pp)) < 0)
2191   {
2192   fprintf(outfile, "no parentheses with name \"");
2193   PCHARSV(*pp, 0, -1, outfile);
2194   fprintf(outfile, "\"\n");
2195   }
2196 *pp = npp;
2197 return p;
2198 }
2199 #endif  /* SUPPORT_PCRE16 */
2200
2201
2202
2203 #ifdef SUPPORT_PCRE32
2204 /*************************************************
2205 *     Read a capture name (32-bit) and check it  *
2206 *************************************************/
2207
2208 /* Note that the text being read is 8-bit. */
2209
2210 static pcre_uint8 *
2211 read_capture_name32(pcre_uint8 *p, pcre_uint32 **pp, pcre *re)
2212 {
2213 pcre_uint32 *npp = *pp;
2214 while (isalnum(*p)) *npp++ = *p++;
2215 *npp++ = 0;
2216 *npp = 0;
2217 if (pcre32_get_stringnumber((pcre32 *)re, (PCRE_SPTR32)(*pp)) < 0)
2218   {
2219   fprintf(outfile, "no parentheses with name \"");
2220   PCHARSV(*pp, 0, -1, outfile);
2221   fprintf(outfile, "\"\n");
2222   }
2223 *pp = npp;
2224 return p;
2225 }
2226 #endif  /* SUPPORT_PCRE32 */
2227
2228
2229
2230 /*************************************************
2231 *            Stack guard function                *
2232 *************************************************/
2233
2234 /* Called from PCRE when set in pcre_stack_guard. We give an error (non-zero)
2235 return when a count overflows. */
2236
2237 static int stack_guard(void)
2238 {
2239 return stack_guard_return;
2240 }
2241
2242 /*************************************************
2243 *              Callout function                  *
2244 *************************************************/
2245
2246 /* Called from PCRE as a result of the (?C) item. We print out where we are in
2247 the match. Yield zero unless more callouts than the fail count, or the callout
2248 data is not zero. */
2249
2250 static int callout(pcre_callout_block *cb)
2251 {
2252 FILE *f = (first_callout | callout_extra)? outfile : NULL;
2253 int i, pre_start, post_start, subject_length;
2254
2255 if (callout_extra)
2256   {
2257   fprintf(f, "Callout %d: last capture = %d\n",
2258     cb->callout_number, cb->capture_last);
2259
2260   if (cb->offset_vector != NULL)
2261     {
2262     for (i = 0; i < cb->capture_top * 2; i += 2)
2263       {
2264       if (cb->offset_vector[i] < 0)
2265         fprintf(f, "%2d: <unset>\n", i/2);
2266       else
2267         {
2268         fprintf(f, "%2d: ", i/2);
2269         PCHARSV(cb->subject, cb->offset_vector[i],
2270           cb->offset_vector[i+1] - cb->offset_vector[i], f);
2271         fprintf(f, "\n");
2272         }
2273       }
2274     }
2275   }
2276
2277 /* Re-print the subject in canonical form, the first time or if giving full
2278 datails. On subsequent calls in the same match, we use pchars just to find the
2279 printed lengths of the substrings. */
2280
2281 if (f != NULL) fprintf(f, "--->");
2282
2283 PCHARS(pre_start, cb->subject, 0, cb->start_match, f);
2284 PCHARS(post_start, cb->subject, cb->start_match,
2285   cb->current_position - cb->start_match, f);
2286
2287 PCHARS(subject_length, cb->subject, 0, cb->subject_length, NULL);
2288
2289 PCHARSV(cb->subject, cb->current_position,
2290   cb->subject_length - cb->current_position, f);
2291
2292 if (f != NULL) fprintf(f, "\n");
2293
2294 /* Always print appropriate indicators, with callout number if not already
2295 shown. For automatic callouts, show the pattern offset. */
2296
2297 if (cb->callout_number == 255)
2298   {
2299   fprintf(outfile, "%+3d ", cb->pattern_position);
2300   if (cb->pattern_position > 99) fprintf(outfile, "\n    ");
2301   }
2302 else
2303   {
2304   if (callout_extra) fprintf(outfile, "    ");
2305     else fprintf(outfile, "%3d ", cb->callout_number);
2306   }
2307
2308 for (i = 0; i < pre_start; i++) fprintf(outfile, " ");
2309 fprintf(outfile, "^");
2310
2311 if (post_start > 0)
2312   {
2313   for (i = 0; i < post_start - 1; i++) fprintf(outfile, " ");
2314   fprintf(outfile, "^");
2315   }
2316
2317 for (i = 0; i < subject_length - pre_start - post_start + 4; i++)
2318   fprintf(outfile, " ");
2319
2320 fprintf(outfile, "%.*s", (cb->next_item_length == 0)? 1 : cb->next_item_length,
2321   pbuffer + cb->pattern_position);
2322
2323 fprintf(outfile, "\n");
2324 first_callout = 0;
2325
2326 if (cb->mark != last_callout_mark)
2327   {
2328   if (cb->mark == NULL)
2329     fprintf(outfile, "Latest Mark: <unset>\n");
2330   else
2331     {
2332     fprintf(outfile, "Latest Mark: ");
2333     PCHARSV(cb->mark, 0, -1, outfile);
2334     putc('\n', outfile);
2335     }
2336   last_callout_mark = cb->mark;
2337   }
2338
2339 if (cb->callout_data != NULL)
2340   {
2341   int callout_data = *((int *)(cb->callout_data));
2342   if (callout_data != 0)
2343     {
2344     fprintf(outfile, "Callout data = %d\n", callout_data);
2345     return callout_data;
2346     }
2347   }
2348
2349 return (cb->callout_number != callout_fail_id)? 0 :
2350        (++callout_count >= callout_fail_count)? 1 : 0;
2351 }
2352
2353
2354 /*************************************************
2355 *            Local malloc functions              *
2356 *************************************************/
2357
2358 /* Alternative malloc function, to test functionality and save the size of a
2359 compiled re, which is the first store request that pcre_compile() makes. The
2360 show_malloc variable is set only during matching. */
2361
2362 static void *new_malloc(size_t size)
2363 {
2364 void *block = malloc(size);
2365 if (show_malloc)
2366   fprintf(outfile, "malloc       %3d %p\n", (int)size, block);
2367 return block;
2368 }
2369
2370 static void new_free(void *block)
2371 {
2372 if (show_malloc)
2373   fprintf(outfile, "free             %p\n", block);
2374 free(block);
2375 }
2376
2377 /* For recursion malloc/free, to test stacking calls */
2378
2379 static void *stack_malloc(size_t size)
2380 {
2381 void *block = malloc(size);
2382 if (show_malloc)
2383   fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block);
2384 return block;
2385 }
2386
2387 static void stack_free(void *block)
2388 {
2389 if (show_malloc)
2390   fprintf(outfile, "stack_free       %p\n", block);
2391 free(block);
2392 }
2393
2394
2395 /*************************************************
2396 *          Call pcre_fullinfo()                  *
2397 *************************************************/
2398
2399 /* Get one piece of information from the pcre_fullinfo() function. When only
2400 one of 8-, 16- or 32-bit is supported, pcre_mode should always have the correct
2401 value, but the code is defensive.
2402
2403 Arguments:
2404   re        compiled regex
2405   study     study data
2406   option    PCRE_INFO_xxx option
2407   ptr       where to put the data
2408
2409 Returns:    0 when OK, < 0 on error
2410 */
2411
2412 static int
2413 new_info(pcre *re, pcre_extra *study, int option, void *ptr)
2414 {
2415 int rc;
2416
2417 if (pcre_mode == PCRE32_MODE)
2418 #ifdef SUPPORT_PCRE32
2419   rc = pcre32_fullinfo((pcre32 *)re, (pcre32_extra *)study, option, ptr);
2420 #else
2421   rc = PCRE_ERROR_BADMODE;
2422 #endif
2423 else if (pcre_mode == PCRE16_MODE)
2424 #ifdef SUPPORT_PCRE16
2425   rc = pcre16_fullinfo((pcre16 *)re, (pcre16_extra *)study, option, ptr);
2426 #else
2427   rc = PCRE_ERROR_BADMODE;
2428 #endif
2429 else
2430 #ifdef SUPPORT_PCRE8
2431   rc = pcre_fullinfo(re, study, option, ptr);
2432 #else
2433   rc = PCRE_ERROR_BADMODE;
2434 #endif
2435
2436 if (rc < 0 && rc != PCRE_ERROR_UNSET)
2437   {
2438   fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc,
2439     pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", option);
2440   if (rc == PCRE_ERROR_BADMODE)
2441     fprintf(outfile, "Running in %d-bit mode but pattern was compiled in "
2442       "%d-bit mode\n", 8 * CHAR_SIZE,
2443       8 * (REAL_PCRE_FLAGS(re) & PCRE_MODE_MASK));
2444   }
2445
2446 return rc;
2447 }
2448
2449
2450
2451 /*************************************************
2452 *             Swap byte functions                *
2453 *************************************************/
2454
2455 /* The following functions swap the bytes of a pcre_uint16 and pcre_uint32
2456 value, respectively.
2457
2458 Arguments:
2459   value        any number
2460
2461 Returns:       the byte swapped value
2462 */
2463
2464 static pcre_uint32
2465 swap_uint32(pcre_uint32 value)
2466 {
2467 return ((value & 0x000000ff) << 24) |
2468        ((value & 0x0000ff00) <<  8) |
2469        ((value & 0x00ff0000) >>  8) |
2470        (value >> 24);
2471 }
2472
2473 static pcre_uint16
2474 swap_uint16(pcre_uint16 value)
2475 {
2476 return (value >> 8) | (value << 8);
2477 }
2478
2479
2480
2481 /*************************************************
2482 *        Flip bytes in a compiled pattern        *
2483 *************************************************/
2484
2485 /* This function is called if the 'F' option was present on a pattern that is
2486 to be written to a file. We flip the bytes of all the integer fields in the
2487 regex data block and the study block. In 16-bit mode this also flips relevant
2488 bytes in the pattern itself. This is to make it possible to test PCRE's
2489 ability to reload byte-flipped patterns, e.g. those compiled on a different
2490 architecture. */
2491
2492 #if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16
2493 static void
2494 regexflip8_or_16(pcre *ere, pcre_extra *extra)
2495 {
2496 real_pcre8_or_16 *re = (real_pcre8_or_16 *)ere;
2497 #ifdef SUPPORT_PCRE16
2498 int op;
2499 pcre_uint16 *ptr = (pcre_uint16 *)re + re->name_table_offset;
2500 int length = re->name_count * re->name_entry_size;
2501 #ifdef SUPPORT_UTF
2502 BOOL utf = (re->options & PCRE_UTF16) != 0;
2503 BOOL utf16_char = FALSE;
2504 #endif /* SUPPORT_UTF */
2505 #endif /* SUPPORT_PCRE16 */
2506
2507 /* Always flip the bytes in the main data block and study blocks. */
2508
2509 re->magic_number = REVERSED_MAGIC_NUMBER;
2510 re->size = swap_uint32(re->size);
2511 re->options = swap_uint32(re->options);
2512 re->flags = swap_uint32(re->flags);
2513 re->limit_match = swap_uint32(re->limit_match);
2514 re->limit_recursion = swap_uint32(re->limit_recursion);
2515 re->first_char = swap_uint16(re->first_char);
2516 re->req_char = swap_uint16(re->req_char);
2517 re->max_lookbehind = swap_uint16(re->max_lookbehind);
2518 re->top_bracket = swap_uint16(re->top_bracket);
2519 re->top_backref = swap_uint16(re->top_backref);
2520 re->name_table_offset = swap_uint16(re->name_table_offset);
2521 re->name_entry_size = swap_uint16(re->name_entry_size);
2522 re->name_count = swap_uint16(re->name_count);
2523 re->ref_count = swap_uint16(re->ref_count);
2524
2525 if (extra != NULL && (extra->flags & PCRE_EXTRA_STUDY_DATA) != 0)
2526   {
2527   pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
2528   rsd->size = swap_uint32(rsd->size);
2529   rsd->flags = swap_uint32(rsd->flags);
2530   rsd->minlength = swap_uint32(rsd->minlength);
2531   }
2532
2533 /* In 8-bit mode, that is all we need to do. In 16-bit mode we must swap bytes
2534 in the name table, if present, and then in the pattern itself. */
2535
2536 #ifdef SUPPORT_PCRE16
2537 if (pcre_mode != PCRE16_MODE) return;
2538
2539 while(TRUE)
2540   {
2541   /* Swap previous characters. */
2542   while (length-- > 0)
2543     {
2544     *ptr = swap_uint16(*ptr);
2545     ptr++;
2546     }
2547 #ifdef SUPPORT_UTF
2548   if (utf16_char)
2549     {
2550     if ((ptr[-1] & 0xfc00) == 0xd800)
2551       {
2552       /* We know that there is only one extra character in UTF-16. */
2553       *ptr = swap_uint16(*ptr);
2554       ptr++;
2555       }
2556     }
2557   utf16_char = FALSE;
2558 #endif /* SUPPORT_UTF */
2559
2560   /* Get next opcode. */
2561
2562   length = 0;
2563   op = *ptr;
2564   *ptr++ = swap_uint16(op);
2565
2566   switch (op)
2567     {
2568     case OP_END:
2569     return;
2570
2571 #ifdef SUPPORT_UTF
2572     case OP_CHAR:
2573     case OP_CHARI:
2574     case OP_NOT:
2575     case OP_NOTI:
2576     case OP_STAR:
2577     case OP_MINSTAR:
2578     case OP_PLUS:
2579     case OP_MINPLUS:
2580     case OP_QUERY:
2581     case OP_MINQUERY:
2582     case OP_UPTO:
2583     case OP_MINUPTO:
2584     case OP_EXACT:
2585     case OP_POSSTAR:
2586     case OP_POSPLUS:
2587     case OP_POSQUERY:
2588     case OP_POSUPTO:
2589     case OP_STARI:
2590     case OP_MINSTARI:
2591     case OP_PLUSI:
2592     case OP_MINPLUSI:
2593     case OP_QUERYI:
2594     case OP_MINQUERYI:
2595     case OP_UPTOI:
2596     case OP_MINUPTOI:
2597     case OP_EXACTI:
2598     case OP_POSSTARI:
2599     case OP_POSPLUSI:
2600     case OP_POSQUERYI:
2601     case OP_POSUPTOI:
2602     case OP_NOTSTAR:
2603     case OP_NOTMINSTAR:
2604     case OP_NOTPLUS:
2605     case OP_NOTMINPLUS:
2606     case OP_NOTQUERY:
2607     case OP_NOTMINQUERY:
2608     case OP_NOTUPTO:
2609     case OP_NOTMINUPTO:
2610     case OP_NOTEXACT:
2611     case OP_NOTPOSSTAR:
2612     case OP_NOTPOSPLUS:
2613     case OP_NOTPOSQUERY:
2614     case OP_NOTPOSUPTO:
2615     case OP_NOTSTARI:
2616     case OP_NOTMINSTARI:
2617     case OP_NOTPLUSI:
2618     case OP_NOTMINPLUSI:
2619     case OP_NOTQUERYI:
2620     case OP_NOTMINQUERYI:
2621     case OP_NOTUPTOI:
2622     case OP_NOTMINUPTOI:
2623     case OP_NOTEXACTI:
2624     case OP_NOTPOSSTARI:
2625     case OP_NOTPOSPLUSI:
2626     case OP_NOTPOSQUERYI:
2627     case OP_NOTPOSUPTOI:
2628     if (utf) utf16_char = TRUE;
2629 #endif
2630     /* Fall through. */
2631
2632     default:
2633     length = OP_lengths16[op] - 1;
2634     break;
2635
2636     case OP_CLASS:
2637     case OP_NCLASS:
2638     /* Skip the character bit map. */
2639     ptr += 32/sizeof(pcre_uint16);
2640     length = 0;
2641     break;
2642
2643     case OP_XCLASS:
2644     /* LINK_SIZE can be 1 or 2 in 16 bit mode. */
2645     if (LINK_SIZE > 1)
2646       length = (int)((((unsigned int)(ptr[0]) << 16) | (unsigned int)(ptr[1]))
2647         - (1 + LINK_SIZE + 1));
2648     else
2649       length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1));
2650
2651     /* Reverse the size of the XCLASS instance. */
2652     *ptr = swap_uint16(*ptr);
2653     ptr++;
2654     if (LINK_SIZE > 1)
2655       {
2656       *ptr = swap_uint16(*ptr);
2657       ptr++;
2658       }
2659
2660     op = *ptr;
2661     *ptr = swap_uint16(op);
2662     ptr++;
2663     if ((op & XCL_MAP) != 0)
2664       {
2665       /* Skip the character bit map. */
2666       ptr += 32/sizeof(pcre_uint16);
2667       length -= 32/sizeof(pcre_uint16);
2668       }
2669     break;
2670     }
2671   }
2672 /* Control should never reach here in 16 bit mode. */
2673 #endif /* SUPPORT_PCRE16 */
2674 }
2675 #endif /* SUPPORT_PCRE[8|16] */
2676
2677
2678
2679 #if defined SUPPORT_PCRE32
2680 static void
2681 regexflip_32(pcre *ere, pcre_extra *extra)
2682 {
2683 real_pcre32 *re = (real_pcre32 *)ere;
2684 int op;
2685 pcre_uint32 *ptr = (pcre_uint32 *)re + re->name_table_offset;
2686 int length = re->name_count * re->name_entry_size;
2687
2688 /* Always flip the bytes in the main data block and study blocks. */
2689
2690 re->magic_number = REVERSED_MAGIC_NUMBER;
2691 re->size = swap_uint32(re->size);
2692 re->options = swap_uint32(re->options);
2693 re->flags = swap_uint32(re->flags);
2694 re->limit_match = swap_uint32(re->limit_match);
2695 re->limit_recursion = swap_uint32(re->limit_recursion);
2696 re->first_char = swap_uint32(re->first_char);
2697 re->req_char = swap_uint32(re->req_char);
2698 re->max_lookbehind = swap_uint16(re->max_lookbehind);
2699 re->top_bracket = swap_uint16(re->top_bracket);
2700 re->top_backref = swap_uint16(re->top_backref);
2701 re->name_table_offset = swap_uint16(re->name_table_offset);
2702 re->name_entry_size = swap_uint16(re->name_entry_size);
2703 re->name_count = swap_uint16(re->name_count);
2704 re->ref_count = swap_uint16(re->ref_count);
2705
2706 if (extra != NULL && (extra->flags & PCRE_EXTRA_STUDY_DATA) != 0)
2707   {
2708   pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
2709   rsd->size = swap_uint32(rsd->size);
2710   rsd->flags = swap_uint32(rsd->flags);
2711   rsd->minlength = swap_uint32(rsd->minlength);
2712   }
2713
2714 /* In 32-bit mode we must swap bytes in the name table, if present, and then in
2715 the pattern itself. */
2716
2717 while(TRUE)
2718   {
2719   /* Swap previous characters. */
2720   while (length-- > 0)
2721     {
2722     *ptr = swap_uint32(*ptr);
2723     ptr++;
2724     }
2725
2726   /* Get next opcode. */
2727
2728   length = 0;
2729   op = *ptr;
2730   *ptr++ = swap_uint32(op);
2731
2732   switch (op)
2733     {
2734     case OP_END:
2735     return;
2736
2737     default:
2738     length = OP_lengths32[op] - 1;
2739     break;
2740
2741     case OP_CLASS:
2742     case OP_NCLASS:
2743     /* Skip the character bit map. */
2744     ptr += 32/sizeof(pcre_uint32);
2745     length = 0;
2746     break;
2747
2748     case OP_XCLASS:
2749     /* LINK_SIZE can only be 1 in 32-bit mode. */
2750     length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1));
2751
2752     /* Reverse the size of the XCLASS instance. */
2753     *ptr = swap_uint32(*ptr);
2754     ptr++;
2755
2756     op = *ptr;
2757     *ptr = swap_uint32(op);
2758     ptr++;
2759     if ((op & XCL_MAP) != 0)
2760       {
2761       /* Skip the character bit map. */
2762       ptr += 32/sizeof(pcre_uint32);
2763       length -= 32/sizeof(pcre_uint32);
2764       }
2765     break;
2766     }
2767   }
2768 /* Control should never reach here in 32 bit mode. */
2769 }
2770
2771 #endif /* SUPPORT_PCRE32 */
2772
2773
2774
2775 static void
2776 regexflip(pcre *ere, pcre_extra *extra)
2777 {
2778 #if defined SUPPORT_PCRE32
2779   if (REAL_PCRE_FLAGS(ere) & PCRE_MODE32)
2780     regexflip_32(ere, extra);
2781 #endif
2782 #if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16
2783   if (REAL_PCRE_FLAGS(ere) & (PCRE_MODE8 | PCRE_MODE16))
2784     regexflip8_or_16(ere, extra);
2785 #endif
2786 }
2787
2788
2789
2790 /*************************************************
2791 *        Check match or recursion limit          *
2792 *************************************************/
2793
2794 static int
2795 check_match_limit(pcre *re, pcre_extra *extra, pcre_uint8 *bptr, int len,
2796   int start_offset, int options, int *use_offsets, int use_size_offsets,
2797   int flag, unsigned long int *limit, int errnumber, const char *msg)
2798 {
2799 int count;
2800 int min = 0;
2801 int mid = 64;
2802 int max = -1;
2803
2804 extra->flags |= flag;
2805
2806 for (;;)
2807   {
2808   *limit = mid;
2809
2810   PCRE_EXEC(count, re, extra, bptr, len, start_offset, options,
2811     use_offsets, use_size_offsets);
2812
2813   if (count == errnumber)
2814     {
2815     /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */
2816     min = mid;
2817     mid = (mid == max - 1)? max : (max > 0)? (min + max)/2 : mid*2;
2818     }
2819
2820   else if (count >= 0 || count == PCRE_ERROR_NOMATCH ||
2821                          count == PCRE_ERROR_PARTIAL)
2822     {
2823     if (mid == min + 1)
2824       {
2825       fprintf(outfile, "Minimum %s limit = %d\n", msg, mid);
2826       break;
2827       }
2828     /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */
2829     max = mid;
2830     mid = (min + mid)/2;
2831     }
2832   else break;    /* Some other error */
2833   }
2834
2835 extra->flags &= ~flag;
2836 return count;
2837 }
2838
2839
2840
2841 /*************************************************
2842 *         Case-independent strncmp() function    *
2843 *************************************************/
2844
2845 /*
2846 Arguments:
2847   s         first string
2848   t         second string
2849   n         number of characters to compare
2850
2851 Returns:    < 0, = 0, or > 0, according to the comparison
2852 */
2853
2854 static int
2855 strncmpic(pcre_uint8 *s, pcre_uint8 *t, int n)
2856 {
2857 while (n--)
2858   {
2859   int c = tolower(*s++) - tolower(*t++);
2860   if (c) return c;
2861   }
2862 return 0;
2863 }
2864
2865
2866
2867 /*************************************************
2868 *         Check multicharacter option            *
2869 *************************************************/
2870
2871 /* This is used both at compile and run-time to check for <xxx> escapes. Print
2872 a message and return 0 if there is no match.
2873
2874 Arguments:
2875   p           points after the leading '<'
2876   f           file for error message
2877   nl          TRUE to check only for newline settings
2878   stype       "modifier" or "escape sequence"
2879
2880 Returns:      appropriate PCRE_NEWLINE_xxx flags, or 0
2881 */
2882
2883 static int
2884 check_mc_option(pcre_uint8 *p, FILE *f, BOOL nl, const char *stype)
2885 {
2886 if (strncmpic(p, (pcre_uint8 *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;
2887 if (strncmpic(p, (pcre_uint8 *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;
2888 if (strncmpic(p, (pcre_uint8 *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;
2889 if (strncmpic(p, (pcre_uint8 *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;
2890 if (strncmpic(p, (pcre_uint8 *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;
2891 if (strncmpic(p, (pcre_uint8 *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF;
2892 if (strncmpic(p, (pcre_uint8 *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE;
2893
2894 if (!nl)
2895   {
2896   if (strncmpic(p, (pcre_uint8 *)"JS>", 3) == 0) return PCRE_JAVASCRIPT_COMPAT;
2897   }
2898
2899 fprintf(f, "Unknown %s at: <%s\n", stype, p);
2900 return 0;
2901 }
2902
2903
2904
2905 /*************************************************
2906 *             Usage function                     *
2907 *************************************************/
2908
2909 static void
2910 usage(void)
2911 {
2912 printf("Usage:     pcretest [options] [<input file> [<output file>]]\n\n");
2913 printf("Input and output default to stdin and stdout.\n");
2914 #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT)
2915 printf("If input is a terminal, readline() is used to read from it.\n");
2916 #else
2917 printf("This version of pcretest is not linked with readline().\n");
2918 #endif
2919 printf("\nOptions:\n");
2920 #ifdef SUPPORT_PCRE16
2921 printf("  -16      use the 16-bit library\n");
2922 #endif
2923 #ifdef SUPPORT_PCRE32
2924 printf("  -32      use the 32-bit library\n");
2925 #endif
2926 printf("  -b       show compiled code\n");
2927 printf("  -C       show PCRE compile-time options and exit\n");
2928 printf("  -C arg   show a specific compile-time option and exit\n");
2929 printf("           with its value if numeric (else 0). The arg can be:\n");
2930 printf("     linksize     internal link size [2, 3, 4]\n");
2931 printf("     pcre8        8 bit library support enabled [0, 1]\n");
2932 printf("     pcre16       16 bit library support enabled [0, 1]\n");
2933 printf("     pcre32       32 bit library support enabled [0, 1]\n");
2934 printf("     utf          Unicode Transformation Format supported [0, 1]\n");
2935 printf("     ucp          Unicode Properties supported [0, 1]\n");
2936 printf("     jit          Just-in-time compiler supported [0, 1]\n");
2937 printf("     newline      Newline type [CR, LF, CRLF, ANYCRLF, ANY]\n");
2938 printf("     bsr          \\R type [ANYCRLF, ANY]\n");
2939 printf("  -d       debug: show compiled code and information (-b and -i)\n");
2940 #if !defined NODFA
2941 printf("  -dfa     force DFA matching for all subjects\n");
2942 #endif
2943 printf("  -help    show usage information\n");
2944 printf("  -i       show information about compiled patterns\n"
2945        "  -M       find MATCH_LIMIT minimum for each subject\n"
2946        "  -m       output memory used information\n"
2947        "  -O       set PCRE_NO_AUTO_POSSESS on each pattern\n"
2948        "  -o <n>   set size of offsets vector to <n>\n");
2949 #if !defined NOPOSIX
2950 printf("  -p       use POSIX interface\n");
2951 #endif
2952 printf("  -q       quiet: do not output PCRE version number at start\n");
2953 printf("  -S <n>   set stack size to <n> megabytes\n");
2954 printf("  -s       force each pattern to be studied at basic level\n"
2955        "  -s+      force each pattern to be studied, using JIT if available\n"
2956        "  -s++     ditto, verifying when JIT was actually used\n"
2957        "  -s+n     force each pattern to be studied, using JIT if available,\n"
2958        "             where 1 <= n <= 7 selects JIT options\n"
2959        "  -s++n    ditto, verifying when JIT was actually used\n"
2960        "  -t       time compilation and execution\n");
2961 printf("  -t <n>   time compilation and execution, repeating <n> times\n");
2962 printf("  -tm      time execution (matching) only\n");
2963 printf("  -tm <n>  time execution (matching) only, repeating <n> times\n");
2964 printf("  -T       same as -t, but show total times at the end\n");
2965 printf("  -TM      same as -tm, but show total time at the end\n");
2966 }
2967
2968
2969
2970 /*************************************************
2971 *                Main Program                    *
2972 *************************************************/
2973
2974 /* Read lines from named file or stdin and write to named file or stdout; lines
2975 consist of a regular expression, in delimiters and optionally followed by
2976 options, followed by a set of test data, terminated by an empty line. */
2977
2978 int main(int argc, char **argv)
2979 {
2980 FILE *infile = stdin;
2981 const char *version;
2982 long int options = 0;
2983 int study_options = 0;
2984 int default_find_match_limit = FALSE;
2985 pcre_uint32 default_options = 0;
2986 int op = 1;
2987 int timeit = 0;
2988 int timeitm = 0;
2989 int showtotaltimes = 0;
2990 int showinfo = 0;
2991 int showstore = 0;
2992 int force_study = -1;
2993 int force_study_options = 0;
2994 int quiet = 0;
2995 int size_offsets = 45;
2996 int size_offsets_max;
2997 int *offsets = NULL;
2998 int debug = 0;
2999 int done = 0;
3000 int all_use_dfa = 0;
3001 int verify_jit = 0;
3002 int yield = 0;
3003 int stack_size;
3004 pcre_uint8 *dbuffer = NULL;
3005 pcre_uint8 lockout[24] = { 0 };
3006 size_t dbuffer_size = 1u << 14;
3007 clock_t total_compile_time = 0;
3008 clock_t total_study_time = 0;
3009 clock_t total_match_time = 0;
3010
3011 #if !defined NOPOSIX
3012 int posix = 0;
3013 #endif
3014 #if !defined NODFA
3015 int *dfa_workspace = NULL;
3016 #endif
3017
3018 pcre_jit_stack *jit_stack = NULL;
3019
3020 /* These vectors store, end-to-end, a list of zero-terminated captured
3021 substring names, each list itself being terminated by an empty name. Assume
3022 that 1024 is plenty long enough for the few names we'll be testing. It is
3023 easiest to keep separate 8-, 16- and 32-bit versions, using the 32-bit version
3024 for the actual memory, to ensure alignment. */
3025
3026 pcre_uint32 copynames[1024];
3027 pcre_uint32 getnames[1024];
3028
3029 #ifdef SUPPORT_PCRE32
3030 pcre_uint32 *cn32ptr;
3031 pcre_uint32 *gn32ptr;
3032 #endif
3033
3034 #ifdef SUPPORT_PCRE16
3035 pcre_uint16 *copynames16 = (pcre_uint16 *)copynames;
3036 pcre_uint16 *getnames16 = (pcre_uint16 *)getnames;
3037 pcre_uint16 *cn16ptr;
3038 pcre_uint16 *gn16ptr;
3039 #endif
3040
3041 #ifdef SUPPORT_PCRE8
3042 pcre_uint8 *copynames8 = (pcre_uint8 *)copynames;
3043 pcre_uint8 *getnames8 = (pcre_uint8 *)getnames;
3044 pcre_uint8 *cn8ptr;
3045 pcre_uint8 *gn8ptr;
3046 #endif
3047
3048 /* Get buffers from malloc() so that valgrind will check their misuse when
3049 debugging. They grow automatically when very long lines are read. The 16-
3050 and 32-bit buffers (buffer16, buffer32) are obtained only if needed. */
3051
3052 buffer = (pcre_uint8 *)malloc(buffer_size);
3053 pbuffer = (pcre_uint8 *)malloc(buffer_size);
3054
3055 /* The outfile variable is static so that new_malloc can use it. */
3056
3057 outfile = stdout;
3058
3059 /* The following  _setmode() stuff is some Windows magic that tells its runtime
3060 library to translate CRLF into a single LF character. At least, that's what
3061 I've been told: never having used Windows I take this all on trust. Originally
3062 it set 0x8000, but then I was advised that _O_BINARY was better. */
3063
3064 #if defined(_WIN32) || defined(WIN32)
3065 _setmode( _fileno( stdout ), _O_BINARY );
3066 #endif
3067
3068 /* Get the version number: both pcre_version() and pcre16_version() give the
3069 same answer. We just need to ensure that we call one that is available. */
3070
3071 #if defined SUPPORT_PCRE8
3072 version = pcre_version();
3073 #elif defined SUPPORT_PCRE16
3074 version = pcre16_version();
3075 #elif defined SUPPORT_PCRE32
3076 version = pcre32_version();
3077 #endif
3078
3079 /* Scan options */
3080
3081 while (argc > 1 && argv[op][0] == '-')
3082   {
3083   pcre_uint8 *endptr;
3084   char *arg = argv[op];
3085
3086   if (strcmp(arg, "-m") == 0) showstore = 1;
3087   else if (strcmp(arg, "-s") == 0) force_study = 0;
3088
3089   else if (strncmp(arg, "-s+", 3) == 0)
3090     {
3091     arg += 3;
3092     if (*arg == '+') { arg++; verify_jit = TRUE; }
3093     force_study = 1;
3094     if (*arg == 0)
3095       force_study_options = jit_study_bits[6];
3096     else if (*arg >= '1' && *arg <= '7')
3097       force_study_options = jit_study_bits[*arg - '1'];
3098     else goto BAD_ARG;
3099     }
3100   else if (strcmp(arg, "-8") == 0)
3101     {
3102 #ifdef SUPPORT_PCRE8
3103     pcre_mode = PCRE8_MODE;
3104 #else
3105     printf("** This version of PCRE was built without 8-bit support\n");
3106     exit(1);
3107 #endif
3108     }
3109   else if (strcmp(arg, "-16") == 0)
3110     {
3111 #ifdef SUPPORT_PCRE16
3112     pcre_mode = PCRE16_MODE;
3113 #else
3114     printf("** This version of PCRE was built without 16-bit support\n");
3115     exit(1);
3116 #endif
3117     }
3118   else if (strcmp(arg, "-32") == 0)
3119     {
3120 #ifdef SUPPORT_PCRE32
3121     pcre_mode = PCRE32_MODE;
3122 #else
3123     printf("** This version of PCRE was built without 32-bit support\n");
3124     exit(1);
3125 #endif
3126     }
3127   else if (strcmp(arg, "-q") == 0) quiet = 1;
3128   else if (strcmp(arg, "-b") == 0) debug = 1;
3129   else if (strcmp(arg, "-i") == 0) showinfo = 1;
3130   else if (strcmp(arg, "-d") == 0) showinfo = debug = 1;
3131   else if (strcmp(arg, "-M") == 0) default_find_match_limit = TRUE;
3132   else if (strcmp(arg, "-O") == 0) default_options |= PCRE_NO_AUTO_POSSESS;
3133 #if !defined NODFA
3134   else if (strcmp(arg, "-dfa") == 0) all_use_dfa = 1;
3135 #endif
3136   else if (strcmp(arg, "-o") == 0 && argc > 2 &&
3137       ((size_offsets = get_value((pcre_uint8 *)argv[op+1], &endptr)),
3138         *endptr == 0))
3139     {
3140     op++;
3141     argc--;
3142     }
3143   else if (strcmp(arg, "-t") == 0 || strcmp(arg, "-tm") == 0 ||
3144            strcmp(arg, "-T") == 0 || strcmp(arg, "-TM") == 0)
3145     {
3146     int temp;
3147     int both = arg[2] == 0;
3148     showtotaltimes = arg[1] == 'T';
3149     if (argc > 2 && (temp = get_value((pcre_uint8 *)argv[op+1], &endptr),
3150                      *endptr == 0))
3151       {
3152       timeitm = temp;
3153       op++;
3154       argc--;
3155       }
3156     else timeitm = LOOPREPEAT;
3157     if (both) timeit = timeitm;
3158     }
3159   else if (strcmp(arg, "-S") == 0 && argc > 2 &&
3160       ((stack_size = get_value((pcre_uint8 *)argv[op+1], &endptr)),
3161         *endptr == 0))
3162     {
3163 #if defined(_WIN32) || defined(WIN32) || defined(__minix) || defined(NATIVE_ZOS) || defined(__VMS)
3164     printf("PCRE: -S not supported on this OS\n");
3165     exit(1);
3166 #else
3167     int rc;
3168     struct rlimit rlim;
3169     getrlimit(RLIMIT_STACK, &rlim);
3170     rlim.rlim_cur = stack_size * 1024 * 1024;
3171     rc = setrlimit(RLIMIT_STACK, &rlim);
3172     if (rc != 0)
3173       {
3174     printf("PCRE: setrlimit() failed with error %d\n", rc);
3175     exit(1);
3176       }
3177     op++;
3178     argc--;
3179 #endif
3180     }
3181 #if !defined NOPOSIX
3182   else if (strcmp(arg, "-p") == 0) posix = 1;
3183 #endif
3184   else if (strcmp(arg, "-C") == 0)
3185     {
3186     int rc;
3187     unsigned long int lrc;
3188
3189     if (argc > 2)
3190       {
3191       if (strcmp(argv[op + 1], "linksize") == 0)
3192         {
3193         (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc);
3194         printf("%d\n", rc);
3195         yield = rc;
3196
3197 #ifdef __VMS
3198         vms_setsymbol("LINKSIZE",0,yield );
3199 #endif
3200         }
3201       else if (strcmp(argv[op + 1], "pcre8") == 0)
3202         {
3203 #ifdef SUPPORT_PCRE8
3204         printf("1\n");
3205         yield = 1;
3206 #else
3207         printf("0\n");
3208         yield = 0;
3209 #endif
3210 #ifdef __VMS
3211         vms_setsymbol("PCRE8",0,yield );
3212 #endif
3213         }
3214       else if (strcmp(argv[op + 1], "pcre16") == 0)
3215         {
3216 #ifdef SUPPORT_PCRE16
3217         printf("1\n");
3218         yield = 1;
3219 #else
3220         printf("0\n");
3221         yield = 0;
3222 #endif
3223 #ifdef __VMS
3224         vms_setsymbol("PCRE16",0,yield );
3225 #endif
3226         }
3227       else if (strcmp(argv[op + 1], "pcre32") == 0)
3228         {
3229 #ifdef SUPPORT_PCRE32
3230         printf("1\n");
3231         yield = 1;
3232 #else
3233         printf("0\n");
3234         yield = 0;
3235 #endif
3236 #ifdef __VMS
3237         vms_setsymbol("PCRE32",0,yield );
3238 #endif
3239         }
3240       else if (strcmp(argv[op + 1], "utf") == 0)
3241         {
3242 #ifdef SUPPORT_PCRE8
3243         if (pcre_mode == PCRE8_MODE)
3244           (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
3245 #endif
3246 #ifdef SUPPORT_PCRE16
3247         if (pcre_mode == PCRE16_MODE)
3248           (void)pcre16_config(PCRE_CONFIG_UTF16, &rc);
3249 #endif
3250 #ifdef SUPPORT_PCRE32
3251         if (pcre_mode == PCRE32_MODE)
3252           (void)pcre32_config(PCRE_CONFIG_UTF32, &rc);
3253 #endif
3254         printf("%d\n", rc);
3255         yield = rc;
3256 #ifdef __VMS
3257         vms_setsymbol("UTF",0,yield );
3258 #endif
3259         }
3260       else if (strcmp(argv[op + 1], "ucp") == 0)
3261         {
3262         (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
3263         printf("%d\n", rc);
3264         yield = rc;
3265         }
3266       else if (strcmp(argv[op + 1], "jit") == 0)
3267         {
3268         (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc);
3269         printf("%d\n", rc);
3270         yield = rc;
3271         }
3272       else if (strcmp(argv[op + 1], "newline") == 0)
3273         {
3274         (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc);
3275         print_newline_config(rc, TRUE);
3276         }
3277       else if (strcmp(argv[op + 1], "bsr") == 0)
3278         {
3279         (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc);
3280         printf("%s\n", rc? "ANYCRLF" : "ANY");
3281         }
3282       else if (strcmp(argv[op + 1], "ebcdic") == 0)
3283         {
3284 #ifdef EBCDIC
3285         printf("1\n");
3286         yield = 1;
3287 #else
3288         printf("0\n");
3289 #endif
3290         }
3291       else if (strcmp(argv[op + 1], "ebcdic-nl") == 0)
3292         {
3293 #ifdef EBCDIC
3294         printf("0x%02x\n", CHAR_LF);
3295 #else
3296         printf("0\n");
3297 #endif
3298         }
3299       else
3300         {
3301         printf("Unknown -C option: %s\n", argv[op + 1]);
3302         }
3303       goto EXIT;
3304       }
3305
3306     /* No argument for -C: output all configuration information. */
3307
3308     printf("PCRE version %s\n", version);
3309     printf("Compiled with\n");
3310
3311 #ifdef EBCDIC
3312     printf("  EBCDIC code support: LF is 0x%02x\n", CHAR_LF);
3313 #endif
3314
3315 /* At least one of SUPPORT_PCRE8 and SUPPORT_PCRE16 will be set. If both
3316 are set, either both UTFs are supported or both are not supported. */
3317
3318 #ifdef SUPPORT_PCRE8
3319     printf("  8-bit support\n");
3320     (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
3321       printf ("  %sUTF-8 support\n", rc ? "" : "No ");
3322 #endif
3323 #ifdef SUPPORT_PCRE16
3324     printf("  16-bit support\n");
3325     (void)pcre16_config(PCRE_CONFIG_UTF16, &rc);
3326     printf ("  %sUTF-16 support\n", rc ? "" : "No ");
3327 #endif
3328 #ifdef SUPPORT_PCRE32
3329     printf("  32-bit support\n");
3330     (void)pcre32_config(PCRE_CONFIG_UTF32, &rc);
3331     printf ("  %sUTF-32 support\n", rc ? "" : "No ");
3332 #endif
3333
3334     (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
3335     printf("  %sUnicode properties support\n", rc? "" : "No ");
3336     (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc);
3337     if (rc)
3338       {
3339       const char *arch;
3340       (void)PCRE_CONFIG(PCRE_CONFIG_JITTARGET, (void *)(&arch));
3341       printf("  Just-in-time compiler support: %s\n", arch);
3342       }
3343     else
3344       printf("  No just-in-time compiler support\n");
3345     (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc);
3346     print_newline_config(rc, FALSE);
3347     (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc);
3348     printf("  \\R matches %s\n", rc? "CR, LF, or CRLF only" :
3349                                      "all Unicode newlines");
3350     (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc);
3351     printf("  Internal link size = %d\n", rc);
3352     (void)PCRE_CONFIG(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);
3353     printf("  POSIX malloc threshold = %d\n", rc);
3354     (void)PCRE_CONFIG(PCRE_CONFIG_PARENS_LIMIT, &lrc);
3355     printf("  Parentheses nest limit = %ld\n", lrc);
3356     (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT, &lrc);
3357     printf("  Default match limit = %ld\n", lrc);
3358     (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &lrc);
3359     printf("  Default recursion depth limit = %ld\n", lrc);
3360     (void)PCRE_CONFIG(PCRE_CONFIG_STACKRECURSE, &rc);
3361     printf("  Match recursion uses %s", rc? "stack" : "heap");
3362     if (showstore)
3363       {
3364       PCRE_EXEC(stack_size, NULL, NULL, NULL, -999, -999, 0, NULL, 0);
3365       printf(": %sframe size = %d bytes", rc? "approximate " : "", -stack_size);
3366       }
3367     printf("\n");
3368     goto EXIT;
3369     }
3370   else if (strcmp(arg, "-help") == 0 ||
3371            strcmp(arg, "--help") == 0)
3372     {
3373     usage();
3374     goto EXIT;
3375     }
3376   else
3377     {
3378     BAD_ARG:
3379     printf("** Unknown or malformed option %s\n", arg);
3380     usage();
3381     yield = 1;
3382     goto EXIT;
3383     }
3384   op++;
3385   argc--;
3386   }
3387
3388 /* Get the store for the offsets vector, and remember what it was */
3389
3390 size_offsets_max = size_offsets;
3391 offsets = (int *)malloc(size_offsets_max * sizeof(int));
3392 if (offsets == NULL)
3393   {
3394   printf("** Failed to get %d bytes of memory for offsets vector\n",
3395     (int)(size_offsets_max * sizeof(int)));
3396   yield = 1;
3397   goto EXIT;
3398   }
3399
3400 /* Sort out the input and output files */
3401
3402 if (argc > 1)
3403   {
3404   infile = fopen(argv[op], INPUT_MODE);
3405   if (infile == NULL)
3406     {
3407     printf("** Failed to open %s\n", argv[op]);
3408     yield = 1;
3409     goto EXIT;
3410     }
3411   }
3412
3413 if (argc > 2)
3414   {
3415   outfile = fopen(argv[op+1], OUTPUT_MODE);
3416   if (outfile == NULL)
3417     {
3418     printf("** Failed to open %s\n", argv[op+1]);
3419     yield = 1;
3420     goto EXIT;
3421     }
3422   }
3423
3424 /* Set alternative malloc function */
3425
3426 #ifdef SUPPORT_PCRE8
3427 pcre_malloc = new_malloc;
3428 pcre_free = new_free;
3429 pcre_stack_malloc = stack_malloc;
3430 pcre_stack_free = stack_free;
3431 #endif
3432
3433 #ifdef SUPPORT_PCRE16
3434 pcre16_malloc = new_malloc;
3435 pcre16_free = new_free;
3436 pcre16_stack_malloc = stack_malloc;
3437 pcre16_stack_free = stack_free;
3438 #endif
3439
3440 #ifdef SUPPORT_PCRE32
3441 pcre32_malloc = new_malloc;
3442 pcre32_free = new_free;
3443 pcre32_stack_malloc = stack_malloc;
3444 pcre32_stack_free = stack_free;
3445 #endif
3446
3447 /* Heading line unless quiet */
3448
3449 if (!quiet) fprintf(outfile, "PCRE version %s\n\n", version);
3450
3451 /* Main loop */
3452
3453 while (!done)
3454   {
3455   pcre *re = NULL;
3456   pcre_extra *extra = NULL;
3457
3458 #if !defined NOPOSIX  /* There are still compilers that require no indent */
3459   regex_t preg = { NULL, 0, 0} ;
3460   int do_posix = 0;
3461 #endif
3462
3463   const char *error;
3464   pcre_uint8 *markptr;
3465   pcre_uint8 *p, *pp, *ppp;
3466   pcre_uint8 *to_file = NULL;
3467   const pcre_uint8 *tables = NULL;
3468   unsigned long int get_options;
3469   unsigned long int true_size, true_study_size = 0;
3470   size_t size;
3471   int do_allcaps = 0;
3472   int do_mark = 0;
3473   int do_study = 0;
3474   int no_force_study = 0;
3475   int do_debug = debug;
3476   int do_G = 0;
3477   int do_g = 0;
3478   int do_showinfo = showinfo;
3479   int do_showrest = 0;
3480   int do_showcaprest = 0;
3481   int do_flip = 0;
3482   int erroroffset, len, delimiter, poffset;
3483
3484 #if !defined NODFA
3485   int dfa_matched = 0;
3486 #endif
3487
3488   use_utf = 0;
3489   debug_lengths = 1;
3490   SET_PCRE_STACK_GUARD(NULL);
3491
3492   if (extend_inputline(infile, buffer, "  re> ") == NULL) break;
3493   if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
3494   fflush(outfile);
3495
3496   p = buffer;
3497   while (isspace(*p)) p++;
3498   if (*p == 0) continue;
3499
3500   /* Handle option lock-out setting */
3501
3502   if (*p == '<' && p[1] == ' ')
3503     {
3504     p += 2;
3505     while (isspace(*p)) p++;
3506     if (strncmp((char *)p, "forbid ", 7) == 0)
3507       {
3508       p += 7;
3509       while (isspace(*p)) p++;
3510       pp = lockout;
3511       while (!isspace(*p) && pp < lockout + sizeof(lockout) - 1)
3512         *pp++ = *p++;
3513       *pp = 0;
3514       }
3515     else
3516       {
3517       printf("** Unrecognized special command '%s'\n", p);
3518       yield = 1;
3519       goto EXIT;
3520       }
3521     continue;
3522     }
3523
3524   /* See if the pattern is to be loaded pre-compiled from a file. */
3525
3526   if (*p == '<' && strchr((char *)(p+1), '<') == NULL)
3527     {
3528     pcre_uint32 magic;
3529     pcre_uint8 sbuf[8];
3530     FILE *f;
3531
3532     p++;
3533     if (*p == '!')
3534       {
3535       do_debug = TRUE;
3536       do_showinfo = TRUE;
3537       p++;
3538       }
3539
3540     pp = p + (int)strlen((char *)p);
3541     while (isspace(pp[-1])) pp--;
3542     *pp = 0;
3543
3544     f = fopen((char *)p, "rb");
3545     if (f == NULL)
3546       {
3547       fprintf(outfile, "Failed to open %s: %s\n", p, strerror(errno));
3548       continue;
3549       }
3550     if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ;
3551
3552     true_size =
3553       (sbuf[0] << 24) | (sbuf[1] << 16) | (sbuf[2] << 8) | sbuf[3];
3554     true_study_size =
3555       (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];
3556
3557     re = (pcre *)new_malloc(true_size);
3558     if (re == NULL)
3559       {
3560       printf("** Failed to get %d bytes of memory for pcre object\n",
3561         (int)true_size);
3562       yield = 1;
3563       goto EXIT;
3564       }
3565     if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;
3566
3567     magic = REAL_PCRE_MAGIC(re);
3568     if (magic != MAGIC_NUMBER)
3569       {
3570       if (swap_uint32(magic) == MAGIC_NUMBER)
3571         {
3572         do_flip = 1;
3573         }
3574       else
3575         {
3576         fprintf(outfile, "Data in %s is not a compiled PCRE regex\n", p);
3577         new_free(re);
3578         fclose(f);
3579         continue;
3580         }
3581       }
3582
3583     /* We hide the byte-invert info for little and big endian tests. */
3584     fprintf(outfile, "Compiled pattern%s loaded from %s\n",
3585       do_flip && (p[-1] == '<') ? " (byte-inverted)" : "", p);
3586
3587     /* Now see if there is any following study data. */
3588
3589     if (true_study_size != 0)
3590       {
3591       pcre_study_data *psd;
3592
3593       extra = (pcre_extra *)new_malloc(sizeof(pcre_extra) + true_study_size);
3594       extra->flags = PCRE_EXTRA_STUDY_DATA;
3595
3596       psd = (pcre_study_data *)(((char *)extra) + sizeof(pcre_extra));
3597       extra->study_data = psd;
3598
3599       if (fread(psd, 1, true_study_size, f) != true_study_size)
3600         {
3601         FAIL_READ:
3602         fprintf(outfile, "Failed to read data from %s\n", p);
3603         if (extra != NULL)
3604           {
3605           PCRE_FREE_STUDY(extra);
3606           }
3607         new_free(re);
3608         fclose(f);
3609         continue;
3610         }
3611       fprintf(outfile, "Study data loaded from %s\n", p);
3612       do_study = 1;     /* To get the data output if requested */
3613       }
3614     else fprintf(outfile, "No study data\n");
3615
3616     /* Flip the necessary bytes. */
3617     if (do_flip)
3618       {
3619       int rc;
3620       PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, NULL);
3621       if (rc == PCRE_ERROR_BADMODE)
3622         {
3623         pcre_uint32 flags_in_host_byte_order;
3624         if (REAL_PCRE_MAGIC(re) == MAGIC_NUMBER)
3625           flags_in_host_byte_order = REAL_PCRE_FLAGS(re);
3626         else
3627           flags_in_host_byte_order = swap_uint32(REAL_PCRE_FLAGS(re));
3628         /* Simulate the result of the function call below. */
3629         fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc,
3630           pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "",
3631           PCRE_INFO_OPTIONS);
3632         fprintf(outfile, "Running in %d-bit mode but pattern was compiled in "
3633           "%d-bit mode\n", 8 * CHAR_SIZE, 8 * (flags_in_host_byte_order & PCRE_MODE_MASK));
3634         new_free(re);
3635         fclose(f);
3636         continue;
3637         }
3638       }
3639
3640     /* Need to know if UTF-8 for printing data strings. */
3641
3642     if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0)
3643       {
3644       new_free(re);
3645       fclose(f);
3646       continue;
3647       }
3648     use_utf = (get_options & PCRE_UTF8) != 0;
3649
3650     fclose(f);
3651     goto SHOW_INFO;
3652     }
3653
3654   /* In-line pattern (the usual case). Get the delimiter and seek the end of
3655   the pattern; if it isn't complete, read more. */
3656
3657   delimiter = *p++;
3658
3659   if (isalnum(delimiter) || delimiter == '\\')
3660     {
3661     fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n");
3662     goto SKIP_DATA;
3663     }
3664
3665   pp = p;
3666   poffset = (int)(p - buffer);
3667
3668   for(;;)
3669     {
3670     while (*pp != 0)
3671       {
3672       if (*pp == '\\' && pp[1] != 0) pp++;
3673         else if (*pp == delimiter) break;
3674       pp++;
3675       }
3676     if (*pp != 0) break;
3677     if ((pp = extend_inputline(infile, pp, "    > ")) == NULL)
3678       {
3679       fprintf(outfile, "** Unexpected EOF\n");
3680       done = 1;
3681       goto CONTINUE;
3682       }
3683     if (infile != stdin) fprintf(outfile, "%s", (char *)pp);
3684     }
3685
3686   /* The buffer may have moved while being extended; reset the start of data
3687   pointer to the correct relative point in the buffer. */
3688
3689   p = buffer + poffset;
3690
3691   /* If the first character after the delimiter is backslash, make
3692   the pattern end with backslash. This is purely to provide a way
3693   of testing for the error message when a pattern ends with backslash. */
3694
3695   if (pp[1] == '\\') *pp++ = '\\';
3696
3697   /* Terminate the pattern at the delimiter, and save a copy of the pattern
3698   for callouts. */
3699
3700   *pp++ = 0;
3701   strcpy((char *)pbuffer, (char *)p);
3702
3703   /* Look for modifiers and options after the final delimiter. */
3704
3705   options = default_options;
3706   study_options = force_study_options;
3707   log_store = showstore;  /* default from command line */
3708
3709   while (*pp != 0)
3710     {
3711     /* Check to see whether this modifier has been locked out for this file.
3712     This is complicated for the multi-character options that begin with '<'.
3713     If there is no '>' in the lockout string, all multi-character modifiers are
3714     locked out. */
3715
3716     if (strchr((char *)lockout, *pp) != NULL)
3717       {
3718       if (*pp == '<' && strchr((char *)lockout, '>') != NULL)
3719         {
3720         int x = check_mc_option(pp+1, outfile, FALSE, "modifier");
3721         if (x == 0) goto SKIP_DATA;
3722
3723         for (ppp = lockout; *ppp != 0; ppp++)
3724           {
3725           if (*ppp == '<')
3726             {
3727             int y = check_mc_option(ppp+1, outfile, FALSE, "modifier");
3728             if (y == 0)
3729               {
3730               printf("** Error in modifier forbid data - giving up.\n");
3731               yield = 1;
3732               goto EXIT;
3733               }
3734             if (x == y)
3735               {
3736               ppp = pp;
3737               while (*ppp != '>') ppp++;
3738               printf("** The %.*s modifier is locked out - giving up.\n",
3739                 (int)(ppp - pp + 1), pp);
3740               yield = 1;
3741               goto EXIT;
3742               }
3743             }
3744           }
3745         }
3746
3747       /* The single-character modifiers are straightforward. */
3748
3749       else
3750         {
3751         printf("** The /%c modifier is locked out - giving up.\n", *pp);
3752         yield = 1;
3753         goto EXIT;
3754         }
3755       }
3756
3757     /* The modifier is not locked out; handle it. */
3758
3759     switch (*pp++)
3760       {
3761       case 'f': options |= PCRE_FIRSTLINE; break;
3762       case 'g': do_g = 1; break;
3763       case 'i': options |= PCRE_CASELESS; break;
3764       case 'm': options |= PCRE_MULTILINE; break;
3765       case 's': options |= PCRE_DOTALL; break;
3766       case 'x': options |= PCRE_EXTENDED; break;
3767
3768       case '+':
3769       if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
3770       break;
3771
3772       case '=': do_allcaps = 1; break;
3773       case 'A': options |= PCRE_ANCHORED; break;
3774       case 'B': do_debug = 1; break;
3775       case 'C': options |= PCRE_AUTO_CALLOUT; break;
3776       case 'D': do_debug = do_showinfo = 1; break;
3777       case 'E': options |= PCRE_DOLLAR_ENDONLY; break;
3778       case 'F': do_flip = 1; break;
3779       case 'G': do_G = 1; break;
3780       case 'I': do_showinfo = 1; break;
3781       case 'J': options |= PCRE_DUPNAMES; break;
3782       case 'K': do_mark = 1; break;
3783       case 'M': log_store = 1; break;
3784       case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;
3785       case 'O': options |= PCRE_NO_AUTO_POSSESS; break;
3786
3787 #if !defined NOPOSIX
3788       case 'P': do_posix = 1; break;
3789 #endif
3790
3791       case 'Q':
3792       switch (*pp)
3793         {
3794         case '0':
3795         case '1':
3796         stack_guard_return = *pp++ - '0';
3797         break;
3798
3799         default:
3800         fprintf(outfile, "** Missing 0 or 1 after /Q\n");
3801         goto SKIP_DATA;
3802         }
3803       SET_PCRE_STACK_GUARD(stack_guard);
3804       break;
3805
3806       case 'S':
3807       do_study = 1;
3808       for (;;)
3809         {
3810         switch (*pp++)
3811           {
3812           case 'S':
3813           do_study = 0;
3814           no_force_study = 1;
3815           break;
3816
3817           case '!':
3818           study_options |= PCRE_STUDY_EXTRA_NEEDED;
3819           break;
3820
3821           case '+':
3822           if (*pp == '+')
3823             {
3824             verify_jit = TRUE;
3825             pp++;
3826             }
3827           if (*pp >= '1' && *pp <= '7')
3828             study_options |= jit_study_bits[*pp++ - '1'];
3829           else
3830             study_options |= jit_study_bits[6];
3831           break;
3832
3833           case '-':
3834           study_options &= ~PCRE_STUDY_ALLJIT;
3835           break;
3836
3837           default:
3838           pp--;
3839           goto ENDLOOP;
3840           }
3841         }
3842       ENDLOOP:
3843       break;
3844
3845       case 'U': options |= PCRE_UNGREEDY; break;
3846       case 'W': options |= PCRE_UCP; break;
3847       case 'X': options |= PCRE_EXTRA; break;
3848       case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
3849       case 'Z': debug_lengths = 0; break;
3850       case '8': options |= PCRE_UTF8; use_utf = 1; break;
3851       case '9': options |= PCRE_NEVER_UTF; break;
3852       case '?': options |= PCRE_NO_UTF8_CHECK; break;
3853
3854       case 'T':
3855       switch (*pp++)
3856         {
3857         case '0': tables = tables0; break;
3858         case '1': tables = tables1; break;
3859
3860         case '\r':
3861         case '\n':
3862         case ' ':
3863         case 0:
3864         fprintf(outfile, "** Missing table number after /T\n");
3865         goto SKIP_DATA;
3866
3867         default:
3868         fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]);
3869         goto SKIP_DATA;
3870         }
3871       break;
3872
3873       case 'L':
3874       ppp = pp;
3875       /* The '\r' test here is so that it works on Windows. */
3876       /* The '0' test is just in case this is an unterminated line. */
3877       while (*ppp != 0 && *ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++;
3878       *ppp = 0;
3879       if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
3880         {
3881         fprintf(outfile, "** Failed to set locale \"%s\"\n", pp);
3882         goto SKIP_DATA;
3883         }
3884       locale_set = 1;
3885       tables = PCRE_MAKETABLES;
3886       pp = ppp;
3887       break;
3888
3889       case '>':
3890       to_file = pp;
3891       while (*pp != 0) pp++;
3892       while (isspace(pp[-1])) pp--;
3893       *pp = 0;
3894       break;
3895
3896       case '<':
3897         {
3898         int x = check_mc_option(pp, outfile, FALSE, "modifier");
3899         if (x == 0) goto SKIP_DATA;
3900         options |= x;
3901         while (*pp++ != '>');
3902         }
3903       break;
3904
3905       case '\r':                      /* So that it works in Windows */
3906       case '\n':
3907       case ' ':
3908       break;
3909
3910       default:
3911       fprintf(outfile, "** Unknown modifier '%c'\n", pp[-1]);
3912       goto SKIP_DATA;
3913       }
3914     }
3915
3916   /* Handle compiling via the POSIX interface, which doesn't support the
3917   timing, showing, or debugging options, nor the ability to pass over
3918   local character tables. Neither does it have 16-bit support. */
3919
3920 #if !defined NOPOSIX
3921   if (posix || do_posix)
3922     {
3923     int rc;
3924     int cflags = 0;
3925
3926     if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE;
3927     if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE;
3928     if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;
3929     if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB;
3930     if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8;
3931     if ((options & PCRE_UCP) != 0) cflags |= REG_UCP;
3932     if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY;
3933
3934     rc = regcomp(&preg, (char *)p, cflags);
3935
3936     /* Compilation failed; go back for another re, skipping to blank line
3937     if non-interactive. */
3938
3939     if (rc != 0)
3940       {
3941       (void)regerror(rc, &preg, (char *)buffer, buffer_size);
3942       fprintf(outfile, "Failed: POSIX code %d: %s\n", rc, buffer);
3943       goto SKIP_DATA;
3944       }
3945     }
3946
3947   /* Handle compiling via the native interface */
3948
3949   else
3950 #endif  /* !defined NOPOSIX */