/[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 1101 by chpe, Tue Oct 16 15:56:30 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-, 16- or 32-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/16/32-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 *pbuffer = NULL;
 static uschar *pbuffer = NULL;  
835    
836    /* Another buffer is needed translation to 16/32-bit character strings. It will
837    obtained and extended as required. */
838    
839    #if defined SUPPORT_PCRE8 && (defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32)
840    
841  /*************************************************  /* We need the table of operator lengths that is used for 16/32-bit compiling, in
842  *        Read or extend an input line            *  order to swap bytes in a pattern for saving/reloading testing. Luckily, the
843  *************************************************/  data is defined as a macro. However, we must ensure that LINK_SIZE is adjusted
844    appropriately for the 16/32-bit world. Just as a safety check, make sure that
845    COMPILE_PCRE[16|32] is *not* set. */
846    
847  /* Input lines are read into buffer, but both patterns and data lines can be  #ifdef COMPILE_PCRE16
848  continued over multiple input lines. In addition, if the buffer fills up, we  #error COMPILE_PCRE16 must not be set when compiling pcretest.c
849  want to automatically expand it so as to be able to handle extremely large  #endif
 lines that are needed for certain stress tests. When the input buffer is  
 expanded, the other two buffers must also be expanded likewise, and the  
 contents of pbuffer, which are a copy of the input for callouts, must be  
 preserved (for when expansion happens for a data line). This is not the most  
 optimal way of handling this, but hey, this is just a test program!  
850    
851  Arguments:  #ifdef COMPILE_PCRE32
852    f            the file to read  #error COMPILE_PCRE32 must not be set when compiling pcretest.c
853    start        where in buffer to start (this *must* be within buffer)  #endif
854    
855  Returns:       pointer to the start of new data  #if LINK_SIZE == 2
856                 could be a copy of start, or could be moved  #undef LINK_SIZE
857                 NULL if no data read and EOF reached  #define LINK_SIZE 1
858  */  #elif LINK_SIZE == 3 || LINK_SIZE == 4
859    #undef LINK_SIZE
860    #define LINK_SIZE 2
861    #else
862    #error LINK_SIZE must be either 2, 3, or 4
863    #endif
864    
865  static uschar *  #undef IMM2_SIZE
866  extend_inputline(FILE *f, uschar *start)  #define IMM2_SIZE 1
 {  
 uschar *here = start;  
867    
868  for (;;)  #endif /* SUPPORT_PCRE8 && (SUPPORT_PCRE16 || SUPPORT_PCRE32) */
   {  
   int rlen = buffer_size - (here - buffer);  
869    
870    if (rlen > 1000)  #ifdef SUPPORT_PCRE16
871      {  static int buffer16_size = 0;
872      int dlen;  static pcre_uint16 *buffer16 = NULL;
873      if (fgets((char *)here, rlen,  f) == NULL)  static const pcre_uint16 OP_lengths16[] = { OP_LENGTHS };
874        return (here == start)? NULL : start;  #endif  /* SUPPORT_PCRE16 */
875      dlen = (int)strlen((char *)here);  
876      if (dlen > 0 && here[dlen - 1] == '\n') return start;  #ifdef SUPPORT_PCRE32
877      here += dlen;  static int buffer32_size = 0;
878      }  static pcre_uint32 *buffer32 = NULL;
879    static const pcre_uint32 OP_lengths32[] = { OP_LENGTHS };
880    #endif  /* SUPPORT_PCRE32 */
881    
882    /* If we have 8-bit support, default to it; if there is also
883    16-or 32-bit support, it can be changed by an option. If there is no 8-bit support,
884    there must be 16-or 32-bit support, so default it to 1. */
885    
886    #if defined SUPPORT_PCRE8
887    static int pcre_mode = PCRE8_MODE;
888    #elif defined SUPPORT_PCRE16
889    static int pcre_mode = PCRE16_MODE;
890    #elif defined SUPPORT_PCRE32
891    static int pcre_mode = PCRE32_MODE;
892    #endif
893    
894    else  /* JIT study options for -s+n and /S+n where '1' <= n <= '7'. */
     {  
     int new_buffer_size = 2*buffer_size;  
     uschar *new_buffer = (unsigned char *)malloc(new_buffer_size);  
     uschar *new_dbuffer = (unsigned char *)malloc(new_buffer_size);  
     uschar *new_pbuffer = (unsigned char *)malloc(new_buffer_size);  
895    
896      if (new_buffer == NULL || new_dbuffer == NULL || new_pbuffer == NULL)  static int jit_study_bits[] =
897        {    {
898        fprintf(stderr, "pcretest: malloc(%d) failed\n", new_buffer_size);    PCRE_STUDY_JIT_COMPILE,
899        exit(1);    PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE,
900        }    PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE,
901      PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
902      PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
903      PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE,
904      PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE +
905        PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE
906    };
907    
908    #define PCRE_STUDY_ALLJIT (PCRE_STUDY_JIT_COMPILE | \
909      PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE)
910    
911    /* Textual explanations for runtime error codes */
912    
913    static const char *errtexts[] = {
914      NULL,  /* 0 is no error */
915      NULL,  /* NOMATCH is handled specially */
916      "NULL argument passed",
917      "bad option value",
918      "magic number missing",
919      "unknown opcode - pattern overwritten?",
920      "no more memory",
921      NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
922      "match limit exceeded",
923      "callout error code",
924      NULL,  /* BADUTF8/16 is handled specially */
925      NULL,  /* BADUTF8/16 offset is handled specially */
926      NULL,  /* PARTIAL is handled specially */
927      "not used - internal error",
928      "internal error - pattern overwritten?",
929      "bad count value",
930      "item unsupported for DFA matching",
931      "backreference condition or recursion test not supported for DFA matching",
932      "match limit not supported for DFA matching",
933      "workspace size exceeded in DFA matching",
934      "too much recursion for DFA matching",
935      "recursion limit exceeded",
936      "not used - internal error",
937      "invalid combination of newline options",
938      "bad offset value",
939      NULL,  /* SHORTUTF8/16 is handled specially */
940      "nested recursion at the same subject position",
941      "JIT stack limit reached",
942      "pattern compiled in wrong mode: 8-bit/16-bit error",
943      "pattern compiled with other endianness",
944      "invalid data in workspace for DFA restart"
945    };
946    
     memcpy(new_buffer, buffer, buffer_size);  
     memcpy(new_pbuffer, pbuffer, buffer_size);  
947    
948      buffer_size = new_buffer_size;  /*************************************************
949    *         Alternate character tables             *
950    *************************************************/
951    
952      start = new_buffer + (start - buffer);  /* By default, the "tables" pointer when calling PCRE is set to NULL, thereby
953      here = new_buffer + (here - buffer);  using the default tables of the library. However, the T option can be used to
954    select alternate sets of tables, for different kinds of testing. Note also that
955    the L (locale) option also adjusts the tables. */
956    
957    /* This is the set of tables distributed as default with PCRE. It recognizes
958    only ASCII characters. */
959    
960    static const pcre_uint8 tables0[] = {
961    
962    /* This table is a lower casing table. */
963    
964        0,  1,  2,  3,  4,  5,  6,  7,
965        8,  9, 10, 11, 12, 13, 14, 15,
966       16, 17, 18, 19, 20, 21, 22, 23,
967       24, 25, 26, 27, 28, 29, 30, 31,
968       32, 33, 34, 35, 36, 37, 38, 39,
969       40, 41, 42, 43, 44, 45, 46, 47,
970       48, 49, 50, 51, 52, 53, 54, 55,
971       56, 57, 58, 59, 60, 61, 62, 63,
972       64, 97, 98, 99,100,101,102,103,
973      104,105,106,107,108,109,110,111,
974      112,113,114,115,116,117,118,119,
975      120,121,122, 91, 92, 93, 94, 95,
976       96, 97, 98, 99,100,101,102,103,
977      104,105,106,107,108,109,110,111,
978      112,113,114,115,116,117,118,119,
979      120,121,122,123,124,125,126,127,
980      128,129,130,131,132,133,134,135,
981      136,137,138,139,140,141,142,143,
982      144,145,146,147,148,149,150,151,
983      152,153,154,155,156,157,158,159,
984      160,161,162,163,164,165,166,167,
985      168,169,170,171,172,173,174,175,
986      176,177,178,179,180,181,182,183,
987      184,185,186,187,188,189,190,191,
988      192,193,194,195,196,197,198,199,
989      200,201,202,203,204,205,206,207,
990      208,209,210,211,212,213,214,215,
991      216,217,218,219,220,221,222,223,
992      224,225,226,227,228,229,230,231,
993      232,233,234,235,236,237,238,239,
994      240,241,242,243,244,245,246,247,
995      248,249,250,251,252,253,254,255,
996    
997    /* This table is a case flipping table. */
998    
999        0,  1,  2,  3,  4,  5,  6,  7,
1000        8,  9, 10, 11, 12, 13, 14, 15,
1001       16, 17, 18, 19, 20, 21, 22, 23,
1002       24, 25, 26, 27, 28, 29, 30, 31,
1003       32, 33, 34, 35, 36, 37, 38, 39,
1004       40, 41, 42, 43, 44, 45, 46, 47,
1005       48, 49, 50, 51, 52, 53, 54, 55,
1006       56, 57, 58, 59, 60, 61, 62, 63,
1007       64, 97, 98, 99,100,101,102,103,
1008      104,105,106,107,108,109,110,111,
1009      112,113,114,115,116,117,118,119,
1010      120,121,122, 91, 92, 93, 94, 95,
1011       96, 65, 66, 67, 68, 69, 70, 71,
1012       72, 73, 74, 75, 76, 77, 78, 79,
1013       80, 81, 82, 83, 84, 85, 86, 87,
1014       88, 89, 90,123,124,125,126,127,
1015      128,129,130,131,132,133,134,135,
1016      136,137,138,139,140,141,142,143,
1017      144,145,146,147,148,149,150,151,
1018      152,153,154,155,156,157,158,159,
1019      160,161,162,163,164,165,166,167,
1020      168,169,170,171,172,173,174,175,
1021      176,177,178,179,180,181,182,183,
1022      184,185,186,187,188,189,190,191,
1023      192,193,194,195,196,197,198,199,
1024      200,201,202,203,204,205,206,207,
1025      208,209,210,211,212,213,214,215,
1026      216,217,218,219,220,221,222,223,
1027      224,225,226,227,228,229,230,231,
1028      232,233,234,235,236,237,238,239,
1029      240,241,242,243,244,245,246,247,
1030      248,249,250,251,252,253,254,255,
1031    
1032    /* This table contains bit maps for various character classes. Each map is 32
1033    bytes long and the bits run from the least significant end of each byte. The
1034    classes that have their own maps are: space, xdigit, digit, upper, lower, word,
1035    graph, print, punct, and cntrl. Other classes are built from combinations. */
1036    
1037      0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
1038      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1039      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1040      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1041    
1042      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1043      0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
1044      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1045      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1046    
1047      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1048      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1049      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1050      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1051    
1052      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1053      0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
1054      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1055      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1056    
1057      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1058      0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
1059      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1060      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1061    
1062      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
1063      0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
1064      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1065      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1066    
1067      0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
1068      0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
1069      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1070      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1071    
1072      0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
1073      0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
1074      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1075      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1076    
1077      0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
1078      0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
1079      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1080      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1081    
1082      0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
1083      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
1084      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1085      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1086    
1087    /* This table identifies various classes of character by individual bits:
1088      0x01   white space character
1089      0x02   letter
1090      0x04   decimal digit
1091      0x08   hexadecimal digit
1092      0x10   alphanumeric or '_'
1093      0x80   regular expression metacharacter or binary zero
1094    */
1095    
1096      free(buffer);    0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
1097      free(dbuffer);    0x00,0x01,0x01,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
1098      free(pbuffer);    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
1099      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
1100      0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /*    - '  */
1101      0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /*  ( - /  */
1102      0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
1103      0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /*  8 - ?  */
1104      0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  @ - G  */
1105      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
1106      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
1107      0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /*  X - _  */
1108      0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  ` - g  */
1109      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  h - o  */
1110      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  p - w  */
1111      0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /*  x -127 */
1112      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
1113      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
1114      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
1115      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
1116      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
1117      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
1118      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
1119      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
1120      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
1121      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
1122      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
1123      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
1124      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
1125      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
1126      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
1127      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
1128    
1129    /* This is a set of tables that came orginally from a Windows user. It seems to
1130    be at least an approximation of ISO 8859. In particular, there are characters
1131    greater than 128 that are marked as spaces, letters, etc. */
1132    
1133    static const pcre_uint8 tables1[] = {
1134    0,1,2,3,4,5,6,7,
1135    8,9,10,11,12,13,14,15,
1136    16,17,18,19,20,21,22,23,
1137    24,25,26,27,28,29,30,31,
1138    32,33,34,35,36,37,38,39,
1139    40,41,42,43,44,45,46,47,
1140    48,49,50,51,52,53,54,55,
1141    56,57,58,59,60,61,62,63,
1142    64,97,98,99,100,101,102,103,
1143    104,105,106,107,108,109,110,111,
1144    112,113,114,115,116,117,118,119,
1145    120,121,122,91,92,93,94,95,
1146    96,97,98,99,100,101,102,103,
1147    104,105,106,107,108,109,110,111,
1148    112,113,114,115,116,117,118,119,
1149    120,121,122,123,124,125,126,127,
1150    128,129,130,131,132,133,134,135,
1151    136,137,138,139,140,141,142,143,
1152    144,145,146,147,148,149,150,151,
1153    152,153,154,155,156,157,158,159,
1154    160,161,162,163,164,165,166,167,
1155    168,169,170,171,172,173,174,175,
1156    176,177,178,179,180,181,182,183,
1157    184,185,186,187,188,189,190,191,
1158    224,225,226,227,228,229,230,231,
1159    232,233,234,235,236,237,238,239,
1160    240,241,242,243,244,245,246,215,
1161    248,249,250,251,252,253,254,223,
1162    224,225,226,227,228,229,230,231,
1163    232,233,234,235,236,237,238,239,
1164    240,241,242,243,244,245,246,247,
1165    248,249,250,251,252,253,254,255,
1166    0,1,2,3,4,5,6,7,
1167    8,9,10,11,12,13,14,15,
1168    16,17,18,19,20,21,22,23,
1169    24,25,26,27,28,29,30,31,
1170    32,33,34,35,36,37,38,39,
1171    40,41,42,43,44,45,46,47,
1172    48,49,50,51,52,53,54,55,
1173    56,57,58,59,60,61,62,63,
1174    64,97,98,99,100,101,102,103,
1175    104,105,106,107,108,109,110,111,
1176    112,113,114,115,116,117,118,119,
1177    120,121,122,91,92,93,94,95,
1178    96,65,66,67,68,69,70,71,
1179    72,73,74,75,76,77,78,79,
1180    80,81,82,83,84,85,86,87,
1181    88,89,90,123,124,125,126,127,
1182    128,129,130,131,132,133,134,135,
1183    136,137,138,139,140,141,142,143,
1184    144,145,146,147,148,149,150,151,
1185    152,153,154,155,156,157,158,159,
1186    160,161,162,163,164,165,166,167,
1187    168,169,170,171,172,173,174,175,
1188    176,177,178,179,180,181,182,183,
1189    184,185,186,187,188,189,190,191,
1190    224,225,226,227,228,229,230,231,
1191    232,233,234,235,236,237,238,239,
1192    240,241,242,243,244,245,246,215,
1193    248,249,250,251,252,253,254,223,
1194    192,193,194,195,196,197,198,199,
1195    200,201,202,203,204,205,206,207,
1196    208,209,210,211,212,213,214,247,
1197    216,217,218,219,220,221,222,255,
1198    0,62,0,0,1,0,0,0,
1199    0,0,0,0,0,0,0,0,
1200    32,0,0,0,1,0,0,0,
1201    0,0,0,0,0,0,0,0,
1202    0,0,0,0,0,0,255,3,
1203    126,0,0,0,126,0,0,0,
1204    0,0,0,0,0,0,0,0,
1205    0,0,0,0,0,0,0,0,
1206    0,0,0,0,0,0,255,3,
1207    0,0,0,0,0,0,0,0,
1208    0,0,0,0,0,0,12,2,
1209    0,0,0,0,0,0,0,0,
1210    0,0,0,0,0,0,0,0,
1211    254,255,255,7,0,0,0,0,
1212    0,0,0,0,0,0,0,0,
1213    255,255,127,127,0,0,0,0,
1214    0,0,0,0,0,0,0,0,
1215    0,0,0,0,254,255,255,7,
1216    0,0,0,0,0,4,32,4,
1217    0,0,0,128,255,255,127,255,
1218    0,0,0,0,0,0,255,3,
1219    254,255,255,135,254,255,255,7,
1220    0,0,0,0,0,4,44,6,
1221    255,255,127,255,255,255,127,255,
1222    0,0,0,0,254,255,255,255,
1223    255,255,255,255,255,255,255,127,
1224    0,0,0,0,254,255,255,255,
1225    255,255,255,255,255,255,255,255,
1226    0,2,0,0,255,255,255,255,
1227    255,255,255,255,255,255,255,127,
1228    0,0,0,0,255,255,255,255,
1229    255,255,255,255,255,255,255,255,
1230    0,0,0,0,254,255,0,252,
1231    1,0,0,248,1,0,0,120,
1232    0,0,0,0,254,255,255,255,
1233    0,0,128,0,0,0,128,0,
1234    255,255,255,255,0,0,0,0,
1235    0,0,0,0,0,0,0,128,
1236    255,255,255,255,0,0,0,0,
1237    0,0,0,0,0,0,0,0,
1238    128,0,0,0,0,0,0,0,
1239    0,1,1,0,1,1,0,0,
1240    0,0,0,0,0,0,0,0,
1241    0,0,0,0,0,0,0,0,
1242    1,0,0,0,128,0,0,0,
1243    128,128,128,128,0,0,128,0,
1244    28,28,28,28,28,28,28,28,
1245    28,28,0,0,0,0,0,128,
1246    0,26,26,26,26,26,26,18,
1247    18,18,18,18,18,18,18,18,
1248    18,18,18,18,18,18,18,18,
1249    18,18,18,128,128,0,128,16,
1250    0,26,26,26,26,26,26,18,
1251    18,18,18,18,18,18,18,18,
1252    18,18,18,18,18,18,18,18,
1253    18,18,18,128,128,0,0,0,
1254    0,0,0,0,0,1,0,0,
1255    0,0,0,0,0,0,0,0,
1256    0,0,0,0,0,0,0,0,
1257    0,0,0,0,0,0,0,0,
1258    1,0,0,0,0,0,0,0,
1259    0,0,18,0,0,0,0,0,
1260    0,0,20,20,0,18,0,0,
1261    0,20,18,0,0,0,0,0,
1262    18,18,18,18,18,18,18,18,
1263    18,18,18,18,18,18,18,18,
1264    18,18,18,18,18,18,18,0,
1265    18,18,18,18,18,18,18,18,
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,0,
1269    18,18,18,18,18,18,18,18
1270    };
1271    
     buffer = new_buffer;  
     dbuffer = new_dbuffer;  
     pbuffer = new_pbuffer;  
     }  
   }  
1272    
 return NULL;  /* Control never gets here */  
 }  
1273    
1274    
1275    #ifndef HAVE_STRERROR
1276    /*************************************************
1277    *     Provide strerror() for non-ANSI libraries  *
1278    *************************************************/
1279    
1280    /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
1281    in their libraries, but can provide the same facility by this simple
1282    alternative function. */
1283    
1284    extern int   sys_nerr;
1285    extern char *sys_errlist[];
1286    
1287    char *
1288    strerror(int n)
1289    {
1290    if (n < 0 || n >= sys_nerr) return "unknown error number";
1291    return sys_errlist[n];
1292    }
1293    #endif /* HAVE_STRERROR */
1294    
1295    
1296    
1297  /*************************************************  /*************************************************
1298  *          Read number from string               *  *       Print newline configuration              *
1299  *************************************************/  *************************************************/
1300    
1301  /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess  /*
1302  around with conditional compilation, just do the job by hand. It is only used  Arguments:
1303  for unpicking arguments, so just keep it simple.    rc         the return code from PCRE_CONFIG_NEWLINE
1304      isc        TRUE if called from "-C newline"
1305  Arguments:  Returns:     nothing
   str           string to be converted  
   endptr        where to put the end pointer  
   
 Returns:        the unsigned long  
1306  */  */
1307    
1308  static int  static void
1309  get_value(unsigned char *str, unsigned char **endptr)  print_newline_config(int rc, BOOL isc)
1310  {  {
1311  int result = 0;  const char *s = NULL;
1312  while(*str != 0 && isspace(*str)) str++;  if (!isc) printf("  Newline sequence is ");
1313  while (isdigit(*str)) result = result * 10 + (int)(*str++ - '0');  switch(rc)
1314  *endptr = str;    {
1315  return(result);    case CHAR_CR: s = "CR"; break;
1316      case CHAR_LF: s = "LF"; break;
1317      case (CHAR_CR<<8 | CHAR_LF): s = "CRLF"; break;
1318      case -1: s = "ANY"; break;
1319      case -2: s = "ANYCRLF"; break;
1320    
1321      default:
1322      printf("a non-standard value: 0x%04x\n", rc);
1323      return;
1324      }
1325    
1326    printf("%s\n", s);
1327  }  }
1328    
1329    
1330    
1331    /*************************************************
1332    *         JIT memory callback                    *
1333    *************************************************/
1334    
1335    static pcre_jit_stack* jit_callback(void *arg)
1336    {
1337    jit_was_used = TRUE;
1338    return (pcre_jit_stack *)arg;
1339    }
1340    
1341    
1342    #if !defined NOUTF || defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32
1343  /*************************************************  /*************************************************
1344  *            Convert UTF-8 string to value       *  *            Convert UTF-8 string to value       *
1345  *************************************************/  *************************************************/
# Line 297  Returns:      >  0 => the number of byte Line 1355  Returns:      >  0 => the number of byte
1355                -6 to 0 => malformed UTF-8 character at offset = (-return)                -6 to 0 => malformed UTF-8 character at offset = (-return)
1356  */  */
1357    
 #if !defined NOUTF8  
   
1358  static int  static int
1359  utf82ord(unsigned char *utf8bytes, int *vptr)  utf82ord(pcre_uint8 *utf8bytes, pcre_uint32 *vptr)
1360  {  {
1361  int c = *utf8bytes++;  pcre_uint32 c = *utf8bytes++;
1362  int d = c;  pcre_uint32 d = c;
1363  int i, j, s;  int i, j, s;
1364    
1365  for (i = -1; i < 6; i++)               /* i is number of additional bytes */  for (i = -1; i < 6; i++)               /* i is number of additional bytes */
# Line 339  if (j != i) return -(i+1); Line 1395  if (j != i) return -(i+1);
1395  *vptr = d;  *vptr = d;
1396  return i+1;  return i+1;
1397  }  }
1398    #endif /* NOUTF || SUPPORT_PCRE16 */
 #endif  
1399    
1400    
1401    
1402    #if !defined NOUTF || defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32
1403  /*************************************************  /*************************************************
1404  *       Convert character value to UTF-8         *  *       Convert character value to UTF-8         *
1405  *************************************************/  *************************************************/
# Line 358  Arguments: Line 1414  Arguments:
1414  Returns:     number of characters placed in the buffer  Returns:     number of characters placed in the buffer
1415  */  */
1416    
 #if !defined NOUTF8  
   
1417  static int  static int
1418  ord2utf8(int cvalue, uschar *utf8bytes)  ord2utf8(pcre_uint32 cvalue, pcre_uint8 *utf8bytes)
1419  {  {
1420  register int i, j;  register int i, j;
1421    if (cvalue > 0x7fffffffu)
1422      return -1;
1423  for (i = 0; i < utf8_table1_size; i++)  for (i = 0; i < utf8_table1_size; i++)
1424    if (cvalue <= utf8_table1[i]) break;    if (cvalue <= utf8_table1[i]) break;
1425  utf8bytes += i;  utf8bytes += i;
# Line 375  for (j = i; j > 0; j--) Line 1431  for (j = i; j > 0; j--)
1431  *utf8bytes = utf8_table2[i] | cvalue;  *utf8bytes = utf8_table2[i] | cvalue;
1432  return i + 1;  return i + 1;
1433  }  }
1434    #endif
1435    
1436    
1437    #ifdef SUPPORT_PCRE16
1438    /*************************************************
1439    *         Convert a string to 16-bit             *
1440    *************************************************/
1441    
1442    /* In non-UTF mode, the space needed for a 16-bit string is exactly double the
1443    8-bit size. For a UTF-8 string, the size needed for UTF-16 is no more than
1444    double, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4
1445    in UTF-16. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-16. The
1446    result is always left in buffer16.
1447    
1448    Note that this function does not object to surrogate values. This is
1449    deliberate; it makes it possible to construct UTF-16 strings that are invalid,
1450    for the purpose of testing that they are correctly faulted.
1451    
1452    Patterns to be converted are either plain ASCII or UTF-8; data lines are always
1453    in UTF-8 so that values greater than 255 can be handled.
1454    
1455    Arguments:
1456      data       TRUE if converting a data line; FALSE for a regex
1457      p          points to a byte string
1458      utf        true if UTF-8 (to be converted to UTF-16)
1459      len        number of bytes in the string (excluding trailing zero)
1460    
1461    Returns:     number of 16-bit data items used (excluding trailing zero)
1462                 OR -1 if a UTF-8 string is malformed
1463                 OR -2 if a value > 0x10ffff is encountered
1464                 OR -3 if a value > 0xffff is encountered when not in UTF mode
1465    */
1466    
1467    static int
1468    to16(int data, pcre_uint8 *p, int utf, int len)
1469    {
1470    pcre_uint16 *pp;
1471    
1472    if (buffer16_size < 2*len + 2)
1473      {
1474      if (buffer16 != NULL) free(buffer16);
1475      buffer16_size = 2*len + 2;
1476      buffer16 = (pcre_uint16 *)malloc(buffer16_size);
1477      if (buffer16 == NULL)
1478        {
1479        fprintf(stderr, "pcretest: malloc(%d) failed for buffer16\n", buffer16_size);
1480        exit(1);
1481        }
1482      }
1483    
1484    pp = buffer16;
1485    
1486    if (!utf && !data)
1487      {
1488      while (len-- > 0) *pp++ = *p++;
1489      }
1490    
1491    else
1492      {
1493      pcre_uint32 c = 0;
1494      while (len > 0)
1495        {
1496        int chlen = utf82ord(p, &c);
1497        if (chlen <= 0) return -1;
1498        if (c > 0x10ffff) return -2;
1499        p += chlen;
1500        len -= chlen;
1501        if (c < 0x10000) *pp++ = c; else
1502          {
1503          if (!utf) return -3;
1504          c -= 0x10000;
1505          *pp++ = 0xD800 | (c >> 10);
1506          *pp++ = 0xDC00 | (c & 0x3ff);
1507          }
1508        }
1509      }
1510    
1511    *pp = 0;
1512    return pp - buffer16;
1513    }
1514  #endif  #endif
1515    
1516    #ifdef SUPPORT_PCRE32
1517    /*************************************************
1518    *         Convert a string to 32-bit             *
1519    *************************************************/
1520    
1521    /* In non-UTF mode, the space needed for a 32-bit string is exactly four times the
1522    8-bit size. For a UTF-8 string, the size needed for UTF-32 is no more than four
1523    times, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4
1524    in UTF-32. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-32. The
1525    result is always left in buffer32.
1526    
1527    Note that this function does not object to surrogate values. This is
1528    deliberate; it makes it possible to construct UTF-32 strings that are invalid,
1529    for the purpose of testing that they are correctly faulted.
1530    
1531    Patterns to be converted are either plain ASCII or UTF-8; data lines are always
1532    in UTF-8 so that values greater than 255 can be handled.
1533    
1534    Arguments:
1535      data       TRUE if converting a data line; FALSE for a regex
1536      p          points to a byte string
1537      utf        true if UTF-8 (to be converted to UTF-32)
1538      len        number of bytes in the string (excluding trailing zero)
1539    
1540    Returns:     number of 32-bit data items used (excluding trailing zero)
1541                 OR -1 if a UTF-8 string is malformed
1542                 OR -2 if a value > 0x10ffff is encountered
1543                 OR -3 if an ill-formed value is encountered (i.e. a surrogate)
1544    */
1545    
1546    static int
1547    to32(int data, pcre_uint8 *p, int utf, int len)
1548    {
1549    pcre_uint32 *pp;
1550    
1551    if (buffer32_size < 4*len + 4)
1552      {
1553      if (buffer32 != NULL) free(buffer32);
1554      buffer32_size = 4*len + 4;
1555      buffer32 = (pcre_uint32 *)malloc(buffer32_size);
1556      if (buffer32 == NULL)
1557        {
1558        fprintf(stderr, "pcretest: malloc(%d) failed for buffer32\n", buffer32_size);
1559        exit(1);
1560        }
1561      }
1562    
1563    pp = buffer32;
1564    
1565    if (!utf && !data)
1566      {
1567      while (len-- > 0) *pp++ = *p++;
1568      }
1569    
1570    else
1571      {
1572      pcre_uint32 c = 0;
1573      while (len > 0)
1574        {
1575        int chlen = utf82ord(p, &c);
1576        if (chlen <= 0) return -1;
1577        if (utf)
1578          {
1579          if (c > 0x10ffff) return -2;
1580          if (!data && (c & 0xfffff800u) == 0xd800u) return -3;
1581          }
1582    
1583        p += chlen;
1584        len -= chlen;
1585        *pp++ = c;
1586        }
1587      }
1588    
1589    *pp = 0;
1590    return pp - buffer32;
1591    }
1592    #endif
1593    
1594    /*************************************************
1595    *        Read or extend an input line            *
1596    *************************************************/
1597    
1598    /* Input lines are read into buffer, but both patterns and data lines can be
1599    continued over multiple input lines. In addition, if the buffer fills up, we
1600    want to automatically expand it so as to be able to handle extremely large
1601    lines that are needed for certain stress tests. When the input buffer is
1602    expanded, the other two buffers must also be expanded likewise, and the
1603    contents of pbuffer, which are a copy of the input for callouts, must be
1604    preserved (for when expansion happens for a data line). This is not the most
1605    optimal way of handling this, but hey, this is just a test program!
1606    
1607    Arguments:
1608      f            the file to read
1609      start        where in buffer to start (this *must* be within buffer)
1610      prompt       for stdin or readline()
1611    
1612    Returns:       pointer to the start of new data
1613                   could be a copy of start, or could be moved
1614                   NULL if no data read and EOF reached
1615    */
1616    
1617    static pcre_uint8 *
1618    extend_inputline(FILE *f, pcre_uint8 *start, const char *prompt)
1619    {
1620    pcre_uint8 *here = start;
1621    
1622    for (;;)
1623      {
1624      size_t rlen = (size_t)(buffer_size - (here - buffer));
1625    
1626      if (rlen > 1000)
1627        {
1628        int dlen;
1629    
1630        /* If libreadline or libedit support is required, use readline() to read a
1631        line if the input is a terminal. Note that readline() removes the trailing
1632        newline, so we must put it back again, to be compatible with fgets(). */
1633    
1634    #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT)
1635        if (isatty(fileno(f)))
1636          {
1637          size_t len;
1638          char *s = readline(prompt);
1639          if (s == NULL) return (here == start)? NULL : start;
1640          len = strlen(s);
1641          if (len > 0) add_history(s);
1642          if (len > rlen - 1) len = rlen - 1;
1643          memcpy(here, s, len);
1644          here[len] = '\n';
1645          here[len+1] = 0;
1646          free(s);
1647          }
1648        else
1649    #endif
1650    
1651        /* Read the next line by normal means, prompting if the file is stdin. */
1652    
1653          {
1654          if (f == stdin) printf("%s", prompt);
1655          if (fgets((char *)here, rlen,  f) == NULL)
1656            return (here == start)? NULL : start;
1657          }
1658    
1659        dlen = (int)strlen((char *)here);
1660        if (dlen > 0 && here[dlen - 1] == '\n') return start;
1661        here += dlen;
1662        }
1663    
1664      else
1665        {
1666        int new_buffer_size = 2*buffer_size;
1667        pcre_uint8 *new_buffer = (pcre_uint8 *)malloc(new_buffer_size);
1668        pcre_uint8 *new_pbuffer = (pcre_uint8 *)malloc(new_buffer_size);
1669    
1670        if (new_buffer == 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(pbuffer);
1686    
1687        buffer = new_buffer;
1688        pbuffer = new_pbuffer;
1689        }
1690      }
1691    
1692    return NULL;  /* Control never gets here */
1693    }
1694    
1695    
1696    
1697    /*************************************************
1698    *          Read number from string               *
1699    *************************************************/
1700    
1701    /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess
1702    around with conditional compilation, just do the job by hand. It is only used
1703    for unpicking arguments, so just keep it simple.
1704    
1705    Arguments:
1706      str           string to be converted
1707      endptr        where to put the end pointer
1708    
1709    Returns:        the unsigned long
1710    */
1711    
1712    static int
1713    get_value(pcre_uint8 *str, pcre_uint8 **endptr)
1714    {
1715    int result = 0;
1716    while(*str != 0 && isspace(*str)) str++;
1717    while (isdigit(*str)) result = result * 10 + (int)(*str++ - '0');
1718    *endptr = str;
1719    return(result);
1720    }
1721    
1722    
1723    
1724    /*************************************************
1725    *             Print one character                *
1726    *************************************************/
1727    
1728    /* Print a single character either literally, or as a hex escape. */
1729    
1730    static int pchar(pcre_uint32 c, FILE *f)
1731    {
1732    int n;
1733    if (PRINTOK(c))
1734      {
1735      if (f != NULL) fprintf(f, "%c", c);
1736      return 1;
1737      }
1738    
1739    if (c < 0x100)
1740      {
1741      if (use_utf)
1742        {
1743        if (f != NULL) fprintf(f, "\\x{%02x}", c);
1744        return 6;
1745        }
1746      else
1747        {
1748        if (f != NULL) fprintf(f, "\\x%02x", c);
1749        return 4;
1750        }
1751      }
1752    
1753    if (f != NULL) n = fprintf(f, "\\x{%02x}", c);
1754    return n >= 0 ? n : 0;
1755    }
1756    
1757    
1758    
1759    #ifdef SUPPORT_PCRE8
1760  /*************************************************  /*************************************************
1761  *             Print character string             *  *         Print 8-bit character string           *
1762  *************************************************/  *************************************************/
1763    
1764  /* Character string printing function. Must handle UTF-8 strings in utf8  /* Must handle UTF-8 strings in utf8 mode. Yields number of characters printed.
1765  mode. Yields number of characters printed. If handed a NULL file, just counts  If handed a NULL file, just counts chars without printing. */
 chars without printing. */  
1766    
1767  static int pchars(unsigned char *p, int length, FILE *f)  static int pchars(pcre_uint8 *p, int length, FILE *f)
1768  {  {
1769  int c = 0;  pcre_uint32 c = 0;
1770  int yield = 0;  int yield = 0;
1771    
1772    if (length < 0)
1773      length = strlen((char *)p);
1774    
1775  while (length-- > 0)  while (length-- > 0)
1776    {    {
1777  #if !defined NOUTF8  #if !defined NOUTF
1778    if (use_utf8)    if (use_utf)
1779      {      {
1780      int rc = utf82ord(p, &c);      int rc = utf82ord(p, &c);
   
1781      if (rc > 0 && rc <= length + 1)   /* Mustn't run over the end */      if (rc > 0 && rc <= length + 1)   /* Mustn't run over the end */
1782        {        {
1783        length -= rc - 1;        length -= rc - 1;
1784        p += rc;        p += rc;
1785        if (PRINTHEX(c))        yield += pchar(c, f);
         {  
         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;  
         }  
1786        continue;        continue;
1787        }        }
1788      }      }
1789  #endif  #endif
1790      c = *p++;
1791      yield += pchar(c, f);
1792      }
1793    
1794     /* Not UTF-8, or malformed UTF-8  */  return yield;
1795    }
1796    #endif
1797    
1798    c = *p++;  
1799    if (PRINTHEX(c))  
1800      {  #ifdef SUPPORT_PCRE16
1801      if (f != NULL) fprintf(f, "%c", c);  /*************************************************
1802      yield++;  *    Find length of 0-terminated 16-bit string   *
1803      }  *************************************************/
1804    else  
1805    static int strlen16(PCRE_SPTR16 p)
1806    {
1807    int len = 0;
1808    while (*p++ != 0) len++;
1809    return len;
1810    }
1811    #endif  /* SUPPORT_PCRE16 */
1812    
1813    
1814    
1815    #ifdef SUPPORT_PCRE32
1816    /*************************************************
1817    *    Find length of 0-terminated 32-bit string   *
1818    *************************************************/
1819    
1820    static int strlen32(PCRE_SPTR32 p)
1821    {
1822    int len = 0;
1823    while (*p++ != 0) len++;
1824    return len;
1825    }
1826    #endif  /* SUPPORT_PCRE32 */
1827    
1828    
1829    
1830    #ifdef SUPPORT_PCRE16
1831    /*************************************************
1832    *           Print 16-bit character string        *
1833    *************************************************/
1834    
1835    /* Must handle UTF-16 strings in utf mode. Yields number of characters printed.
1836    If handed a NULL file, just counts chars without printing. */
1837    
1838    static int pchars16(PCRE_SPTR16 p, int length, FILE *f)
1839    {
1840    int yield = 0;
1841    
1842    if (length < 0)
1843      length = strlen16(p);
1844    
1845    while (length-- > 0)
1846      {
1847      pcre_uint32 c = *p++ & 0xffff;
1848    #if !defined NOUTF
1849      if (use_utf && c >= 0xD800 && c < 0xDC00 && length > 0)
1850      {      {
1851      if (f != NULL) fprintf(f, "\\x%02x", c);      int d = *p & 0xffff;
1852      yield += 4;      if (d >= 0xDC00 && d < 0xDFFF)
1853          {
1854          c = ((c & 0x3ff) << 10) + (d & 0x3ff) + 0x10000;
1855          length--;
1856          p++;
1857          }
1858      }      }
1859    #endif
1860      yield += pchar(c, f);
1861      }
1862    
1863    return yield;
1864    }
1865    #endif  /* SUPPORT_PCRE16 */
1866    
1867    
1868    
1869    #ifdef SUPPORT_PCRE32
1870    /*************************************************
1871    *           Print 32-bit character string        *
1872    *************************************************/
1873    
1874    /* Must handle UTF-32 strings in utf mode. Yields number of characters printed.
1875    If handed a NULL file, just counts chars without printing. */
1876    
1877    static int pchars32(PCRE_SPTR32 p, int length, FILE *f)
1878    {
1879    int yield = 0;
1880    
1881    if (length < 0)
1882      length = strlen32(p);
1883    
1884    while (length-- > 0)
1885      {
1886      pcre_uint32 c = *p++;
1887      yield += pchar(c, f);
1888    }    }
1889    
1890  return yield;  return yield;
1891  }  }
1892    #endif  /* SUPPORT_PCRE32 */
1893    
1894    
1895    
1896    #ifdef SUPPORT_PCRE8
1897    /*************************************************
1898    *     Read a capture name (8-bit) and check it   *
1899    *************************************************/
1900    
1901    static pcre_uint8 *
1902    read_capture_name8(pcre_uint8 *p, pcre_uint8 **pp, pcre *re)
1903    {
1904    pcre_uint8 *npp = *pp;
1905    while (isalnum(*p)) *npp++ = *p++;
1906    *npp++ = 0;
1907    *npp = 0;
1908    if (pcre_get_stringnumber(re, (char *)(*pp)) < 0)
1909      {
1910      fprintf(outfile, "no parentheses with name \"");
1911      PCHARSV(*pp, 0, -1, outfile);
1912      fprintf(outfile, "\"\n");
1913      }
1914    
1915    *pp = npp;
1916    return p;
1917    }
1918    #endif  /* SUPPORT_PCRE8 */
1919    
1920    
1921    
1922    #ifdef SUPPORT_PCRE16
1923    /*************************************************
1924    *     Read a capture name (16-bit) and check it  *
1925    *************************************************/
1926    
1927    /* Note that the text being read is 8-bit. */
1928    
1929    static pcre_uint8 *
1930    read_capture_name16(pcre_uint8 *p, pcre_uint16 **pp, pcre *re)
1931    {
1932    pcre_uint16 *npp = *pp;
1933    while (isalnum(*p)) *npp++ = *p++;
1934    *npp++ = 0;
1935    *npp = 0;
1936    if (pcre16_get_stringnumber((pcre16 *)re, (PCRE_SPTR16)(*pp)) < 0)
1937      {
1938      fprintf(outfile, "no parentheses with name \"");
1939      PCHARSV(*pp, 0, -1, outfile);
1940      fprintf(outfile, "\"\n");
1941      }
1942    *pp = npp;
1943    return p;
1944    }
1945    #endif  /* SUPPORT_PCRE16 */
1946    
1947    
1948    
1949    #ifdef SUPPORT_PCRE32
1950    /*************************************************
1951    *     Read a capture name (32-bit) and check it  *
1952    *************************************************/
1953    
1954    /* Note that the text being read is 8-bit. */
1955    
1956    static pcre_uint8 *
1957    read_capture_name32(pcre_uint8 *p, pcre_uint32 **pp, pcre *re)
1958    {
1959    pcre_uint32 *npp = *pp;
1960    while (isalnum(*p)) *npp++ = *p++;
1961    *npp++ = 0;
1962    *npp = 0;
1963    if (pcre32_get_stringnumber((pcre32 *)re, (PCRE_SPTR32)(*pp)) < 0)
1964      {
1965      fprintf(outfile, "no parentheses with name \"");
1966      PCHARSV(*pp, 0, -1, outfile);
1967      fprintf(outfile, "\"\n");
1968      }
1969    *pp = npp;
1970    return p;
1971    }
1972    #endif  /* SUPPORT_PCRE32 */
1973    
1974    
1975    
# Line 468  if (callout_extra) Line 1998  if (callout_extra)
1998      else      else
1999        {        {
2000        fprintf(f, "%2d: ", i/2);        fprintf(f, "%2d: ", i/2);
2001        (void)pchars((unsigned char *)cb->subject + cb->offset_vector[i],        PCHARSV(cb->subject, cb->offset_vector[i],
2002          cb->offset_vector[i+1] - cb->offset_vector[i], f);          cb->offset_vector[i+1] - cb->offset_vector[i], f);
2003        fprintf(f, "\n");        fprintf(f, "\n");
2004        }        }
# Line 481  printed lengths of the substrings. */ Line 2011  printed lengths of the substrings. */
2011    
2012  if (f != NULL) fprintf(f, "--->");  if (f != NULL) fprintf(f, "--->");
2013    
2014  pre_start = pchars((unsigned char *)cb->subject, cb->start_match, f);  PCHARS(pre_start, cb->subject, 0, cb->start_match, f);
2015  post_start = pchars((unsigned char *)(cb->subject + cb->start_match),  PCHARS(post_start, cb->subject, cb->start_match,
2016    cb->current_position - cb->start_match, f);    cb->current_position - cb->start_match, f);
2017    
2018  subject_length = pchars((unsigned char *)cb->subject, cb->subject_length, NULL);  PCHARS(subject_length, cb->subject, 0, cb->subject_length, NULL);
2019    
2020  (void)pchars((unsigned char *)(cb->subject + cb->current_position),  PCHARSV(cb->subject, cb->current_position,
2021    cb->subject_length - cb->current_position, f);    cb->subject_length - cb->current_position, f);
2022    
2023  if (f != NULL) fprintf(f, "\n");  if (f != NULL) fprintf(f, "\n");
# Line 524  fprintf(outfile, "%.*s", (cb->next_item_ Line 2054  fprintf(outfile, "%.*s", (cb->next_item_
2054  fprintf(outfile, "\n");  fprintf(outfile, "\n");
2055  first_callout = 0;  first_callout = 0;
2056    
2057    if (cb->mark != last_callout_mark)
2058      {
2059      if (cb->mark == NULL)
2060        fprintf(outfile, "Latest Mark: <unset>\n");
2061      else
2062        {
2063        fprintf(outfile, "Latest Mark: ");
2064        PCHARSV(cb->mark, 0, -1, outfile);
2065        putc('\n', outfile);
2066        }
2067      last_callout_mark = cb->mark;
2068      }
2069    
2070  if (cb->callout_data != NULL)  if (cb->callout_data != NULL)
2071    {    {
2072    int callout_data = *((int *)(cb->callout_data));    int callout_data = *((int *)(cb->callout_data));
# Line 543  return (cb->callout_number != callout_fa Line 2086  return (cb->callout_number != callout_fa
2086  *            Local malloc functions              *  *            Local malloc functions              *
2087  *************************************************/  *************************************************/
2088    
2089  /* Alternative malloc function, to test functionality and show the size of the  /* Alternative malloc function, to test functionality and save the size of a
2090  compiled re. */  compiled re, which is the first store request that pcre_compile() makes. The
2091    show_malloc variable is set only during matching. */
2092    
2093  static void *new_malloc(size_t size)  static void *new_malloc(size_t size)
2094  {  {
2095  void *block = malloc(size);  void *block = malloc(size);
2096  gotten_store = size;  gotten_store = size;
2097    if (first_gotten_store == 0) first_gotten_store = size;
2098  if (show_malloc)  if (show_malloc)
2099    fprintf(outfile, "malloc       %3d %p\n", (int)size, block);    fprintf(outfile, "malloc       %3d %p\n", (int)size, block);
2100  return block;  return block;
# Line 562  if (show_malloc) Line 2107  if (show_malloc)
2107  free(block);  free(block);
2108  }  }
2109    
   
2110  /* For recursion malloc/free, to test stacking calls */  /* For recursion malloc/free, to test stacking calls */
2111    
2112  static void *stack_malloc(size_t size)  static void *stack_malloc(size_t size)
# Line 573  if (show_malloc) Line 2117  if (show_malloc)
2117  return block;  return block;
2118  }  }
2119    
2120  static void stack_free(void *block)  static void stack_free(void *block)
2121    {
2122    if (show_malloc)
2123      fprintf(outfile, "stack_free       %p\n", block);
2124    free(block);
2125    }
2126    
2127    
2128    /*************************************************
2129    *          Call pcre_fullinfo()                  *
2130    *************************************************/
2131    
2132    /* Get one piece of information from the pcre_fullinfo() function. When only
2133    one of 8-, 16- or 32-bit is supported, pcre_mode should always have the correct
2134    value, but the code is defensive.
2135    
2136    Arguments:
2137      re        compiled regex
2138      study     study data
2139      option    PCRE_INFO_xxx option
2140      ptr       where to put the data
2141    
2142    Returns:    0 when OK, < 0 on error
2143    */
2144    
2145    static int
2146    new_info(pcre *re, pcre_extra *study, int option, void *ptr)
2147    {
2148    int rc;
2149    
2150    if (pcre_mode == PCRE32_MODE)
2151    #ifdef SUPPORT_PCRE32
2152      rc = pcre32_fullinfo((pcre32 *)re, (pcre32_extra *)study, option, ptr);
2153    #else
2154      rc = PCRE_ERROR_BADMODE;
2155    #endif
2156    else if (pcre_mode == PCRE16_MODE)
2157    #ifdef SUPPORT_PCRE16
2158      rc = pcre16_fullinfo((pcre16 *)re, (pcre16_extra *)study, option, ptr);
2159    #else
2160      rc = PCRE_ERROR_BADMODE;
2161    #endif
2162    else
2163    #ifdef SUPPORT_PCRE8
2164      rc = pcre_fullinfo(re, study, option, ptr);
2165    #else
2166      rc = PCRE_ERROR_BADMODE;
2167    #endif
2168    
2169    if (rc < 0)
2170      {
2171      fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc,
2172        pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", option);
2173      if (rc == PCRE_ERROR_BADMODE)
2174        fprintf(outfile, "Running in %d-bit mode but pattern was compiled in "
2175          "%d-bit mode\n", 8 * CHAR_SIZE,
2176          8 * (REAL_PCRE_FLAGS(re) & PCRE_MODE_MASK));
2177      }
2178    
2179    return rc;
2180    }
2181    
2182    
2183    
2184    /*************************************************
2185    *             Swap byte functions                *
2186    *************************************************/
2187    
2188    /* The following functions swap the bytes of a pcre_uint16 and pcre_uint32
2189    value, respectively.
2190    
2191    Arguments:
2192      value        any number
2193    
2194    Returns:       the byte swapped value
2195    */
2196    
2197    static pcre_uint32
2198    swap_uint32(pcre_uint32 value)
2199    {
2200    return ((value & 0x000000ff) << 24) |
2201           ((value & 0x0000ff00) <<  8) |
2202           ((value & 0x00ff0000) >>  8) |
2203           (value >> 24);
2204    }
2205    
2206    static pcre_uint16
2207    swap_uint16(pcre_uint16 value)
2208    {
2209    return (value >> 8) | (value << 8);
2210    }
2211    
2212    
2213    
2214    /*************************************************
2215    *        Flip bytes in a compiled pattern        *
2216    *************************************************/
2217    
2218    /* This function is called if the 'F' option was present on a pattern that is
2219    to be written to a file. We flip the bytes of all the integer fields in the
2220    regex data block and the study block. In 16-bit mode this also flips relevant
2221    bytes in the pattern itself. This is to make it possible to test PCRE's
2222    ability to reload byte-flipped patterns, e.g. those compiled on a different
2223    architecture. */
2224    
2225    #if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16
2226    static void
2227    regexflip8_or_16(pcre *ere, pcre_extra *extra)
2228    {
2229    real_pcre8_or_16 *re = (real_pcre8_or_16 *)ere;
2230    #ifdef SUPPORT_PCRE16
2231    int op;
2232    pcre_uint16 *ptr = (pcre_uint16 *)re + re->name_table_offset;
2233    int length = re->name_count * re->name_entry_size;
2234    #ifdef SUPPORT_UTF
2235    BOOL utf = (re->options & PCRE_UTF16) != 0;
2236    BOOL utf16_char = FALSE;
2237    #endif /* SUPPORT_UTF */
2238    #endif /* SUPPORT_PCRE16 */
2239    
2240    /* Always flip the bytes in the main data block and study blocks. */
2241    
2242    re->magic_number = REVERSED_MAGIC_NUMBER;
2243    re->size = swap_uint32(re->size);
2244    re->options = swap_uint32(re->options);
2245    re->flags = swap_uint16(re->flags);
2246    re->top_bracket = swap_uint16(re->top_bracket);
2247    re->top_backref = swap_uint16(re->top_backref);
2248    re->first_char = swap_uint16(re->first_char);
2249    re->req_char = swap_uint16(re->req_char);
2250    re->name_table_offset = swap_uint16(re->name_table_offset);
2251    re->name_entry_size = swap_uint16(re->name_entry_size);
2252    re->name_count = swap_uint16(re->name_count);
2253    
2254    if (extra != NULL)
2255      {
2256      pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
2257      rsd->size = swap_uint32(rsd->size);
2258      rsd->flags = swap_uint32(rsd->flags);
2259      rsd->minlength = swap_uint32(rsd->minlength);
2260      }
2261    
2262    /* In 8-bit mode, that is all we need to do. In 16-bit mode we must swap bytes
2263    in the name table, if present, and then in the pattern itself. */
2264    
2265    #ifdef SUPPORT_PCRE16
2266    if (pcre_mode != PCRE16_MODE) return;
2267    
2268    while(TRUE)
2269      {
2270      /* Swap previous characters. */
2271      while (length-- > 0)
2272        {
2273        *ptr = swap_uint16(*ptr);
2274        ptr++;
2275        }
2276    #ifdef SUPPORT_UTF
2277      if (utf16_char)
2278        {
2279        if ((ptr[-1] & 0xfc00) == 0xd800)
2280          {
2281          /* We know that there is only one extra character in UTF-16. */
2282          *ptr = swap_uint16(*ptr);
2283          ptr++;
2284          }
2285        }
2286      utf16_char = FALSE;
2287    #endif /* SUPPORT_UTF */
2288    
2289      /* Get next opcode. */
2290    
2291      length = 0;
2292      op = *ptr;
2293      *ptr++ = swap_uint16(op);
2294    
2295      switch (op)
2296        {
2297        case OP_END:
2298        return;
2299    
2300    #ifdef SUPPORT_UTF
2301        case OP_CHAR:
2302        case OP_CHARI:
2303        case OP_NOT:
2304        case OP_NOTI:
2305        case OP_STAR:
2306        case OP_MINSTAR:
2307        case OP_PLUS:
2308        case OP_MINPLUS:
2309        case OP_QUERY:
2310        case OP_MINQUERY:
2311        case OP_UPTO:
2312        case OP_MINUPTO:
2313        case OP_EXACT:
2314        case OP_POSSTAR:
2315        case OP_POSPLUS:
2316        case OP_POSQUERY:
2317        case OP_POSUPTO:
2318        case OP_STARI:
2319        case OP_MINSTARI:
2320        case OP_PLUSI:
2321        case OP_MINPLUSI:
2322        case OP_QUERYI:
2323        case OP_MINQUERYI:
2324        case OP_UPTOI:
2325        case OP_MINUPTOI:
2326        case OP_EXACTI:
2327        case OP_POSSTARI:
2328        case OP_POSPLUSI:
2329        case OP_POSQUERYI:
2330        case OP_POSUPTOI:
2331        case OP_NOTSTAR:
2332        case OP_NOTMINSTAR:
2333        case OP_NOTPLUS:
2334        case OP_NOTMINPLUS:
2335        case OP_NOTQUERY:
2336        case OP_NOTMINQUERY:
2337        case OP_NOTUPTO:
2338        case OP_NOTMINUPTO:
2339        case OP_NOTEXACT:
2340        case OP_NOTPOSSTAR:
2341        case OP_NOTPOSPLUS:
2342        case OP_NOTPOSQUERY:
2343        case OP_NOTPOSUPTO:
2344        case OP_NOTSTARI:
2345        case OP_NOTMINSTARI:
2346        case OP_NOTPLUSI:
2347        case OP_NOTMINPLUSI:
2348        case OP_NOTQUERYI:
2349        case OP_NOTMINQUERYI:
2350        case OP_NOTUPTOI:
2351        case OP_NOTMINUPTOI:
2352        case OP_NOTEXACTI:
2353        case OP_NOTPOSSTARI:
2354        case OP_NOTPOSPLUSI:
2355        case OP_NOTPOSQUERYI:
2356        case OP_NOTPOSUPTOI:
2357        if (utf) utf16_char = TRUE;
2358    #endif
2359        /* Fall through. */
2360    
2361        default:
2362        length = OP_lengths16[op] - 1;
2363        break;
2364    
2365        case OP_CLASS:
2366        case OP_NCLASS:
2367        /* Skip the character bit map. */
2368        ptr += 32/sizeof(pcre_uint16);
2369        length = 0;
2370        break;
2371    
2372        case OP_XCLASS:
2373        /* LINK_SIZE can be 1 or 2 in 16 bit mode. */
2374        if (LINK_SIZE > 1)
2375          length = (int)((((unsigned int)(ptr[0]) << 16) | (unsigned int)(ptr[1]))
2376            - (1 + LINK_SIZE + 1));
2377        else
2378          length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1));
2379    
2380        /* Reverse the size of the XCLASS instance. */
2381        *ptr = swap_uint16(*ptr);
2382        ptr++;
2383        if (LINK_SIZE > 1)
2384          {
2385          *ptr = swap_uint16(*ptr);
2386          ptr++;
2387          }
2388    
2389        op = *ptr;
2390        *ptr = swap_uint16(op);
2391        ptr++;
2392        if ((op & XCL_MAP) != 0)
2393          {
2394          /* Skip the character bit map. */
2395          ptr += 32/sizeof(pcre_uint16);
2396          length -= 32/sizeof(pcre_uint16);
2397          }
2398        break;
2399        }
2400      }
2401    /* Control should never reach here in 16 bit mode. */
2402    #endif /* SUPPORT_PCRE16 */
2403    }
2404    #endif /* SUPPORT_PCRE[8|16] */
2405    
2406    
2407    
2408    #if defined SUPPORT_PCRE32
2409    static void
2410    regexflip_32(pcre *ere, pcre_extra *extra)
2411  {  {
2412  if (show_malloc)  real_pcre32 *re = (real_pcre32 *)ere;
2413    fprintf(outfile, "stack_free       %p\n", block);  int op;
2414  free(block);  pcre_uint32 *ptr = (pcre_uint32 *)re + re->name_table_offset;
2415  }  int length = re->name_count * re->name_entry_size;
2416    #ifdef SUPPORT_UTF
2417    BOOL utf = (re->options & PCRE_UTF32) != 0;
2418    #endif /* SUPPORT_UTF */
2419    
2420    /* Always flip the bytes in the main data block and study blocks. */
2421    
2422    re->magic_number = REVERSED_MAGIC_NUMBER;
2423    re->size = swap_uint32(re->size);
2424    re->options = swap_uint32(re->options);
2425    re->flags = swap_uint16(re->flags);
2426    re->top_bracket = swap_uint16(re->top_bracket);
2427    re->top_backref = swap_uint16(re->top_backref);
2428    re->first_char = swap_uint32(re->first_char);
2429    re->req_char = swap_uint32(re->req_char);
2430    re->name_table_offset = swap_uint16(re->name_table_offset);
2431    re->name_entry_size = swap_uint16(re->name_entry_size);
2432    re->name_count = swap_uint16(re->name_count);
2433    
2434    if (extra != NULL)
2435      {
2436      pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
2437      rsd->size = swap_uint32(rsd->size);
2438      rsd->flags = swap_uint32(rsd->flags);
2439      rsd->minlength = swap_uint32(rsd->minlength);
2440      }
2441    
2442  /*************************************************  /* In 32-bit mode we must swap bytes
2443  *          Call pcre_fullinfo()                  *  in the name table, if present, and then in the pattern itself. */
2444  *************************************************/  
2445    while(TRUE)
2446      {
2447      /* Swap previous characters. */
2448      while (length-- > 0)
2449        {
2450        *ptr = swap_uint32(*ptr);
2451        ptr++;
2452        }
2453    
2454  /* Get one piece of information from the pcre_fullinfo() function */    /* Get next opcode. */
2455    
2456  static void new_info(pcre *re, pcre_extra *study, int option, void *ptr)    length = 0;
2457  {    op = *ptr;
2458  int rc;    *ptr++ = swap_uint32(op);
2459  if ((rc = pcre_fullinfo(re, study, option, ptr)) < 0)  
2460    fprintf(outfile, "Error %d from pcre_fullinfo(%d)\n", rc, option);    switch (op)
2461        {
2462        case OP_END:
2463        return;
2464    
2465        default:
2466        length = OP_lengths32[op] - 1;
2467        break;
2468    
2469        case OP_CLASS:
2470        case OP_NCLASS:
2471        /* Skip the character bit map. */
2472        ptr += 32/sizeof(pcre_uint32);
2473        length = 0;
2474        break;
2475    
2476        case OP_XCLASS:
2477        /* LINK_SIZE can only be 1 in 32-bit mode. */
2478        length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1));
2479    
2480        /* Reverse the size of the XCLASS instance. */
2481        *ptr = swap_uint32(*ptr);
2482        ptr++;
2483    
2484        op = *ptr;
2485        *ptr = swap_uint32(op);
2486        ptr++;
2487        if ((op & XCL_MAP) != 0)
2488          {
2489          /* Skip the character bit map. */
2490          ptr += 32/sizeof(pcre_uint32);
2491          length -= 32/sizeof(pcre_uint32);
2492          }
2493        break;
2494        }
2495      }
2496    /* Control should never reach here in 32 bit mode. */
2497  }  }
2498    
2499    #endif /* SUPPORT_PCRE32 */
2500    
2501    
 /*************************************************  
 *         Byte flipping function                 *  
 *************************************************/  
2502    
2503  static unsigned long int  static void
2504  byteflip(unsigned long int value, int n)  regexflip(pcre *ere, pcre_extra *extra)
2505  {  {
2506  if (n == 2) return ((value & 0x00ff) << 8) | ((value & 0xff00) >> 8);  #if defined SUPPORT_PCRE32
2507  return ((value & 0x000000ff) << 24) |    if (REAL_PCRE_FLAGS(ere) & PCRE_MODE32)
2508         ((value & 0x0000ff00) <<  8) |      regexflip_32(ere, extra);
2509         ((value & 0x00ff0000) >>  8) |  #endif
2510         ((value & 0xff000000) >> 24);  #if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16
2511      if (REAL_PCRE_FLAGS(ere) & (PCRE_MODE8 | PCRE_MODE16))
2512        regexflip8_or_16(ere, extra);
2513    #endif
2514  }  }
2515    
2516    
2517    
   
2518  /*************************************************  /*************************************************
2519  *        Check match or recursion limit          *  *        Check match or recursion limit          *
2520  *************************************************/  *************************************************/
2521    
2522  static int  static int
2523  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,
2524    int start_offset, int options, int *use_offsets, int use_size_offsets,    int start_offset, int options, int *use_offsets, int use_size_offsets,
2525    int flag, unsigned long int *limit, int errnumber, const char *msg)    int flag, unsigned long int *limit, int errnumber, const char *msg)
2526  {  {
# Line 633  for (;;) Line 2535  for (;;)
2535    {    {
2536    *limit = mid;    *limit = mid;
2537    
2538    count = pcre_exec(re, extra, (char *)bptr, len, start_offset, options,    PCRE_EXEC(count, re, extra, bptr, len, start_offset, options,
2539      use_offsets, use_size_offsets);      use_offsets, use_size_offsets);
2540    
2541    if (count == errnumber)    if (count == errnumber)
# Line 678  Returns:    < 0, = 0, or > 0, according Line 2580  Returns:    < 0, = 0, or > 0, according
2580  */  */
2581    
2582  static int  static int
2583  strncmpic(uschar *s, uschar *t, int n)  strncmpic(pcre_uint8 *s, pcre_uint8 *t, int n)
2584  {  {
2585  while (n--)  while (n--)
2586    {    {
# Line 694  return 0; Line 2596  return 0;
2596  *         Check newline indicator                *  *         Check newline indicator                *
2597  *************************************************/  *************************************************/
2598    
2599  /* 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
2600  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.  
2601    
2602  Arguments:  Arguments:
2603    p           points after the leading '<'    p           points after the leading '<'
# Line 706  Returns:      appropriate PCRE_NEWLINE_x Line 2607  Returns:      appropriate PCRE_NEWLINE_x
2607  */  */
2608    
2609  static int  static int
2610  check_newline(uschar *p, FILE *f)  check_newline(pcre_uint8 *p, FILE *f)
2611  {  {
2612  if (strncmpic(p, (uschar *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;  if (strncmpic(p, (pcre_uint8 *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;
2613  if (strncmpic(p, (uschar *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;  if (strncmpic(p, (pcre_uint8 *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;
2614  if (strncmpic(p, (uschar *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;  if (strncmpic(p, (pcre_uint8 *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;
2615  if (strncmpic(p, (uschar *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;  if (strncmpic(p, (pcre_uint8 *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;
2616  if (strncmpic(p, (uschar *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;  if (strncmpic(p, (pcre_uint8 *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;
2617  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;
2618  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;
2619  fprintf(f, "Unknown newline type at: <%s\n", p);  fprintf(f, "Unknown newline type at: <%s\n", p);
2620  return 0;  return 0;
2621  }  }
# Line 728  return 0; Line 2629  return 0;
2629  static void  static void
2630  usage(void)  usage(void)
2631  {  {
2632  printf("Usage:     pcretest [options] [<input> [<output>]]\n");  printf("Usage:     pcretest [options] [<input file> [<output file>]]\n\n");
2633  printf("  -b       show compiled code (bytecode)\n");  printf("Input and output default to stdin and stdout.\n");
2634    #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT)
2635    printf("If input is a terminal, readline() is used to read from it.\n");
2636    #else
2637    printf("This version of pcretest is not linked with readline().\n");
2638    #endif
2639    printf("\nOptions:\n");
2640    #ifdef SUPPORT_PCRE16
2641    printf("  -16      use the 16-bit library\n");
2642    #endif
2643    #ifdef SUPPORT_PCRE32
2644    printf("  -32      use the 32-bit library\n");
2645    #endif
2646    printf("  -b       show compiled code\n");
2647  printf("  -C       show PCRE compile-time options and exit\n");  printf("  -C       show PCRE compile-time options and exit\n");
2648    printf("  -C arg   show a specific compile-time option\n");
2649    printf("           and exit with its value. The arg can be:\n");
2650    printf("     linksize     internal link size [2, 3, 4]\n");
2651    printf("     pcre8        8 bit library support enabled [0, 1]\n");
2652    printf("     pcre16       16 bit library support enabled [0, 1]\n");
2653    printf("     pcre32       32 bit library support enabled [0, 1]\n");
2654    printf("     utf          Unicode Transformation Format supported [0, 1]\n");
2655    printf("     ucp          Unicode Properties supported [0, 1]\n");
2656    printf("     jit          Just-in-time compiler supported [0, 1]\n");
2657    printf("     newline      Newline type [CR, LF, CRLF, ANYCRLF, ANY, ???]\n");
2658  printf("  -d       debug: show compiled code and information (-b and -i)\n");  printf("  -d       debug: show compiled code and information (-b and -i)\n");
2659  #if !defined NODFA  #if !defined NODFA
2660  printf("  -dfa     force DFA matching for all subjects\n");  printf("  -dfa     force DFA matching for all subjects\n");
2661  #endif  #endif
2662  printf("  -help    show usage information\n");  printf("  -help    show usage information\n");
2663  printf("  -i       show information about compiled patterns\n"  printf("  -i       show information about compiled patterns\n"
2664           "  -M       find MATCH_LIMIT minimum for each subject\n"
2665         "  -m       output memory used information\n"         "  -m       output memory used information\n"
2666         "  -o <n>   set size of offsets vector to <n>\n");         "  -o <n>   set size of offsets vector to <n>\n");
2667  #if !defined NOPOSIX  #if !defined NOPOSIX
# Line 744  printf("  -p       use POSIX interface\n Line 2669  printf("  -p       use POSIX interface\n
2669  #endif  #endif
2670  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
2671  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
2672  printf("  -s       output store (memory) used information\n"  printf("  -s       force each pattern to be studied at basic level\n"
2673           "  -s+      force each pattern to be studied, using JIT if available\n"
2674           "  -s++     ditto, verifying when JIT was actually used\n"
2675           "  -s+n     force each pattern to be studied, using JIT if available,\n"
2676           "             where 1 <= n <= 7 selects JIT options\n"
2677           "  -s++n    ditto, verifying when JIT was actually used\n"
2678         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
2679  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
2680  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 2694  options, followed by a set of test data,
2694  int main(int argc, char **argv)  int main(int argc, char **argv)
2695  {  {
2696  FILE *infile = stdin;  FILE *infile = stdin;
2697    const char *version;
2698  int options = 0;  int options = 0;
2699  int study_options = 0;  int study_options = 0;
2700    int default_find_match_limit = FALSE;
2701  int op = 1;  int op = 1;
2702  int timeit = 0;  int timeit = 0;
2703  int timeitm = 0;  int timeitm = 0;
2704  int showinfo = 0;  int showinfo = 0;
2705  int showstore = 0;  int showstore = 0;
2706    int force_study = -1;
2707    int force_study_options = 0;
2708  int quiet = 0;  int quiet = 0;
2709  int size_offsets = 45;  int size_offsets = 45;
2710  int size_offsets_max;  int size_offsets_max;
2711  int *offsets = NULL;  int *offsets = NULL;
 #if !defined NOPOSIX  
 int posix = 0;  
 #endif  
2712  int debug = 0;  int debug = 0;
2713  int done = 0;  int done = 0;
2714  int all_use_dfa = 0;  int all_use_dfa = 0;
2715    int verify_jit = 0;
2716  int yield = 0;  int yield = 0;
2717  int stack_size;  int stack_size;
2718    pcre_uint8 *dbuffer = NULL;
2719    size_t dbuffer_size = 1u << 14;
2720    
2721    #if !defined NOPOSIX
2722    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  /* These vectors store, end-to-end, a list of captured substring names. Assume  /* These vectors store, end-to-end, a list of zero-terminated captured
2731  that 1024 is plenty long enough for the few names we'll be testing. */  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 copynames[1024];  #ifdef SUPPORT_PCRE16
2745  uschar getnames[1024];  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  uschar *copynamesptr;  #ifdef SUPPORT_PCRE8
2752  uschar *getnamesptr;  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  /* Get buffers from malloc() so that Electric Fence will check their misuse  /* Get buffers from malloc() so that valgrind will check their misuse when
2759  when I am debugging. They grow automatically when very long lines are read. */  debugging. They grow automatically when very long lines are read. The 16-
2760    and 32-bit buffers (buffer16, buffer32) are obtained only if needed. */
2761    
2762  buffer = (unsigned char *)malloc(buffer_size);  buffer = (pcre_uint8 *)malloc(buffer_size);
2763  dbuffer = (unsigned char *)malloc(buffer_size);  pbuffer = (pcre_uint8 *)malloc(buffer_size);
 pbuffer = (unsigned char *)malloc(buffer_size);  
2764    
2765  /* The outfile variable is static so that new_malloc can use it. */  /* The outfile variable is static so that new_malloc can use it. */
2766    
# Line 813  it set 0x8000, but then I was advised th Line 2775  it set 0x8000, but then I was advised th
2775  _setmode( _fileno( stdout ), _O_BINARY );  _setmode( _fileno( stdout ), _O_BINARY );
2776  #endif  #endif
2777    
2778    /* Get the version number: both pcre_version() and pcre16_version() give the
2779    same answer. We just need to ensure that we call one that is available. */
2780    
2781    #if defined SUPPORT_PCRE8
2782    version = pcre_version();
2783    #elif defined SUPPORT_PCRE16
2784    version = pcre16_version();
2785    #elif defined SUPPORT_PCRE32
2786    version = pcre32_version();
2787    #endif
2788    
2789  /* Scan options */  /* Scan options */
2790    
2791  while (argc > 1 && argv[op][0] == '-')  while (argc > 1 && argv[op][0] == '-')
2792    {    {
2793    unsigned char *endptr;    pcre_uint8 *endptr;
2794      char *arg = argv[op];
2795    
2796    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(arg, "-m") == 0) showstore = 1;
2797      showstore = 1;    else if (strcmp(arg, "-s") == 0) force_study = 0;
2798    else if (strcmp(argv[op], "-q") == 0) quiet = 1;  
2799    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strncmp(arg, "-s+", 3) == 0)
2800    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;      {
2801    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;      arg += 3;
2802        if (*arg == '+') { arg++; verify_jit = TRUE; }
2803        force_study = 1;
2804        if (*arg == 0)
2805          force_study_options = jit_study_bits[6];
2806        else if (*arg >= '1' && *arg <= '7')
2807          force_study_options = jit_study_bits[*arg - '1'];
2808        else goto BAD_ARG;
2809        }
2810      else if (strcmp(arg, "-8") == 0)
2811        {
2812    #ifdef SUPPORT_PCRE8
2813        pcre_mode = PCRE8_MODE;
2814    #else
2815        printf("** This version of PCRE was built without 8-bit support\n");
2816        exit(1);
2817    #endif
2818        }
2819      else if (strcmp(arg, "-16") == 0)
2820        {
2821    #ifdef SUPPORT_PCRE16
2822        pcre_mode = PCRE16_MODE;
2823    #else
2824        printf("** This version of PCRE was built without 16-bit support\n");
2825        exit(1);
2826    #endif
2827        }
2828      else if (strcmp(arg, "-32") == 0)
2829        {
2830    #ifdef SUPPORT_PCRE32
2831        pcre_mode = PCRE32_MODE;
2832    #else
2833        printf("** This version of PCRE was built without 32-bit support\n");
2834        exit(1);
2835    #endif
2836        }
2837      else if (strcmp(arg, "-q") == 0) quiet = 1;
2838      else if (strcmp(arg, "-b") == 0) debug = 1;
2839      else if (strcmp(arg, "-i") == 0) showinfo = 1;
2840      else if (strcmp(arg, "-d") == 0) showinfo = debug = 1;
2841      else if (strcmp(arg, "-M") == 0) default_find_match_limit = TRUE;
2842  #if !defined NODFA  #if !defined NODFA
2843    else if (strcmp(argv[op], "-dfa") == 0) all_use_dfa = 1;    else if (strcmp(arg, "-dfa") == 0) all_use_dfa = 1;
2844  #endif  #endif
2845    else if (strcmp(argv[op], "-o") == 0 && argc > 2 &&    else if (strcmp(arg, "-o") == 0 && argc > 2 &&
2846        ((size_offsets = get_value((unsigned char *)argv[op+1], &endptr)),        ((size_offsets = get_value((pcre_uint8 *)argv[op+1], &endptr)),
2847          *endptr == 0))          *endptr == 0))
2848      {      {
2849      op++;      op++;
2850      argc--;      argc--;
2851      }      }
2852    else if (strcmp(argv[op], "-t") == 0 || strcmp(argv[op], "-tm") == 0)    else if (strcmp(arg, "-t") == 0 || strcmp(arg, "-tm") == 0)
2853      {      {
2854      int both = argv[op][2] == 0;      int both = arg[2] == 0;
2855      int temp;      int temp;
2856      if (argc > 2 && (temp = get_value((unsigned char *)argv[op+1], &endptr),      if (argc > 2 && (temp = get_value((pcre_uint8 *)argv[op+1], &endptr),
2857                       *endptr == 0))                       *endptr == 0))
2858        {        {
2859        timeitm = temp;        timeitm = temp;
# Line 849  while (argc > 1 && argv[op][0] == '-') Line 2863  while (argc > 1 && argv[op][0] == '-')
2863      else timeitm = LOOPREPEAT;      else timeitm = LOOPREPEAT;
2864      if (both) timeit = timeitm;      if (both) timeit = timeitm;
2865      }      }
2866    else if (strcmp(argv[op], "-S") == 0 && argc > 2 &&    else if (strcmp(arg, "-S") == 0 && argc > 2 &&
2867        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((pcre_uint8 *)argv[op+1], &endptr)),
2868          *endptr == 0))          *endptr == 0))
2869      {      {
2870  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix) || defined(NATIVE_ZOS)
2871      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
2872      exit(1);      exit(1);
2873  #else  #else
# Line 872  while (argc > 1 && argv[op][0] == '-') Line 2886  while (argc > 1 && argv[op][0] == '-')
2886  #endif  #endif
2887      }      }
2888  #if !defined NOPOSIX  #if !defined NOPOSIX
2889    else if (strcmp(argv[op], "-p") == 0) posix = 1;    else if (strcmp(arg, "-p") == 0) posix = 1;
2890  #endif  #endif
2891    else if (strcmp(argv[op], "-C") == 0)    else if (strcmp(arg, "-C") == 0)
2892      {      {
2893      int rc;      int rc;
2894      printf("PCRE version %s\n", pcre_version());      unsigned long int lrc;
2895    
2896        if (argc > 2)
2897          {
2898          if (strcmp(argv[op + 1], "linksize") == 0)
2899            {
2900            (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc);
2901            printf("%d\n", rc);
2902            yield = rc;
2903            }
2904          else if (strcmp(argv[op + 1], "pcre8") == 0)
2905            {
2906    #ifdef SUPPORT_PCRE8
2907            printf("1\n");
2908            yield = 1;
2909    #else
2910            printf("0\n");
2911            yield = 0;
2912    #endif
2913            }
2914          else if (strcmp(argv[op + 1], "pcre16") == 0)
2915            {
2916    #ifdef SUPPORT_PCRE16
2917            printf("1\n");
2918            yield = 1;
2919    #else
2920            printf("0\n");
2921            yield = 0;
2922    #endif
2923            }
2924          else if (strcmp(argv[op + 1], "pcre32") == 0)
2925            {
2926    #ifdef SUPPORT_PCRE32
2927            printf("1\n");
2928            yield = 1;
2929    #else
2930            printf("0\n");
2931            yield = 0;
2932    #endif
2933            goto EXIT;
2934            }
2935          if (strcmp(argv[op + 1], "utf") == 0)
2936            {
2937    #ifdef SUPPORT_PCRE8
2938            if (pcre_mode == PCRE8_MODE)
2939              (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
2940    #endif
2941    #ifdef SUPPORT_PCRE16
2942            if (pcre_mode == PCRE16_MODE)
2943              (void)pcre16_config(PCRE_CONFIG_UTF16, &rc);
2944    #endif
2945    #ifdef SUPPORT_PCRE32
2946            if (pcre_mode == PCRE32_MODE)
2947              (void)pcre32_config(PCRE_CONFIG_UTF32, &rc);
2948    #endif
2949            printf("%d\n", rc);
2950            yield = rc;
2951            goto EXIT;
2952            }
2953          else if (strcmp(argv[op + 1], "ucp") == 0)
2954            {
2955            (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
2956            printf("%d\n", rc);
2957            yield = rc;
2958            }
2959          else if (strcmp(argv[op + 1], "jit") == 0)
2960            {
2961            (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc);
2962            printf("%d\n", rc);
2963            yield = rc;
2964            }
2965          else if (strcmp(argv[op + 1], "newline") == 0)
2966            {
2967            (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc);
2968            print_newline_config(rc, TRUE);
2969            }
2970          else if (strcmp(argv[op + 1], "ebcdic") == 0)
2971            {
2972    #ifdef EBCDIC
2973            printf("1\n");
2974            yield = 1;
2975    #else
2976            printf("0\n");
2977    #endif
2978            }
2979          else if (strcmp(argv[op + 1], "ebcdic-nl") == 0)
2980            {
2981    #ifdef EBCDIC
2982            printf("0x%02x\n", CHAR_LF);
2983    #else
2984            printf("0\n");
2985    #endif
2986            }
2987          else
2988            {
2989            printf("Unknown -C option: %s\n", argv[op + 1]);
2990            }
2991          goto EXIT;
2992          }
2993    
2994        /* No argument for -C: output all configuration information. */
2995    
2996        printf("PCRE version %s\n", version);
2997      printf("Compiled with\n");      printf("Compiled with\n");
2998    
2999    #ifdef EBCDIC
3000        printf("  EBCDIC code support: LF is 0x%02x\n", CHAR_LF);
3001    #endif
3002    
3003    /* At least one of SUPPORT_PCRE8 and SUPPORT_PCRE16 will be set. If both
3004    are set, either both UTFs are supported or both are not supported. */
3005    
3006    #ifdef SUPPORT_PCRE8
3007        printf("  8-bit support\n");
3008      (void)pcre_config(PCRE_CONFIG_UTF8, &rc);      (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
3009      printf("  %sUTF-8 support\n", rc? "" : "No ");        printf ("  %sUTF-8 support\n", rc ? "" : "No ");
3010      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);  #endif
3011    #ifdef SUPPORT_PCRE16
3012        printf("  16-bit support\n");
3013        (void)pcre16_config(PCRE_CONFIG_UTF16, &rc);
3014        printf ("  %sUTF-16 support\n", rc ? "" : "No ");
3015    #endif
3016    #ifdef SUPPORT_PCRE32
3017        printf("  32-bit support\n");
3018        (void)pcre32_config(PCRE_CONFIG_UTF32, &rc);
3019        printf ("  %sUTF-32 support\n", rc ? "" : "No ");
3020    #endif
3021    
3022        (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
3023      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
3024      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc);
3025      printf("  Newline sequence is %s\n", (rc == '\r')? "CR" :      if (rc)
3026        (rc == '\n')? "LF" : (rc == ('\r'<<8 | '\n'))? "CRLF" :        {
3027        (rc == -2)? "ANYCRLF" :        const char *arch;
3028        (rc == -1)? "ANY" : "???");        (void)PCRE_CONFIG(PCRE_CONFIG_JITTARGET, (void *)(&arch));
3029      (void)pcre_config(PCRE_CONFIG_BSR, &rc);        printf("  Just-in-time compiler support: %s\n", arch);
3030          }
3031        else
3032          printf("  No just-in-time compiler support\n");
3033        (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc);
3034        print_newline_config(rc, FALSE);
3035        (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc);
3036      printf("  \\R matches %s\n", rc? "CR, LF, or CRLF only" :      printf("  \\R matches %s\n", rc? "CR, LF, or CRLF only" :
3037                                       "all Unicode newlines");                                       "all Unicode newlines");
3038      (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc);
3039      printf("  Internal link size = %d\n", rc);      printf("  Internal link size = %d\n", rc);
3040      (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);
3041      printf("  POSIX malloc threshold = %d\n", rc);      printf("  POSIX malloc threshold = %d\n", rc);
3042      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT, &lrc);
3043      printf("  Default match limit = %d\n", rc);      printf("  Default match limit = %ld\n", lrc);
3044      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &lrc);
3045      printf("  Default recursion depth limit = %d\n", rc);      printf("  Default recursion depth limit = %ld\n", lrc);
3046      (void)pcre_config(PCRE_CONFIG_STACKRECURSE, &rc);      (void)PCRE_CONFIG(PCRE_CONFIG_STACKRECURSE, &rc);
3047      printf("  Match recursion uses %s\n", rc? "stack" : "heap");      printf("  Match recursion uses %s", rc? "stack" : "heap");
3048        if (showstore)
3049          {
3050          PCRE_EXEC(stack_size, NULL, NULL, NULL, -999, -999, 0, NULL, 0);
3051          printf(": %sframe size = %d bytes", rc? "approximate " : "", -stack_size);
3052          }
3053        printf("\n");
3054      goto EXIT;      goto EXIT;
3055      }      }
3056    else if (strcmp(argv[op], "-help") == 0 ||    else if (strcmp(arg, "-help") == 0 ||
3057             strcmp(argv[op], "--help") == 0)             strcmp(arg, "--help") == 0)
3058      {      {
3059      usage();      usage();
3060      goto EXIT;      goto EXIT;
3061      }      }
3062    else    else
3063      {      {
3064      printf("** Unknown or malformed option %s\n", argv[op]);      BAD_ARG:
3065        printf("** Unknown or malformed option %s\n", arg);
3066      usage();      usage();
3067      yield = 1;      yield = 1;
3068      goto EXIT;      goto EXIT;
# Line 958  if (argc > 2) Line 3109  if (argc > 2)
3109    
3110  /* Set alternative malloc function */  /* Set alternative malloc function */
3111    
3112    #ifdef SUPPORT_PCRE8
3113  pcre_malloc = new_malloc;  pcre_malloc = new_malloc;
3114  pcre_free = new_free;  pcre_free = new_free;
3115  pcre_stack_malloc = stack_malloc;  pcre_stack_malloc = stack_malloc;
3116  pcre_stack_free = stack_free;  pcre_stack_free = stack_free;
3117    #endif
3118    
3119    #ifdef SUPPORT_PCRE16
3120    pcre16_malloc = new_malloc;
3121    pcre16_free = new_free;
3122    pcre16_stack_malloc = stack_malloc;
3123    pcre16_stack_free = stack_free;
3124    #endif
3125    
3126    #ifdef SUPPORT_PCRE32
3127    pcre32_malloc = new_malloc;
3128    pcre32_free = new_free;
3129    pcre32_stack_malloc = stack_malloc;
3130    pcre32_stack_free = stack_free;
3131    #endif
3132    
3133  /* Heading line unless quiet, then prompt for first regex if stdin */  /* Heading line unless quiet, then prompt for first regex if stdin */
3134    
3135  if (!quiet) fprintf(outfile, "PCRE version %s\n\n", pcre_version());  if (!quiet) fprintf(outfile, "PCRE version %s\n\n", version);
3136    
3137  /* Main loop */  /* Main loop */
3138    
# Line 980  while (!done) Line 3147  while (!done)
3147  #endif  #endif
3148    
3149    const char *error;    const char *error;
3150    unsigned char *p, *pp, *ppp;    pcre_uint8 *markptr;
3151    unsigned char *to_file = NULL;    pcre_uint8 *p, *pp, *ppp;
3152    const unsigned char *tables = NULL;    pcre_uint8 *to_file = NULL;
3153      const pcre_uint8 *tables = NULL;
3154      unsigned long int get_options;
3155    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
3156    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
3157      int do_allcaps = 0;
3158      int do_mark = 0;
3159    int do_study = 0;    int do_study = 0;
3160      int no_force_study = 0;
3161    int do_debug = debug;    int do_debug = debug;
3162    int do_G = 0;    int do_G = 0;
3163    int do_g = 0;    int do_g = 0;
3164    int do_showinfo = showinfo;    int do_showinfo = showinfo;
3165    int do_showrest = 0;    int do_showrest = 0;
3166      int do_showcaprest = 0;
3167    int do_flip = 0;    int do_flip = 0;
3168    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
3169    
3170    use_utf8 = 0;  #if !defined NODFA
3171      int dfa_matched = 0;
3172    #endif
3173    
3174      use_utf = 0;
3175    debug_lengths = 1;    debug_lengths = 1;
3176    
3177    if (infile == stdin) printf("  re> ");    if (extend_inputline(infile, buffer, "  re> ") == NULL) break;
   if (extend_inputline(infile, buffer) == NULL) break;  
3178    if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);    if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
3179    fflush(outfile);    fflush(outfile);
3180    
# Line 1010  while (!done) Line 3186  while (!done)
3186    
3187    if (*p == '<' && strchr((char *)(p+1), '<') == NULL)    if (*p == '<' && strchr((char *)(p+1), '<') == NULL)
3188      {      {
3189      unsigned long int magic, get_options;      pcre_uint32 magic;
3190      uschar sbuf[8];      pcre_uint8 sbuf[8];
3191      FILE *f;      FILE *f;
3192    
3193      p++;      p++;
3194        if (*p == '!')
3195          {
3196          do_debug = TRUE;
3197          do_showinfo = TRUE;
3198          p++;
3199          }
3200    
3201      pp = p + (int)strlen((char *)p);      pp = p + (int)strlen((char *)p);
3202      while (isspace(pp[-1])) pp--;      while (isspace(pp[-1])) pp--;
3203      *pp = 0;      *pp = 0;
# Line 1026  while (!done) Line 3209  while (!done)
3209        continue;        continue;
3210        }        }
3211    
3212        first_gotten_store = 0;
3213      if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ;      if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ;
3214    
3215      true_size =      true_size =
# Line 1033  while (!done) Line 3217  while (!done)
3217      true_study_size =      true_study_size =
3218        (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];        (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];
3219    
3220      re = (real_pcre *)new_malloc(true_size);      re = (pcre *)new_malloc(true_size);
3221      regex_gotten_store = gotten_store;      if (re == NULL)
3222          {
3223          printf("** Failed to get %d bytes of memory for pcre object\n",
3224            (int)true_size);
3225          yield = 1;
3226          goto EXIT;
3227          }
3228        regex_gotten_store = first_gotten_store;
3229    
3230      if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;      if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;
3231    
3232      magic = ((real_pcre *)re)->magic_number;      magic = REAL_PCRE_MAGIC(re);
3233      if (magic != MAGIC_NUMBER)      if (magic != MAGIC_NUMBER)
3234        {        {
3235        if (byteflip(magic, sizeof(magic)) == MAGIC_NUMBER)        if (swap_uint32(magic) == MAGIC_NUMBER)
3236          {          {
3237          do_flip = 1;          do_flip = 1;
3238          }          }
3239        else        else
3240          {          {
3241          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);
3242            new_free(re);
3243          fclose(f);          fclose(f);
3244          continue;          continue;
3245          }          }
3246        }        }
3247    
3248      fprintf(outfile, "Compiled regex%s loaded from %s\n",      /* We hide the byte-invert info for little and big endian tests. */
3249        do_flip? " (byte-inverted)" : "", p);      fprintf(outfile, "Compiled pattern%s loaded from %s\n",
3250          do_flip && (p[-1] == '<') ? " (byte-inverted)" : "", p);
3251    
3252      /* Need to know if UTF-8 for printing data strings */      /* Now see if there is any following study data. */
   
     new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);  
     use_utf8 = (get_options & PCRE_UTF8) != 0;  
   
     /* Now see if there is any following study data */  
3253    
3254      if (true_study_size != 0)      if (true_study_size != 0)
3255        {        {
# Line 1077  while (!done) Line 3265  while (!done)
3265          {          {
3266          FAIL_READ:          FAIL_READ:
3267          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
3268          if (extra != NULL) new_free(extra);          if (extra != NULL)
3269          if (re != NULL) new_free(re);            {
3270              PCRE_FREE_STUDY(extra);
3271              }
3272            new_free(re);
3273          fclose(f);          fclose(f);
3274          continue;          continue;
3275          }          }
# Line 1087  while (!done) Line 3278  while (!done)
3278        }        }
3279      else fprintf(outfile, "No study data\n");      else fprintf(outfile, "No study data\n");
3280    
3281        /* Flip the necessary bytes. */
3282        if (do_flip)
3283          {
3284          int rc;
3285          PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, NULL);
3286          if (rc == PCRE_ERROR_BADMODE)
3287            {
3288            /* Simulate the result of the function call below. */
3289            fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc,
3290              pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "",
3291              PCRE_INFO_OPTIONS);
3292            fprintf(outfile, "Running in %d-bit mode but pattern was compiled in "
3293              "%d-bit mode\n", 8 * CHAR_SIZE,
3294              8 * (REAL_PCRE_FLAGS(re) & PCRE_MODE_MASK));
3295            new_free(re);
3296            fclose(f);
3297            continue;
3298            }
3299          }
3300    
3301        /* Need to know if UTF-8 for printing data strings. */
3302    
3303        if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0)
3304          {
3305          new_free(re);
3306          fclose(f);
3307          continue;
3308          }
3309        use_utf = (get_options & PCRE_UTF8) != 0;
3310    
3311      fclose(f);      fclose(f);
3312      goto SHOW_INFO;      goto SHOW_INFO;
3313      }      }
3314    
3315    /* 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
3316    the pattern; if is isn't complete, read more. */    the pattern; if it isn't complete, read more. */
3317    
3318    delimiter = *p++;    delimiter = *p++;
3319    
3320    if (isalnum(delimiter) || delimiter == '\\')    if (isalnum(delimiter) || delimiter == '\\')
3321      {      {
3322      fprintf(outfile, "** Delimiter must not be alphameric or \\\n");      fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n");
3323      goto SKIP_DATA;      goto SKIP_DATA;
3324      }      }
3325    
3326    pp = p;    pp = p;
3327    poffset = p - buffer;    poffset = (int)(p - buffer);
3328    
3329    for(;;)    for(;;)
3330      {      {
# Line 1114  while (!done) Line 3335  while (!done)
3335        pp++;        pp++;
3336        }        }
3337      if (*pp != 0) break;      if (*pp != 0) break;
3338      if (infile == stdin) printf("    > ");      if ((pp = extend_inputline(infile, pp, "    > ")) == NULL)
     if ((pp = extend_inputline(infile, pp)) == NULL)  
3339        {        {
3340        fprintf(outfile, "** Unexpected EOF\n");        fprintf(outfile, "** Unexpected EOF\n");
3341        done = 1;        done = 1;
# Line 1144  while (!done) Line 3364  while (!done)
3364    /* Look for options after final delimiter */    /* Look for options after final delimiter */
3365    
3366    options = 0;    options = 0;
3367    study_options = 0;    study_options = force_study_options;
3368    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
3369    
3370    while (*pp != 0)    while (*pp != 0)
# Line 1158  while (!done) Line 3378  while (!done)
3378        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
3379        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
3380    
3381        case '+': do_showrest = 1; break;        case '+':
3382          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
3383          break;
3384    
3385          case '=': do_allcaps = 1; break;
3386        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
3387        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
3388        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1168  while (!done) Line 3392  while (!done)
3392        case 'G': do_G = 1; break;        case 'G': do_G = 1; break;
3393        case 'I': do_showinfo = 1; break;        case 'I': do_showinfo = 1; break;
3394        case 'J': options |= PCRE_DUPNAMES; break;        case 'J': options |= PCRE_DUPNAMES; break;
3395          case 'K': do_mark = 1; break;
3396        case 'M': log_store = 1; break;        case 'M': log_store = 1; break;
3397        case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;        case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;
3398    
# Line 1175  while (!done) Line 3400  while (!done)
3400        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
3401  #endif  #endif
3402    
3403        case 'S': do_study = 1; break;        case 'S':
3404          do_study = 1;
3405          for (;;)
3406            {
3407            switch (*pp++)
3408              {
3409              case 'S':
3410              do_study = 0;
3411              no_force_study = 1;
3412              break;
3413    
3414              case '!':
3415              study_options |= PCRE_STUDY_EXTRA_NEEDED;
3416              break;
3417    
3418              case '+':
3419              if (*pp == '+')
3420                {
3421                verify_jit = TRUE;
3422                pp++;
3423                }
3424              if (*pp >= '1' && *pp <= '7')
3425                study_options |= jit_study_bits[*pp++ - '1'];
3426              else
3427                study_options |= jit_study_bits[6];
3428              break;
3429    
3430              case '-':
3431              study_options &= ~PCRE_STUDY_ALLJIT;
3432              break;
3433    
3434              default:
3435              pp--;
3436              goto ENDLOOP;
3437              }
3438            }
3439          ENDLOOP:
3440          break;
3441    
3442        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
3443          case 'W': options |= PCRE_UCP; break;
3444        case 'X': options |= PCRE_EXTRA; break;        case 'X': options |= PCRE_EXTRA; break;
3445          case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
3446        case 'Z': debug_lengths = 0; break;        case 'Z': debug_lengths = 0; break;
3447        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;        case '8': options |= PCRE_UTF8; use_utf = 1; break;
3448        case '?': options |= PCRE_NO_UTF8_CHECK; break;        case '?': options |= PCRE_NO_UTF8_CHECK; break;
3449    
3450          case 'T':
3451          switch (*pp++)
3452            {
3453            case '0': tables = tables0; break;
3454            case '1': tables = tables1; break;
3455    
3456            case '\r':
3457            case '\n':
3458            case ' ':
3459            case 0:
3460            fprintf(outfile, "** Missing table number after /T\n");
3461            goto SKIP_DATA;
3462    
3463            default:
3464            fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]);
3465            goto SKIP_DATA;
3466            }
3467          break;
3468    
3469        case 'L':        case 'L':
3470        ppp = pp;        ppp = pp;
3471        /* 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 3478  while (!done)
3478          goto SKIP_DATA;          goto SKIP_DATA;
3479          }          }
3480        locale_set = 1;        locale_set = 1;
3481        tables = pcre_maketables();        tables = PCRE_MAKETABLES;
3482        pp = ppp;        pp = ppp;
3483        break;        break;
3484    
# Line 1207  while (!done) Line 3491  while (!done)
3491    
3492        case '<':        case '<':
3493          {          {
3494          int x = check_newline(pp, outfile);          if (strncmpic(pp, (pcre_uint8 *)"JS>", 3) == 0)
3495          if (x == 0) goto SKIP_DATA;            {
3496          options |= x;            options |= PCRE_JAVASCRIPT_COMPAT;
3497          while (*pp++ != '>');            pp += 3;
3498              }
3499            else
3500              {
3501              int x = check_newline(pp, outfile);
3502              if (x == 0) goto SKIP_DATA;
3503              options |= x;
3504              while (*pp++ != '>');
3505              }
3506          }          }
3507        break;        break;
3508    
# Line 1227  while (!done) Line 3519  while (!done)
3519    
3520    /* Handle compiling via the POSIX interface, which doesn't support the    /* Handle compiling via the POSIX interface, which doesn't support the
3521    timing, showing, or debugging options, nor the ability to pass over    timing, showing, or debugging options, nor the ability to pass over
3522    local character tables. */    local character tables. Neither does it have 16-bit support. */
3523    
3524  #if !defined NOPOSIX  #if !defined NOPOSIX
3525    if (posix || do_posix)    if (posix || do_posix)
# Line 1240  while (!done) Line 3532  while (!done)
3532      if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;      if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;
3533      if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB;      if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB;
3534      if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8;      if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8;
3535        if ((options & PCRE_UCP) != 0) cflags |= REG_UCP;
3536        if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY;
3537    
3538        first_gotten_store = 0;
3539      rc = regcomp(&preg, (char *)p, cflags);      rc = regcomp(&preg, (char *)p, cflags);
3540    
3541      /* Compilation failed; go back for another re, skipping to blank line      /* Compilation failed; go back for another re, skipping to blank line
# Line 1260  while (!done) Line 3555  while (!done)
3555  #endif  /* !defined NOPOSIX */  #endif  /* !defined NOPOSIX */
3556    
3557      {      {
3558        /* In 16- or 32-bit mode, convert the input. */
3559    
3560    #ifdef SUPPORT_PCRE16
3561        if (pcre_mode == PCRE16_MODE)
3562          {
3563          switch(to16(FALSE, p, options & PCRE_UTF8, (int)strlen((char *)p)))
3564            {
3565            case -1:
3566            fprintf(outfile, "**Failed: invalid UTF-8 string cannot be "
3567              "converted to UTF-16\n");
3568            goto SKIP_DATA;
3569    
3570            case -2:
3571            fprintf(outfile, "**Failed: character value greater than 0x10ffff "
3572              "cannot be converted to UTF-16\n");
3573            goto SKIP_DATA;
3574    
3575            case -3: /* "Impossible error" when to16 is called arg1 FALSE */
3576            fprintf(outfile, "**Failed: character value greater than 0xffff "
3577              "cannot be converted to 16-bit in non-UTF mode\n");
3578            goto SKIP_DATA;
3579    
3580            default:
3581            break;
3582            }
3583          p = (pcre_uint8 *)buffer16;
3584          }
3585    #endif
3586    
3587    #ifdef SUPPORT_PCRE32
3588        if (pcre_mode == PCRE32_MODE)
3589          {
3590          switch(to32(FALSE, p, options & PCRE_UTF32, (int)strlen((char *)p)))
3591            {
3592            case -1:
3593            fprintf(outfile, "**Failed: invalid UTF-8 string cannot be "
3594              "converted to UTF-32\n");
3595            goto SKIP_DATA;
3596    
3597            case -2:
3598            fprintf(outfile, "**Failed: character value greater than 0x10ffff "
3599              "cannot be converted to UTF-32\n");
3600            goto SKIP_DATA;
3601    
3602            case -3:
3603            fprintf(outfile, "**Failed: character value is ill-formed UTF-32\n");
3604            goto SKIP_DATA;
3605    
3606            default:
3607            break;
3608            }
3609          p = (pcre_uint8 *)buffer32;
3610          }
3611    #endif
3612    
3613        /* Compile many times when timing */
3614    
3615      if (timeit > 0)      if (timeit > 0)
3616        {        {
3617        register int i;        register int i;
# Line 1267  while (!done) Line 3619  while (!done)
3619        clock_t start_time = clock();        clock_t start_time = clock();
3620        for (i = 0; i < timeit; i++)        for (i = 0; i < timeit; i++)
3621          {          {
3622          re = pcre_compile((char *)p, options, &error, &erroroffset, tables);          PCRE_COMPILE(re, p, options, &error, &erroroffset, tables);
3623          if (re != NULL) free(re);          if (re != NULL) free(re);
3624          }          }
3625        time_taken = clock() - start_time;        time_taken = clock() - start_time;
# Line 1276  while (!done) Line 3628  while (!done)
3628            (double)CLOCKS_PER_SEC);            (double)CLOCKS_PER_SEC);
3629        }        }
3630    
3631      re = pcre_compile((char *)p, options, &error, &erroroffset, tables);      first_gotten_store = 0;
3632        PCRE_COMPILE(re, p, options, &error, &erroroffset, tables);
3633    
3634      /* Compilation failed; go back for another re, skipping to blank line      /* Compilation failed; go back for another re, skipping to blank line
3635      if non-interactive. */      if non-interactive. */
# Line 1289  while (!done) Line 3642  while (!done)
3642          {          {
3643          for (;;)          for (;;)
3644            {            {
3645            if (extend_inputline(infile, buffer) == NULL)            if (extend_inputline(infile, buffer, NULL) == NULL)
3646              {              {
3647              done = 1;              done = 1;
3648              goto CONTINUE;              goto CONTINUE;
# Line 1303  while (!done) Line 3656  while (!done)
3656        goto CONTINUE;        goto CONTINUE;
3657        }        }
3658    
3659      /* Compilation succeeded; print data if required. There are now two      /* Compilation succeeded. It is now possible to set the UTF-8 option from
3660      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
3661      returns only limited data. Check that it agrees with the newer one. */      lines. */
3662    
3663      if (log_store)      if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0)
3664        fprintf(outfile, "Memory allocation (code space): %d\n",        goto SKIP_DATA;
3665          (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));  
3666    
3667      /* Extract the size for possible writing before possibly flipping it,      /* Extract the size for possible writing before possibly flipping it,
3668      and remember the store that was got. */      and remember the store that was got. */
3669    
3670      true_size = ((real_pcre *)re)->size;      true_size = REAL_PCRE_SIZE(re);
3671      regex_gotten_store = gotten_store;      regex_gotten_store = first_gotten_store;
3672    
3673        /* Output code size information if requested */
3674    
3675        if (log_store)
3676          {
3677          int name_count, name_entry_size, real_pcre_size;
3678    
3679          new_info(re, NULL, PCRE_INFO_NAMECOUNT, &name_count);
3680          new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size);
3681    #ifdef SUPPORT_PCRE8
3682          if (REAL_PCRE_FLAGS(re) & PCRE_MODE8)
3683            real_pcre_size = sizeof(real_pcre);
3684    #endif
3685    #ifdef SUPPORT_PCRE16
3686          if (REAL_PCRE_FLAGS(re) & PCRE_MODE16)
3687            real_pcre_size = sizeof(real_pcre16);
3688    #endif
3689    #ifdef SUPPORT_PCRE32
3690          if (REAL_PCRE_FLAGS(re) & PCRE_MODE32)
3691            real_pcre_size = sizeof(real_pcre32);
3692    #endif
3693          fprintf(outfile, "Memory allocation (code space): %d\n",
3694            (int)(first_gotten_store - real_pcre_size - name_count * name_entry_size));
3695          }
3696    
3697      /* 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
3698      help with the matching. */      help with the matching, unless the pattern has the SS option, which
3699        suppresses the effect of /S (used for a few test patterns where studying is
3700        never sensible). */
3701    
3702      if (do_study)      if (do_study || (force_study >= 0 && !no_force_study))
3703        {        {
3704        if (timeit > 0)        if (timeit > 0)
3705          {          {
# Line 1330  while (!done) Line 3707  while (!done)
3707          clock_t time_taken;          clock_t time_taken;
3708          clock_t start_time = clock();          clock_t start_time = clock();
3709          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
3710            extra = pcre_study(re, study_options, &error);            {
3711              PCRE_STUDY(extra, re, study_options, &error);
3712              }
3713          time_taken = clock() - start_time;          time_taken = clock() - start_time;
3714          if (extra != NULL) free(extra);          if (extra != NULL)
3715              {
3716              PCRE_FREE_STUDY(extra);
3717              }
3718          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
3719            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
3720              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
3721          }          }
3722        extra = pcre_study(re, study_options, &error);        PCRE_STUDY(extra, re, study_options, &error);
3723        if (error != NULL)        if (error != NULL)
3724          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
3725        else if (extra != NULL)        else if (extra != NULL)
3726            {
3727          true_study_size = ((pcre_study_data *)(extra->study_data))->size;          true_study_size = ((pcre_study_data *)(extra->study_data))->size;
3728            if (log_store)
3729              {
3730              size_t jitsize;
3731              if (new_info(re, extra, PCRE_INFO_JITSIZE, &jitsize) == 0 &&
3732                  jitsize != 0)
3733                fprintf(outfile, "Memory allocation (JIT code): %d\n", (int)jitsize);
3734              }
3735            }
3736        }        }
3737    
3738      /* 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. */  
3739    
3740      if (do_flip)      if (do_mark)
3741        {        {
3742        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)  
3743          {          {
3744          pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);          extra = (pcre_extra *)malloc(sizeof(pcre_extra));
3745          rsd->size = byteflip(rsd->size, sizeof(rsd->size));          extra->flags = 0;
         rsd->options = byteflip(rsd->options, sizeof(rsd->options));  
3746          }          }
3747          extra->mark = &markptr;
3748          extra->flags |= PCRE_EXTRA_MARK;
3749        }        }
3750    
3751      /* Extract information from the compiled data if required */      /* Extract and display information from the compiled data if required. */
3752    
3753      SHOW_INFO:      SHOW_INFO:
3754    
3755      if (do_debug)      if (do_debug)
3756        {        {
3757        fprintf(outfile, "------------------------------------------------------------------\n");        fprintf(outfile, "------------------------------------------------------------------\n");
3758        pcre_printint(re, outfile, debug_lengths);        PCRE_PRINTINT(re, outfile, debug_lengths);
3759        }        }
3760    
3761        /* We already have the options in get_options (see above) */
3762    
3763      if (do_showinfo)      if (do_showinfo)
3764        {        {
3765        unsigned long int get_options, all_options;        unsigned long int all_options;
3766  #if !defined NOINFOCHECK        pcre_uint32 first_char, need_char;
3767        int old_first_char, old_options, old_count;        int count, backrefmax, first_char_set, need_char_set, okpartial, jchanged,
3768  #endif          hascrorlf, maxlookbehind;
       int count, backrefmax, first_char, need_char, okpartial, jchanged,  
         hascrorlf;  
3769        int nameentrysize, namecount;        int nameentrysize, namecount;
3770        const uschar *nametable;        const pcre_uint8 *nametable;
3771    
3772        new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);        if (new_info(re, NULL, PCRE_INFO_SIZE, &size) +
3773        new_info(re, NULL, PCRE_INFO_SIZE, &size);            new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count) +
3774        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);            new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax) +
3775        new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);            new_info(re, NULL, PCRE_INFO_FIRSTLITERAL, &first_char) +
3776        new_info(re, NULL, PCRE_INFO_FIRSTBYTE, &first_char);            new_info(re, NULL, PCRE_INFO_FIRSTLITERALSET, &first_char_set) +
3777        new_info(re, NULL, PCRE_INFO_LASTLITERAL, &need_char);            new_info(re, NULL, PCRE_INFO_LASTLITERAL2, &need_char) +
3778        new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize);            new_info(re, NULL, PCRE_INFO_LASTLITERAL2SET, &need_char_set) +
3779        new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount);            new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize) +
3780        new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable);            new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount) +
3781        new_info(re, NULL, PCRE_INFO_OKPARTIAL, &okpartial);            new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable) +
3782        new_info(re, NULL, PCRE_INFO_JCHANGED, &jchanged);            new_info(re, NULL, PCRE_INFO_OKPARTIAL, &okpartial) +
3783        new_info(re, NULL, PCRE_INFO_HASCRORLF, &hascrorlf);            new_info(re, NULL, PCRE_INFO_JCHANGED, &jchanged) +
3784              new_info(re, NULL, PCRE_INFO_HASCRORLF, &hascrorlf) +
3785  #if !defined NOINFOCHECK            new_info(re, NULL, PCRE_INFO_MAXLOOKBEHIND, &maxlookbehind)
3786        old_count = pcre_info(re, &old_options, &old_first_char);            != 0)
3787        if (count < 0) fprintf(outfile,          goto SKIP_DATA;
         "Error %d from pcre_info()\n", count);  
       else  
         {  
         if (old_count != count) fprintf(outfile,  
           "Count disagreement: pcre_fullinfo=%d pcre_info=%d\n", count,  
             old_count);  
   
         if (old_first_char != first_char) fprintf(outfile,  
           "First char disagreement: pcre_fullinfo=%d pcre_info=%d\n",  
             first_char, old_first_char);  
   
         if (old_options != (int)get_options) fprintf(outfile,  
           "Options disagreement: pcre_fullinfo=%ld pcre_info=%d\n",  
             get_options, old_options);  
         }  
 #endif  
3788    
3789        if (size != regex_gotten_store) fprintf(outfile,        if (size != regex_gotten_store) fprintf(outfile,
3790          "Size disagreement: pcre_fullinfo=%d call to malloc for %d\n",          "Size disagreement: pcre_fullinfo=%d call to malloc for %d\n",
# Line 1447  while (!done) Line 3799  while (!done)
3799          fprintf(outfile, "Named capturing subpatterns:\n");          fprintf(outfile, "Named capturing subpatterns:\n");
3800          while (namecount-- > 0)          while (namecount-- > 0)
3801            {            {
3802            fprintf(outfile, "  %s %*s%3d\n", nametable + 2,            int imm2_size = pcre_mode == PCRE8_MODE ? 2 : 1;
3803              nameentrysize - 3 - (int)strlen((char *)nametable + 2), "",            int length = (int)STRLEN(nametable + imm2_size);
3804              GET2(nametable, 0));            fprintf(outfile, "  ");
3805            nametable += nameentrysize;            PCHARSV(nametable, imm2_size, length, outfile);
3806              while (length++ < nameentrysize - imm2_size) putc(' ', outfile);
3807    #ifdef SUPPORT_PCRE32
3808              if (pcre_mode == PCRE32_MODE)
3809                fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR32)nametable)[0]));
3810    #endif
3811    #ifdef SUPPORT_PCRE16
3812              if (pcre_mode == PCRE16_MODE)
3813                fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR16)nametable)[0]));
3814    #endif
3815    #ifdef SUPPORT_PCRE8
3816              if (pcre_mode == PCRE8_MODE)
3817                fprintf(outfile, "%3d\n", ((int)nametable[0] << 8) | (int)nametable[1]);
3818    #endif
3819              nametable += nameentrysize * CHAR_SIZE;
3820            }            }
3821          }          }
3822    
3823        if (!okpartial) fprintf(outfile, "Partial matching not supported\n");        if (!okpartial) fprintf(outfile, "Partial matching not supported\n");
3824        if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n");        if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n");
3825    
3826        all_options = ((real_pcre *)re)->options;        all_options = REAL_PCRE_OPTIONS(re);
3827        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));        if (do_flip) all_options = swap_uint32(all_options);
3828    
3829        if (get_options == 0) fprintf(outfile, "No options\n");        if (get_options == 0) fprintf(outfile, "No options\n");
3830          else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",          else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
3831            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
3832            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
3833            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
# Line 1474  while (!done) Line 3840  while (!done)
3840            ((get_options & PCRE_EXTRA) != 0)? " extra" : "",            ((get_options & PCRE_EXTRA) != 0)? " extra" : "",
3841            ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",            ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",
3842            ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "",            ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "",
3843            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",            ((get_options & PCRE_UTF8) != 0)? " utf" : "",
3844            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_UCP) != 0)? " ucp" : "",
3845              ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf_check" : "",
3846              ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "",
3847            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
3848    
3849        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");
# Line 1506  while (!done) Line 3874  while (!done)
3874          break;          break;
3875          }          }
3876    
3877        if (first_char == -1)        if (first_char_set == 2)
3878          {          {
3879          fprintf(outfile, "First char at start or follows newline\n");          fprintf(outfile, "First char at start or follows newline\n");
3880          }          }
3881        else if (first_char < 0)        else if (first_char_set == 1)
         {  
         fprintf(outfile, "No first char\n");  
         }  
       else  
3882          {          {
3883          int ch = first_char & 255;          const char *caseless =
3884          const char *caseless = ((first_char & REQ_CASELESS) == 0)?            ((REAL_PCRE_FLAGS(re) & PCRE_FCH_CASELESS) == 0)?