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