/[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 142 by ph10, Fri Mar 30 15:55:18 2007 UTC revision 675 by ph10, Sat Aug 27 10:18:46 2011 UTC
# Line 36  POSSIBILITY OF SUCH DAMAGE. Line 36  POSSIBILITY OF SUCH DAMAGE.
36  */  */
37    
38    
39    #ifdef HAVE_CONFIG_H
40    #include "config.h"
41    #endif
42    
43  #include <ctype.h>  #include <ctype.h>
44  #include <stdio.h>  #include <stdio.h>
45  #include <string.h>  #include <string.h>
# Line 44  POSSIBILITY OF SUCH DAMAGE. Line 48  POSSIBILITY OF SUCH DAMAGE.
48  #include <locale.h>  #include <locale.h>
49  #include <errno.h>  #include <errno.h>
50    
51    #ifdef SUPPORT_LIBREADLINE
52    #ifdef HAVE_UNISTD_H
53    #include <unistd.h>
54    #endif
55    #include <readline/readline.h>
56    #include <readline/history.h>
57    #endif
58    
59    
60  /* A number of things vary for Windows builds. Originally, pcretest opened its  /* A number of things vary for Windows builds. Originally, pcretest opened its
61  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 59  input mode under Windows. */ Line 71  input mode under Windows. */
71  #define INPUT_MODE   "r"  #define INPUT_MODE   "r"
72  #define OUTPUT_MODE  "wb"  #define OUTPUT_MODE  "wb"
73    
74    #ifndef isatty
75    #define isatty _isatty         /* This is what Windows calls them, I'm told, */
76    #endif                         /* though in some environments they seem to   */
77                                   /* be already defined, hence the #ifndefs.    */
78    #ifndef fileno
79    #define fileno _fileno
80    #endif
81    
82    /* A user sent this fix for Borland Builder 5 under Windows. */
83    
84    #ifdef __BORLANDC__
85    #define _setmode(handle, mode) setmode(handle, mode)
86    #endif
87    
88    /* Not Windows */
89    
90  #else  #else
91  #include <sys/time.h>          /* These two includes are needed */  #include <sys/time.h>          /* These two includes are needed */
92  #include <sys/resource.h>      /* for setrlimit(). */  #include <sys/resource.h>      /* for setrlimit(). */
# Line 67  input mode under Windows. */ Line 95  input mode under Windows. */
95  #endif  #endif
96    
97    
98  #define PCRE_SPY        /* For Win32 build, import data, not export */  /* We have to include pcre_internal.h because we need the internal info for
99    displaying the results of pcre_study() and we also need to know about the
100  /* We include pcre_internal.h because we need the internal info for displaying  internal macros, structures, and other internal data values; pcretest has
101  the results of pcre_study() and we also need to know about the internal  "inside information" compared to a program that strictly follows the PCRE API.
102  macros, structures, and other internal data values; pcretest has "inside  
103  information" compared to a program that strictly follows the PCRE API. */  Although pcre_internal.h does itself include pcre.h, we explicitly include it
104    here before pcre_internal.h so that the PCRE_EXP_xxx macros get set
105    appropriately for an application, not for building PCRE. */
106    
107    #include "pcre.h"
108  #include "pcre_internal.h"  #include "pcre_internal.h"
109    
110  /* We need access to the data tables that PCRE uses. So as not to have to keep  /* We need access to some of the data tables that PCRE uses. So as not to have
111  two copies, we include the source file here, changing the names of the external  to keep two copies, we include the source file here, changing the names of the
112  symbols to prevent clashes. */  external symbols to prevent clashes. */
113    
114    #define _pcre_ucp_gentype      ucp_gentype
115    #define _pcre_ucp_typerange    ucp_typerange
116  #define _pcre_utf8_table1      utf8_table1  #define _pcre_utf8_table1      utf8_table1
117  #define _pcre_utf8_table1_size utf8_table1_size  #define _pcre_utf8_table1_size utf8_table1_size
118  #define _pcre_utf8_table2      utf8_table2  #define _pcre_utf8_table2      utf8_table2
119  #define _pcre_utf8_table3      utf8_table3  #define _pcre_utf8_table3      utf8_table3
120  #define _pcre_utf8_table4      utf8_table4  #define _pcre_utf8_table4      utf8_table4
121    #define _pcre_utf8_char_sizes  utf8_char_sizes
122  #define _pcre_utt              utt  #define _pcre_utt              utt
123  #define _pcre_utt_size         utt_size  #define _pcre_utt_size         utt_size
124    #define _pcre_utt_names        utt_names
125  #define _pcre_OP_lengths       OP_lengths  #define _pcre_OP_lengths       OP_lengths
126    
127  #include "pcre_tables.c"  #include "pcre_tables.c"
128    
129  /* We also need the pcre_printint() function for printing out compiled  /* We also need the pcre_printint() function for printing out compiled
130  patterns. This function is in a separate file so that it can be included in  patterns. This function is in a separate file so that it can be included in
131  pcre_compile.c when that module is compiled with debugging enabled.  pcre_compile.c when that module is compiled with debugging enabled. It needs to
132    know which case is being compiled. */
 The definition of the macro PRINTABLE, which determines whether to print an  
 output character as-is or as a hex value when showing compiled patterns, is  
 contained in this file. We uses it here also, in cases when the locale has not  
 been explicitly changed, so as to get consistent output from systems that  
 differ in their output from isprint() even in the "C" locale. */  
133    
134    #define COMPILING_PCRETEST
135  #include "pcre_printint.src"  #include "pcre_printint.src"
136    
137  #define PRINTHEX(c) (locale_set? isprint(c) : PRINTABLE(c))  /* The definition of the macro PRINTABLE, which determines whether to print an
138    output character as-is or as a hex value when showing compiled patterns, is
139    contained in the printint.src file. We uses it here also, in cases when the
140    locale has not been explicitly changed, so as to get consistent output from
141    systems that differ in their output from isprint() even in the "C" locale. */
142    
143    #define PRINTHEX(c) (locale_set? isprint(c) : PRINTABLE(c))
144    
145  /* It is possible to compile this test program without including support for  /* It is possible to compile this test program without including support for
146  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 149  static int callout_count; Line 185  static int callout_count;
185  static int callout_extra;  static int callout_extra;
186  static int callout_fail_count;  static int callout_fail_count;
187  static int callout_fail_id;  static int callout_fail_id;
188    static int debug_lengths;
189  static int first_callout;  static int first_callout;
190  static int locale_set = 0;  static int locale_set = 0;
191  static int show_malloc;  static int show_malloc;
192  static int use_utf8;  static int use_utf8;
193  static size_t gotten_store;  static size_t gotten_store;
194    static const unsigned char *last_callout_mark = NULL;
195    
196  /* The buffers grow automatically if very long input lines are encountered. */  /* The buffers grow automatically if very long input lines are encountered. */
197    
# Line 162  static uschar *buffer = NULL; Line 200  static uschar *buffer = NULL;
200  static uschar *dbuffer = NULL;  static uschar *dbuffer = NULL;
201  static uschar *pbuffer = NULL;  static uschar *pbuffer = NULL;
202    
203    /* Textual explanations for runtime error codes */
204    
205    static const char *errtexts[] = {
206      NULL,  /* 0 is no error */
207      NULL,  /* NOMATCH is handled specially */
208      "NULL argument passed",
209      "bad option value",
210      "magic number missing",
211      "unknown opcode - pattern overwritten?",
212      "no more memory",
213      NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
214      "match limit exceeded",
215      "callout error code",
216      NULL,  /* BADUTF8 is handled specially */
217      "bad UTF-8 offset",
218      NULL,  /* PARTIAL is handled specially */
219      "not used - internal error",
220      "internal error - pattern overwritten?",
221      "bad count value",
222      "item unsupported for DFA matching",
223      "backreference condition or recursion test not supported for DFA matching",
224      "match limit not supported for DFA matching",
225      "workspace size exceeded in DFA matching",
226      "too much recursion for DFA matching",
227      "recursion limit exceeded",
228      "not used - internal error",
229      "invalid combination of newline options",
230      "bad offset value",
231      NULL,  /* SHORTUTF8 is handled specially */
232      "nested recursion at the same subject position"
233    };
234    
235    
236    /*************************************************
237    *         Alternate character tables             *
238    *************************************************/
239    
240    /* By default, the "tables" pointer when calling PCRE is set to NULL, thereby
241    using the default tables of the library. However, the T option can be used to
242    select alternate sets of tables, for different kinds of testing. Note also that
243    the L (locale) option also adjusts the tables. */
244    
245    /* This is the set of tables distributed as default with PCRE. It recognizes
246    only ASCII characters. */
247    
248    static const unsigned char tables0[] = {
249    
250    /* This table is a lower casing table. */
251    
252        0,  1,  2,  3,  4,  5,  6,  7,
253        8,  9, 10, 11, 12, 13, 14, 15,
254       16, 17, 18, 19, 20, 21, 22, 23,
255       24, 25, 26, 27, 28, 29, 30, 31,
256       32, 33, 34, 35, 36, 37, 38, 39,
257       40, 41, 42, 43, 44, 45, 46, 47,
258       48, 49, 50, 51, 52, 53, 54, 55,
259       56, 57, 58, 59, 60, 61, 62, 63,
260       64, 97, 98, 99,100,101,102,103,
261      104,105,106,107,108,109,110,111,
262      112,113,114,115,116,117,118,119,
263      120,121,122, 91, 92, 93, 94, 95,
264       96, 97, 98, 99,100,101,102,103,
265      104,105,106,107,108,109,110,111,
266      112,113,114,115,116,117,118,119,
267      120,121,122,123,124,125,126,127,
268      128,129,130,131,132,133,134,135,
269      136,137,138,139,140,141,142,143,
270      144,145,146,147,148,149,150,151,
271      152,153,154,155,156,157,158,159,
272      160,161,162,163,164,165,166,167,
273      168,169,170,171,172,173,174,175,
274      176,177,178,179,180,181,182,183,
275      184,185,186,187,188,189,190,191,
276      192,193,194,195,196,197,198,199,
277      200,201,202,203,204,205,206,207,
278      208,209,210,211,212,213,214,215,
279      216,217,218,219,220,221,222,223,
280      224,225,226,227,228,229,230,231,
281      232,233,234,235,236,237,238,239,
282      240,241,242,243,244,245,246,247,
283      248,249,250,251,252,253,254,255,
284    
285    /* This table is a case flipping table. */
286    
287        0,  1,  2,  3,  4,  5,  6,  7,
288        8,  9, 10, 11, 12, 13, 14, 15,
289       16, 17, 18, 19, 20, 21, 22, 23,
290       24, 25, 26, 27, 28, 29, 30, 31,
291       32, 33, 34, 35, 36, 37, 38, 39,
292       40, 41, 42, 43, 44, 45, 46, 47,
293       48, 49, 50, 51, 52, 53, 54, 55,
294       56, 57, 58, 59, 60, 61, 62, 63,
295       64, 97, 98, 99,100,101,102,103,
296      104,105,106,107,108,109,110,111,
297      112,113,114,115,116,117,118,119,
298      120,121,122, 91, 92, 93, 94, 95,
299       96, 65, 66, 67, 68, 69, 70, 71,
300       72, 73, 74, 75, 76, 77, 78, 79,
301       80, 81, 82, 83, 84, 85, 86, 87,
302       88, 89, 90,123,124,125,126,127,
303      128,129,130,131,132,133,134,135,
304      136,137,138,139,140,141,142,143,
305      144,145,146,147,148,149,150,151,
306      152,153,154,155,156,157,158,159,
307      160,161,162,163,164,165,166,167,
308      168,169,170,171,172,173,174,175,
309      176,177,178,179,180,181,182,183,
310      184,185,186,187,188,189,190,191,
311      192,193,194,195,196,197,198,199,
312      200,201,202,203,204,205,206,207,
313      208,209,210,211,212,213,214,215,
314      216,217,218,219,220,221,222,223,
315      224,225,226,227,228,229,230,231,
316      232,233,234,235,236,237,238,239,
317      240,241,242,243,244,245,246,247,
318      248,249,250,251,252,253,254,255,
319    
320    /* This table contains bit maps for various character classes. Each map is 32
321    bytes long and the bits run from the least significant end of each byte. The
322    classes that have their own maps are: space, xdigit, digit, upper, lower, word,
323    graph, print, punct, and cntrl. Other classes are built from combinations. */
324    
325      0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
326      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
327      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
328      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
329    
330      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
331      0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
332      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
333      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
334    
335      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
336      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
337      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
338      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
339    
340      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
341      0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
342      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
343      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
344    
345      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
346      0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
347      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
348      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
349    
350      0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
351      0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
352      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
353      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
354    
355      0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
356      0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
357      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
358      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
359    
360      0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
361      0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
362      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
363      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
364    
365      0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
366      0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
367      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
368      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
369    
370      0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
371      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
372      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
373      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
374    
375    /* This table identifies various classes of character by individual bits:
376      0x01   white space character
377      0x02   letter
378      0x04   decimal digit
379      0x08   hexadecimal digit
380      0x10   alphanumeric or '_'
381      0x80   regular expression metacharacter or binary zero
382    */
383    
384      0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
385      0x00,0x01,0x01,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
386      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
387      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
388      0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /*    - '  */
389      0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /*  ( - /  */
390      0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
391      0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /*  8 - ?  */
392      0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  @ - G  */
393      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
394      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
395      0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /*  X - _  */
396      0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  ` - g  */
397      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  h - o  */
398      0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  p - w  */
399      0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /*  x -127 */
400      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
401      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
402      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
403      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
404      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
405      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
406      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
407      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
408      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
409      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
410      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
411      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
412      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
413      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
414      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
415      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
416    
417    /* This is a set of tables that came orginally from a Windows user. It seems to
418    be at least an approximation of ISO 8859. In particular, there are characters
419    greater than 128 that are marked as spaces, letters, etc. */
420    
421    static const unsigned char tables1[] = {
422    0,1,2,3,4,5,6,7,
423    8,9,10,11,12,13,14,15,
424    16,17,18,19,20,21,22,23,
425    24,25,26,27,28,29,30,31,
426    32,33,34,35,36,37,38,39,
427    40,41,42,43,44,45,46,47,
428    48,49,50,51,52,53,54,55,
429    56,57,58,59,60,61,62,63,
430    64,97,98,99,100,101,102,103,
431    104,105,106,107,108,109,110,111,
432    112,113,114,115,116,117,118,119,
433    120,121,122,91,92,93,94,95,
434    96,97,98,99,100,101,102,103,
435    104,105,106,107,108,109,110,111,
436    112,113,114,115,116,117,118,119,
437    120,121,122,123,124,125,126,127,
438    128,129,130,131,132,133,134,135,
439    136,137,138,139,140,141,142,143,
440    144,145,146,147,148,149,150,151,
441    152,153,154,155,156,157,158,159,
442    160,161,162,163,164,165,166,167,
443    168,169,170,171,172,173,174,175,
444    176,177,178,179,180,181,182,183,
445    184,185,186,187,188,189,190,191,
446    224,225,226,227,228,229,230,231,
447    232,233,234,235,236,237,238,239,
448    240,241,242,243,244,245,246,215,
449    248,249,250,251,252,253,254,223,
450    224,225,226,227,228,229,230,231,
451    232,233,234,235,236,237,238,239,
452    240,241,242,243,244,245,246,247,
453    248,249,250,251,252,253,254,255,
454    0,1,2,3,4,5,6,7,
455    8,9,10,11,12,13,14,15,
456    16,17,18,19,20,21,22,23,
457    24,25,26,27,28,29,30,31,
458    32,33,34,35,36,37,38,39,
459    40,41,42,43,44,45,46,47,
460    48,49,50,51,52,53,54,55,
461    56,57,58,59,60,61,62,63,
462    64,97,98,99,100,101,102,103,
463    104,105,106,107,108,109,110,111,
464    112,113,114,115,116,117,118,119,
465    120,121,122,91,92,93,94,95,
466    96,65,66,67,68,69,70,71,
467    72,73,74,75,76,77,78,79,
468    80,81,82,83,84,85,86,87,
469    88,89,90,123,124,125,126,127,
470    128,129,130,131,132,133,134,135,
471    136,137,138,139,140,141,142,143,
472    144,145,146,147,148,149,150,151,
473    152,153,154,155,156,157,158,159,
474    160,161,162,163,164,165,166,167,
475    168,169,170,171,172,173,174,175,
476    176,177,178,179,180,181,182,183,
477    184,185,186,187,188,189,190,191,
478    224,225,226,227,228,229,230,231,
479    232,233,234,235,236,237,238,239,
480    240,241,242,243,244,245,246,215,
481    248,249,250,251,252,253,254,223,
482    192,193,194,195,196,197,198,199,
483    200,201,202,203,204,205,206,207,
484    208,209,210,211,212,213,214,247,
485    216,217,218,219,220,221,222,255,
486    0,62,0,0,1,0,0,0,
487    0,0,0,0,0,0,0,0,
488    32,0,0,0,1,0,0,0,
489    0,0,0,0,0,0,0,0,
490    0,0,0,0,0,0,255,3,
491    126,0,0,0,126,0,0,0,
492    0,0,0,0,0,0,0,0,
493    0,0,0,0,0,0,0,0,
494    0,0,0,0,0,0,255,3,
495    0,0,0,0,0,0,0,0,
496    0,0,0,0,0,0,12,2,
497    0,0,0,0,0,0,0,0,
498    0,0,0,0,0,0,0,0,
499    254,255,255,7,0,0,0,0,
500    0,0,0,0,0,0,0,0,
501    255,255,127,127,0,0,0,0,
502    0,0,0,0,0,0,0,0,
503    0,0,0,0,254,255,255,7,
504    0,0,0,0,0,4,32,4,
505    0,0,0,128,255,255,127,255,
506    0,0,0,0,0,0,255,3,
507    254,255,255,135,254,255,255,7,
508    0,0,0,0,0,4,44,6,
509    255,255,127,255,255,255,127,255,
510    0,0,0,0,254,255,255,255,
511    255,255,255,255,255,255,255,127,
512    0,0,0,0,254,255,255,255,
513    255,255,255,255,255,255,255,255,
514    0,2,0,0,255,255,255,255,
515    255,255,255,255,255,255,255,127,
516    0,0,0,0,255,255,255,255,
517    255,255,255,255,255,255,255,255,
518    0,0,0,0,254,255,0,252,
519    1,0,0,248,1,0,0,120,
520    0,0,0,0,254,255,255,255,
521    0,0,128,0,0,0,128,0,
522    255,255,255,255,0,0,0,0,
523    0,0,0,0,0,0,0,128,
524    255,255,255,255,0,0,0,0,
525    0,0,0,0,0,0,0,0,
526    128,0,0,0,0,0,0,0,
527    0,1,1,0,1,1,0,0,
528    0,0,0,0,0,0,0,0,
529    0,0,0,0,0,0,0,0,
530    1,0,0,0,128,0,0,0,
531    128,128,128,128,0,0,128,0,
532    28,28,28,28,28,28,28,28,
533    28,28,0,0,0,0,0,128,
534    0,26,26,26,26,26,26,18,
535    18,18,18,18,18,18,18,18,
536    18,18,18,18,18,18,18,18,
537    18,18,18,128,128,0,128,16,
538    0,26,26,26,26,26,26,18,
539    18,18,18,18,18,18,18,18,
540    18,18,18,18,18,18,18,18,
541    18,18,18,128,128,0,0,0,
542    0,0,0,0,0,1,0,0,
543    0,0,0,0,0,0,0,0,
544    0,0,0,0,0,0,0,0,
545    0,0,0,0,0,0,0,0,
546    1,0,0,0,0,0,0,0,
547    0,0,18,0,0,0,0,0,
548    0,0,20,20,0,18,0,0,
549    0,20,18,0,0,0,0,0,
550    18,18,18,18,18,18,18,18,
551    18,18,18,18,18,18,18,18,
552    18,18,18,18,18,18,18,0,
553    18,18,18,18,18,18,18,18,
554    18,18,18,18,18,18,18,18,
555    18,18,18,18,18,18,18,18,
556    18,18,18,18,18,18,18,0,
557    18,18,18,18,18,18,18,18
558    };
559    
560    
561    
562    
563    #ifndef HAVE_STRERROR
564    /*************************************************
565    *     Provide strerror() for non-ANSI libraries  *
566    *************************************************/
567    
568    /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
569    in their libraries, but can provide the same facility by this simple
570    alternative function. */
571    
572    extern int   sys_nerr;
573    extern char *sys_errlist[];
574    
575    char *
576    strerror(int n)
577    {
578    if (n < 0 || n >= sys_nerr) return "unknown error number";
579    return sys_errlist[n];
580    }
581    #endif /* HAVE_STRERROR */
582    
583    
584    /*************************************************
585    *         JIT memory callback                    *
586    *************************************************/
587    
588    static pcre_jit_stack* jit_callback(void *arg)
589    {
590    return (pcre_jit_stack *)arg;
591    }
592    
593    
594  /*************************************************  /*************************************************
# Line 180  optimal way of handling this, but hey, t Line 607  optimal way of handling this, but hey, t
607  Arguments:  Arguments:
608    f            the file to read    f            the file to read
609    start        where in buffer to start (this *must* be within buffer)    start        where in buffer to start (this *must* be within buffer)
610      prompt       for stdin or readline()
611    
612  Returns:       pointer to the start of new data  Returns:       pointer to the start of new data
613                 could be a copy of start, or could be moved                 could be a copy of start, or could be moved
# Line 187  Returns:       pointer to the start of n Line 615  Returns:       pointer to the start of n
615  */  */
616    
617  static uschar *  static uschar *
618  extend_inputline(FILE *f, uschar *start)  extend_inputline(FILE *f, uschar *start, const char *prompt)
619  {  {
620  uschar *here = start;  uschar *here = start;
621    
622  for (;;)  for (;;)
623    {    {
624    int rlen = buffer_size - (here - buffer);    int rlen = (int)(buffer_size - (here - buffer));
625    
626    if (rlen > 1000)    if (rlen > 1000)
627      {      {
628      int dlen;      int dlen;
629      if (fgets((char *)here, rlen,  f) == NULL)  
630        return (here == start)? NULL : start;      /* If libreadline support is required, use readline() to read a line if the
631        input is a terminal. Note that readline() removes the trailing newline, so
632        we must put it back again, to be compatible with fgets(). */
633    
634    #ifdef SUPPORT_LIBREADLINE
635        if (isatty(fileno(f)))
636          {
637          size_t len;
638          char *s = readline(prompt);
639          if (s == NULL) return (here == start)? NULL : start;
640          len = strlen(s);
641          if (len > 0) add_history(s);
642          if (len > rlen - 1) len = rlen - 1;
643          memcpy(here, s, len);
644          here[len] = '\n';
645          here[len+1] = 0;
646          free(s);
647          }
648        else
649    #endif
650    
651        /* Read the next line by normal means, prompting if the file is stdin. */
652    
653          {
654          if (f == stdin) printf("%s", prompt);
655          if (fgets((char *)here, rlen,  f) == NULL)
656            return (here == start)? NULL : start;
657          }
658    
659      dlen = (int)strlen((char *)here);      dlen = (int)strlen((char *)here);
660      if (dlen > 0 && here[dlen - 1] == '\n') return start;      if (dlen > 0 && here[dlen - 1] == '\n') return start;
661      here += dlen;      here += dlen;
# Line 515  fprintf(outfile, "%.*s", (cb->next_item_ Line 971  fprintf(outfile, "%.*s", (cb->next_item_
971  fprintf(outfile, "\n");  fprintf(outfile, "\n");
972  first_callout = 0;  first_callout = 0;
973    
974    if (cb->mark != last_callout_mark)
975      {
976      fprintf(outfile, "Latest Mark: %s\n",
977        (cb->mark == NULL)? "<unset>" : (char *)(cb->mark));
978      last_callout_mark = cb->mark;
979      }
980    
981  if (cb->callout_data != NULL)  if (cb->callout_data != NULL)
982    {    {
983    int callout_data = *((int *)(cb->callout_data));    int callout_data = *((int *)(cb->callout_data));
# Line 534  return (cb->callout_number != callout_fa Line 997  return (cb->callout_number != callout_fa
997  *            Local malloc functions              *  *            Local malloc functions              *
998  *************************************************/  *************************************************/
999    
1000  /* Alternative malloc function, to test functionality and show the size of the  /* Alternative malloc function, to test functionality and save the size of a
1001  compiled re. */  compiled re. The show_malloc variable is set only during matching. */
1002    
1003  static void *new_malloc(size_t size)  static void *new_malloc(size_t size)
1004  {  {
# Line 553  if (show_malloc) Line 1016  if (show_malloc)
1016  free(block);  free(block);
1017  }  }
1018    
   
1019  /* For recursion malloc/free, to test stacking calls */  /* For recursion malloc/free, to test stacking calls */
1020    
1021  static void *stack_malloc(size_t size)  static void *stack_malloc(size_t size)
# Line 588  if ((rc = pcre_fullinfo(re, study, optio Line 1050  if ((rc = pcre_fullinfo(re, study, optio
1050    
1051    
1052  /*************************************************  /*************************************************
1053    *      Check for supported JIT architecture      *
1054    *************************************************/
1055    
1056    /* If it won't JIT-compile a very simple regex, return FALSE. */
1057    
1058    static int check_jit_arch(void)
1059    {
1060    const char *error;
1061    int erroffset, rc;
1062    pcre *re = pcre_compile("abc", 0, &error, &erroffset, NULL);
1063    pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
1064    rc = extra != NULL && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
1065      extra->executable_jit != NULL;
1066    pcre_free_study(extra);
1067    free(re);
1068    return rc;
1069    }
1070    
1071    
1072    /*************************************************
1073  *         Byte flipping function                 *  *         Byte flipping function                 *
1074  *************************************************/  *************************************************/
1075    
# Line 656  return count; Line 1138  return count;
1138    
1139    
1140  /*************************************************  /*************************************************
1141    *         Case-independent strncmp() function    *
1142    *************************************************/
1143    
1144    /*
1145    Arguments:
1146      s         first string
1147      t         second string
1148      n         number of characters to compare
1149    
1150    Returns:    < 0, = 0, or > 0, according to the comparison
1151    */
1152    
1153    static int
1154    strncmpic(uschar *s, uschar *t, int n)
1155    {
1156    while (n--)
1157      {
1158      int c = tolower(*s++) - tolower(*t++);
1159      if (c) return c;
1160      }
1161    return 0;
1162    }
1163    
1164    
1165    
1166    /*************************************************
1167  *         Check newline indicator                *  *         Check newline indicator                *
1168  *************************************************/  *************************************************/
1169    
1170  /* 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
1171  xxx is LF, CR, CRLF, or ANY. Print a message and return 0 if there is no match.  a message and return 0 if there is no match.
1172    
1173  Arguments:  Arguments:
1174    p           points after the leading '<'    p           points after the leading '<'
# Line 672  Returns:      appropriate PCRE_NEWLINE_x Line 1180  Returns:      appropriate PCRE_NEWLINE_x
1180  static int  static int
1181  check_newline(uschar *p, FILE *f)  check_newline(uschar *p, FILE *f)
1182  {  {
1183  if (strncmp((char *)p, "cr>", 3) == 0) return PCRE_NEWLINE_CR;  if (strncmpic(p, (uschar *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;
1184  if (strncmp((char *)p, "lf>", 3) == 0) return PCRE_NEWLINE_LF;  if (strncmpic(p, (uschar *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;
1185  if (strncmp((char *)p, "crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;  if (strncmpic(p, (uschar *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;
1186  if (strncmp((char *)p, "any>", 4) == 0) return PCRE_NEWLINE_ANY;  if (strncmpic(p, (uschar *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;
1187    if (strncmpic(p, (uschar *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;
1188    if (strncmpic(p, (uschar *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF;
1189    if (strncmpic(p, (uschar *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE;
1190  fprintf(f, "Unknown newline type at: <%s\n", p);  fprintf(f, "Unknown newline type at: <%s\n", p);
1191  return 0;  return 0;
1192  }  }
# Line 689  return 0; Line 1200  return 0;
1200  static void  static void
1201  usage(void)  usage(void)
1202  {  {
1203  printf("Usage:     pcretest [options] [<input> [<output>]]\n");  printf("Usage:     pcretest [options] [<input file> [<output file>]]\n\n");
1204    printf("Input and output default to stdin and stdout.\n");
1205    #ifdef SUPPORT_LIBREADLINE
1206    printf("If input is a terminal, readline() is used to read from it.\n");
1207    #else
1208    printf("This version of pcretest is not linked with readline().\n");
1209    #endif
1210    printf("\nOptions:\n");
1211  printf("  -b       show compiled code (bytecode)\n");  printf("  -b       show compiled code (bytecode)\n");
1212  printf("  -C       show PCRE compile-time options and exit\n");  printf("  -C       show PCRE compile-time options and exit\n");
1213  printf("  -d       debug: show compiled code and information (-b and -i)\n");  printf("  -d       debug: show compiled code and information (-b and -i)\n");
# Line 698  printf("  -dfa     force DFA matching fo Line 1216  printf("  -dfa     force DFA matching fo
1216  #endif  #endif
1217  printf("  -help    show usage information\n");  printf("  -help    show usage information\n");
1218  printf("  -i       show information about compiled patterns\n"  printf("  -i       show information about compiled patterns\n"
1219           "  -M       find MATCH_LIMIT minimum for each subject\n"
1220         "  -m       output memory used information\n"         "  -m       output memory used information\n"
1221         "  -o <n>   set size of offsets vector to <n>\n");         "  -o <n>   set size of offsets vector to <n>\n");
1222  #if !defined NOPOSIX  #if !defined NOPOSIX
# Line 705  printf("  -p       use POSIX interface\n Line 1224  printf("  -p       use POSIX interface\n
1224  #endif  #endif
1225  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
1226  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
1227  printf("  -s       output store (memory) used information\n"  printf("  -s       force each pattern to be studied at basic level\n"
1228           "  -s+      force each pattern to be studied, using JIT if available\n"
1229         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
1230  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
1231  printf("  -tm      time execution (matching) only\n");  printf("  -tm      time execution (matching) only\n");
# Line 727  int main(int argc, char **argv) Line 1247  int main(int argc, char **argv)
1247  FILE *infile = stdin;  FILE *infile = stdin;
1248  int options = 0;  int options = 0;
1249  int study_options = 0;  int study_options = 0;
1250    int default_find_match_limit = FALSE;
1251  int op = 1;  int op = 1;
1252  int timeit = 0;  int timeit = 0;
1253  int timeitm = 0;  int timeitm = 0;
1254  int showinfo = 0;  int showinfo = 0;
1255  int showstore = 0;  int showstore = 0;
1256    int force_study = -1;
1257    int force_study_options = 0;
1258  int quiet = 0;  int quiet = 0;
1259  int size_offsets = 45;  int size_offsets = 45;
1260  int size_offsets_max;  int size_offsets_max;
# Line 745  int all_use_dfa = 0; Line 1268  int all_use_dfa = 0;
1268  int yield = 0;  int yield = 0;
1269  int stack_size;  int stack_size;
1270    
1271    pcre_jit_stack *jit_stack = NULL;
1272    
1273    
1274  /* These vectors store, end-to-end, a list of captured substring names. Assume  /* These vectors store, end-to-end, a list of captured substring names. Assume
1275  that 1024 is plenty long enough for the few names we'll be testing. */  that 1024 is plenty long enough for the few names we'll be testing. */
1276    
# Line 780  while (argc > 1 && argv[op][0] == '-') Line 1306  while (argc > 1 && argv[op][0] == '-')
1306    {    {
1307    unsigned char *endptr;    unsigned char *endptr;
1308    
1309    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1310      showstore = 1;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1311      else if (strcmp(argv[op], "-s+") == 0)
1312        {
1313        force_study = 1;
1314        force_study_options = PCRE_STUDY_JIT_COMPILE;
1315        }
1316    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1317    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1318    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
1319    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
1320      else if (strcmp(argv[op], "-M") == 0) default_find_match_limit = TRUE;
1321  #if !defined NODFA  #if !defined NODFA
1322    else if (strcmp(argv[op], "-dfa") == 0) all_use_dfa = 1;    else if (strcmp(argv[op], "-dfa") == 0) all_use_dfa = 1;
1323  #endif  #endif
# Line 814  while (argc > 1 && argv[op][0] == '-') Line 1346  while (argc > 1 && argv[op][0] == '-')
1346        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
1347          *endptr == 0))          *endptr == 0))
1348      {      {
1349  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix)
1350      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
1351      exit(1);      exit(1);
1352  #else  #else
# Line 838  while (argc > 1 && argv[op][0] == '-') Line 1370  while (argc > 1 && argv[op][0] == '-')
1370    else if (strcmp(argv[op], "-C") == 0)    else if (strcmp(argv[op], "-C") == 0)
1371      {      {
1372      int rc;      int rc;
1373        unsigned long int lrc;
1374      printf("PCRE version %s\n", pcre_version());      printf("PCRE version %s\n", pcre_version());
1375      printf("Compiled with\n");      printf("Compiled with\n");
1376      (void)pcre_config(PCRE_CONFIG_UTF8, &rc);      (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
1377      printf("  %sUTF-8 support\n", rc? "" : "No ");      printf("  %sUTF-8 support\n", rc? "" : "No ");
1378      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
1379      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1380        (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1381        if (rc)
1382          printf("  Just-in-time compiler support%s\n", check_jit_arch()?
1383            "" : " (but this architecture is unsupported)");
1384        else
1385          printf("  No just-in-time compiler support\n");
1386      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
1387      printf("  Newline sequence is %s\n", (rc == '\r')? "CR" :      /* Note that these values are always the ASCII values, even
1388        (rc == '\n')? "LF" : (rc == ('\r'<<8 | '\n'))? "CRLF" :      in EBCDIC environments. CR is 13 and NL is 10. */
1389        printf("  Newline sequence is %s\n", (rc == 13)? "CR" :
1390          (rc == 10)? "LF" : (rc == (13<<8 | 10))? "CRLF" :
1391          (rc == -2)? "ANYCRLF" :
1392        (rc == -1)? "ANY" : "???");        (rc == -1)? "ANY" : "???");
1393        (void)pcre_config(PCRE_CONFIG_BSR, &rc);
1394        printf("  \\R matches %s\n", rc? "CR, LF, or CRLF only" :
1395                                         "all Unicode newlines");
1396      (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);      (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);
1397      printf("  Internal link size = %d\n", rc);      printf("  Internal link size = %d\n", rc);
1398      (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);      (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);
1399      printf("  POSIX malloc threshold = %d\n", rc);      printf("  POSIX malloc threshold = %d\n", rc);
1400      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT, &rc);      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT, &lrc);
1401      printf("  Default match limit = %d\n", rc);      printf("  Default match limit = %ld\n", lrc);
1402      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &rc);      (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &lrc);
1403      printf("  Default recursion depth limit = %d\n", rc);      printf("  Default recursion depth limit = %ld\n", lrc);
1404      (void)pcre_config(PCRE_CONFIG_STACKRECURSE, &rc);      (void)pcre_config(PCRE_CONFIG_STACKRECURSE, &rc);
1405      printf("  Match recursion uses %s\n", rc? "stack" : "heap");      printf("  Match recursion uses %s\n", rc? "stack" : "heap");
1406      goto EXIT;      goto EXIT;
# Line 884  offsets = (int *)malloc(size_offsets_max Line 1429  offsets = (int *)malloc(size_offsets_max
1429  if (offsets == NULL)  if (offsets == NULL)
1430    {    {
1431    printf("** Failed to get %d bytes of memory for offsets vector\n",    printf("** Failed to get %d bytes of memory for offsets vector\n",
1432      size_offsets_max * sizeof(int));      (int)(size_offsets_max * sizeof(int)));
1433    yield = 1;    yield = 1;
1434    goto EXIT;    goto EXIT;
1435    }    }
# Line 937  while (!done) Line 1482  while (!done)
1482  #endif  #endif
1483    
1484    const char *error;    const char *error;
1485      unsigned char *markptr;
1486    unsigned char *p, *pp, *ppp;    unsigned char *p, *pp, *ppp;
1487    unsigned char *to_file = NULL;    unsigned char *to_file = NULL;
1488    const unsigned char *tables = NULL;    const unsigned char *tables = NULL;
1489    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
1490    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
1491      int do_allcaps = 0;
1492      int do_mark = 0;
1493    int do_study = 0;    int do_study = 0;
1494      int no_force_study = 0;
1495    int do_debug = debug;    int do_debug = debug;
   int debug_lengths = 1;  
1496    int do_G = 0;    int do_G = 0;
1497    int do_g = 0;    int do_g = 0;
1498    int do_showinfo = showinfo;    int do_showinfo = showinfo;
1499    int do_showrest = 0;    int do_showrest = 0;
1500      int do_showcaprest = 0;
1501    int do_flip = 0;    int do_flip = 0;
1502    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
1503    
1504    use_utf8 = 0;    use_utf8 = 0;
1505      debug_lengths = 1;
1506    
1507    if (infile == stdin) printf("  re> ");    if (extend_inputline(infile, buffer, "  re> ") == NULL) break;
   if (extend_inputline(infile, buffer) == NULL) break;  
1508    if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);    if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
1509    fflush(outfile);    fflush(outfile);
1510    
# Line 1010  while (!done) Line 1559  while (!done)
1559          }          }
1560        }        }
1561    
1562      fprintf(outfile, "Compiled regex%s loaded from %s\n",      fprintf(outfile, "Compiled pattern%s loaded from %s\n",
1563        do_flip? " (byte-inverted)" : "", p);        do_flip? " (byte-inverted)" : "", p);
1564    
1565      /* Need to know if UTF-8 for printing data strings */      /* Need to know if UTF-8 for printing data strings */
# Line 1018  while (!done) Line 1567  while (!done)
1567      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1568      use_utf8 = (get_options & PCRE_UTF8) != 0;      use_utf8 = (get_options & PCRE_UTF8) != 0;
1569    
1570      /* Now see if there is any following study data */      /* Now see if there is any following study data. */
1571    
1572      if (true_study_size != 0)      if (true_study_size != 0)
1573        {        {
# Line 1034  while (!done) Line 1583  while (!done)
1583          {          {
1584          FAIL_READ:          FAIL_READ:
1585          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
1586          if (extra != NULL) new_free(extra);          if (extra != NULL) pcre_free_study(extra);
1587          if (re != NULL) new_free(re);          if (re != NULL) new_free(re);
1588          fclose(f);          fclose(f);
1589          continue;          continue;
# Line 1055  while (!done) Line 1604  while (!done)
1604    
1605    if (isalnum(delimiter) || delimiter == '\\')    if (isalnum(delimiter) || delimiter == '\\')
1606      {      {
1607      fprintf(outfile, "** Delimiter must not be alphameric or \\\n");      fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n");
1608      goto SKIP_DATA;      goto SKIP_DATA;
1609      }      }
1610    
1611    pp = p;    pp = p;
1612    poffset = p - buffer;    poffset = (int)(p - buffer);
1613    
1614    for(;;)    for(;;)
1615      {      {
# Line 1071  while (!done) Line 1620  while (!done)
1620        pp++;        pp++;
1621        }        }
1622      if (*pp != 0) break;      if (*pp != 0) break;
1623      if (infile == stdin) printf("    > ");      if ((pp = extend_inputline(infile, pp, "    > ")) == NULL)
     if ((pp = extend_inputline(infile, pp)) == NULL)  
1624        {        {
1625        fprintf(outfile, "** Unexpected EOF\n");        fprintf(outfile, "** Unexpected EOF\n");
1626        done = 1;        done = 1;
# Line 1101  while (!done) Line 1649  while (!done)
1649    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1650    
1651    options = 0;    options = 0;
   study_options = 0;  
1652    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1653    
1654    while (*pp != 0)    while (*pp != 0)
# Line 1115  while (!done) Line 1662  while (!done)
1662        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
1663        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
1664    
1665        case '+': do_showrest = 1; break;        case '+':
1666          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
1667          break;
1668    
1669          case '=': do_allcaps = 1; break;
1670        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1671        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
1672        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1125  while (!done) Line 1676  while (!done)
1676        case 'G': do_G = 1; break;        case 'G': do_G = 1; break;
1677        case 'I': do_showinfo = 1; break;        case 'I': do_showinfo = 1; break;
1678        case 'J': options |= PCRE_DUPNAMES; break;        case 'J': options |= PCRE_DUPNAMES; break;
1679          case 'K': do_mark = 1; break;
1680        case 'M': log_store = 1; break;        case 'M': log_store = 1; break;
1681        case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;        case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;
1682    
# Line 1132  while (!done) Line 1684  while (!done)
1684        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
1685  #endif  #endif
1686    
1687        case 'S': do_study = 1; break;        case 'S':
1688          if (do_study == 0)
1689            {
1690            do_study = 1;
1691            if (*pp == '+')
1692              {
1693              study_options |= PCRE_STUDY_JIT_COMPILE;
1694              pp++;
1695              }
1696            }
1697          else
1698            {
1699            do_study = 0;
1700            no_force_study = 1;
1701            }
1702          break;
1703    
1704        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
1705          case 'W': options |= PCRE_UCP; break;
1706        case 'X': options |= PCRE_EXTRA; break;        case 'X': options |= PCRE_EXTRA; break;
1707          case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
1708        case 'Z': debug_lengths = 0; break;        case 'Z': debug_lengths = 0; break;
1709        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;
1710        case '?': options |= PCRE_NO_UTF8_CHECK; break;        case '?': options |= PCRE_NO_UTF8_CHECK; break;
1711    
1712          case 'T':
1713          switch (*pp++)
1714            {
1715            case '0': tables = tables0; break;
1716            case '1': tables = tables1; break;
1717    
1718            case '\r':
1719            case '\n':
1720            case ' ':
1721            case 0:
1722            fprintf(outfile, "** Missing table number after /T\n");
1723            goto SKIP_DATA;
1724    
1725            default:
1726            fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]);
1727            goto SKIP_DATA;
1728            }
1729          break;
1730    
1731        case 'L':        case 'L':
1732        ppp = pp;        ppp = pp;
1733        /* The '\r' test here is so that it works on Windows. */        /* The '\r' test here is so that it works on Windows. */
# Line 1164  while (!done) Line 1753  while (!done)
1753    
1754        case '<':        case '<':
1755          {          {
1756          int x = check_newline(pp, outfile);          if (strncmpic(pp, (uschar *)"JS>", 3) == 0)
1757          if (x == 0) goto SKIP_DATA;            {
1758          options |= x;            options |= PCRE_JAVASCRIPT_COMPAT;
1759          while (*pp++ != '>');            pp += 3;
1760              }
1761            else
1762              {
1763              int x = check_newline(pp, outfile);
1764              if (x == 0) goto SKIP_DATA;
1765              options |= x;
1766              while (*pp++ != '>');
1767              }
1768          }          }
1769        break;        break;
1770    
# Line 1197  while (!done) Line 1794  while (!done)
1794      if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;      if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;
1795      if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB;      if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB;
1796      if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8;      if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8;
1797        if ((options & PCRE_UCP) != 0) cflags |= REG_UCP;
1798        if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY;
1799    
1800      rc = regcomp(&preg, (char *)p, cflags);      rc = regcomp(&preg, (char *)p, cflags);
1801    
# Line 1217  while (!done) Line 1816  while (!done)
1816  #endif  /* !defined NOPOSIX */  #endif  /* !defined NOPOSIX */
1817    
1818      {      {
1819        unsigned long int get_options;
1820    
1821      if (timeit > 0)      if (timeit > 0)
1822        {        {
1823        register int i;        register int i;
# Line 1246  while (!done) Line 1847  while (!done)
1847          {          {
1848          for (;;)          for (;;)
1849            {            {
1850            if (extend_inputline(infile, buffer) == NULL)            if (extend_inputline(infile, buffer, NULL) == NULL)
1851              {              {
1852              done = 1;              done = 1;
1853              goto CONTINUE;              goto CONTINUE;
# Line 1260  while (!done) Line 1861  while (!done)
1861        goto CONTINUE;        goto CONTINUE;
1862        }        }
1863    
1864      /* Compilation succeeded; print data if required. There are now two      /* Compilation succeeded. It is now possible to set the UTF-8 option from
1865      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
1866      returns only limited data. Check that it agrees with the newer one. */      lines. */
1867    
1868        new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1869        if ((get_options & PCRE_UTF8) != 0) use_utf8 = 1;
1870    
1871        /* Print information if required. There are now two info-returning
1872        functions. The old one has a limited interface and returns only limited
1873        data. Check that it agrees with the newer one. */
1874    
1875      if (log_store)      if (log_store)
1876        fprintf(outfile, "Memory allocation (code space): %d\n",        fprintf(outfile, "Memory allocation (code space): %d\n",
# Line 1276  while (!done) Line 1884  while (!done)
1884      true_size = ((real_pcre *)re)->size;      true_size = ((real_pcre *)re)->size;
1885      regex_gotten_store = gotten_store;      regex_gotten_store = gotten_store;
1886    
1887      /* 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
1888      help with the matching. */      help with the matching, unless the pattern has the SS option, which
1889        suppresses the effect of /S (used for a few test patterns where studying is
1890        never sensible). */
1891    
1892      if (do_study)      if (do_study || (force_study >= 0 && !no_force_study))
1893        {        {
1894        if (timeit > 0)        if (timeit > 0)
1895          {          {
# Line 1287  while (!done) Line 1897  while (!done)
1897          clock_t time_taken;          clock_t time_taken;
1898          clock_t start_time = clock();          clock_t start_time = clock();
1899          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
1900            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options | force_study_options, &error);
1901          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1902          if (extra != NULL) free(extra);          if (extra != NULL) pcre_free_study(extra);
1903          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1904            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
1905              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1906          }          }
1907        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options | force_study_options, &error);
1908        if (error != NULL)        if (error != NULL)
1909          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1910        else if (extra != NULL)        else if (extra != NULL)
1911          true_study_size = ((pcre_study_data *)(extra->study_data))->size;          true_study_size = ((pcre_study_data *)(extra->study_data))->size;
1912        }        }
1913    
1914        /* If /K was present, we set up for handling MARK data. */
1915    
1916        if (do_mark)
1917          {
1918          if (extra == NULL)
1919            {
1920            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
1921            extra->flags = 0;
1922            }
1923          extra->mark = &markptr;
1924          extra->flags |= PCRE_EXTRA_MARK;
1925          }
1926    
1927      /* If the 'F' option was present, we flip the bytes of all the integer      /* If the 'F' option was present, we flip the bytes of all the integer
1928      fields in the regex data block and the study block. This is to make it      fields in the regex data block and the study block. This is to make it
1929      possible to test PCRE's handling of byte-flipped patterns, e.g. those      possible to test PCRE's handling of byte-flipped patterns, e.g. those
# Line 1309  while (!done) Line 1932  while (!done)
1932      if (do_flip)      if (do_flip)
1933        {        {
1934        real_pcre *rre = (real_pcre *)re;        real_pcre *rre = (real_pcre *)re;
1935        rre->magic_number = byteflip(rre->magic_number, sizeof(rre->magic_number));        rre->magic_number =
1936            byteflip(rre->magic_number, sizeof(rre->magic_number));
1937        rre->size = byteflip(rre->size, sizeof(rre->size));        rre->size = byteflip(rre->size, sizeof(rre->size));
1938        rre->options = byteflip(rre->options, sizeof(rre->options));        rre->options = byteflip(rre->options, sizeof(rre->options));
1939        rre->top_bracket = byteflip(rre->top_bracket, sizeof(rre->top_bracket));        rre->flags = (pcre_uint16)byteflip(rre->flags, sizeof(rre->flags));
1940        rre->top_backref = byteflip(rre->top_backref, sizeof(rre->top_backref));        rre->top_bracket =
1941        rre->first_byte = byteflip(rre->first_byte, sizeof(rre->first_byte));          (pcre_uint16)byteflip(rre->top_bracket, sizeof(rre->top_bracket));
1942        rre->req_byte = byteflip(rre->req_byte, sizeof(rre->req_byte));        rre->top_backref =
1943        rre->name_table_offset = byteflip(rre->name_table_offset,          (pcre_uint16)byteflip(rre->top_backref, sizeof(rre->top_backref));
1944          rre->first_byte =
1945            (pcre_uint16)byteflip(rre->first_byte, sizeof(rre->first_byte));
1946          rre->req_byte =
1947            (pcre_uint16)byteflip(rre->req_byte, sizeof(rre->req_byte));
1948          rre->name_table_offset = (pcre_uint16)byteflip(rre->name_table_offset,
1949          sizeof(rre->name_table_offset));          sizeof(rre->name_table_offset));
1950        rre->name_entry_size = byteflip(rre->name_entry_size,        rre->name_entry_size = (pcre_uint16)byteflip(rre->name_entry_size,
1951          sizeof(rre->name_entry_size));          sizeof(rre->name_entry_size));
1952        rre->name_count = byteflip(rre->name_count, sizeof(rre->name_count));        rre->name_count = (pcre_uint16)byteflip(rre->name_count,
1953            sizeof(rre->name_count));
1954    
1955        if (extra != NULL)        if (extra != NULL)
1956          {          {
1957          pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);          pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
1958          rsd->size = byteflip(rsd->size, sizeof(rsd->size));          rsd->size = byteflip(rsd->size, sizeof(rsd->size));
1959          rsd->options = byteflip(rsd->options, sizeof(rsd->options));          rsd->flags = byteflip(rsd->flags, sizeof(rsd->flags));
1960            rsd->minlength = byteflip(rsd->minlength, sizeof(rsd->minlength));
1961          }          }
1962        }        }
1963    
# Line 1340  while (!done) Line 1971  while (!done)
1971        pcre_printint(re, outfile, debug_lengths);        pcre_printint(re, outfile, debug_lengths);
1972        }        }
1973    
1974        /* We already have the options in get_options (see above) */
1975    
1976      if (do_showinfo)      if (do_showinfo)
1977        {        {
1978        unsigned long int get_options, all_options;        unsigned long int all_options;
1979  #if !defined NOINFOCHECK  #if !defined NOINFOCHECK
1980        int old_first_char, old_options, old_count;        int old_first_char, old_options, old_count;
1981  #endif  #endif
1982        int count, backrefmax, first_char, need_char;        int count, backrefmax, first_char, need_char, okpartial, jchanged,
1983            hascrorlf;
1984        int nameentrysize, namecount;        int nameentrysize, namecount;
1985        const uschar *nametable;        const uschar *nametable;
1986    
       new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);  
1987        new_info(re, NULL, PCRE_INFO_SIZE, &size);        new_info(re, NULL, PCRE_INFO_SIZE, &size);
1988        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
1989        new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);        new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);
# Line 1359  while (!done) Line 1992  while (!done)
1992        new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize);        new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize);
1993        new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount);        new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount);
1994        new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable);        new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable);
1995          new_info(re, NULL, PCRE_INFO_OKPARTIAL, &okpartial);
1996          new_info(re, NULL, PCRE_INFO_JCHANGED, &jchanged);
1997          new_info(re, NULL, PCRE_INFO_HASCRORLF, &hascrorlf);
1998    
1999  #if !defined NOINFOCHECK  #if !defined NOINFOCHECK
2000        old_count = pcre_info(re, &old_options, &old_first_char);        old_count = pcre_info(re, &old_options, &old_first_char);
# Line 1400  while (!done) Line 2036  while (!done)
2036            }            }
2037          }          }
2038    
2039        /* The NOPARTIAL bit is a private bit in the options, so we have        if (!okpartial) fprintf(outfile, "Partial matching not supported\n");
2040        to fish it out via out back door */        if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n");
2041    
2042        all_options = ((real_pcre *)re)->options;        all_options = ((real_pcre *)re)->options;
2043        if (do_flip)        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));
         {  
         all_options = byteflip(all_options, sizeof(all_options));  
          }  
   
       if ((all_options & PCRE_NOPARTIAL) != 0)  
         fprintf(outfile, "Partial matching not supported\n");  
2044    
2045        if (get_options == 0) fprintf(outfile, "No options\n");        if (get_options == 0) fprintf(outfile, "No options\n");
2046          else fprintf(outfile, "Options:%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",
2047            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
2048            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
2049            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
2050            ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",            ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",
2051            ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "",            ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "",
2052            ((get_options & PCRE_DOTALL) != 0)? " dotall" : "",            ((get_options & PCRE_DOTALL) != 0)? " dotall" : "",
2053              ((get_options & PCRE_BSR_ANYCRLF) != 0)? " bsr_anycrlf" : "",
2054              ((get_options & PCRE_BSR_UNICODE) != 0)? " bsr_unicode" : "",
2055            ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",            ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",
2056            ((get_options & PCRE_EXTRA) != 0)? " extra" : "",            ((get_options & PCRE_EXTRA) != 0)? " extra" : "",
2057            ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",            ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",
2058            ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "",            ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "",
2059            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",
2060              ((get_options & PCRE_UCP) != 0)? " ucp" : "",
2061            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",
2062              ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "",
2063            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
2064    
2065          if (jchanged) fprintf(outfile, "Duplicate name status changes\n");
2066    
2067        switch (get_options & PCRE_NEWLINE_BITS)        switch (get_options & PCRE_NEWLINE_BITS)
2068          {          {
2069          case PCRE_NEWLINE_CR:          case PCRE_NEWLINE_CR:
# Line 1442  while (!done) Line 2078  while (!done)
2078          fprintf(outfile, "Forced newline sequence: CRLF\n");          fprintf(outfile, "Forced newline sequence: CRLF\n");
2079          break;          break;
2080    
2081            case PCRE_NEWLINE_ANYCRLF:
2082            fprintf(outfile, "Forced newline sequence: ANYCRLF\n");
2083            break;
2084    
2085          case PCRE_NEWLINE_ANY:          case PCRE_NEWLINE_ANY:
2086          fprintf(outfile, "Forced newline sequence: ANY\n");          fprintf(outfile, "Forced newline sequence: ANY\n");
2087          break;          break;
# Line 1487  while (!done) Line 2127  while (!done)
2127        /* Don't output study size; at present it is in any case a fixed        /* Don't output study size; at present it is in any case a fixed
2128        value, but it varies, depending on the computer architecture, and        value, but it varies, depending on the computer architecture, and
2129        so messes up the test suite. (And with the /F option, it might be        so messes up the test suite. (And with the /F option, it might be
2130        flipped.) */        flipped.) If study was forced by an external -s, don't show this
2131          information unless -i or -d was also present. This means that, except
2132          when auto-callouts are involved, the output from runs with and without
2133          -s should be identical. */
2134    
2135        if (do_study)        if (do_study || (force_study >= 0 && showinfo && !no_force_study))
2136          {          {
2137          if (extra == NULL)          if (extra == NULL)
2138            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
2139          else          else
2140            {            {
2141            uschar *start_bits = NULL;            uschar *start_bits = NULL;
2142            new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits);            int minlength;
2143    
2144              new_info(re, extra, PCRE_INFO_MINLENGTH, &minlength);
2145              fprintf(outfile, "Subject length lower bound = %d\n", minlength);
2146    
2147              new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits);
2148            if (start_bits == NULL)            if (start_bits == NULL)
2149              fprintf(outfile, "No starting byte set\n");              fprintf(outfile, "No set of starting bytes\n");
2150            else            else
2151              {              {
2152              int i;              int i;
# Line 1529  while (!done) Line 2176  while (!done)
2176              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2177              }              }
2178            }            }
2179    
2180            /* Show this only if the JIT was set by /S, not by -s. */
2181    
2182            if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2183              {
2184              int jit;
2185              new_info(re, extra, PCRE_INFO_JIT, &jit);
2186              if (jit)
2187                fprintf(outfile, "JIT study was successful\n");
2188              else
2189    #ifdef SUPPORT_JIT
2190                fprintf(outfile, "JIT study was not successful\n");
2191    #else
2192                fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2193    #endif
2194              }
2195          }          }
2196        }        }
2197    
# Line 1546  while (!done) Line 2209  while (!done)
2209        else        else
2210          {          {
2211          uschar sbuf[8];          uschar sbuf[8];
2212          sbuf[0] = (true_size >> 24)  & 255;          sbuf[0] = (uschar)((true_size >> 24) & 255);
2213          sbuf[1] = (true_size >> 16)  & 255;          sbuf[1] = (uschar)((true_size >> 16) & 255);
2214          sbuf[2] = (true_size >>  8)  & 255;          sbuf[2] = (uschar)((true_size >>  8) & 255);
2215          sbuf[3] = (true_size)  & 255;          sbuf[3] = (uschar)((true_size) & 255);
2216    
2217          sbuf[4] = (true_study_size >> 24)  & 255;          sbuf[4] = (uschar)((true_study_size >> 24) & 255);
2218          sbuf[5] = (true_study_size >> 16)  & 255;          sbuf[5] = (uschar)((true_study_size >> 16) & 255);
2219          sbuf[6] = (true_study_size >>  8)  & 255;          sbuf[6] = (uschar)((true_study_size >>  8) & 255);
2220          sbuf[7] = (true_study_size)  & 255;          sbuf[7] = (uschar)((true_study_size) & 255);
2221    
2222          if (fwrite(sbuf, 1, 8, f) < 8 ||          if (fwrite(sbuf, 1, 8, f) < 8 ||
2223              fwrite(re, 1, true_size, f) < true_size)              fwrite(re, 1, true_size, f) < true_size)
# Line 1563  while (!done) Line 2226  while (!done)
2226            }            }
2227          else          else
2228            {            {
2229            fprintf(outfile, "Compiled regex written to %s\n", to_file);            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
2230    
2231              /* If there is study data, write it. */
2232    
2233            if (extra != NULL)            if (extra != NULL)
2234              {              {
2235              if (fwrite(extra->study_data, 1, true_study_size, f) <              if (fwrite(extra->study_data, 1, true_study_size, f) <
# Line 1573  while (!done) Line 2239  while (!done)
2239                  strerror(errno));                  strerror(errno));
2240                }                }
2241              else fprintf(outfile, "Study data written to %s\n", to_file);              else fprintf(outfile, "Study data written to %s\n", to_file);
   
2242              }              }
2243            }            }
2244          fclose(f);          fclose(f);
2245          }          }
2246    
2247        new_free(re);        new_free(re);
2248        if (extra != NULL) new_free(extra);        if (extra != NULL) pcre_free_study(extra);
2249        if (tables != NULL) new_free((void *)tables);        if (locale_set)
2250            {
2251            new_free((void *)tables);
2252            setlocale(LC_CTYPE, "C");
2253            locale_set = 0;
2254            }
2255        continue;  /* With next regex */        continue;  /* With next regex */
2256        }        }
2257      }        /* End of non-POSIX compile */      }        /* End of non-POSIX compile */
# Line 1591  while (!done) Line 2261  while (!done)
2261    for (;;)    for (;;)
2262      {      {
2263      uschar *q;      uschar *q;
2264      uschar *bptr = dbuffer;      uschar *bptr;
2265      int *use_offsets = offsets;      int *use_offsets = offsets;
2266      int use_size_offsets = size_offsets;      int use_size_offsets = size_offsets;
2267      int callout_data = 0;      int callout_data = 0;
2268      int callout_data_set = 0;      int callout_data_set = 0;
2269      int count, c;      int count, c;
2270      int copystrings = 0;      int copystrings = 0;
2271      int find_match_limit = 0;      int find_match_limit = default_find_match_limit;
2272      int getstrings = 0;      int getstrings = 0;
2273      int getlist = 0;      int getlist = 0;
2274      int gmatched = 0;      int gmatched = 0;
2275      int start_offset = 0;      int start_offset = 0;
2276        int start_offset_sign = 1;
2277      int g_notempty = 0;      int g_notempty = 0;
2278      int use_dfa = 0;      int use_dfa = 0;
2279    
# Line 1616  while (!done) Line 2287  while (!done)
2287    
2288      pcre_callout = callout;      pcre_callout = callout;
2289      first_callout = 1;      first_callout = 1;
2290        last_callout_mark = NULL;
2291      callout_extra = 0;      callout_extra = 0;
2292      callout_count = 0;      callout_count = 0;
2293      callout_fail_count = 999999;      callout_fail_count = 999999;
# Line 1628  while (!done) Line 2300  while (!done)
2300      len = 0;      len = 0;
2301      for (;;)      for (;;)
2302        {        {
2303        if (infile == stdin) printf("data> ");        if (extend_inputline(infile, buffer + len, "data> ") == NULL)
       if (extend_inputline(infile, buffer + len) == NULL)  
2304          {          {
2305          if (len > 0) break;          if (len > 0)    /* Reached EOF without hitting a newline */
2306              {
2307              fprintf(outfile, "\n");
2308              break;
2309              }
2310          done = 1;          done = 1;
2311          goto CONTINUE;          goto CONTINUE;
2312          }          }
# Line 1647  while (!done) Line 2322  while (!done)
2322      p = buffer;      p = buffer;
2323      while (isspace(*p)) p++;      while (isspace(*p)) p++;
2324    
2325      q = dbuffer;      bptr = q = dbuffer;
2326      while ((c = *p++) != 0)      while ((c = *p++) != 0)
2327        {        {
2328        int i = 0;        int i = 0;
# Line 1697  while (!done) Line 2372  while (!done)
2372              {              {
2373              unsigned char buff8[8];              unsigned char buff8[8];
2374              int ii, utn;              int ii, utn;
2375              utn = ord2utf8(c, buff8);              if (use_utf8)
2376              for (ii = 0; ii < utn - 1; ii++) *q++ = buff8[ii];                {
2377              c = buff8[ii];   /* Last byte */                utn = ord2utf8(c, buff8);
2378                  for (ii = 0; ii < utn - 1; ii++) *q++ = buff8[ii];
2379                  c = buff8[ii];   /* Last byte */
2380                  }
2381                else
2382                 {
2383                 if (c > 255)
2384                   fprintf(outfile, "** Character \\x{%x} is greater than 255 and "
2385                     "UTF-8 mode is not enabled.\n"
2386                     "** Truncation will probably give the wrong result.\n", c);
2387                 }
2388              p = pt + 1;              p = pt + 1;
2389              break;              break;
2390              }              }
# Line 1722  while (!done) Line 2407  while (!done)
2407          continue;          continue;
2408    
2409          case '>':          case '>':
2410            if (*p == '-')
2411              {
2412              start_offset_sign = -1;
2413              p++;
2414              }
2415          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';
2416            start_offset *= start_offset_sign;
2417          continue;          continue;
2418    
2419          case 'A':  /* Option setting */          case 'A':  /* Option setting */
# Line 1795  while (!done) Line 2486  while (!done)
2486  #endif  #endif
2487            use_dfa = 1;            use_dfa = 1;
2488          continue;          continue;
2489    #endif
2490    
2491    #if !defined NODFA
2492          case 'F':          case 'F':
2493          options |= PCRE_DFA_SHORTEST;          options |= PCRE_DFA_SHORTEST;
2494          continue;          continue;
# Line 1819  while (!done) Line 2512  while (!done)
2512            getnamesptr = npp;            getnamesptr = npp;
2513            }            }
2514          continue;          continue;
2515    
2516            case 'J':
2517            while(isdigit(*p)) n = n * 10 + *p++ - '0';
2518            if (extra != NULL
2519                && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2520                && extra->executable_jit != NULL)
2521              {
2522              if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2523              jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2524              pcre_assign_jit_stack(extra, jit_callback, jit_stack);
2525              }
2526            continue;
2527    
2528          case 'L':          case 'L':
2529          getlist = 1;          getlist = 1;
# Line 1829  while (!done) Line 2534  while (!done)
2534          continue;          continue;
2535    
2536          case 'N':          case 'N':
2537          options |= PCRE_NOTEMPTY;          if ((options & PCRE_NOTEMPTY) != 0)
2538              options = (options & ~PCRE_NOTEMPTY) | PCRE_NOTEMPTY_ATSTART;
2539            else
2540              options |= PCRE_NOTEMPTY;
2541          continue;          continue;
2542    
2543          case 'O':          case 'O':
# Line 1842  while (!done) Line 2550  while (!done)
2550            if (offsets == NULL)            if (offsets == NULL)
2551              {              {
2552              printf("** Failed to get %d bytes of memory for offsets vector\n",              printf("** Failed to get %d bytes of memory for offsets vector\n",
2553                size_offsets_max * sizeof(int));                (int)(size_offsets_max * sizeof(int)));
2554              yield = 1;              yield = 1;
2555              goto EXIT;              goto EXIT;
2556              }              }
# Line 1852  while (!done) Line 2560  while (!done)
2560          continue;          continue;
2561    
2562          case 'P':          case 'P':
2563          options |= PCRE_PARTIAL;          options |= ((options & PCRE_PARTIAL_SOFT) == 0)?
2564              PCRE_PARTIAL_SOFT : PCRE_PARTIAL_HARD;
2565          continue;          continue;
2566    
2567          case 'Q':          case 'Q':
# Line 1887  while (!done) Line 2596  while (!done)
2596          show_malloc = 1;          show_malloc = 1;
2597          continue;          continue;
2598    
2599            case 'Y':
2600            options |= PCRE_NO_START_OPTIMIZE;
2601            continue;
2602    
2603          case 'Z':          case 'Z':
2604          options |= PCRE_NOTEOL;          options |= PCRE_NOTEOL;
2605          continue;          continue;
# Line 1907  while (!done) Line 2620  while (!done)
2620        *q++ = c;        *q++ = c;
2621        }        }
2622      *q = 0;      *q = 0;
2623      len = q - dbuffer;      len = (int)(q - dbuffer);
2624    
2625        /* Move the data to the end of the buffer so that a read over the end of
2626        the buffer will be seen by valgrind, even if it doesn't cause a crash. If
2627        we are using the POSIX interface, we must include the terminating zero. */
2628    
2629    #if !defined NOPOSIX
2630        if (posix || do_posix)
2631          {
2632          memmove(bptr + buffer_size - len - 1, bptr, len + 1);
2633          bptr += buffer_size - len - 1;
2634          }
2635        else
2636    #endif
2637          {
2638          memmove(bptr + buffer_size - len, bptr, len);
2639          bptr += buffer_size - len;
2640          }
2641    
2642      if ((all_use_dfa || use_dfa) && find_match_limit)      if ((all_use_dfa || use_dfa) && find_match_limit)
2643        {        {
# Line 1928  while (!done) Line 2658  while (!done)
2658          pmatch = (regmatch_t *)malloc(sizeof(regmatch_t) * use_size_offsets);          pmatch = (regmatch_t *)malloc(sizeof(regmatch_t) * use_size_offsets);
2659        if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL;        if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL;
2660        if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL;        if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL;
2661          if ((options & PCRE_NOTEMPTY) != 0) eflags |= REG_NOTEMPTY;
2662    
2663        rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags);        rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags);
2664    
# Line 1952  while (!done) Line 2683  while (!done)
2683              (void)pchars(dbuffer + pmatch[i].rm_so,              (void)pchars(dbuffer + pmatch[i].rm_so,
2684                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
2685              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2686              if (i == 0 && do_showrest)              if (do_showcaprest || (i == 0 && do_showrest))
2687                {                {
2688                fprintf(outfile, " 0+ ");                fprintf(outfile, "%2d+ ", (int)i);
2689                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
2690                  outfile);                  outfile);
2691                fprintf(outfile, "\n");                fprintf(outfile, "\n");
# Line 1972  while (!done) Line 2703  while (!done)
2703    
2704      for (;; gmatched++)    /* Loop for /g or /G */      for (;; gmatched++)    /* Loop for /g or /G */
2705        {        {
2706        int gany_fudge;        markptr = NULL;
2707    
2708        if (timeitm > 0)        if (timeitm > 0)
2709          {          {
2710          register int i;          register int i;
# Line 1984  while (!done) Line 2716  while (!done)
2716            {            {
2717            int workspace[1000];            int workspace[1000];
2718            for (i = 0; i < timeitm; i++)            for (i = 0; i < timeitm; i++)
2719              count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,              count = pcre_dfa_exec(re, extra, (char *)bptr, len, start_offset,
2720                options | g_notempty, use_offsets, use_size_offsets, workspace,                options | g_notempty, use_offsets, use_size_offsets, workspace,
2721                sizeof(workspace)/sizeof(int));                sizeof(workspace)/sizeof(int));
2722            }            }
# Line 2003  while (!done) Line 2735  while (!done)
2735    
2736        /* If find_match_limit is set, we want to do repeated matches with        /* If find_match_limit is set, we want to do repeated matches with
2737        varying limits in order to find the minimum value for the match limit and        varying limits in order to find the minimum value for the match limit and
2738        for the recursion limit. */        for the recursion limit. The match limits are relevant only to the normal
2739          running of pcre_exec(), so disable the JIT optimization. This makes it
2740          possible to run the same set of tests with and without JIT externally
2741          requested. */
2742    
2743        if (find_match_limit)        if (find_match_limit)
2744          {          {
# Line 2012  while (!done) Line 2747  while (!done)
2747            extra = (pcre_extra *)malloc(sizeof(pcre_extra));            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
2748            extra->flags = 0;            extra->flags = 0;
2749            }            }
2750            else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2751    
2752          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2753            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
2754            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
# Line 2047  while (!done) Line 2783  while (!done)
2783        else if (all_use_dfa || use_dfa)        else if (all_use_dfa || use_dfa)
2784          {          {
2785          int workspace[1000];          int workspace[1000];
2786          count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,          count = pcre_dfa_exec(re, extra, (char *)bptr, len, start_offset,
2787            options | g_notempty, use_offsets, use_size_offsets, workspace,            options | g_notempty, use_offsets, use_size_offsets, workspace,
2788            sizeof(workspace)/sizeof(int));            sizeof(workspace)/sizeof(int));
2789          if (count == 0)          if (count == 0)
# Line 2095  while (!done) Line 2831  while (!done)
2831              }              }
2832            }            }
2833    
2834            /* do_allcaps requests showing of all captures in the pattern, to check
2835            unset ones at the end. */
2836    
2837            if (do_allcaps)
2838              {
2839              new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
2840              count++;   /* Allow for full match */
2841              if (count * 2 > use_size_offsets) count = use_size_offsets/2;
2842              }
2843    
2844            /* Output the captured substrings */
2845    
2846          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2847            {            {
2848            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
2849                {
2850                if (use_offsets[i] != -1)
2851                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2852                    use_offsets[i], i);
2853                if (use_offsets[i+1] != -1)
2854                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2855                    use_offsets[i+1], i+1);
2856              fprintf(outfile, "%2d: <unset>\n", i/2);              fprintf(outfile, "%2d: <unset>\n", i/2);
2857                }
2858            else            else
2859              {              {
2860              fprintf(outfile, "%2d: ", i/2);              fprintf(outfile, "%2d: ", i/2);
2861              (void)pchars(bptr + use_offsets[i],              (void)pchars(bptr + use_offsets[i],
2862                use_offsets[i+1] - use_offsets[i], outfile);                use_offsets[i+1] - use_offsets[i], outfile);
2863              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2864              if (i == 0)              if (do_showcaprest || (i == 0 && do_showrest))
2865                {                {
2866                if (do_showrest)                fprintf(outfile, "%2d+ ", i/2);
2867                  {                (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
2868                  fprintf(outfile, " 0+ ");                  outfile);
2869                  (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],                fprintf(outfile, "\n");
                   outfile);  
                 fprintf(outfile, "\n");  
                 }  
2870                }                }
2871              }              }
2872            }            }
2873    
2874            if (markptr != NULL) fprintf(outfile, "MK: %s\n", markptr);
2875    
2876          for (i = 0; i < 32; i++)          for (i = 0; i < 32; i++)
2877            {            {
2878            if ((copystrings & (1 << i)) != 0)            if ((copystrings & (1 << i)) != 0)
# Line 2191  while (!done) Line 2946  while (!done)
2946                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
2947              if (stringlist[i] != NULL)              if (stringlist[i] != NULL)
2948                fprintf(outfile, "string list not terminated by NULL\n");                fprintf(outfile, "string list not terminated by NULL\n");
             /* free((void *)stringlist); */  
2949              pcre_free_substring_list(stringlist);              pcre_free_substring_list(stringlist);
2950              }              }
2951            }            }
# Line 2201  while (!done) Line 2955  while (!done)
2955    
2956        else if (count == PCRE_ERROR_PARTIAL)        else if (count == PCRE_ERROR_PARTIAL)
2957          {          {
2958          fprintf(outfile, "Partial match");          if (markptr == NULL) fprintf(outfile, "Partial match");
2959  #if !defined NODFA            else fprintf(outfile, "Partial match, mark=%s", markptr);
2960          if ((all_use_dfa || use_dfa) && use_size_offsets > 2)          if (use_size_offsets > 1)
2961            fprintf(outfile, ": %.*s", use_offsets[1] - use_offsets[0],            {
2962              bptr + use_offsets[0]);            fprintf(outfile, ": ");
2963  #endif            pchars(bptr + use_offsets[0], use_offsets[1] - use_offsets[0],
2964                outfile);
2965              }
2966          fprintf(outfile, "\n");          fprintf(outfile, "\n");
2967          break;  /* Out of the /g loop */          break;  /* Out of the /g loop */
2968          }          }
2969    
2970        /* Failed to match. If this is a /g or /G loop and we previously set        /* Failed to match. If this is a /g or /G loop and we previously set
2971        g_notempty after a null match, this is not necessarily the end.        g_notempty after a null match, this is not necessarily the end. We want
2972        We want to advance the start offset, and continue. In the case of UTF-8        to advance the start offset, and continue. We won't be at the end of the
2973        matching, the advance must be one character, not one byte. Fudge the        string - that was checked before setting g_notempty.
2974        offset values to achieve this. We won't be at the end of the string -  
2975        that was checked before setting g_notempty. */        Complication arises in the case when the newline convention is "any",
2976          "crlf", or "anycrlf". If the previous match was at the end of a line
2977          terminated by CRLF, an advance of one character just passes the \r,
2978          whereas we should prefer the longer newline sequence, as does the code in
2979          pcre_exec(). Fudge the offset value to achieve this. We check for a
2980          newline setting in the pattern; if none was set, use pcre_config() to
2981          find the default.
2982    
2983          Otherwise, in the case of UTF-8 matching, the advance must be one
2984          character, not one byte. */
2985    
2986        else        else
2987          {          {
2988          if (g_notempty != 0)          if (g_notempty != 0)
2989            {            {
2990            int onechar = 1;            int onechar = 1;
2991              unsigned int obits = ((real_pcre *)re)->options;
2992            use_offsets[0] = start_offset;            use_offsets[0] = start_offset;
2993            if (use_utf8)            if ((obits & PCRE_NEWLINE_BITS) == 0)
2994                {
2995                int d;
2996                (void)pcre_config(PCRE_CONFIG_NEWLINE, &d);
2997                /* Note that these values are always the ASCII ones, even in
2998                EBCDIC environments. CR = 13, NL = 10. */
2999                obits = (d == 13)? PCRE_NEWLINE_CR :
3000                        (d == 10)? PCRE_NEWLINE_LF :
3001                        (d == (13<<8 | 10))? PCRE_NEWLINE_CRLF :
3002                        (d == -2)? PCRE_NEWLINE_ANYCRLF :
3003                        (d == -1)? PCRE_NEWLINE_ANY : 0;
3004                }
3005              if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||
3006                   (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF ||
3007                   (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)
3008                  &&
3009                  start_offset < len - 1 &&
3010                  bptr[start_offset] == '\r' &&
3011                  bptr[start_offset+1] == '\n')
3012                onechar++;
3013              else if (use_utf8)
3014              {              {
3015              while (start_offset + onechar < len)              while (start_offset + onechar < len)
3016                {                {
3017                int tb = bptr[start_offset+onechar];                if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break;
3018                if (tb <= 127) break;                onechar++;
               tb &= 0xc0;  
               if (tb != 0 && tb != 0xc0) onechar++;  
3019                }                }
3020              }              }
3021            use_offsets[1] = start_offset + onechar;            use_offsets[1] = start_offset + onechar;
3022            }            }
3023          else          else
3024            {            {
3025            if (count == PCRE_ERROR_NOMATCH)            switch(count)
3026              {              {
3027              if (gmatched == 0) fprintf(outfile, "No match\n");              case PCRE_ERROR_NOMATCH:
3028                if (gmatched == 0)
3029                  {
3030                  if (markptr == NULL) fprintf(outfile, "No match\n");
3031                    else fprintf(outfile, "No match, mark = %s\n", markptr);
3032                  }
3033                break;
3034    
3035                case PCRE_ERROR_BADUTF8:
3036                case PCRE_ERROR_SHORTUTF8:
3037                fprintf(outfile, "Error %d (%s UTF-8 string)", count,
3038                  (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
3039                if (use_size_offsets >= 2)
3040                  fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
3041                    use_offsets[1]);
3042                fprintf(outfile, "\n");
3043                break;
3044    
3045                default:
3046                if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
3047                  fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
3048                else
3049                  fprintf(outfile, "Error %d (Unexpected value)\n", count);
3050                break;
3051              }              }
3052            else fprintf(outfile, "Error %d\n", count);  
3053            break;  /* Out of the /g loop */            break;  /* Out of the /g loop */
3054            }            }
3055          }          }
# Line 2252  while (!done) Line 3059  while (!done)
3059        if (!do_g && !do_G) break;        if (!do_g && !do_G) break;
3060    
3061        /* If we have matched an empty string, first check to see if we are at        /* If we have matched an empty string, first check to see if we are at
3062        the end of the subject. If so, the /g loop is over. Otherwise, mimic        the end of the subject. If so, the /g loop is over. Otherwise, mimic what
3063        what Perl's /g options does. This turns out to be rather cunning. First        Perl's /g options does. This turns out to be rather cunning. First we set
3064        we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match again at the        PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED and try the match again at the
3065        same point. If this fails (picked up above) we advance to the next        same point. If this fails (picked up above) we advance to the next
3066        character.        character. */
   
       Yet more complication arises in the case when the newline option is  
       "any" and a pattern in multiline mode has to match at the start of a  
       line. If a previous match was at the end of a line, and advance of one  
       character just passes the \r, whereas we should prefer the longer newline  
       sequence, as does the code in pcre_exec(). So we fudge it. */  
3067    
3068        g_notempty = 0;        g_notempty = 0;
       gany_fudge = 0;  
3069    
3070        if (use_offsets[0] == use_offsets[1])        if (use_offsets[0] == use_offsets[1])
3071          {          {
3072          if (use_offsets[0] == len) break;          if (use_offsets[0] == len) break;
3073          g_notempty = PCRE_NOTEMPTY | PCRE_ANCHORED;          g_notempty = PCRE_NOTEMPTY_ATSTART | PCRE_ANCHORED;
         if ((((real_pcre *)re)->options & PCRE_STARTLINE) != 0 &&  
             (((real_pcre *)re)->options & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY &&  
             use_offsets[0] < len - 1 &&  
             bptr[use_offsets[0]] == '\r' &&  
             bptr[use_offsets[0]+1] == '\n')  
           gany_fudge = 1;  
3074          }          }
3075    
3076        /* For /g, update the start offset, leaving the rest alone */        /* For /g, update the start offset, leaving the rest alone */
3077    
3078        if (do_g) start_offset = use_offsets[1] + gany_fudge;        if (do_g) start_offset = use_offsets[1];
3079    
3080        /* For /G, update the pointer and length */        /* For /G, update the pointer and length */
3081    
3082        else        else
3083          {          {
3084          bptr += use_offsets[1] + gany_fudge;          bptr += use_offsets[1];
3085          len -= use_offsets[1] + gany_fudge;          len -= use_offsets[1];
3086          }          }
3087        }  /* End of loop for /g and /G */        }  /* End of loop for /g and /G */
3088    
# Line 2302  while (!done) Line 3096  while (!done)
3096  #endif  #endif
3097    
3098    if (re != NULL) new_free(re);    if (re != NULL) new_free(re);
3099    if (extra != NULL) new_free(extra);    if (extra != NULL) pcre_free_study(extra);
3100    if (tables != NULL)    if (locale_set)
3101      {      {
3102      new_free((void *)tables);      new_free((void *)tables);
3103      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3104      locale_set = 0;      locale_set = 0;
3105      }      }
3106      if (jit_stack != NULL)
3107        {
3108        pcre_jit_stack_free(jit_stack);
3109        jit_stack = NULL;
3110        }
3111    }    }
3112    
3113  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

Legend:
Removed from v.142  
changed lines
  Added in v.675

  ViewVC Help
Powered by ViewVC 1.1.5