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