/[pcre]/code/trunk/pcretest.c
ViewVC logotype

Diff of /code/trunk/pcretest.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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