1/************************************************* 2* PCRE testing program * 3*************************************************/ 4 5/* This program was hacked up as a tester for PCRE. I really should have 6written it more tidily in the first place. Will I ever learn? It has grown and 7been extended and consequently is now rather, er, *very* untidy in places. The 8addition of 16-bit support has made it even worse. :-( 9 10----------------------------------------------------------------------------- 11Redistribution and use in source and binary forms, with or without 12modification, 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 25THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35POSSIBILITY OF SUCH DAMAGE. 36----------------------------------------------------------------------------- 37*/ 38 39/* This program now supports the testing of all of the 8-bit, 16-bit, and 4032-bit PCRE libraries in a single program. This is different from the modules 41such as pcre_compile.c in the library itself, which are compiled separately for 42each mode. If two modes are enabled, for example, pcre_compile.c is compiled 43twice. By contrast, pcretest.c is compiled only once. Therefore, it must not 44make use of any of the macros from pcre_internal.h that depend on 45COMPILE_PCRE8, COMPILE_PCRE16, or COMPILE_PCRE32. It does, however, make use of 46SUPPORT_PCRE8, SUPPORT_PCRE16, and SUPPORT_PCRE32 to ensure that it calls only 47supported library functions. */ 48 49#ifdef HAVE_CONFIG_H 50#include "config.h" 51#endif 52 53#include <ctype.h> 54#include <stdio.h> 55#include <string.h> 56#include <stdlib.h> 57#include <time.h> 58#include <locale.h> 59#include <errno.h> 60 61/* Both libreadline and libedit are optionally supported. The user-supplied 62original patch uses readline/readline.h for libedit, but in at least one system 63it is installed as editline/readline.h, so the configuration code now looks for 64that first, falling back to readline/readline.h. */ 65 66#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 67#ifdef HAVE_UNISTD_H 68#include <unistd.h> 69#endif 70#if defined(SUPPORT_LIBREADLINE) 71#include <readline/readline.h> 72#include <readline/history.h> 73#else 74#if defined(HAVE_EDITLINE_READLINE_H) 75#include <editline/readline.h> 76#else 77#include <readline/readline.h> 78#endif 79#endif 80#endif 81 82/* A number of things vary for Windows builds. Originally, pcretest opened its 83input and output without "b"; then I was told that "b" was needed in some 84environments, so it was added for release 5.0 to both the input and output. (It 85makes no difference on Unix-like systems.) Later I was told that it is wrong 86for the input on Windows. I've now abstracted the modes into two macros that 87are set here, to make it easier to fiddle with them, and removed "b" from the 88input mode under Windows. */ 89 90#if defined(_WIN32) || defined(WIN32) 91#include <io.h> /* For _setmode() */ 92#include <fcntl.h> /* For _O_BINARY */ 93#define INPUT_MODE "r" 94#define OUTPUT_MODE "wb" 95 96#ifndef isatty 97#define isatty _isatty /* This is what Windows calls them, I'm told, */ 98#endif /* though in some environments they seem to */ 99 /* be already defined, hence the #ifndefs. */ 100#ifndef fileno 101#define fileno _fileno 102#endif 103 104/* A user sent this fix for Borland Builder 5 under Windows. */ 105 106#ifdef __BORLANDC__ 107#define _setmode(handle, mode) setmode(handle, mode) 108#endif 109 110/* Not Windows */ 111 112#else 113#include <sys/time.h> /* These two includes are needed */ 114#include <sys/resource.h> /* for setrlimit(). */ 115#if defined NATIVE_ZOS /* z/OS uses non-binary I/O */ 116#define INPUT_MODE "r" 117#define OUTPUT_MODE "w" 118#else 119#define INPUT_MODE "rb" 120#define OUTPUT_MODE "wb" 121#endif 122#endif 123 124#ifdef __VMS 125#include <ssdef.h> 126void vms_setsymbol( char *, char *, int ); 127#endif 128 129 130#define PRIV(name) name 131 132/* We have to include pcre_internal.h because we need the internal info for 133displaying the results of pcre_study() and we also need to know about the 134internal macros, structures, and other internal data values; pcretest has 135"inside information" compared to a program that strictly follows the PCRE API. 136 137Although pcre_internal.h does itself include pcre.h, we explicitly include it 138here before pcre_internal.h so that the PCRE_EXP_xxx macros get set 139appropriately for an application, not for building PCRE. */ 140 141#include "pcre.h" 142#include "pcre_internal.h" 143 144/* The pcre_printint() function, which prints the internal form of a compiled 145regex, is held in a separate file so that (a) it can be compiled in either 1468-, 16- or 32-bit mode, and (b) it can be #included directly in pcre_compile.c 147when that is compiled in debug mode. */ 148 149#ifdef SUPPORT_PCRE8 150void pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths); 151#endif 152#ifdef SUPPORT_PCRE16 153void pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths); 154#endif 155#ifdef SUPPORT_PCRE32 156void pcre32_printint(pcre *external_re, FILE *f, BOOL print_lengths); 157#endif 158 159/* We need access to some of the data tables that PCRE uses. So as not to have 160to keep two copies, we include the source files here, changing the names of the 161external symbols to prevent clashes. */ 162 163#define PCRE_INCLUDED 164 165#include "pcre_tables.c" 166#include "pcre_ucd.c" 167 168/* The definition of the macro PRINTABLE, which determines whether to print an 169output character as-is or as a hex value when showing compiled patterns, is 170the same as in the printint.src file. We uses it here in cases when the locale 171has not been explicitly changed, so as to get consistent output from systems 172that differ in their output from isprint() even in the "C" locale. */ 173 174#ifdef EBCDIC 175#define PRINTABLE(c) ((c) >= 64 && (c) < 255) 176#else 177#define PRINTABLE(c) ((c) >= 32 && (c) < 127) 178#endif 179 180#define PRINTOK(c) (locale_set? isprint(c) : PRINTABLE(c)) 181 182/* Posix support is disabled in 16 or 32 bit only mode. */ 183#if !defined SUPPORT_PCRE8 && !defined NOPOSIX 184#define NOPOSIX 185#endif 186 187/* It is possible to compile this test program without including support for 188testing the POSIX interface, though this is not available via the standard 189Makefile. */ 190 191#if !defined NOPOSIX 192#include "pcreposix.h" 193#endif 194 195/* It is also possible, originally for the benefit of a version that was 196imported into Exim, to build pcretest without support for UTF8 or UTF16 (define 197NOUTF), without the interface to the DFA matcher (NODFA). In fact, we 198automatically cut out the UTF support if PCRE is built without it. */ 199 200#ifndef SUPPORT_UTF 201#ifndef NOUTF 202#define NOUTF 203#endif 204#endif 205 206/* To make the code a bit tidier for 8/16/32-bit support, we define macros 207for all the pcre[16]_xxx functions (except pcre16_fullinfo, which is called 208only from one place and is handled differently). I couldn't dream up any way of 209using a single macro to do this in a generic way, because of the many different 210argument requirements. We know that at least one of SUPPORT_PCRE8 and 211SUPPORT_PCRE16 must be set. First define macros for each individual mode; then 212use these in the definitions of generic macros. 213 214**** Special note about the PCHARSxxx macros: the address of the string to be 215printed is always given as two arguments: a base address followed by an offset. 216The base address is cast to the correct data size for 8 or 16 bit data; the 217offset is in units of this size. If the string were given as base+offset in one 218argument, the casting might be incorrectly applied. */ 219 220#ifdef SUPPORT_PCRE8 221 222#define PCHARS8(lv, p, offset, len, f) \ 223 lv = pchars((pcre_uint8 *)(p) + offset, len, f) 224 225#define PCHARSV8(p, offset, len, f) \ 226 (void)pchars((pcre_uint8 *)(p) + offset, len, f) 227 228#define READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re) \ 229 p = read_capture_name8(p, cn8, re) 230 231#define STRLEN8(p) ((int)strlen((char *)p)) 232 233#define SET_PCRE_CALLOUT8(callout) \ 234 pcre_callout = callout 235 236#define SET_PCRE_STACK_GUARD8(stack_guard) \ 237 pcre_stack_guard = stack_guard 238 239#define PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata) \ 240 pcre_assign_jit_stack(extra, callback, userdata) 241 242#define PCRE_COMPILE8(re, pat, options, error, erroffset, tables) \ 243 re = pcre_compile((char *)pat, options, error, erroffset, tables) 244 245#define PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 246 namesptr, cbuffer, size) \ 247 rc = pcre_copy_named_substring(re, (char *)bptr, offsets, count, \ 248 (char *)namesptr, cbuffer, size) 249 250#define PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size) \ 251 rc = pcre_copy_substring((char *)bptr, offsets, count, i, cbuffer, size) 252 253#define PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 254 offsets, size_offsets, workspace, size_workspace) \ 255 count = pcre_dfa_exec(re, extra, (char *)bptr, len, start_offset, options, \ 256 offsets, size_offsets, workspace, size_workspace) 257 258#define PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 259 offsets, size_offsets) \ 260 count = pcre_exec(re, extra, (char *)bptr, len, start_offset, options, \ 261 offsets, size_offsets) 262 263#define PCRE_FREE_STUDY8(extra) \ 264 pcre_free_study(extra) 265 266#define PCRE_FREE_SUBSTRING8(substring) \ 267 pcre_free_substring(substring) 268 269#define PCRE_FREE_SUBSTRING_LIST8(listptr) \ 270 pcre_free_substring_list(listptr) 271 272#define PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 273 getnamesptr, subsptr) \ 274 rc = pcre_get_named_substring(re, (char *)bptr, offsets, count, \ 275 (char *)getnamesptr, subsptr) 276 277#define PCRE_GET_STRINGNUMBER8(n, rc, ptr) \ 278 n = pcre_get_stringnumber(re, (char *)ptr) 279 280#define PCRE_GET_SUBSTRING8(rc, bptr, offsets, count, i, subsptr) \ 281 rc = pcre_get_substring((char *)bptr, offsets, count, i, subsptr) 282 283#define PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr) \ 284 rc = pcre_get_substring_list((const char *)bptr, offsets, count, listptr) 285 286#define PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables) \ 287 rc = pcre_pattern_to_host_byte_order(re, extra, tables) 288 289#define PCRE_PRINTINT8(re, outfile, debug_lengths) \ 290 pcre_printint(re, outfile, debug_lengths) 291 292#define PCRE_STUDY8(extra, re, options, error) \ 293 extra = pcre_study(re, options, error) 294 295#define PCRE_JIT_STACK_ALLOC8(startsize, maxsize) \ 296 pcre_jit_stack_alloc(startsize, maxsize) 297 298#define PCRE_JIT_STACK_FREE8(stack) \ 299 pcre_jit_stack_free(stack) 300 301#define pcre8_maketables pcre_maketables 302 303#endif /* SUPPORT_PCRE8 */ 304 305/* -----------------------------------------------------------*/ 306 307#ifdef SUPPORT_PCRE16 308 309#define PCHARS16(lv, p, offset, len, f) \ 310 lv = pchars16((PCRE_SPTR16)(p) + offset, len, f) 311 312#define PCHARSV16(p, offset, len, f) \ 313 (void)pchars16((PCRE_SPTR16)(p) + offset, len, f) 314 315#define READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re) \ 316 p = read_capture_name16(p, cn16, re) 317 318#define STRLEN16(p) ((int)strlen16((PCRE_SPTR16)p)) 319 320#define SET_PCRE_CALLOUT16(callout) \ 321 pcre16_callout = (int (*)(pcre16_callout_block *))callout 322 323#define SET_PCRE_STACK_GUARD16(stack_guard) \ 324 pcre16_stack_guard = (int (*)(void))stack_guard 325 326#define PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata) \ 327 pcre16_assign_jit_stack((pcre16_extra *)extra, \ 328 (pcre16_jit_callback)callback, userdata) 329 330#define PCRE_COMPILE16(re, pat, options, error, erroffset, tables) \ 331 re = (pcre *)pcre16_compile((PCRE_SPTR16)pat, options, error, erroffset, \ 332 tables) 333 334#define PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 335 namesptr, cbuffer, size) \ 336 rc = pcre16_copy_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \ 337 count, (PCRE_SPTR16)namesptr, (PCRE_UCHAR16 *)cbuffer, size/2) 338 339#define PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size) \ 340 rc = pcre16_copy_substring((PCRE_SPTR16)bptr, offsets, count, i, \ 341 (PCRE_UCHAR16 *)cbuffer, size/2) 342 343#define PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 344 offsets, size_offsets, workspace, size_workspace) \ 345 count = pcre16_dfa_exec((pcre16 *)re, (pcre16_extra *)extra, \ 346 (PCRE_SPTR16)bptr, len, start_offset, options, offsets, size_offsets, \ 347 workspace, size_workspace) 348 349#define PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 350 offsets, size_offsets) \ 351 count = pcre16_exec((pcre16 *)re, (pcre16_extra *)extra, (PCRE_SPTR16)bptr, \ 352 len, start_offset, options, offsets, size_offsets) 353 354#define PCRE_FREE_STUDY16(extra) \ 355 pcre16_free_study((pcre16_extra *)extra) 356 357#define PCRE_FREE_SUBSTRING16(substring) \ 358 pcre16_free_substring((PCRE_SPTR16)substring) 359 360#define PCRE_FREE_SUBSTRING_LIST16(listptr) \ 361 pcre16_free_substring_list((PCRE_SPTR16 *)listptr) 362 363#define PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 364 getnamesptr, subsptr) \ 365 rc = pcre16_get_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \ 366 count, (PCRE_SPTR16)getnamesptr, (PCRE_SPTR16 *)(void*)subsptr) 367 368#define PCRE_GET_STRINGNUMBER16(n, rc, ptr) \ 369 n = pcre16_get_stringnumber(re, (PCRE_SPTR16)ptr) 370 371#define PCRE_GET_SUBSTRING16(rc, bptr, offsets, count, i, subsptr) \ 372 rc = pcre16_get_substring((PCRE_SPTR16)bptr, offsets, count, i, \ 373 (PCRE_SPTR16 *)(void*)subsptr) 374 375#define PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr) \ 376 rc = pcre16_get_substring_list((PCRE_SPTR16)bptr, offsets, count, \ 377 (PCRE_SPTR16 **)(void*)listptr) 378 379#define PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables) \ 380 rc = pcre16_pattern_to_host_byte_order((pcre16 *)re, (pcre16_extra *)extra, \ 381 tables) 382 383#define PCRE_PRINTINT16(re, outfile, debug_lengths) \ 384 pcre16_printint(re, outfile, debug_lengths) 385 386#define PCRE_STUDY16(extra, re, options, error) \ 387 extra = (pcre_extra *)pcre16_study((pcre16 *)re, options, error) 388 389#define PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \ 390 (pcre_jit_stack *)pcre16_jit_stack_alloc(startsize, maxsize) 391 392#define PCRE_JIT_STACK_FREE16(stack) \ 393 pcre16_jit_stack_free((pcre16_jit_stack *)stack) 394 395#endif /* SUPPORT_PCRE16 */ 396 397/* -----------------------------------------------------------*/ 398 399#ifdef SUPPORT_PCRE32 400 401#define PCHARS32(lv, p, offset, len, f) \ 402 lv = pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f) 403 404#define PCHARSV32(p, offset, len, f) \ 405 (void)pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f) 406 407#define READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re) \ 408 p = read_capture_name32(p, cn32, re) 409 410#define STRLEN32(p) ((int)strlen32((PCRE_SPTR32)p)) 411 412#define SET_PCRE_CALLOUT32(callout) \ 413 pcre32_callout = (int (*)(pcre32_callout_block *))callout 414 415#define SET_PCRE_STACK_GUARD32(stack_guard) \ 416 pcre32_stack_guard = (int (*)(void))stack_guard 417 418#define PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata) \ 419 pcre32_assign_jit_stack((pcre32_extra *)extra, \ 420 (pcre32_jit_callback)callback, userdata) 421 422#define PCRE_COMPILE32(re, pat, options, error, erroffset, tables) \ 423 re = (pcre *)pcre32_compile((PCRE_SPTR32)pat, options, error, erroffset, \ 424 tables) 425 426#define PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 427 namesptr, cbuffer, size) \ 428 rc = pcre32_copy_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \ 429 count, (PCRE_SPTR32)namesptr, (PCRE_UCHAR32 *)cbuffer, size/2) 430 431#define PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size) \ 432 rc = pcre32_copy_substring((PCRE_SPTR32)bptr, offsets, count, i, \ 433 (PCRE_UCHAR32 *)cbuffer, size/2) 434 435#define PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 436 offsets, size_offsets, workspace, size_workspace) \ 437 count = pcre32_dfa_exec((pcre32 *)re, (pcre32_extra *)extra, \ 438 (PCRE_SPTR32)bptr, len, start_offset, options, offsets, size_offsets, \ 439 workspace, size_workspace) 440 441#define PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 442 offsets, size_offsets) \ 443 count = pcre32_exec((pcre32 *)re, (pcre32_extra *)extra, (PCRE_SPTR32)bptr, \ 444 len, start_offset, options, offsets, size_offsets) 445 446#define PCRE_FREE_STUDY32(extra) \ 447 pcre32_free_study((pcre32_extra *)extra) 448 449#define PCRE_FREE_SUBSTRING32(substring) \ 450 pcre32_free_substring((PCRE_SPTR32)substring) 451 452#define PCRE_FREE_SUBSTRING_LIST32(listptr) \ 453 pcre32_free_substring_list((PCRE_SPTR32 *)listptr) 454 455#define PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 456 getnamesptr, subsptr) \ 457 rc = pcre32_get_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \ 458 count, (PCRE_SPTR32)getnamesptr, (PCRE_SPTR32 *)(void*)subsptr) 459 460#define PCRE_GET_STRINGNUMBER32(n, rc, ptr) \ 461 n = pcre32_get_stringnumber(re, (PCRE_SPTR32)ptr) 462 463#define PCRE_GET_SUBSTRING32(rc, bptr, offsets, count, i, subsptr) \ 464 rc = pcre32_get_substring((PCRE_SPTR32)bptr, offsets, count, i, \ 465 (PCRE_SPTR32 *)(void*)subsptr) 466 467#define PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr) \ 468 rc = pcre32_get_substring_list((PCRE_SPTR32)bptr, offsets, count, \ 469 (PCRE_SPTR32 **)(void*)listptr) 470 471#define PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables) \ 472 rc = pcre32_pattern_to_host_byte_order((pcre32 *)re, (pcre32_extra *)extra, \ 473 tables) 474 475#define PCRE_PRINTINT32(re, outfile, debug_lengths) \ 476 pcre32_printint(re, outfile, debug_lengths) 477 478#define PCRE_STUDY32(extra, re, options, error) \ 479 extra = (pcre_extra *)pcre32_study((pcre32 *)re, options, error) 480 481#define PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \ 482 (pcre_jit_stack *)pcre32_jit_stack_alloc(startsize, maxsize) 483 484#define PCRE_JIT_STACK_FREE32(stack) \ 485 pcre32_jit_stack_free((pcre32_jit_stack *)stack) 486 487#endif /* SUPPORT_PCRE32 */ 488 489 490/* ----- More than one mode is supported; a runtime test is needed, except for 491pcre_config(), and the JIT stack functions, when it doesn't matter which 492available version is called. ----- */ 493 494enum { 495 PCRE8_MODE, 496 PCRE16_MODE, 497 PCRE32_MODE 498}; 499 500#if (defined (SUPPORT_PCRE8) + defined (SUPPORT_PCRE16) + \ 501 defined (SUPPORT_PCRE32)) >= 2 502 503#define CHAR_SIZE (1 << pcre_mode) 504 505/* There doesn't seem to be an easy way of writing these macros that can cope 506with the 3 pairs of bit sizes plus all three bit sizes. So just handle all the 507cases separately. */ 508 509/* ----- All three modes supported ----- */ 510 511#if defined(SUPPORT_PCRE8) && defined(SUPPORT_PCRE16) && defined(SUPPORT_PCRE32) 512 513#define PCHARS(lv, p, offset, len, f) \ 514 if (pcre_mode == PCRE32_MODE) \ 515 PCHARS32(lv, p, offset, len, f); \ 516 else if (pcre_mode == PCRE16_MODE) \ 517 PCHARS16(lv, p, offset, len, f); \ 518 else \ 519 PCHARS8(lv, p, offset, len, f) 520 521#define PCHARSV(p, offset, len, f) \ 522 if (pcre_mode == PCRE32_MODE) \ 523 PCHARSV32(p, offset, len, f); \ 524 else if (pcre_mode == PCRE16_MODE) \ 525 PCHARSV16(p, offset, len, f); \ 526 else \ 527 PCHARSV8(p, offset, len, f) 528 529#define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \ 530 if (pcre_mode == PCRE32_MODE) \ 531 READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re); \ 532 else if (pcre_mode == PCRE16_MODE) \ 533 READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re); \ 534 else \ 535 READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re) 536 537#define SET_PCRE_CALLOUT(callout) \ 538 if (pcre_mode == PCRE32_MODE) \ 539 SET_PCRE_CALLOUT32(callout); \ 540 else if (pcre_mode == PCRE16_MODE) \ 541 SET_PCRE_CALLOUT16(callout); \ 542 else \ 543 SET_PCRE_CALLOUT8(callout) 544 545#define SET_PCRE_STACK_GUARD(stack_guard) \ 546 if (pcre_mode == PCRE32_MODE) \ 547 SET_PCRE_STACK_GUARD32(stack_guard); \ 548 else if (pcre_mode == PCRE16_MODE) \ 549 SET_PCRE_STACK_GUARD16(stack_guard); \ 550 else \ 551 SET_PCRE_STACK_GUARD8(stack_guard) 552 553#define STRLEN(p) (pcre_mode == PCRE32_MODE ? STRLEN32(p) : pcre_mode == PCRE16_MODE ? STRLEN16(p) : STRLEN8(p)) 554 555#define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \ 556 if (pcre_mode == PCRE32_MODE) \ 557 PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata); \ 558 else if (pcre_mode == PCRE16_MODE) \ 559 PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata); \ 560 else \ 561 PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata) 562 563#define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \ 564 if (pcre_mode == PCRE32_MODE) \ 565 PCRE_COMPILE32(re, pat, options, error, erroffset, tables); \ 566 else if (pcre_mode == PCRE16_MODE) \ 567 PCRE_COMPILE16(re, pat, options, error, erroffset, tables); \ 568 else \ 569 PCRE_COMPILE8(re, pat, options, error, erroffset, tables) 570 571#define PCRE_CONFIG pcre_config 572 573#define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 574 namesptr, cbuffer, size) \ 575 if (pcre_mode == PCRE32_MODE) \ 576 PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 577 namesptr, cbuffer, size); \ 578 else if (pcre_mode == PCRE16_MODE) \ 579 PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 580 namesptr, cbuffer, size); \ 581 else \ 582 PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 583 namesptr, cbuffer, size) 584 585#define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \ 586 if (pcre_mode == PCRE32_MODE) \ 587 PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size); \ 588 else if (pcre_mode == PCRE16_MODE) \ 589 PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size); \ 590 else \ 591 PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size) 592 593#define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \ 594 offsets, size_offsets, workspace, size_workspace) \ 595 if (pcre_mode == PCRE32_MODE) \ 596 PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 597 offsets, size_offsets, workspace, size_workspace); \ 598 else if (pcre_mode == PCRE16_MODE) \ 599 PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 600 offsets, size_offsets, workspace, size_workspace); \ 601 else \ 602 PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 603 offsets, size_offsets, workspace, size_workspace) 604 605#define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \ 606 offsets, size_offsets) \ 607 if (pcre_mode == PCRE32_MODE) \ 608 PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 609 offsets, size_offsets); \ 610 else if (pcre_mode == PCRE16_MODE) \ 611 PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 612 offsets, size_offsets); \ 613 else \ 614 PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 615 offsets, size_offsets) 616 617#define PCRE_FREE_STUDY(extra) \ 618 if (pcre_mode == PCRE32_MODE) \ 619 PCRE_FREE_STUDY32(extra); \ 620 else if (pcre_mode == PCRE16_MODE) \ 621 PCRE_FREE_STUDY16(extra); \ 622 else \ 623 PCRE_FREE_STUDY8(extra) 624 625#define PCRE_FREE_SUBSTRING(substring) \ 626 if (pcre_mode == PCRE32_MODE) \ 627 PCRE_FREE_SUBSTRING32(substring); \ 628 else if (pcre_mode == PCRE16_MODE) \ 629 PCRE_FREE_SUBSTRING16(substring); \ 630 else \ 631 PCRE_FREE_SUBSTRING8(substring) 632 633#define PCRE_FREE_SUBSTRING_LIST(listptr) \ 634 if (pcre_mode == PCRE32_MODE) \ 635 PCRE_FREE_SUBSTRING_LIST32(listptr); \ 636 else if (pcre_mode == PCRE16_MODE) \ 637 PCRE_FREE_SUBSTRING_LIST16(listptr); \ 638 else \ 639 PCRE_FREE_SUBSTRING_LIST8(listptr) 640 641#define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 642 getnamesptr, subsptr) \ 643 if (pcre_mode == PCRE32_MODE) \ 644 PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 645 getnamesptr, subsptr); \ 646 else if (pcre_mode == PCRE16_MODE) \ 647 PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 648 getnamesptr, subsptr); \ 649 else \ 650 PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 651 getnamesptr, subsptr) 652 653#define PCRE_GET_STRINGNUMBER(n, rc, ptr) \ 654 if (pcre_mode == PCRE32_MODE) \ 655 PCRE_GET_STRINGNUMBER32(n, rc, ptr); \ 656 else if (pcre_mode == PCRE16_MODE) \ 657 PCRE_GET_STRINGNUMBER16(n, rc, ptr); \ 658 else \ 659 PCRE_GET_STRINGNUMBER8(n, rc, ptr) 660 661#define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \ 662 if (pcre_mode == PCRE32_MODE) \ 663 PCRE_GET_SUBSTRING32(rc, bptr, use_offsets, count, i, subsptr); \ 664 else if (pcre_mode == PCRE16_MODE) \ 665 PCRE_GET_SUBSTRING16(rc, bptr, use_offsets, count, i, subsptr); \ 666 else \ 667 PCRE_GET_SUBSTRING8(rc, bptr, use_offsets, count, i, subsptr) 668 669#define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \ 670 if (pcre_mode == PCRE32_MODE) \ 671 PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr); \ 672 else if (pcre_mode == PCRE16_MODE) \ 673 PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr); \ 674 else \ 675 PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr) 676 677#define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \ 678 (pcre_mode == PCRE32_MODE ? \ 679 PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \ 680 : pcre_mode == PCRE16_MODE ? \ 681 PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \ 682 : PCRE_JIT_STACK_ALLOC8(startsize, maxsize)) 683 684#define PCRE_JIT_STACK_FREE(stack) \ 685 if (pcre_mode == PCRE32_MODE) \ 686 PCRE_JIT_STACK_FREE32(stack); \ 687 else if (pcre_mode == PCRE16_MODE) \ 688 PCRE_JIT_STACK_FREE16(stack); \ 689 else \ 690 PCRE_JIT_STACK_FREE8(stack) 691 692#define PCRE_MAKETABLES \ 693 (pcre_mode == PCRE32_MODE ? pcre32_maketables() : pcre_mode == PCRE16_MODE ? pcre16_maketables() : pcre_maketables()) 694 695#define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \ 696 if (pcre_mode == PCRE32_MODE) \ 697 PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables); \ 698 else if (pcre_mode == PCRE16_MODE) \ 699 PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables); \ 700 else \ 701 PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables) 702 703#define PCRE_PRINTINT(re, outfile, debug_lengths) \ 704 if (pcre_mode == PCRE32_MODE) \ 705 PCRE_PRINTINT32(re, outfile, debug_lengths); \ 706 else if (pcre_mode == PCRE16_MODE) \ 707 PCRE_PRINTINT16(re, outfile, debug_lengths); \ 708 else \ 709 PCRE_PRINTINT8(re, outfile, debug_lengths) 710 711#define PCRE_STUDY(extra, re, options, error) \ 712 if (pcre_mode == PCRE32_MODE) \ 713 PCRE_STUDY32(extra, re, options, error); \ 714 else if (pcre_mode == PCRE16_MODE) \ 715 PCRE_STUDY16(extra, re, options, error); \ 716 else \ 717 PCRE_STUDY8(extra, re, options, error) 718 719 720/* ----- Two out of three modes are supported ----- */ 721 722#else 723 724/* We can use some macro trickery to make a single set of definitions work in 725the three different cases. */ 726 727/* ----- 32-bit and 16-bit but not 8-bit supported ----- */ 728 729#if defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE16) 730#define BITONE 32 731#define BITTWO 16 732 733/* ----- 32-bit and 8-bit but not 16-bit supported ----- */ 734 735#elif defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE8) 736#define BITONE 32 737#define BITTWO 8 738 739/* ----- 16-bit and 8-bit but not 32-bit supported ----- */ 740 741#else 742#define BITONE 16 743#define BITTWO 8 744#endif 745 746#define glue(a,b) a##b 747#define G(a,b) glue(a,b) 748 749 750/* ----- Common macros for two-mode cases ----- */ 751 752#define PCHARS(lv, p, offset, len, f) \ 753 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 754 G(PCHARS,BITONE)(lv, p, offset, len, f); \ 755 else \ 756 G(PCHARS,BITTWO)(lv, p, offset, len, f) 757 758#define PCHARSV(p, offset, len, f) \ 759 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 760 G(PCHARSV,BITONE)(p, offset, len, f); \ 761 else \ 762 G(PCHARSV,BITTWO)(p, offset, len, f) 763 764#define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \ 765 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 766 G(READ_CAPTURE_NAME,BITONE)(p, cn8, cn16, cn32, re); \ 767 else \ 768 G(READ_CAPTURE_NAME,BITTWO)(p, cn8, cn16, cn32, re) 769 770#define SET_PCRE_CALLOUT(callout) \ 771 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 772 G(SET_PCRE_CALLOUT,BITONE)(callout); \ 773 else \ 774 G(SET_PCRE_CALLOUT,BITTWO)(callout) 775 776#define SET_PCRE_STACK_GUARD(stack_guard) \ 777 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 778 G(SET_PCRE_STACK_GUARD,BITONE)(stack_guard); \ 779 else \ 780 G(SET_PCRE_STACK_GUARD,BITTWO)(stack_guard) 781 782#define STRLEN(p) ((pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 783 G(STRLEN,BITONE)(p) : G(STRLEN,BITTWO)(p)) 784 785#define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \ 786 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 787 G(PCRE_ASSIGN_JIT_STACK,BITONE)(extra, callback, userdata); \ 788 else \ 789 G(PCRE_ASSIGN_JIT_STACK,BITTWO)(extra, callback, userdata) 790 791#define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \ 792 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 793 G(PCRE_COMPILE,BITONE)(re, pat, options, error, erroffset, tables); \ 794 else \ 795 G(PCRE_COMPILE,BITTWO)(re, pat, options, error, erroffset, tables) 796 797#define PCRE_CONFIG G(G(pcre,BITONE),_config) 798 799#define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 800 namesptr, cbuffer, size) \ 801 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 802 G(PCRE_COPY_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \ 803 namesptr, cbuffer, size); \ 804 else \ 805 G(PCRE_COPY_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \ 806 namesptr, cbuffer, size) 807 808#define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \ 809 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 810 G(PCRE_COPY_SUBSTRING,BITONE)(rc, bptr, offsets, count, i, cbuffer, size); \ 811 else \ 812 G(PCRE_COPY_SUBSTRING,BITTWO)(rc, bptr, offsets, count, i, cbuffer, size) 813 814#define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \ 815 offsets, size_offsets, workspace, size_workspace) \ 816 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 817 G(PCRE_DFA_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \ 818 offsets, size_offsets, workspace, size_workspace); \ 819 else \ 820 G(PCRE_DFA_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \ 821 offsets, size_offsets, workspace, size_workspace) 822 823#define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \ 824 offsets, size_offsets) \ 825 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 826 G(PCRE_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \ 827 offsets, size_offsets); \ 828 else \ 829 G(PCRE_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \ 830 offsets, size_offsets) 831 832#define PCRE_FREE_STUDY(extra) \ 833 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 834 G(PCRE_FREE_STUDY,BITONE)(extra); \ 835 else \ 836 G(PCRE_FREE_STUDY,BITTWO)(extra) 837 838#define PCRE_FREE_SUBSTRING(substring) \ 839 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 840 G(PCRE_FREE_SUBSTRING,BITONE)(substring); \ 841 else \ 842 G(PCRE_FREE_SUBSTRING,BITTWO)(substring) 843 844#define PCRE_FREE_SUBSTRING_LIST(listptr) \ 845 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 846 G(PCRE_FREE_SUBSTRING_LIST,BITONE)(listptr); \ 847 else \ 848 G(PCRE_FREE_SUBSTRING_LIST,BITTWO)(listptr) 849 850#define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 851 getnamesptr, subsptr) \ 852 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 853 G(PCRE_GET_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \ 854 getnamesptr, subsptr); \ 855 else \ 856 G(PCRE_GET_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \ 857 getnamesptr, subsptr) 858 859#define PCRE_GET_STRINGNUMBER(n, rc, ptr) \ 860 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 861 G(PCRE_GET_STRINGNUMBER,BITONE)(n, rc, ptr); \ 862 else \ 863 G(PCRE_GET_STRINGNUMBER,BITTWO)(n, rc, ptr) 864 865#define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \ 866 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 867 G(PCRE_GET_SUBSTRING,BITONE)(rc, bptr, use_offsets, count, i, subsptr); \ 868 else \ 869 G(PCRE_GET_SUBSTRING,BITTWO)(rc, bptr, use_offsets, count, i, subsptr) 870 871#define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \ 872 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 873 G(PCRE_GET_SUBSTRING_LIST,BITONE)(rc, bptr, offsets, count, listptr); \ 874 else \ 875 G(PCRE_GET_SUBSTRING_LIST,BITTWO)(rc, bptr, offsets, count, listptr) 876 877#define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \ 878 (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 879 G(PCRE_JIT_STACK_ALLOC,BITONE)(startsize, maxsize) \ 880 : G(PCRE_JIT_STACK_ALLOC,BITTWO)(startsize, maxsize) 881 882#define PCRE_JIT_STACK_FREE(stack) \ 883 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 884 G(PCRE_JIT_STACK_FREE,BITONE)(stack); \ 885 else \ 886 G(PCRE_JIT_STACK_FREE,BITTWO)(stack) 887 888#define PCRE_MAKETABLES \ 889 (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 890 G(G(pcre,BITONE),_maketables)() : G(G(pcre,BITTWO),_maketables)() 891 892#define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \ 893 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 894 G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITONE)(rc, re, extra, tables); \ 895 else \ 896 G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITTWO)(rc, re, extra, tables) 897 898#define PCRE_PRINTINT(re, outfile, debug_lengths) \ 899 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 900 G(PCRE_PRINTINT,BITONE)(re, outfile, debug_lengths); \ 901 else \ 902 G(PCRE_PRINTINT,BITTWO)(re, outfile, debug_lengths) 903 904#define PCRE_STUDY(extra, re, options, error) \ 905 if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 906 G(PCRE_STUDY,BITONE)(extra, re, options, error); \ 907 else \ 908 G(PCRE_STUDY,BITTWO)(extra, re, options, error) 909 910#endif /* Two out of three modes */ 911 912/* ----- End of cases where more than one mode is supported ----- */ 913 914 915/* ----- Only 8-bit mode is supported ----- */ 916 917#elif defined SUPPORT_PCRE8 918#define CHAR_SIZE 1 919#define PCHARS PCHARS8 920#define PCHARSV PCHARSV8 921#define READ_CAPTURE_NAME READ_CAPTURE_NAME8 922#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT8 923#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD8 924#define STRLEN STRLEN8 925#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK8 926#define PCRE_COMPILE PCRE_COMPILE8 927#define PCRE_CONFIG pcre_config 928#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING8 929#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING8 930#define PCRE_DFA_EXEC PCRE_DFA_EXEC8 931#define PCRE_EXEC PCRE_EXEC8 932#define PCRE_FREE_STUDY PCRE_FREE_STUDY8 933#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING8 934#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST8 935#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING8 936#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER8 937#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING8 938#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST8 939#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC8 940#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE8 941#define PCRE_MAKETABLES pcre_maketables() 942#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER8 943#define PCRE_PRINTINT PCRE_PRINTINT8 944#define PCRE_STUDY PCRE_STUDY8 945 946/* ----- Only 16-bit mode is supported ----- */ 947 948#elif defined SUPPORT_PCRE16 949#define CHAR_SIZE 2 950#define PCHARS PCHARS16 951#define PCHARSV PCHARSV16 952#define READ_CAPTURE_NAME READ_CAPTURE_NAME16 953#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT16 954#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD16 955#define STRLEN STRLEN16 956#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK16 957#define PCRE_COMPILE PCRE_COMPILE16 958#define PCRE_CONFIG pcre16_config 959#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING16 960#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING16 961#define PCRE_DFA_EXEC PCRE_DFA_EXEC16 962#define PCRE_EXEC PCRE_EXEC16 963#define PCRE_FREE_STUDY PCRE_FREE_STUDY16 964#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING16 965#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST16 966#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING16 967#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER16 968#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING16 969#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST16 970#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC16 971#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE16 972#define PCRE_MAKETABLES pcre16_maketables() 973#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER16 974#define PCRE_PRINTINT PCRE_PRINTINT16 975#define PCRE_STUDY PCRE_STUDY16 976 977/* ----- Only 32-bit mode is supported ----- */ 978 979#elif defined SUPPORT_PCRE32 980#define CHAR_SIZE 4 981#define PCHARS PCHARS32 982#define PCHARSV PCHARSV32 983#define READ_CAPTURE_NAME READ_CAPTURE_NAME32 984#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT32 985#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD32 986#define STRLEN STRLEN32 987#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK32 988#define PCRE_COMPILE PCRE_COMPILE32 989#define PCRE_CONFIG pcre32_config 990#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING32 991#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING32 992#define PCRE_DFA_EXEC PCRE_DFA_EXEC32 993#define PCRE_EXEC PCRE_EXEC32 994#define PCRE_FREE_STUDY PCRE_FREE_STUDY32 995#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING32 996#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST32 997#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING32 998#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER32 999#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING32 1000#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST32 1001#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC32 1002#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE32 1003#define PCRE_MAKETABLES pcre32_maketables() 1004#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER32 1005#define PCRE_PRINTINT PCRE_PRINTINT32 1006#define PCRE_STUDY PCRE_STUDY32 1007 1008#endif 1009 1010/* ----- End of mode-specific function call macros ----- */ 1011 1012 1013/* Other parameters */ 1014 1015#ifndef CLOCKS_PER_SEC 1016#ifdef CLK_TCK 1017#define CLOCKS_PER_SEC CLK_TCK 1018#else 1019#define CLOCKS_PER_SEC 100 1020#endif 1021#endif 1022 1023#if !defined NODFA 1024#define DFA_WS_DIMENSION 1000 1025#endif 1026 1027/* This is the default loop count for timing. */ 1028 1029#define LOOPREPEAT 500000 1030 1031/* Static variables */ 1032 1033static FILE *outfile; 1034static int log_store = 0; 1035static int callout_count; 1036static int callout_extra; 1037static int callout_fail_count; 1038static int callout_fail_id; 1039static int debug_lengths; 1040static int first_callout; 1041static int jit_was_used; 1042static int locale_set = 0; 1043static int show_malloc; 1044static int stack_guard_return; 1045static int use_utf; 1046static const unsigned char *last_callout_mark = NULL; 1047 1048/* The buffers grow automatically if very long input lines are encountered. */ 1049 1050static int buffer_size = 50000; 1051static pcre_uint8 *buffer = NULL; 1052static pcre_uint8 *pbuffer = NULL; 1053 1054/* Just as a safety check, make sure that COMPILE_PCRE[16|32] are *not* set. */ 1055 1056#ifdef COMPILE_PCRE16 1057#error COMPILE_PCRE16 must not be set when compiling pcretest.c 1058#endif 1059 1060#ifdef COMPILE_PCRE32 1061#error COMPILE_PCRE32 must not be set when compiling pcretest.c 1062#endif 1063 1064/* We need buffers for building 16/32-bit strings, and the tables of operator 1065lengths that are used for 16/32-bit compiling, in order to swap bytes in a 1066pattern for saving/reloading testing. Luckily, the data for these tables is 1067defined as a macro. However, we must ensure that LINK_SIZE and IMM2_SIZE (which 1068are used in the tables) are adjusted appropriately for the 16/32-bit world. 1069LINK_SIZE is also used later in this program. */ 1070 1071#ifdef SUPPORT_PCRE16 1072#undef IMM2_SIZE 1073#define IMM2_SIZE 1 1074 1075#if LINK_SIZE == 2 1076#undef LINK_SIZE 1077#define LINK_SIZE 1 1078#elif LINK_SIZE == 3 || LINK_SIZE == 4 1079#undef LINK_SIZE 1080#define LINK_SIZE 2 1081#else 1082#error LINK_SIZE must be either 2, 3, or 4 1083#endif 1084 1085static int buffer16_size = 0; 1086static pcre_uint16 *buffer16 = NULL; 1087static const pcre_uint16 OP_lengths16[] = { OP_LENGTHS }; 1088#endif /* SUPPORT_PCRE16 */ 1089 1090#ifdef SUPPORT_PCRE32 1091#undef IMM2_SIZE 1092#define IMM2_SIZE 1 1093#undef LINK_SIZE 1094#define LINK_SIZE 1 1095 1096static int buffer32_size = 0; 1097static pcre_uint32 *buffer32 = NULL; 1098static const pcre_uint32 OP_lengths32[] = { OP_LENGTHS }; 1099#endif /* SUPPORT_PCRE32 */ 1100 1101/* If we have 8-bit support, default to it; if there is also 16-or 32-bit 1102support, it can be changed by an option. If there is no 8-bit support, there 1103must be 16-or 32-bit support, so default it to 1. */ 1104 1105#if defined SUPPORT_PCRE8 1106static int pcre_mode = PCRE8_MODE; 1107#elif defined SUPPORT_PCRE16 1108static int pcre_mode = PCRE16_MODE; 1109#elif defined SUPPORT_PCRE32 1110static int pcre_mode = PCRE32_MODE; 1111#endif 1112 1113/* JIT study options for -s+n and /S+n where '1' <= n <= '7'. */ 1114 1115static int jit_study_bits[] = 1116 { 1117 PCRE_STUDY_JIT_COMPILE, 1118 PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE, 1119 PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE, 1120 PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 1121 PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 1122 PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 1123 PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + 1124 PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE 1125}; 1126 1127#define PCRE_STUDY_ALLJIT (PCRE_STUDY_JIT_COMPILE | \ 1128 PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE) 1129 1130/* Textual explanations for runtime error codes */ 1131 1132static const char *errtexts[] = { 1133 NULL, /* 0 is no error */ 1134 NULL, /* NOMATCH is handled specially */ 1135 "NULL argument passed", 1136 "bad option value", 1137 "magic number missing", 1138 "unknown opcode - pattern overwritten?", 1139 "no more memory", 1140 NULL, /* never returned by pcre_exec() or pcre_dfa_exec() */ 1141 "match limit exceeded", 1142 "callout error code", 1143 NULL, /* BADUTF8/16 is handled specially */ 1144 NULL, /* BADUTF8/16 offset is handled specially */ 1145 NULL, /* PARTIAL is handled specially */ 1146 "not used - internal error", 1147 "internal error - pattern overwritten?", 1148 "bad count value", 1149 "item unsupported for DFA matching", 1150 "backreference condition or recursion test not supported for DFA matching", 1151 "match limit not supported for DFA matching", 1152 "workspace size exceeded in DFA matching", 1153 "too much recursion for DFA matching", 1154 "recursion limit exceeded", 1155 "not used - internal error", 1156 "invalid combination of newline options", 1157 "bad offset value", 1158 NULL, /* SHORTUTF8/16 is handled specially */ 1159 "nested recursion at the same subject position", 1160 "JIT stack limit reached", 1161 "pattern compiled in wrong mode: 8-bit/16-bit error", 1162 "pattern compiled with other endianness", 1163 "invalid data in workspace for DFA restart", 1164 "bad JIT option", 1165 "bad length" 1166}; 1167 1168 1169/************************************************* 1170* Alternate character tables * 1171*************************************************/ 1172 1173/* By default, the "tables" pointer when calling PCRE is set to NULL, thereby 1174using the default tables of the library. However, the T option can be used to 1175select alternate sets of tables, for different kinds of testing. Note also that 1176the L (locale) option also adjusts the tables. */ 1177 1178/* This is the set of tables distributed as default with PCRE. It recognizes 1179only ASCII characters. */ 1180 1181static const pcre_uint8 tables0[] = { 1182 1183/* This table is a lower casing table. */ 1184 1185 0, 1, 2, 3, 4, 5, 6, 7, 1186 8, 9, 10, 11, 12, 13, 14, 15, 1187 16, 17, 18, 19, 20, 21, 22, 23, 1188 24, 25, 26, 27, 28, 29, 30, 31, 1189 32, 33, 34, 35, 36, 37, 38, 39, 1190 40, 41, 42, 43, 44, 45, 46, 47, 1191 48, 49, 50, 51, 52, 53, 54, 55, 1192 56, 57, 58, 59, 60, 61, 62, 63, 1193 64, 97, 98, 99,100,101,102,103, 1194 104,105,106,107,108,109,110,111, 1195 112,113,114,115,116,117,118,119, 1196 120,121,122, 91, 92, 93, 94, 95, 1197 96, 97, 98, 99,100,101,102,103, 1198 104,105,106,107,108,109,110,111, 1199 112,113,114,115,116,117,118,119, 1200 120,121,122,123,124,125,126,127, 1201 128,129,130,131,132,133,134,135, 1202 136,137,138,139,140,141,142,143, 1203 144,145,146,147,148,149,150,151, 1204 152,153,154,155,156,157,158,159, 1205 160,161,162,163,164,165,166,167, 1206 168,169,170,171,172,173,174,175, 1207 176,177,178,179,180,181,182,183, 1208 184,185,186,187,188,189,190,191, 1209 192,193,194,195,196,197,198,199, 1210 200,201,202,203,204,205,206,207, 1211 208,209,210,211,212,213,214,215, 1212 216,217,218,219,220,221,222,223, 1213 224,225,226,227,228,229,230,231, 1214 232,233,234,235,236,237,238,239, 1215 240,241,242,243,244,245,246,247, 1216 248,249,250,251,252,253,254,255, 1217 1218/* This table is a case flipping table. */ 1219 1220 0, 1, 2, 3, 4, 5, 6, 7, 1221 8, 9, 10, 11, 12, 13, 14, 15, 1222 16, 17, 18, 19, 20, 21, 22, 23, 1223 24, 25, 26, 27, 28, 29, 30, 31, 1224 32, 33, 34, 35, 36, 37, 38, 39, 1225 40, 41, 42, 43, 44, 45, 46, 47, 1226 48, 49, 50, 51, 52, 53, 54, 55, 1227 56, 57, 58, 59, 60, 61, 62, 63, 1228 64, 97, 98, 99,100,101,102,103, 1229 104,105,106,107,108,109,110,111, 1230 112,113,114,115,116,117,118,119, 1231 120,121,122, 91, 92, 93, 94, 95, 1232 96, 65, 66, 67, 68, 69, 70, 71, 1233 72, 73, 74, 75, 76, 77, 78, 79, 1234 80, 81, 82, 83, 84, 85, 86, 87, 1235 88, 89, 90,123,124,125,126,127, 1236 128,129,130,131,132,133,134,135, 1237 136,137,138,139,140,141,142,143, 1238 144,145,146,147,148,149,150,151, 1239 152,153,154,155,156,157,158,159, 1240 160,161,162,163,164,165,166,167, 1241 168,169,170,171,172,173,174,175, 1242 176,177,178,179,180,181,182,183, 1243 184,185,186,187,188,189,190,191, 1244 192,193,194,195,196,197,198,199, 1245 200,201,202,203,204,205,206,207, 1246 208,209,210,211,212,213,214,215, 1247 216,217,218,219,220,221,222,223, 1248 224,225,226,227,228,229,230,231, 1249 232,233,234,235,236,237,238,239, 1250 240,241,242,243,244,245,246,247, 1251 248,249,250,251,252,253,254,255, 1252 1253/* This table contains bit maps for various character classes. Each map is 32 1254bytes long and the bits run from the least significant end of each byte. The 1255classes that have their own maps are: space, xdigit, digit, upper, lower, word, 1256graph, print, punct, and cntrl. Other classes are built from combinations. */ 1257 1258 0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00, 1259 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1260 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1261 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1262 1263 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 1264 0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00, 1265 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1266 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1267 1268 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 1269 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1270 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1271 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1272 1273 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1274 0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00, 1275 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1276 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1277 1278 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1279 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07, 1280 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1281 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1282 1283 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 1284 0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07, 1285 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1286 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1287 1288 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff, 1289 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 1290 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1291 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1292 1293 0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff, 1294 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 1295 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1296 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1297 1298 0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc, 1299 0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78, 1300 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1301 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1302 1303 0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00, 1304 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80, 1305 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1306 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 1307 1308/* This table identifies various classes of character by individual bits: 1309 0x01 white space character 1310 0x02 letter 1311 0x04 decimal digit 1312 0x08 hexadecimal digit 1313 0x10 alphanumeric or '_' 1314 0x80 regular expression metacharacter or binary zero 1315*/ 1316 1317 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */ 1318 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */ 1319 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */ 1320 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */ 1321 0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */ 1322 0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /* ( - / */ 1323 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */ 1324 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /* 8 - ? */ 1325 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* @ - G */ 1326 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* H - O */ 1327 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* P - W */ 1328 0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /* X - _ */ 1329 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* ` - g */ 1330 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* h - o */ 1331 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* p - w */ 1332 0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /* x -127 */ 1333 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */ 1334 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */ 1335 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */ 1336 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */ 1337 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */ 1338 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */ 1339 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */ 1340 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */ 1341 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */ 1342 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */ 1343 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */ 1344 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */ 1345 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */ 1346 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */ 1347 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */ 1348 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */ 1349 1350/* This is a set of tables that came originally from a Windows user. It seems 1351to be at least an approximation of ISO 8859. In particular, there are 1352characters greater than 128 that are marked as spaces, letters, etc. */ 1353 1354static const pcre_uint8 tables1[] = { 13550,1,2,3,4,5,6,7, 13568,9,10,11,12,13,14,15, 135716,17,18,19,20,21,22,23, 135824,25,26,27,28,29,30,31, 135932,33,34,35,36,37,38,39, 136040,41,42,43,44,45,46,47, 136148,49,50,51,52,53,54,55, 136256,57,58,59,60,61,62,63, 136364,97,98,99,100,101,102,103, 1364104,105,106,107,108,109,110,111, 1365112,113,114,115,116,117,118,119, 1366120,121,122,91,92,93,94,95, 136796,97,98,99,100,101,102,103, 1368104,105,106,107,108,109,110,111, 1369112,113,114,115,116,117,118,119, 1370120,121,122,123,124,125,126,127, 1371128,129,130,131,132,133,134,135, 1372136,137,138,139,140,141,142,143, 1373144,145,146,147,148,149,150,151, 1374152,153,154,155,156,157,158,159, 1375160,161,162,163,164,165,166,167, 1376168,169,170,171,172,173,174,175, 1377176,177,178,179,180,181,182,183, 1378184,185,186,187,188,189,190,191, 1379224,225,226,227,228,229,230,231, 1380232,233,234,235,236,237,238,239, 1381240,241,242,243,244,245,246,215, 1382248,249,250,251,252,253,254,223, 1383224,225,226,227,228,229,230,231, 1384232,233,234,235,236,237,238,239, 1385240,241,242,243,244,245,246,247, 1386248,249,250,251,252,253,254,255, 13870,1,2,3,4,5,6,7, 13888,9,10,11,12,13,14,15, 138916,17,18,19,20,21,22,23, 139024,25,26,27,28,29,30,31, 139132,33,34,35,36,37,38,39, 139240,41,42,43,44,45,46,47, 139348,49,50,51,52,53,54,55, 139456,57,58,59,60,61,62,63, 139564,97,98,99,100,101,102,103, 1396104,105,106,107,108,109,110,111, 1397112,113,114,115,116,117,118,119, 1398120,121,122,91,92,93,94,95, 139996,65,66,67,68,69,70,71, 140072,73,74,75,76,77,78,79, 140180,81,82,83,84,85,86,87, 140288,89,90,123,124,125,126,127, 1403128,129,130,131,132,133,134,135, 1404136,137,138,139,140,141,142,143, 1405144,145,146,147,148,149,150,151, 1406152,153,154,155,156,157,158,159, 1407160,161,162,163,164,165,166,167, 1408168,169,170,171,172,173,174,175, 1409176,177,178,179,180,181,182,183, 1410184,185,186,187,188,189,190,191, 1411224,225,226,227,228,229,230,231, 1412232,233,234,235,236,237,238,239, 1413240,241,242,243,244,245,246,215, 1414248,249,250,251,252,253,254,223, 1415192,193,194,195,196,197,198,199, 1416200,201,202,203,204,205,206,207, 1417208,209,210,211,212,213,214,247, 1418216,217,218,219,220,221,222,255, 14190,62,0,0,1,0,0,0, 14200,0,0,0,0,0,0,0, 142132,0,0,0,1,0,0,0, 14220,0,0,0,0,0,0,0, 14230,0,0,0,0,0,255,3, 1424126,0,0,0,126,0,0,0, 14250,0,0,0,0,0,0,0, 14260,0,0,0,0,0,0,0, 14270,0,0,0,0,0,255,3, 14280,0,0,0,0,0,0,0, 14290,0,0,0,0,0,12,2, 14300,0,0,0,0,0,0,0, 14310,0,0,0,0,0,0,0, 1432254,255,255,7,0,0,0,0, 14330,0,0,0,0,0,0,0, 1434255,255,127,127,0,0,0,0, 14350,0,0,0,0,0,0,0, 14360,0,0,0,254,255,255,7, 14370,0,0,0,0,4,32,4, 14380,0,0,128,255,255,127,255, 14390,0,0,0,0,0,255,3, 1440254,255,255,135,254,255,255,7, 14410,0,0,0,0,4,44,6, 1442255,255,127,255,255,255,127,255, 14430,0,0,0,254,255,255,255, 1444255,255,255,255,255,255,255,127, 14450,0,0,0,254,255,255,255, 1446255,255,255,255,255,255,255,255, 14470,2,0,0,255,255,255,255, 1448255,255,255,255,255,255,255,127, 14490,0,0,0,255,255,255,255, 1450255,255,255,255,255,255,255,255, 14510,0,0,0,254,255,0,252, 14521,0,0,248,1,0,0,120, 14530,0,0,0,254,255,255,255, 14540,0,128,0,0,0,128,0, 1455255,255,255,255,0,0,0,0, 14560,0,0,0,0,0,0,128, 1457255,255,255,255,0,0,0,0, 14580,0,0,0,0,0,0,0, 1459128,0,0,0,0,0,0,0, 14600,1,1,0,1,1,0,0, 14610,0,0,0,0,0,0,0, 14620,0,0,0,0,0,0,0, 14631,0,0,0,128,0,0,0, 1464128,128,128,128,0,0,128,0, 146528,28,28,28,28,28,28,28, 146628,28,0,0,0,0,0,128, 14670,26,26,26,26,26,26,18, 146818,18,18,18,18,18,18,18, 146918,18,18,18,18,18,18,18, 147018,18,18,128,128,0,128,16, 14710,26,26,26,26,26,26,18, 147218,18,18,18,18,18,18,18, 147318,18,18,18,18,18,18,18, 147418,18,18,128,128,0,0,0, 14750,0,0,0,0,1,0,0, 14760,0,0,0,0,0,0,0, 14770,0,0,0,0,0,0,0, 14780,0,0,0,0,0,0,0, 14791,0,0,0,0,0,0,0, 14800,0,18,0,0,0,0,0, 14810,0,20,20,0,18,0,0, 14820,20,18,0,0,0,0,0, 148318,18,18,18,18,18,18,18, 148418,18,18,18,18,18,18,18, 148518,18,18,18,18,18,18,0, 148618,18,18,18,18,18,18,18, 148718,18,18,18,18,18,18,18, 148818,18,18,18,18,18,18,18, 148918,18,18,18,18,18,18,0, 149018,18,18,18,18,18,18,18 1491}; 1492 1493 1494 1495 1496#ifndef HAVE_STRERROR 1497/************************************************* 1498* Provide strerror() for non-ANSI libraries * 1499*************************************************/ 1500 1501/* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror() 1502in their libraries, but can provide the same facility by this simple 1503alternative function. */ 1504 1505extern int sys_nerr; 1506extern char *sys_errlist[]; 1507 1508char * 1509strerror(int n) 1510{ 1511if (n < 0 || n >= sys_nerr) return "unknown error number"; 1512return sys_errlist[n]; 1513} 1514#endif /* HAVE_STRERROR */ 1515 1516 1517 1518/************************************************* 1519* Print newline configuration * 1520*************************************************/ 1521 1522/* 1523Arguments: 1524 rc the return code from PCRE_CONFIG_NEWLINE 1525 isc TRUE if called from "-C newline" 1526Returns: nothing 1527*/ 1528 1529static void 1530print_newline_config(int rc, BOOL isc) 1531{ 1532const char *s = NULL; 1533if (!isc) printf(" Newline sequence is "); 1534switch(rc) 1535 { 1536 case CHAR_CR: s = "CR"; break; 1537 case CHAR_LF: s = "LF"; break; 1538 case (CHAR_CR<<8 | CHAR_LF): s = "CRLF"; break; 1539 case -1: s = "ANY"; break; 1540 case -2: s = "ANYCRLF"; break; 1541 1542 default: 1543 printf("a non-standard value: 0x%04x\n", rc); 1544 return; 1545 } 1546 1547printf("%s\n", s); 1548} 1549 1550 1551 1552/************************************************* 1553* JIT memory callback * 1554*************************************************/ 1555 1556static pcre_jit_stack* jit_callback(void *arg) 1557{ 1558jit_was_used = TRUE; 1559return (pcre_jit_stack *)arg; 1560} 1561 1562 1563#if !defined NOUTF || defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32 1564/************************************************* 1565* Convert UTF-8 string to value * 1566*************************************************/ 1567 1568/* This function takes one or more bytes that represents a UTF-8 character, 1569and returns the value of the character. 1570 1571Argument: 1572 utf8bytes a pointer to the byte vector 1573 vptr a pointer to an int to receive the value 1574 1575Returns: > 0 => the number of bytes consumed 1576 -6 to 0 => malformed UTF-8 character at offset = (-return) 1577*/ 1578 1579static int 1580utf82ord(pcre_uint8 *utf8bytes, pcre_uint32 *vptr) 1581{ 1582pcre_uint32 c = *utf8bytes++; 1583pcre_uint32 d = c; 1584int i, j, s; 1585 1586for (i = -1; i < 6; i++) /* i is number of additional bytes */ 1587 { 1588 if ((d & 0x80) == 0) break; 1589 d <<= 1; 1590 } 1591 1592if (i == -1) { *vptr = c; return 1; } /* ascii character */ 1593if (i == 0 || i == 6) return 0; /* invalid UTF-8 */ 1594 1595/* i now has a value in the range 1-5 */ 1596 1597s = 6*i; 1598d = (c & utf8_table3[i]) << s; 1599 1600for (j = 0; j < i; j++) 1601 { 1602 c = *utf8bytes++; 1603 if ((c & 0xc0) != 0x80) return -(j+1); 1604 s -= 6; 1605 d |= (c & 0x3f) << s; 1606 } 1607 1608/* Check that encoding was the correct unique one */ 1609 1610for (j = 0; j < utf8_table1_size; j++) 1611 if (d <= (pcre_uint32)utf8_table1[j]) break; 1612if (j != i) return -(i+1); 1613 1614/* Valid value */ 1615 1616*vptr = d; 1617return i+1; 1618} 1619#endif /* NOUTF || SUPPORT_PCRE16 */ 1620 1621 1622 1623#if defined SUPPORT_PCRE8 && !defined NOUTF 1624/************************************************* 1625* Convert character value to UTF-8 * 1626*************************************************/ 1627 1628/* This function takes an integer value in the range 0 - 0x7fffffff 1629and encodes it as a UTF-8 character in 0 to 6 bytes. 1630 1631Arguments: 1632 cvalue the character value 1633 utf8bytes pointer to buffer for result - at least 6 bytes long 1634 1635Returns: number of characters placed in the buffer 1636*/ 1637 1638static int 1639ord2utf8(pcre_uint32 cvalue, pcre_uint8 *utf8bytes) 1640{ 1641register int i, j; 1642if (cvalue > 0x7fffffffu) 1643 return -1; 1644for (i = 0; i < utf8_table1_size; i++) 1645 if (cvalue <= (pcre_uint32)utf8_table1[i]) break; 1646utf8bytes += i; 1647for (j = i; j > 0; j--) 1648 { 1649 *utf8bytes-- = 0x80 | (cvalue & 0x3f); 1650 cvalue >>= 6; 1651 } 1652*utf8bytes = utf8_table2[i] | cvalue; 1653return i + 1; 1654} 1655#endif 1656 1657 1658#ifdef SUPPORT_PCRE16 1659/************************************************* 1660* Convert a string to 16-bit * 1661*************************************************/ 1662 1663/* In non-UTF mode, the space needed for a 16-bit string is exactly double the 16648-bit size. For a UTF-8 string, the size needed for UTF-16 is no more than 1665double, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4 1666in UTF-16. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-16. The 1667result is always left in buffer16. 1668 1669Note that this function does not object to surrogate values. This is 1670deliberate; it makes it possible to construct UTF-16 strings that are invalid, 1671for the purpose of testing that they are correctly faulted. 1672 1673Patterns to be converted are either plain ASCII or UTF-8; data lines are always 1674in UTF-8 so that values greater than 255 can be handled. 1675 1676Arguments: 1677 data TRUE if converting a data line; FALSE for a regex 1678 p points to a byte string 1679 utf true if UTF-8 (to be converted to UTF-16) 1680 len number of bytes in the string (excluding trailing zero) 1681 1682Returns: number of 16-bit data items used (excluding trailing zero) 1683 OR -1 if a UTF-8 string is malformed 1684 OR -2 if a value > 0x10ffff is encountered 1685 OR -3 if a value > 0xffff is encountered when not in UTF mode 1686*/ 1687 1688static int 1689to16(int data, pcre_uint8 *p, int utf, int len) 1690{ 1691pcre_uint16 *pp; 1692 1693if (buffer16_size < 2*len + 2) 1694 { 1695 if (buffer16 != NULL) free(buffer16); 1696 buffer16_size = 2*len + 2; 1697 buffer16 = (pcre_uint16 *)malloc(buffer16_size); 1698 if (buffer16 == NULL) 1699 { 1700 fprintf(stderr, "pcretest: malloc(%d) failed for buffer16\n", buffer16_size); 1701 exit(1); 1702 } 1703 } 1704 1705pp = buffer16; 1706 1707if (!utf && !data) 1708 { 1709 while (len-- > 0) *pp++ = *p++; 1710 } 1711 1712else 1713 { 1714 pcre_uint32 c = 0; 1715 while (len > 0) 1716 { 1717 int chlen = utf82ord(p, &c); 1718 if (chlen <= 0) return -1; 1719 if (c > 0x10ffff) return -2; 1720 p += chlen; 1721 len -= chlen; 1722 if (c < 0x10000) *pp++ = c; else 1723 { 1724 if (!utf) return -3; 1725 c -= 0x10000; 1726 *pp++ = 0xD800 | (c >> 10); 1727 *pp++ = 0xDC00 | (c & 0x3ff); 1728 } 1729 } 1730 } 1731 1732*pp = 0; 1733return pp - buffer16; 1734} 1735#endif 1736 1737#ifdef SUPPORT_PCRE32 1738/************************************************* 1739* Convert a string to 32-bit * 1740*************************************************/ 1741 1742/* In non-UTF mode, the space needed for a 32-bit string is exactly four times the 17438-bit size. For a UTF-8 string, the size needed for UTF-32 is no more than four 1744times, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4 1745in UTF-32. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-32. The 1746result is always left in buffer32. 1747 1748Note that this function does not object to surrogate values. This is 1749deliberate; it makes it possible to construct UTF-32 strings that are invalid, 1750for the purpose of testing that they are correctly faulted. 1751 1752Patterns to be converted are either plain ASCII or UTF-8; data lines are always 1753in UTF-8 so that values greater than 255 can be handled. 1754 1755Arguments: 1756 data TRUE if converting a data line; FALSE for a regex 1757 p points to a byte string 1758 utf true if UTF-8 (to be converted to UTF-32) 1759 len number of bytes in the string (excluding trailing zero) 1760 1761Returns: number of 32-bit data items used (excluding trailing zero) 1762 OR -1 if a UTF-8 string is malformed 1763 OR -2 if a value > 0x10ffff is encountered 1764 OR -3 if an ill-formed value is encountered (i.e. a surrogate) 1765*/ 1766 1767static int 1768to32(int data, pcre_uint8 *p, int utf, int len) 1769{ 1770pcre_uint32 *pp; 1771 1772if (buffer32_size < 4*len + 4) 1773 { 1774 if (buffer32 != NULL) free(buffer32); 1775 buffer32_size = 4*len + 4; 1776 buffer32 = (pcre_uint32 *)malloc(buffer32_size); 1777 if (buffer32 == NULL) 1778 { 1779 fprintf(stderr, "pcretest: malloc(%d) failed for buffer32\n", buffer32_size); 1780 exit(1); 1781 } 1782 } 1783 1784pp = buffer32; 1785 1786if (!utf && !data) 1787 { 1788 while (len-- > 0) *pp++ = *p++; 1789 } 1790 1791else 1792 { 1793 pcre_uint32 c = 0; 1794 while (len > 0) 1795 { 1796 int chlen = utf82ord(p, &c); 1797 if (chlen <= 0) return -1; 1798 if (utf) 1799 { 1800 if (c > 0x10ffff) return -2; 1801 if (!data && (c & 0xfffff800u) == 0xd800u) return -3; 1802 } 1803 1804 p += chlen; 1805 len -= chlen; 1806 *pp++ = c; 1807 } 1808 } 1809 1810*pp = 0; 1811return pp - buffer32; 1812} 1813 1814/* Check that a 32-bit character string is valid UTF-32. 1815 1816Arguments: 1817 string points to the string 1818 length length of string, or -1 if the string is zero-terminated 1819 1820Returns: TRUE if the string is a valid UTF-32 string 1821 FALSE otherwise 1822*/ 1823 1824#ifdef NEVER /* Not used */ 1825#ifdef SUPPORT_UTF 1826static BOOL 1827valid_utf32(pcre_uint32 *string, int length) 1828{ 1829register pcre_uint32 *p; 1830register pcre_uint32 c; 1831 1832for (p = string; length-- > 0; p++) 1833 { 1834 c = *p; 1835 if (c > 0x10ffffu) return FALSE; /* Too big */ 1836 if ((c & 0xfffff800u) == 0xd800u) return FALSE; /* Surrogate */ 1837 } 1838 1839return TRUE; 1840} 1841#endif /* SUPPORT_UTF */ 1842#endif /* NEVER */ 1843#endif /* SUPPORT_PCRE32 */ 1844 1845 1846/************************************************* 1847* Read or extend an input line * 1848*************************************************/ 1849 1850/* Input lines are read into buffer, but both patterns and data lines can be 1851continued over multiple input lines. In addition, if the buffer fills up, we 1852want to automatically expand it so as to be able to handle extremely large 1853lines that are needed for certain stress tests. When the input buffer is 1854expanded, the other two buffers must also be expanded likewise, and the 1855contents of pbuffer, which are a copy of the input for callouts, must be 1856preserved (for when expansion happens for a data line). This is not the most 1857optimal way of handling this, but hey, this is just a test program! 1858 1859Arguments: 1860 f the file to read 1861 start where in buffer to start (this *must* be within buffer) 1862 prompt for stdin or readline() 1863 1864Returns: pointer to the start of new data 1865 could be a copy of start, or could be moved 1866 NULL if no data read and EOF reached 1867*/ 1868 1869static pcre_uint8 * 1870extend_inputline(FILE *f, pcre_uint8 *start, const char *prompt) 1871{ 1872pcre_uint8 *here = start; 1873 1874for (;;) 1875 { 1876 size_t rlen = (size_t)(buffer_size - (here - buffer)); 1877 1878 if (rlen > 1000) 1879 { 1880 int dlen; 1881 1882 /* If libreadline or libedit support is required, use readline() to read a 1883 line if the input is a terminal. Note that readline() removes the trailing 1884 newline, so we must put it back again, to be compatible with fgets(). */ 1885 1886#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 1887 if (isatty(fileno(f))) 1888 { 1889 size_t len; 1890 char *s = readline(prompt); 1891 if (s == NULL) return (here == start)? NULL : start; 1892 len = strlen(s); 1893 if (len > 0) add_history(s); 1894 if (len > rlen - 1) len = rlen - 1; 1895 memcpy(here, s, len); 1896 here[len] = '\n'; 1897 here[len+1] = 0; 1898 free(s); 1899 } 1900 else 1901#endif 1902 1903 /* Read the next line by normal means, prompting if the file is stdin. */ 1904 1905 { 1906 if (f == stdin) printf("%s", prompt); 1907 if (fgets((char *)here, rlen, f) == NULL) 1908 return (here == start)? NULL : start; 1909 } 1910 1911 dlen = (int)strlen((char *)here); 1912 if (dlen > 0 && here[dlen - 1] == '\n') return start; 1913 here += dlen; 1914 } 1915 1916 else 1917 { 1918 int new_buffer_size = 2*buffer_size; 1919 pcre_uint8 *new_buffer = (pcre_uint8 *)malloc(new_buffer_size); 1920 pcre_uint8 *new_pbuffer = (pcre_uint8 *)malloc(new_buffer_size); 1921 1922 if (new_buffer == NULL || new_pbuffer == NULL) 1923 { 1924 fprintf(stderr, "pcretest: malloc(%d) failed\n", new_buffer_size); 1925 exit(1); 1926 } 1927 1928 memcpy(new_buffer, buffer, buffer_size); 1929 memcpy(new_pbuffer, pbuffer, buffer_size); 1930 1931 buffer_size = new_buffer_size; 1932 1933 start = new_buffer + (start - buffer); 1934 here = new_buffer + (here - buffer); 1935 1936 free(buffer); 1937 free(pbuffer); 1938 1939 buffer = new_buffer; 1940 pbuffer = new_pbuffer; 1941 } 1942 } 1943 1944/* Control never gets here */ 1945} 1946 1947 1948 1949/************************************************* 1950* Read number from string * 1951*************************************************/ 1952 1953/* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess 1954around with conditional compilation, just do the job by hand. It is only used 1955for unpicking arguments, so just keep it simple. 1956 1957Arguments: 1958 str string to be converted 1959 endptr where to put the end pointer 1960 1961Returns: the unsigned long 1962*/ 1963 1964static int 1965get_value(pcre_uint8 *str, pcre_uint8 **endptr) 1966{ 1967int result = 0; 1968while(*str != 0 && isspace(*str)) str++; 1969while (isdigit(*str)) result = result * 10 + (int)(*str++ - '0'); 1970*endptr = str; 1971return(result); 1972} 1973 1974 1975 1976/************************************************* 1977* Print one character * 1978*************************************************/ 1979 1980/* Print a single character either literally, or as a hex escape. */ 1981 1982static int pchar(pcre_uint32 c, FILE *f) 1983{ 1984int n = 0; 1985if (PRINTOK(c)) 1986 { 1987 if (f != NULL) fprintf(f, "%c", c); 1988 return 1; 1989 } 1990 1991if (c < 0x100) 1992 { 1993 if (use_utf) 1994 { 1995 if (f != NULL) fprintf(f, "\\x{%02x}", c); 1996 return 6; 1997 } 1998 else 1999 { 2000 if (f != NULL) fprintf(f, "\\x%02x", c); 2001 return 4; 2002 } 2003 } 2004 2005if (f != NULL) n = fprintf(f, "\\x{%02x}", c); 2006return n >= 0 ? n : 0; 2007} 2008 2009 2010 2011#ifdef SUPPORT_PCRE8 2012/************************************************* 2013* Print 8-bit character string * 2014*************************************************/ 2015 2016/* Must handle UTF-8 strings in utf8 mode. Yields number of characters printed. 2017If handed a NULL file, just counts chars without printing. */ 2018 2019static int pchars(pcre_uint8 *p, int length, FILE *f) 2020{ 2021pcre_uint32 c = 0; 2022int yield = 0; 2023 2024if (length < 0) 2025 length = strlen((char *)p); 2026 2027while (length-- > 0) 2028 { 2029#if !defined NOUTF 2030 if (use_utf) 2031 { 2032 int rc = utf82ord(p, &c); 2033 if (rc > 0 && rc <= length + 1) /* Mustn't run over the end */ 2034 { 2035 length -= rc - 1; 2036 p += rc; 2037 yield += pchar(c, f); 2038 continue; 2039 } 2040 } 2041#endif 2042 c = *p++; 2043 yield += pchar(c, f); 2044 } 2045 2046return yield; 2047} 2048#endif 2049 2050 2051 2052#ifdef SUPPORT_PCRE16 2053/************************************************* 2054* Find length of 0-terminated 16-bit string * 2055*************************************************/ 2056 2057static int strlen16(PCRE_SPTR16 p) 2058{ 2059PCRE_SPTR16 pp = p; 2060while (*pp != 0) pp++; 2061return (int)(pp - p); 2062} 2063#endif /* SUPPORT_PCRE16 */ 2064 2065 2066 2067#ifdef SUPPORT_PCRE32 2068/************************************************* 2069* Find length of 0-terminated 32-bit string * 2070*************************************************/ 2071 2072static int strlen32(PCRE_SPTR32 p) 2073{ 2074PCRE_SPTR32 pp = p; 2075while (*pp != 0) pp++; 2076return (int)(pp - p); 2077} 2078#endif /* SUPPORT_PCRE32 */ 2079 2080 2081 2082#ifdef SUPPORT_PCRE16 2083/************************************************* 2084* Print 16-bit character string * 2085*************************************************/ 2086 2087/* Must handle UTF-16 strings in utf mode. Yields number of characters printed. 2088If handed a NULL file, just counts chars without printing. */ 2089 2090static int pchars16(PCRE_SPTR16 p, int length, FILE *f) 2091{ 2092int yield = 0; 2093 2094if (length < 0) 2095 length = strlen16(p); 2096 2097while (length-- > 0) 2098 { 2099 pcre_uint32 c = *p++ & 0xffff; 2100#if !defined NOUTF 2101 if (use_utf && c >= 0xD800 && c < 0xDC00 && length > 0) 2102 { 2103 int d = *p & 0xffff; 2104 if (d >= 0xDC00 && d <= 0xDFFF) 2105 { 2106 c = ((c & 0x3ff) << 10) + (d & 0x3ff) + 0x10000; 2107 length--; 2108 p++; 2109 } 2110 } 2111#endif 2112 yield += pchar(c, f); 2113 } 2114 2115return yield; 2116} 2117#endif /* SUPPORT_PCRE16 */ 2118 2119 2120 2121#ifdef SUPPORT_PCRE32 2122/************************************************* 2123* Print 32-bit character string * 2124*************************************************/ 2125 2126/* Must handle UTF-32 strings in utf mode. Yields number of characters printed. 2127If handed a NULL file, just counts chars without printing. */ 2128 2129static int pchars32(PCRE_SPTR32 p, int length, BOOL utf, FILE *f) 2130{ 2131int yield = 0; 2132 2133(void)(utf); /* Avoid compiler warning */ 2134 2135if (length < 0) 2136 length = strlen32(p); 2137 2138while (length-- > 0) 2139 { 2140 pcre_uint32 c = *p++; 2141 yield += pchar(c, f); 2142 } 2143 2144return yield; 2145} 2146#endif /* SUPPORT_PCRE32 */ 2147 2148 2149 2150#ifdef SUPPORT_PCRE8 2151/************************************************* 2152* Read a capture name (8-bit) and check it * 2153*************************************************/ 2154 2155static pcre_uint8 * 2156read_capture_name8(pcre_uint8 *p, pcre_uint8 **pp, pcre *re) 2157{ 2158pcre_uint8 *npp = *pp; 2159while (isalnum(*p)) *npp++ = *p++; 2160*npp++ = 0; 2161*npp = 0; 2162if (pcre_get_stringnumber(re, (char *)(*pp)) < 0) 2163 { 2164 fprintf(outfile, "no parentheses with name \""); 2165 PCHARSV(*pp, 0, -1, outfile); 2166 fprintf(outfile, "\"\n"); 2167 } 2168 2169*pp = npp; 2170return p; 2171} 2172#endif /* SUPPORT_PCRE8 */ 2173 2174 2175 2176#ifdef SUPPORT_PCRE16 2177/************************************************* 2178* Read a capture name (16-bit) and check it * 2179*************************************************/ 2180 2181/* Note that the text being read is 8-bit. */ 2182 2183static pcre_uint8 * 2184read_capture_name16(pcre_uint8 *p, pcre_uint16 **pp, pcre *re) 2185{ 2186pcre_uint16 *npp = *pp; 2187while (isalnum(*p)) *npp++ = *p++; 2188*npp++ = 0; 2189*npp = 0; 2190if (pcre16_get_stringnumber((pcre16 *)re, (PCRE_SPTR16)(*pp)) < 0) 2191 { 2192 fprintf(outfile, "no parentheses with name \""); 2193 PCHARSV(*pp, 0, -1, outfile); 2194 fprintf(outfile, "\"\n"); 2195 } 2196*pp = npp; 2197return p; 2198} 2199#endif /* SUPPORT_PCRE16 */ 2200 2201 2202 2203#ifdef SUPPORT_PCRE32 2204/************************************************* 2205* Read a capture name (32-bit) and check it * 2206*************************************************/ 2207 2208/* Note that the text being read is 8-bit. */ 2209 2210static pcre_uint8 * 2211read_capture_name32(pcre_uint8 *p, pcre_uint32 **pp, pcre *re) 2212{ 2213pcre_uint32 *npp = *pp; 2214while (isalnum(*p)) *npp++ = *p++; 2215*npp++ = 0; 2216*npp = 0; 2217if (pcre32_get_stringnumber((pcre32 *)re, (PCRE_SPTR32)(*pp)) < 0) 2218 { 2219 fprintf(outfile, "no parentheses with name \""); 2220 PCHARSV(*pp, 0, -1, outfile); 2221 fprintf(outfile, "\"\n"); 2222 } 2223*pp = npp; 2224return p; 2225} 2226#endif /* SUPPORT_PCRE32 */ 2227 2228 2229 2230/************************************************* 2231* Stack guard function * 2232*************************************************/ 2233 2234/* Called from PCRE when set in pcre_stack_guard. We give an error (non-zero) 2235return when a count overflows. */ 2236 2237static int stack_guard(void) 2238{ 2239return stack_guard_return; 2240} 2241 2242/************************************************* 2243* Callout function * 2244*************************************************/ 2245 2246/* Called from PCRE as a result of the (?C) item. We print out where we are in 2247the match. Yield zero unless more callouts than the fail count, or the callout 2248data is not zero. */ 2249 2250static int callout(pcre_callout_block *cb) 2251{ 2252FILE *f = (first_callout | callout_extra)? outfile : NULL; 2253int i, pre_start, post_start, subject_length; 2254 2255if (callout_extra) 2256 { 2257 fprintf(f, "Callout %d: last capture = %d\n", 2258 cb->callout_number, cb->capture_last); 2259 2260 for (i = 0; i < cb->capture_top * 2; i += 2) 2261 { 2262 if (cb->offset_vector[i] < 0) 2263 fprintf(f, "%2d: <unset>\n", i/2); 2264 else 2265 { 2266 fprintf(f, "%2d: ", i/2); 2267 PCHARSV(cb->subject, cb->offset_vector[i], 2268 cb->offset_vector[i+1] - cb->offset_vector[i], f); 2269 fprintf(f, "\n"); 2270 } 2271 } 2272 } 2273 2274/* Re-print the subject in canonical form, the first time or if giving full 2275datails. On subsequent calls in the same match, we use pchars just to find the 2276printed lengths of the substrings. */ 2277 2278if (f != NULL) fprintf(f, "--->"); 2279 2280PCHARS(pre_start, cb->subject, 0, cb->start_match, f); 2281PCHARS(post_start, cb->subject, cb->start_match, 2282 cb->current_position - cb->start_match, f); 2283 2284PCHARS(subject_length, cb->subject, 0, cb->subject_length, NULL); 2285 2286PCHARSV(cb->subject, cb->current_position, 2287 cb->subject_length - cb->current_position, f); 2288 2289if (f != NULL) fprintf(f, "\n"); 2290 2291/* Always print appropriate indicators, with callout number if not already 2292shown. For automatic callouts, show the pattern offset. */ 2293 2294if (cb->callout_number == 255) 2295 { 2296 fprintf(outfile, "%+3d ", cb->pattern_position); 2297 if (cb->pattern_position > 99) fprintf(outfile, "\n "); 2298 } 2299else 2300 { 2301 if (callout_extra) fprintf(outfile, " "); 2302 else fprintf(outfile, "%3d ", cb->callout_number); 2303 } 2304 2305for (i = 0; i < pre_start; i++) fprintf(outfile, " "); 2306fprintf(outfile, "^"); 2307 2308if (post_start > 0) 2309 { 2310 for (i = 0; i < post_start - 1; i++) fprintf(outfile, " "); 2311 fprintf(outfile, "^"); 2312 } 2313 2314for (i = 0; i < subject_length - pre_start - post_start + 4; i++) 2315 fprintf(outfile, " "); 2316 2317fprintf(outfile, "%.*s", (cb->next_item_length == 0)? 1 : cb->next_item_length, 2318 pbuffer + cb->pattern_position); 2319 2320fprintf(outfile, "\n"); 2321first_callout = 0; 2322 2323if (cb->mark != last_callout_mark) 2324 { 2325 if (cb->mark == NULL) 2326 fprintf(outfile, "Latest Mark: <unset>\n"); 2327 else 2328 { 2329 fprintf(outfile, "Latest Mark: "); 2330 PCHARSV(cb->mark, 0, -1, outfile); 2331 putc('\n', outfile); 2332 } 2333 last_callout_mark = cb->mark; 2334 } 2335 2336if (cb->callout_data != NULL) 2337 { 2338 int callout_data = *((int *)(cb->callout_data)); 2339 if (callout_data != 0) 2340 { 2341 fprintf(outfile, "Callout data = %d\n", callout_data); 2342 return callout_data; 2343 } 2344 } 2345 2346return (cb->callout_number != callout_fail_id)? 0 : 2347 (++callout_count >= callout_fail_count)? 1 : 0; 2348} 2349 2350 2351/************************************************* 2352* Local malloc functions * 2353*************************************************/ 2354 2355/* Alternative malloc function, to test functionality and save the size of a 2356compiled re, which is the first store request that pcre_compile() makes. The 2357show_malloc variable is set only during matching. */ 2358 2359static void *new_malloc(size_t size) 2360{ 2361void *block = malloc(size); 2362if (show_malloc) 2363 fprintf(outfile, "malloc %3d %p\n", (int)size, block); 2364return block; 2365} 2366 2367static void new_free(void *block) 2368{ 2369if (show_malloc) 2370 fprintf(outfile, "free %p\n", block); 2371free(block); 2372} 2373 2374/* For recursion malloc/free, to test stacking calls */ 2375 2376static void *stack_malloc(size_t size) 2377{ 2378void *block = malloc(size); 2379if (show_malloc) 2380 fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block); 2381return block; 2382} 2383 2384static void stack_free(void *block) 2385{ 2386if (show_malloc) 2387 fprintf(outfile, "stack_free %p\n", block); 2388free(block); 2389} 2390 2391 2392/************************************************* 2393* Call pcre_fullinfo() * 2394*************************************************/ 2395 2396/* Get one piece of information from the pcre_fullinfo() function. When only 2397one of 8-, 16- or 32-bit is supported, pcre_mode should always have the correct 2398value, but the code is defensive. 2399 2400Arguments: 2401 re compiled regex 2402 study study data 2403 option PCRE_INFO_xxx option 2404 ptr where to put the data 2405 2406Returns: 0 when OK, < 0 on error 2407*/ 2408 2409static int 2410new_info(pcre *re, pcre_extra *study, int option, void *ptr) 2411{ 2412int rc; 2413 2414if (pcre_mode == PCRE32_MODE) 2415#ifdef SUPPORT_PCRE32 2416 rc = pcre32_fullinfo((pcre32 *)re, (pcre32_extra *)study, option, ptr); 2417#else 2418 rc = PCRE_ERROR_BADMODE; 2419#endif 2420else if (pcre_mode == PCRE16_MODE) 2421#ifdef SUPPORT_PCRE16 2422 rc = pcre16_fullinfo((pcre16 *)re, (pcre16_extra *)study, option, ptr); 2423#else 2424 rc = PCRE_ERROR_BADMODE; 2425#endif 2426else 2427#ifdef SUPPORT_PCRE8 2428 rc = pcre_fullinfo(re, study, option, ptr); 2429#else 2430 rc = PCRE_ERROR_BADMODE; 2431#endif 2432 2433if (rc < 0 && rc != PCRE_ERROR_UNSET) 2434 { 2435 fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc, 2436 pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", option); 2437 if (rc == PCRE_ERROR_BADMODE) 2438 fprintf(outfile, "Running in %d-bit mode but pattern was compiled in " 2439 "%d-bit mode\n", 8 * CHAR_SIZE, 2440 8 * (REAL_PCRE_FLAGS(re) & PCRE_MODE_MASK)); 2441 } 2442 2443return rc; 2444} 2445 2446 2447 2448/************************************************* 2449* Swap byte functions * 2450*************************************************/ 2451 2452/* The following functions swap the bytes of a pcre_uint16 and pcre_uint32 2453value, respectively. 2454 2455Arguments: 2456 value any number 2457 2458Returns: the byte swapped value 2459*/ 2460 2461static pcre_uint32 2462swap_uint32(pcre_uint32 value) 2463{ 2464return ((value & 0x000000ff) << 24) | 2465 ((value & 0x0000ff00) << 8) | 2466 ((value & 0x00ff0000) >> 8) | 2467 (value >> 24); 2468} 2469 2470static pcre_uint16 2471swap_uint16(pcre_uint16 value) 2472{ 2473return (value >> 8) | (value << 8); 2474} 2475 2476 2477 2478/************************************************* 2479* Flip bytes in a compiled pattern * 2480*************************************************/ 2481 2482/* This function is called if the 'F' option was present on a pattern that is 2483to be written to a file. We flip the bytes of all the integer fields in the 2484regex data block and the study block. In 16-bit mode this also flips relevant 2485bytes in the pattern itself. This is to make it possible to test PCRE's 2486ability to reload byte-flipped patterns, e.g. those compiled on a different 2487architecture. */ 2488 2489#if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16 2490static void 2491regexflip8_or_16(pcre *ere, pcre_extra *extra) 2492{ 2493real_pcre8_or_16 *re = (real_pcre8_or_16 *)ere; 2494#ifdef SUPPORT_PCRE16 2495int op; 2496pcre_uint16 *ptr = (pcre_uint16 *)re + re->name_table_offset; 2497int length = re->name_count * re->name_entry_size; 2498#ifdef SUPPORT_UTF 2499BOOL utf = (re->options & PCRE_UTF16) != 0; 2500BOOL utf16_char = FALSE; 2501#endif /* SUPPORT_UTF */ 2502#endif /* SUPPORT_PCRE16 */ 2503 2504/* Always flip the bytes in the main data block and study blocks. */ 2505 2506re->magic_number = REVERSED_MAGIC_NUMBER; 2507re->size = swap_uint32(re->size); 2508re->options = swap_uint32(re->options); 2509re->flags = swap_uint32(re->flags); 2510re->limit_match = swap_uint32(re->limit_match); 2511re->limit_recursion = swap_uint32(re->limit_recursion); 2512re->first_char = swap_uint16(re->first_char); 2513re->req_char = swap_uint16(re->req_char); 2514re->max_lookbehind = swap_uint16(re->max_lookbehind); 2515re->top_bracket = swap_uint16(re->top_bracket); 2516re->top_backref = swap_uint16(re->top_backref); 2517re->name_table_offset = swap_uint16(re->name_table_offset); 2518re->name_entry_size = swap_uint16(re->name_entry_size); 2519re->name_count = swap_uint16(re->name_count); 2520re->ref_count = swap_uint16(re->ref_count); 2521 2522if (extra != NULL) 2523 { 2524 pcre_study_data *rsd = (pcre_study_data *)(extra->study_data); 2525 rsd->size = swap_uint32(rsd->size); 2526 rsd->flags = swap_uint32(rsd->flags); 2527 rsd->minlength = swap_uint32(rsd->minlength); 2528 } 2529 2530/* In 8-bit mode, that is all we need to do. In 16-bit mode we must swap bytes 2531in the name table, if present, and then in the pattern itself. */ 2532 2533#ifdef SUPPORT_PCRE16 2534if (pcre_mode != PCRE16_MODE) return; 2535 2536while(TRUE) 2537 { 2538 /* Swap previous characters. */ 2539 while (length-- > 0) 2540 { 2541 *ptr = swap_uint16(*ptr); 2542 ptr++; 2543 } 2544#ifdef SUPPORT_UTF 2545 if (utf16_char) 2546 { 2547 if ((ptr[-1] & 0xfc00) == 0xd800) 2548 { 2549 /* We know that there is only one extra character in UTF-16. */ 2550 *ptr = swap_uint16(*ptr); 2551 ptr++; 2552 } 2553 } 2554 utf16_char = FALSE; 2555#endif /* SUPPORT_UTF */ 2556 2557 /* Get next opcode. */ 2558 2559 length = 0; 2560 op = *ptr; 2561 *ptr++ = swap_uint16(op); 2562 2563 switch (op) 2564 { 2565 case OP_END: 2566 return; 2567 2568#ifdef SUPPORT_UTF 2569 case OP_CHAR: 2570 case OP_CHARI: 2571 case OP_NOT: 2572 case OP_NOTI: 2573 case OP_STAR: 2574 case OP_MINSTAR: 2575 case OP_PLUS: 2576 case OP_MINPLUS: 2577 case OP_QUERY: 2578 case OP_MINQUERY: 2579 case OP_UPTO: 2580 case OP_MINUPTO: 2581 case OP_EXACT: 2582 case OP_POSSTAR: 2583 case OP_POSPLUS: 2584 case OP_POSQUERY: 2585 case OP_POSUPTO: 2586 case OP_STARI: 2587 case OP_MINSTARI: 2588 case OP_PLUSI: 2589 case OP_MINPLUSI: 2590 case OP_QUERYI: 2591 case OP_MINQUERYI: 2592 case OP_UPTOI: 2593 case OP_MINUPTOI: 2594 case OP_EXACTI: 2595 case OP_POSSTARI: 2596 case OP_POSPLUSI: 2597 case OP_POSQUERYI: 2598 case OP_POSUPTOI: 2599 case OP_NOTSTAR: 2600 case OP_NOTMINSTAR: 2601 case OP_NOTPLUS: 2602 case OP_NOTMINPLUS: 2603 case OP_NOTQUERY: 2604 case OP_NOTMINQUERY: 2605 case OP_NOTUPTO: 2606 case OP_NOTMINUPTO: 2607 case OP_NOTEXACT: 2608 case OP_NOTPOSSTAR: 2609 case OP_NOTPOSPLUS: 2610 case OP_NOTPOSQUERY: 2611 case OP_NOTPOSUPTO: 2612 case OP_NOTSTARI: 2613 case OP_NOTMINSTARI: 2614 case OP_NOTPLUSI: 2615 case OP_NOTMINPLUSI: 2616 case OP_NOTQUERYI: 2617 case OP_NOTMINQUERYI: 2618 case OP_NOTUPTOI: 2619 case OP_NOTMINUPTOI: 2620 case OP_NOTEXACTI: 2621 case OP_NOTPOSSTARI: 2622 case OP_NOTPOSPLUSI: 2623 case OP_NOTPOSQUERYI: 2624 case OP_NOTPOSUPTOI: 2625 if (utf) utf16_char = TRUE; 2626#endif 2627 /* Fall through. */ 2628 2629 default: 2630 length = OP_lengths16[op] - 1; 2631 break; 2632 2633 case OP_CLASS: 2634 case OP_NCLASS: 2635 /* Skip the character bit map. */ 2636 ptr += 32/sizeof(pcre_uint16); 2637 length = 0; 2638 break; 2639 2640 case OP_XCLASS: 2641 /* LINK_SIZE can be 1 or 2 in 16 bit mode. */ 2642 if (LINK_SIZE > 1) 2643 length = (int)((((unsigned int)(ptr[0]) << 16) | (unsigned int)(ptr[1])) 2644 - (1 + LINK_SIZE + 1)); 2645 else 2646 length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1)); 2647 2648 /* Reverse the size of the XCLASS instance. */ 2649 *ptr = swap_uint16(*ptr); 2650 ptr++; 2651 if (LINK_SIZE > 1) 2652 { 2653 *ptr = swap_uint16(*ptr); 2654 ptr++; 2655 } 2656 2657 op = *ptr; 2658 *ptr = swap_uint16(op); 2659 ptr++; 2660 if ((op & XCL_MAP) != 0) 2661 { 2662 /* Skip the character bit map. */ 2663 ptr += 32/sizeof(pcre_uint16); 2664 length -= 32/sizeof(pcre_uint16); 2665 } 2666 break; 2667 } 2668 } 2669/* Control should never reach here in 16 bit mode. */ 2670#endif /* SUPPORT_PCRE16 */ 2671} 2672#endif /* SUPPORT_PCRE[8|16] */ 2673 2674 2675 2676#if defined SUPPORT_PCRE32 2677static void 2678regexflip_32(pcre *ere, pcre_extra *extra) 2679{ 2680real_pcre32 *re = (real_pcre32 *)ere; 2681int op; 2682pcre_uint32 *ptr = (pcre_uint32 *)re + re->name_table_offset; 2683int length = re->name_count * re->name_entry_size; 2684 2685/* Always flip the bytes in the main data block and study blocks. */ 2686 2687re->magic_number = REVERSED_MAGIC_NUMBER; 2688re->size = swap_uint32(re->size); 2689re->options = swap_uint32(re->options); 2690re->flags = swap_uint32(re->flags); 2691re->limit_match = swap_uint32(re->limit_match); 2692re->limit_recursion = swap_uint32(re->limit_recursion); 2693re->first_char = swap_uint32(re->first_char); 2694re->req_char = swap_uint32(re->req_char); 2695re->max_lookbehind = swap_uint16(re->max_lookbehind); 2696re->top_bracket = swap_uint16(re->top_bracket); 2697re->top_backref = swap_uint16(re->top_backref); 2698re->name_table_offset = swap_uint16(re->name_table_offset); 2699re->name_entry_size = swap_uint16(re->name_entry_size); 2700re->name_count = swap_uint16(re->name_count); 2701re->ref_count = swap_uint16(re->ref_count); 2702 2703if (extra != NULL) 2704 { 2705 pcre_study_data *rsd = (pcre_study_data *)(extra->study_data); 2706 rsd->size = swap_uint32(rsd->size); 2707 rsd->flags = swap_uint32(rsd->flags); 2708 rsd->minlength = swap_uint32(rsd->minlength); 2709 } 2710 2711/* In 32-bit mode we must swap bytes in the name table, if present, and then in 2712the pattern itself. */ 2713 2714while(TRUE) 2715 { 2716 /* Swap previous characters. */ 2717 while (length-- > 0) 2718 { 2719 *ptr = swap_uint32(*ptr); 2720 ptr++; 2721 } 2722 2723 /* Get next opcode. */ 2724 2725 length = 0; 2726 op = *ptr; 2727 *ptr++ = swap_uint32(op); 2728 2729 switch (op) 2730 { 2731 case OP_END: 2732 return; 2733 2734 default: 2735 length = OP_lengths32[op] - 1; 2736 break; 2737 2738 case OP_CLASS: 2739 case OP_NCLASS: 2740 /* Skip the character bit map. */ 2741 ptr += 32/sizeof(pcre_uint32); 2742 length = 0; 2743 break; 2744 2745 case OP_XCLASS: 2746 /* LINK_SIZE can only be 1 in 32-bit mode. */ 2747 length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1)); 2748 2749 /* Reverse the size of the XCLASS instance. */ 2750 *ptr = swap_uint32(*ptr); 2751 ptr++; 2752 2753 op = *ptr; 2754 *ptr = swap_uint32(op); 2755 ptr++; 2756 if ((op & XCL_MAP) != 0) 2757 { 2758 /* Skip the character bit map. */ 2759 ptr += 32/sizeof(pcre_uint32); 2760 length -= 32/sizeof(pcre_uint32); 2761 } 2762 break; 2763 } 2764 } 2765/* Control should never reach here in 32 bit mode. */ 2766} 2767 2768#endif /* SUPPORT_PCRE32 */ 2769 2770 2771 2772static void 2773regexflip(pcre *ere, pcre_extra *extra) 2774{ 2775#if defined SUPPORT_PCRE32 2776 if (REAL_PCRE_FLAGS(ere) & PCRE_MODE32) 2777 regexflip_32(ere, extra); 2778#endif 2779#if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16 2780 if (REAL_PCRE_FLAGS(ere) & (PCRE_MODE8 | PCRE_MODE16)) 2781 regexflip8_or_16(ere, extra); 2782#endif 2783} 2784 2785 2786 2787/************************************************* 2788* Check match or recursion limit * 2789*************************************************/ 2790 2791static int 2792check_match_limit(pcre *re, pcre_extra *extra, pcre_uint8 *bptr, int len, 2793 int start_offset, int options, int *use_offsets, int use_size_offsets, 2794 int flag, unsigned long int *limit, int errnumber, const char *msg) 2795{ 2796int count; 2797int min = 0; 2798int mid = 64; 2799int max = -1; 2800 2801extra->flags |= flag; 2802 2803for (;;) 2804 { 2805 *limit = mid; 2806 2807 PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, 2808 use_offsets, use_size_offsets); 2809 2810 if (count == errnumber) 2811 { 2812 /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */ 2813 min = mid; 2814 mid = (mid == max - 1)? max : (max > 0)? (min + max)/2 : mid*2; 2815 } 2816 2817 else if (count >= 0 || count == PCRE_ERROR_NOMATCH || 2818 count == PCRE_ERROR_PARTIAL) 2819 { 2820 if (mid == min + 1) 2821 { 2822 fprintf(outfile, "Minimum %s limit = %d\n", msg, mid); 2823 break; 2824 } 2825 /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */ 2826 max = mid; 2827 mid = (min + mid)/2; 2828 } 2829 else break; /* Some other error */ 2830 } 2831 2832extra->flags &= ~flag; 2833return count; 2834} 2835 2836 2837 2838/************************************************* 2839* Case-independent strncmp() function * 2840*************************************************/ 2841 2842/* 2843Arguments: 2844 s first string 2845 t second string 2846 n number of characters to compare 2847 2848Returns: < 0, = 0, or > 0, according to the comparison 2849*/ 2850 2851static int 2852strncmpic(pcre_uint8 *s, pcre_uint8 *t, int n) 2853{ 2854while (n--) 2855 { 2856 int c = tolower(*s++) - tolower(*t++); 2857 if (c) return c; 2858 } 2859return 0; 2860} 2861 2862 2863 2864/************************************************* 2865* Check multicharacter option * 2866*************************************************/ 2867 2868/* This is used both at compile and run-time to check for <xxx> escapes. Print 2869a message and return 0 if there is no match. 2870 2871Arguments: 2872 p points after the leading '<' 2873 f file for error message 2874 nl TRUE to check only for newline settings 2875 stype "modifier" or "escape sequence" 2876 2877Returns: appropriate PCRE_NEWLINE_xxx flags, or 0 2878*/ 2879 2880static int 2881check_mc_option(pcre_uint8 *p, FILE *f, BOOL nl, const char *stype) 2882{ 2883if (strncmpic(p, (pcre_uint8 *)"cr>", 3) == 0) return PCRE_NEWLINE_CR; 2884if (strncmpic(p, (pcre_uint8 *)"lf>", 3) == 0) return PCRE_NEWLINE_LF; 2885if (strncmpic(p, (pcre_uint8 *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF; 2886if (strncmpic(p, (pcre_uint8 *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF; 2887if (strncmpic(p, (pcre_uint8 *)"any>", 4) == 0) return PCRE_NEWLINE_ANY; 2888if (strncmpic(p, (pcre_uint8 *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF; 2889if (strncmpic(p, (pcre_uint8 *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE; 2890 2891if (!nl) 2892 { 2893 if (strncmpic(p, (pcre_uint8 *)"JS>", 3) == 0) return PCRE_JAVASCRIPT_COMPAT; 2894 } 2895 2896fprintf(f, "Unknown %s at: <%s\n", stype, p); 2897return 0; 2898} 2899 2900 2901 2902/************************************************* 2903* Usage function * 2904*************************************************/ 2905 2906static void 2907usage(void) 2908{ 2909printf("Usage: pcretest [options] [<input file> [<output file>]]\n\n"); 2910printf("Input and output default to stdin and stdout.\n"); 2911#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 2912printf("If input is a terminal, readline() is used to read from it.\n"); 2913#else 2914printf("This version of pcretest is not linked with readline().\n"); 2915#endif 2916printf("\nOptions:\n"); 2917#ifdef SUPPORT_PCRE16 2918printf(" -16 use the 16-bit library\n"); 2919#endif 2920#ifdef SUPPORT_PCRE32 2921printf(" -32 use the 32-bit library\n"); 2922#endif 2923printf(" -b show compiled code\n"); 2924printf(" -C show PCRE compile-time options and exit\n"); 2925printf(" -C arg show a specific compile-time option and exit\n"); 2926printf(" with its value if numeric (else 0). The arg can be:\n"); 2927printf(" linksize internal link size [2, 3, 4]\n"); 2928printf(" pcre8 8 bit library support enabled [0, 1]\n"); 2929printf(" pcre16 16 bit library support enabled [0, 1]\n"); 2930printf(" pcre32 32 bit library support enabled [0, 1]\n"); 2931printf(" utf Unicode Transformation Format supported [0, 1]\n"); 2932printf(" ucp Unicode Properties supported [0, 1]\n"); 2933printf(" jit Just-in-time compiler supported [0, 1]\n"); 2934printf(" newline Newline type [CR, LF, CRLF, ANYCRLF, ANY]\n"); 2935printf(" bsr \\R type [ANYCRLF, ANY]\n"); 2936printf(" -d debug: show compiled code and information (-b and -i)\n"); 2937#if !defined NODFA 2938printf(" -dfa force DFA matching for all subjects\n"); 2939#endif 2940printf(" -help show usage information\n"); 2941printf(" -i show information about compiled patterns\n" 2942 " -M find MATCH_LIMIT minimum for each subject\n" 2943 " -m output memory used information\n" 2944 " -O set PCRE_NO_AUTO_POSSESS on each pattern\n" 2945 " -o <n> set size of offsets vector to <n>\n"); 2946#if !defined NOPOSIX 2947printf(" -p use POSIX interface\n"); 2948#endif 2949printf(" -q quiet: do not output PCRE version number at start\n"); 2950printf(" -S <n> set stack size to <n> megabytes\n"); 2951printf(" -s force each pattern to be studied at basic level\n" 2952 " -s+ force each pattern to be studied, using JIT if available\n" 2953 " -s++ ditto, verifying when JIT was actually used\n" 2954 " -s+n force each pattern to be studied, using JIT if available,\n" 2955 " where 1 <= n <= 7 selects JIT options\n" 2956 " -s++n ditto, verifying when JIT was actually used\n" 2957 " -t time compilation and execution\n"); 2958printf(" -t <n> time compilation and execution, repeating <n> times\n"); 2959printf(" -tm time execution (matching) only\n"); 2960printf(" -tm <n> time execution (matching) only, repeating <n> times\n"); 2961printf(" -T same as -t, but show total times at the end\n"); 2962printf(" -TM same as -tm, but show total time at the end\n"); 2963} 2964 2965 2966 2967/************************************************* 2968* Main Program * 2969*************************************************/ 2970 2971/* Read lines from named file or stdin and write to named file or stdout; lines 2972consist of a regular expression, in delimiters and optionally followed by 2973options, followed by a set of test data, terminated by an empty line. */ 2974 2975int main(int argc, char **argv) 2976{ 2977FILE *infile = stdin; 2978const char *version; 2979int options = 0; 2980int study_options = 0; 2981int default_find_match_limit = FALSE; 2982pcre_uint32 default_options = 0; 2983int op = 1; 2984int timeit = 0; 2985int timeitm = 0; 2986int showtotaltimes = 0; 2987int showinfo = 0; 2988int showstore = 0; 2989int force_study = -1; 2990int force_study_options = 0; 2991int quiet = 0; 2992int size_offsets = 45; 2993int size_offsets_max; 2994int *offsets = NULL; 2995int debug = 0; 2996int done = 0; 2997int all_use_dfa = 0; 2998int verify_jit = 0; 2999int yield = 0; 3000int stack_size; 3001pcre_uint8 *dbuffer = NULL; 3002pcre_uint8 lockout[24] = { 0 }; 3003size_t dbuffer_size = 1u << 14; 3004clock_t total_compile_time = 0; 3005clock_t total_study_time = 0; 3006clock_t total_match_time = 0; 3007 3008#if !defined NOPOSIX 3009int posix = 0; 3010#endif 3011#if !defined NODFA 3012int *dfa_workspace = NULL; 3013#endif 3014 3015pcre_jit_stack *jit_stack = NULL; 3016 3017/* These vectors store, end-to-end, a list of zero-terminated captured 3018substring names, each list itself being terminated by an empty name. Assume 3019that 1024 is plenty long enough for the few names we'll be testing. It is 3020easiest to keep separate 8-, 16- and 32-bit versions, using the 32-bit version 3021for the actual memory, to ensure alignment. */ 3022 3023pcre_uint32 copynames[1024]; 3024pcre_uint32 getnames[1024]; 3025 3026#ifdef SUPPORT_PCRE32 3027pcre_uint32 *cn32ptr; 3028pcre_uint32 *gn32ptr; 3029#endif 3030 3031#ifdef SUPPORT_PCRE16 3032pcre_uint16 *copynames16 = (pcre_uint16 *)copynames; 3033pcre_uint16 *getnames16 = (pcre_uint16 *)getnames; 3034pcre_uint16 *cn16ptr; 3035pcre_uint16 *gn16ptr; 3036#endif 3037 3038#ifdef SUPPORT_PCRE8 3039pcre_uint8 *copynames8 = (pcre_uint8 *)copynames; 3040pcre_uint8 *getnames8 = (pcre_uint8 *)getnames; 3041pcre_uint8 *cn8ptr; 3042pcre_uint8 *gn8ptr; 3043#endif 3044 3045/* Get buffers from malloc() so that valgrind will check their misuse when 3046debugging. They grow automatically when very long lines are read. The 16- 3047and 32-bit buffers (buffer16, buffer32) are obtained only if needed. */ 3048 3049buffer = (pcre_uint8 *)malloc(buffer_size); 3050pbuffer = (pcre_uint8 *)malloc(buffer_size); 3051 3052/* The outfile variable is static so that new_malloc can use it. */ 3053 3054outfile = stdout; 3055 3056/* The following _setmode() stuff is some Windows magic that tells its runtime 3057library to translate CRLF into a single LF character. At least, that's what 3058I've been told: never having used Windows I take this all on trust. Originally 3059it set 0x8000, but then I was advised that _O_BINARY was better. */ 3060 3061#if defined(_WIN32) || defined(WIN32) 3062_setmode( _fileno( stdout ), _O_BINARY ); 3063#endif 3064 3065/* Get the version number: both pcre_version() and pcre16_version() give the 3066same answer. We just need to ensure that we call one that is available. */ 3067 3068#if defined SUPPORT_PCRE8 3069version = pcre_version(); 3070#elif defined SUPPORT_PCRE16 3071version = pcre16_version(); 3072#elif defined SUPPORT_PCRE32 3073version = pcre32_version(); 3074#endif 3075 3076/* Scan options */ 3077 3078while (argc > 1 && argv[op][0] == '-') 3079 { 3080 pcre_uint8 *endptr; 3081 char *arg = argv[op]; 3082 3083 if (strcmp(arg, "-m") == 0) showstore = 1; 3084 else if (strcmp(arg, "-s") == 0) force_study = 0; 3085 3086 else if (strncmp(arg, "-s+", 3) == 0) 3087 { 3088 arg += 3; 3089 if (*arg == '+') { arg++; verify_jit = TRUE; } 3090 force_study = 1; 3091 if (*arg == 0) 3092 force_study_options = jit_study_bits[6]; 3093 else if (*arg >= '1' && *arg <= '7') 3094 force_study_options = jit_study_bits[*arg - '1']; 3095 else goto BAD_ARG; 3096 } 3097 else if (strcmp(arg, "-8") == 0) 3098 { 3099#ifdef SUPPORT_PCRE8 3100 pcre_mode = PCRE8_MODE; 3101#else 3102 printf("** This version of PCRE was built without 8-bit support\n"); 3103 exit(1); 3104#endif 3105 } 3106 else if (strcmp(arg, "-16") == 0) 3107 { 3108#ifdef SUPPORT_PCRE16 3109 pcre_mode = PCRE16_MODE; 3110#else 3111 printf("** This version of PCRE was built without 16-bit support\n"); 3112 exit(1); 3113#endif 3114 } 3115 else if (strcmp(arg, "-32") == 0) 3116 { 3117#ifdef SUPPORT_PCRE32 3118 pcre_mode = PCRE32_MODE; 3119#else 3120 printf("** This version of PCRE was built without 32-bit support\n"); 3121 exit(1); 3122#endif 3123 } 3124 else if (strcmp(arg, "-q") == 0) quiet = 1; 3125 else if (strcmp(arg, "-b") == 0) debug = 1; 3126 else if (strcmp(arg, "-i") == 0) showinfo = 1; 3127 else if (strcmp(arg, "-d") == 0) showinfo = debug = 1; 3128 else if (strcmp(arg, "-M") == 0) default_find_match_limit = TRUE; 3129 else if (strcmp(arg, "-O") == 0) default_options |= PCRE_NO_AUTO_POSSESS; 3130#if !defined NODFA 3131 else if (strcmp(arg, "-dfa") == 0) all_use_dfa = 1; 3132#endif 3133 else if (strcmp(arg, "-o") == 0 && argc > 2 && 3134 ((size_offsets = get_value((pcre_uint8 *)argv[op+1], &endptr)), 3135 *endptr == 0)) 3136 { 3137 op++; 3138 argc--; 3139 } 3140 else if (strcmp(arg, "-t") == 0 || strcmp(arg, "-tm") == 0 || 3141 strcmp(arg, "-T") == 0 || strcmp(arg, "-TM") == 0) 3142 { 3143 int temp; 3144 int both = arg[2] == 0; 3145 showtotaltimes = arg[1] == 'T'; 3146 if (argc > 2 && (temp = get_value((pcre_uint8 *)argv[op+1], &endptr), 3147 *endptr == 0)) 3148 { 3149 timeitm = temp; 3150 op++; 3151 argc--; 3152 } 3153 else timeitm = LOOPREPEAT; 3154 if (both) timeit = timeitm; 3155 } 3156 else if (strcmp(arg, "-S") == 0 && argc > 2 && 3157 ((stack_size = get_value((pcre_uint8 *)argv[op+1], &endptr)), 3158 *endptr == 0)) 3159 { 3160#if defined(_WIN32) || defined(WIN32) || defined(__minix) || defined(NATIVE_ZOS) || defined(__VMS) 3161 printf("PCRE: -S not supported on this OS\n"); 3162 exit(1); 3163#else 3164 int rc; 3165 struct rlimit rlim; 3166 getrlimit(RLIMIT_STACK, &rlim); 3167 rlim.rlim_cur = stack_size * 1024 * 1024; 3168 rc = setrlimit(RLIMIT_STACK, &rlim); 3169 if (rc != 0) 3170 { 3171 printf("PCRE: setrlimit() failed with error %d\n", rc); 3172 exit(1); 3173 } 3174 op++; 3175 argc--; 3176#endif 3177 } 3178#if !defined NOPOSIX 3179 else if (strcmp(arg, "-p") == 0) posix = 1; 3180#endif 3181 else if (strcmp(arg, "-C") == 0) 3182 { 3183 int rc; 3184 unsigned long int lrc; 3185 3186 if (argc > 2) 3187 { 3188 if (strcmp(argv[op + 1], "linksize") == 0) 3189 { 3190 (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc); 3191 printf("%d\n", rc); 3192 yield = rc; 3193 3194#ifdef __VMS 3195 vms_setsymbol("LINKSIZE",0,yield ); 3196#endif 3197 } 3198 else if (strcmp(argv[op + 1], "pcre8") == 0) 3199 { 3200#ifdef SUPPORT_PCRE8 3201 printf("1\n"); 3202 yield = 1; 3203#else 3204 printf("0\n"); 3205 yield = 0; 3206#endif 3207#ifdef __VMS 3208 vms_setsymbol("PCRE8",0,yield ); 3209#endif 3210 } 3211 else if (strcmp(argv[op + 1], "pcre16") == 0) 3212 { 3213#ifdef SUPPORT_PCRE16 3214 printf("1\n"); 3215 yield = 1; 3216#else 3217 printf("0\n"); 3218 yield = 0; 3219#endif 3220#ifdef __VMS 3221 vms_setsymbol("PCRE16",0,yield ); 3222#endif 3223 } 3224 else if (strcmp(argv[op + 1], "pcre32") == 0) 3225 { 3226#ifdef SUPPORT_PCRE32 3227 printf("1\n"); 3228 yield = 1; 3229#else 3230 printf("0\n"); 3231 yield = 0; 3232#endif 3233#ifdef __VMS 3234 vms_setsymbol("PCRE32",0,yield ); 3235#endif 3236 } 3237 else if (strcmp(argv[op + 1], "utf") == 0) 3238 { 3239#ifdef SUPPORT_PCRE8 3240 if (pcre_mode == PCRE8_MODE) 3241 (void)pcre_config(PCRE_CONFIG_UTF8, &rc); 3242#endif 3243#ifdef SUPPORT_PCRE16 3244 if (pcre_mode == PCRE16_MODE) 3245 (void)pcre16_config(PCRE_CONFIG_UTF16, &rc); 3246#endif 3247#ifdef SUPPORT_PCRE32 3248 if (pcre_mode == PCRE32_MODE) 3249 (void)pcre32_config(PCRE_CONFIG_UTF32, &rc); 3250#endif 3251 printf("%d\n", rc); 3252 yield = rc; 3253#ifdef __VMS 3254 vms_setsymbol("UTF",0,yield ); 3255#endif 3256 } 3257 else if (strcmp(argv[op + 1], "ucp") == 0) 3258 { 3259 (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc); 3260 printf("%d\n", rc); 3261 yield = rc; 3262 } 3263 else if (strcmp(argv[op + 1], "jit") == 0) 3264 { 3265 (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc); 3266 printf("%d\n", rc); 3267 yield = rc; 3268 } 3269 else if (strcmp(argv[op + 1], "newline") == 0) 3270 { 3271 (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc); 3272 print_newline_config(rc, TRUE); 3273 } 3274 else if (strcmp(argv[op + 1], "bsr") == 0) 3275 { 3276 (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc); 3277 printf("%s\n", rc? "ANYCRLF" : "ANY"); 3278 } 3279 else if (strcmp(argv[op + 1], "ebcdic") == 0) 3280 { 3281#ifdef EBCDIC 3282 printf("1\n"); 3283 yield = 1; 3284#else 3285 printf("0\n"); 3286#endif 3287 } 3288 else if (strcmp(argv[op + 1], "ebcdic-nl") == 0) 3289 { 3290#ifdef EBCDIC 3291 printf("0x%02x\n", CHAR_LF); 3292#else 3293 printf("0\n"); 3294#endif 3295 } 3296 else 3297 { 3298 printf("Unknown -C option: %s\n", argv[op + 1]); 3299 } 3300 goto EXIT; 3301 } 3302 3303 /* No argument for -C: output all configuration information. */ 3304 3305 printf("PCRE version %s\n", version); 3306 printf("Compiled with\n"); 3307 3308#ifdef EBCDIC 3309 printf(" EBCDIC code support: LF is 0x%02x\n", CHAR_LF); 3310#endif 3311 3312/* At least one of SUPPORT_PCRE8 and SUPPORT_PCRE16 will be set. If both 3313are set, either both UTFs are supported or both are not supported. */ 3314 3315#ifdef SUPPORT_PCRE8 3316 printf(" 8-bit support\n"); 3317 (void)pcre_config(PCRE_CONFIG_UTF8, &rc); 3318 printf (" %sUTF-8 support\n", rc ? "" : "No "); 3319#endif 3320#ifdef SUPPORT_PCRE16 3321 printf(" 16-bit support\n"); 3322 (void)pcre16_config(PCRE_CONFIG_UTF16, &rc); 3323 printf (" %sUTF-16 support\n", rc ? "" : "No "); 3324#endif 3325#ifdef SUPPORT_PCRE32 3326 printf(" 32-bit support\n"); 3327 (void)pcre32_config(PCRE_CONFIG_UTF32, &rc); 3328 printf (" %sUTF-32 support\n", rc ? "" : "No "); 3329#endif 3330 3331 (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc); 3332 printf(" %sUnicode properties support\n", rc? "" : "No "); 3333 (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc); 3334 if (rc) 3335 { 3336 const char *arch; 3337 (void)PCRE_CONFIG(PCRE_CONFIG_JITTARGET, (void *)(&arch)); 3338 printf(" Just-in-time compiler support: %s\n", arch); 3339 } 3340 else 3341 printf(" No just-in-time compiler support\n"); 3342 (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc); 3343 print_newline_config(rc, FALSE); 3344 (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc); 3345 printf(" \\R matches %s\n", rc? "CR, LF, or CRLF only" : 3346 "all Unicode newlines"); 3347 (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc); 3348 printf(" Internal link size = %d\n", rc); 3349 (void)PCRE_CONFIG(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc); 3350 printf(" POSIX malloc threshold = %d\n", rc); 3351 (void)PCRE_CONFIG(PCRE_CONFIG_PARENS_LIMIT, &lrc); 3352 printf(" Parentheses nest limit = %ld\n", lrc); 3353 (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT, &lrc); 3354 printf(" Default match limit = %ld\n", lrc); 3355 (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &lrc); 3356 printf(" Default recursion depth limit = %ld\n", lrc); 3357 (void)PCRE_CONFIG(PCRE_CONFIG_STACKRECURSE, &rc); 3358 printf(" Match recursion uses %s", rc? "stack" : "heap"); 3359 if (showstore) 3360 { 3361 PCRE_EXEC(stack_size, NULL, NULL, NULL, -999, -999, 0, NULL, 0); 3362 printf(": %sframe size = %d bytes", rc? "approximate " : "", -stack_size); 3363 } 3364 printf("\n"); 3365 goto EXIT; 3366 } 3367 else if (strcmp(arg, "-help") == 0 || 3368 strcmp(arg, "--help") == 0) 3369 { 3370 usage(); 3371 goto EXIT; 3372 } 3373 else 3374 { 3375 BAD_ARG: 3376 printf("** Unknown or malformed option %s\n", arg); 3377 usage(); 3378 yield = 1; 3379 goto EXIT; 3380 } 3381 op++; 3382 argc--; 3383 } 3384 3385/* Get the store for the offsets vector, and remember what it was */ 3386 3387size_offsets_max = size_offsets; 3388offsets = (int *)malloc(size_offsets_max * sizeof(int)); 3389if (offsets == NULL) 3390 { 3391 printf("** Failed to get %d bytes of memory for offsets vector\n", 3392 (int)(size_offsets_max * sizeof(int))); 3393 yield = 1; 3394 goto EXIT; 3395 } 3396 3397/* Sort out the input and output files */ 3398 3399if (argc > 1) 3400 { 3401 infile = fopen(argv[op], INPUT_MODE); 3402 if (infile == NULL) 3403 { 3404 printf("** Failed to open %s\n", argv[op]); 3405 yield = 1; 3406 goto EXIT; 3407 } 3408 } 3409 3410if (argc > 2) 3411 { 3412 outfile = fopen(argv[op+1], OUTPUT_MODE); 3413 if (outfile == NULL) 3414 { 3415 printf("** Failed to open %s\n", argv[op+1]); 3416 yield = 1; 3417 goto EXIT; 3418 } 3419 } 3420 3421/* Set alternative malloc function */ 3422 3423#ifdef SUPPORT_PCRE8 3424pcre_malloc = new_malloc; 3425pcre_free = new_free; 3426pcre_stack_malloc = stack_malloc; 3427pcre_stack_free = stack_free; 3428#endif 3429 3430#ifdef SUPPORT_PCRE16 3431pcre16_malloc = new_malloc; 3432pcre16_free = new_free; 3433pcre16_stack_malloc = stack_malloc; 3434pcre16_stack_free = stack_free; 3435#endif 3436 3437#ifdef SUPPORT_PCRE32 3438pcre32_malloc = new_malloc; 3439pcre32_free = new_free; 3440pcre32_stack_malloc = stack_malloc; 3441pcre32_stack_free = stack_free; 3442#endif 3443 3444/* Heading line unless quiet */ 3445 3446if (!quiet) fprintf(outfile, "PCRE version %s\n\n", version); 3447 3448/* Main loop */ 3449 3450while (!done) 3451 { 3452 pcre *re = NULL; 3453 pcre_extra *extra = NULL; 3454 3455#if !defined NOPOSIX /* There are still compilers that require no indent */ 3456 regex_t preg; 3457 int do_posix = 0; 3458#endif 3459 3460 const char *error; 3461 pcre_uint8 *markptr; 3462 pcre_uint8 *p, *pp, *ppp; 3463 pcre_uint8 *to_file = NULL; 3464 const pcre_uint8 *tables = NULL; 3465 unsigned long int get_options; 3466 unsigned long int true_size, true_study_size = 0; 3467 size_t size; 3468 int do_allcaps = 0; 3469 int do_mark = 0; 3470 int do_study = 0; 3471 int no_force_study = 0; 3472 int do_debug = debug; 3473 int do_G = 0; 3474 int do_g = 0; 3475 int do_showinfo = showinfo; 3476 int do_showrest = 0; 3477 int do_showcaprest = 0; 3478 int do_flip = 0; 3479 int erroroffset, len, delimiter, poffset; 3480 3481#if !defined NODFA 3482 int dfa_matched = 0; 3483#endif 3484 3485 use_utf = 0; 3486 debug_lengths = 1; 3487 SET_PCRE_STACK_GUARD(NULL); 3488 3489 if (extend_inputline(infile, buffer, " re> ") == NULL) break; 3490 if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); 3491 fflush(outfile); 3492 3493 p = buffer; 3494 while (isspace(*p)) p++; 3495 if (*p == 0) continue; 3496 3497 /* Handle option lock-out setting */ 3498 3499 if (*p == '<' && p[1] == ' ') 3500 { 3501 p += 2; 3502 while (isspace(*p)) p++; 3503 if (strncmp((char *)p, "forbid ", 7) == 0) 3504 { 3505 p += 7; 3506 while (isspace(*p)) p++; 3507 pp = lockout; 3508 while (!isspace(*p) && pp < lockout + sizeof(lockout) - 1) 3509 *pp++ = *p++; 3510 *pp = 0; 3511 } 3512 else 3513 { 3514 printf("** Unrecognized special command '%s'\n", p); 3515 yield = 1; 3516 goto EXIT; 3517 } 3518 continue; 3519 } 3520 3521 /* See if the pattern is to be loaded pre-compiled from a file. */ 3522 3523 if (*p == '<' && strchr((char *)(p+1), '<') == NULL) 3524 { 3525 pcre_uint32 magic; 3526 pcre_uint8 sbuf[8]; 3527 FILE *f; 3528 3529 p++; 3530 if (*p == '!') 3531 { 3532 do_debug = TRUE; 3533 do_showinfo = TRUE; 3534 p++; 3535 } 3536 3537 pp = p + (int)strlen((char *)p); 3538 while (isspace(pp[-1])) pp--; 3539 *pp = 0; 3540 3541 f = fopen((char *)p, "rb"); 3542 if (f == NULL) 3543 { 3544 fprintf(outfile, "Failed to open %s: %s\n", p, strerror(errno)); 3545 continue; 3546 } 3547 if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ; 3548 3549 true_size = 3550 (sbuf[0] << 24) | (sbuf[1] << 16) | (sbuf[2] << 8) | sbuf[3]; 3551 true_study_size = 3552 (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7]; 3553 3554 re = (pcre *)new_malloc(true_size); 3555 if (re == NULL) 3556 { 3557 printf("** Failed to get %d bytes of memory for pcre object\n", 3558 (int)true_size); 3559 yield = 1; 3560 goto EXIT; 3561 } 3562 if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ; 3563 3564 magic = REAL_PCRE_MAGIC(re); 3565 if (magic != MAGIC_NUMBER) 3566 { 3567 if (swap_uint32(magic) == MAGIC_NUMBER) 3568 { 3569 do_flip = 1; 3570 } 3571 else 3572 { 3573 fprintf(outfile, "Data in %s is not a compiled PCRE regex\n", p); 3574 new_free(re); 3575 fclose(f); 3576 continue; 3577 } 3578 } 3579 3580 /* We hide the byte-invert info for little and big endian tests. */ 3581 fprintf(outfile, "Compiled pattern%s loaded from %s\n", 3582 do_flip && (p[-1] == '<') ? " (byte-inverted)" : "", p); 3583 3584 /* Now see if there is any following study data. */ 3585 3586 if (true_study_size != 0) 3587 { 3588 pcre_study_data *psd; 3589 3590 extra = (pcre_extra *)new_malloc(sizeof(pcre_extra) + true_study_size); 3591 extra->flags = PCRE_EXTRA_STUDY_DATA; 3592 3593 psd = (pcre_study_data *)(((char *)extra) + sizeof(pcre_extra)); 3594 extra->study_data = psd; 3595 3596 if (fread(psd, 1, true_study_size, f) != true_study_size) 3597 { 3598 FAIL_READ: 3599 fprintf(outfile, "Failed to read data from %s\n", p); 3600 if (extra != NULL) 3601 { 3602 PCRE_FREE_STUDY(extra); 3603 } 3604 new_free(re); 3605 fclose(f); 3606 continue; 3607 } 3608 fprintf(outfile, "Study data loaded from %s\n", p); 3609 do_study = 1; /* To get the data output if requested */ 3610 } 3611 else fprintf(outfile, "No study data\n"); 3612 3613 /* Flip the necessary bytes. */ 3614 if (do_flip) 3615 { 3616 int rc; 3617 PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, NULL); 3618 if (rc == PCRE_ERROR_BADMODE) 3619 { 3620 pcre_uint32 flags_in_host_byte_order; 3621 if (REAL_PCRE_MAGIC(re) == MAGIC_NUMBER) 3622 flags_in_host_byte_order = REAL_PCRE_FLAGS(re); 3623 else 3624 flags_in_host_byte_order = swap_uint32(REAL_PCRE_FLAGS(re)); 3625 /* Simulate the result of the function call below. */ 3626 fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc, 3627 pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", 3628 PCRE_INFO_OPTIONS); 3629 fprintf(outfile, "Running in %d-bit mode but pattern was compiled in " 3630 "%d-bit mode\n", 8 * CHAR_SIZE, 8 * (flags_in_host_byte_order & PCRE_MODE_MASK)); 3631 new_free(re); 3632 fclose(f); 3633 continue; 3634 } 3635 } 3636 3637 /* Need to know if UTF-8 for printing data strings. */ 3638 3639 if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0) 3640 { 3641 new_free(re); 3642 fclose(f); 3643 continue; 3644 } 3645 use_utf = (get_options & PCRE_UTF8) != 0; 3646 3647 fclose(f); 3648 goto SHOW_INFO; 3649 } 3650 3651 /* In-line pattern (the usual case). Get the delimiter and seek the end of 3652 the pattern; if it isn't complete, read more. */ 3653 3654 delimiter = *p++; 3655 3656 if (isalnum(delimiter) || delimiter == '\\') 3657 { 3658 fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n"); 3659 goto SKIP_DATA; 3660 } 3661 3662 pp = p; 3663 poffset = (int)(p - buffer); 3664 3665 for(;;) 3666 { 3667 while (*pp != 0) 3668 { 3669 if (*pp == '\\' && pp[1] != 0) pp++; 3670 else if (*pp == delimiter) break; 3671 pp++; 3672 } 3673 if (*pp != 0) break; 3674 if ((pp = extend_inputline(infile, pp, " > ")) == NULL) 3675 { 3676 fprintf(outfile, "** Unexpected EOF\n"); 3677 done = 1; 3678 goto CONTINUE; 3679 } 3680 if (infile != stdin) fprintf(outfile, "%s", (char *)pp); 3681 } 3682 3683 /* The buffer may have moved while being extended; reset the start of data 3684 pointer to the correct relative point in the buffer. */ 3685 3686 p = buffer + poffset; 3687 3688 /* If the first character after the delimiter is backslash, make 3689 the pattern end with backslash. This is purely to provide a way 3690 of testing for the error message when a pattern ends with backslash. */ 3691 3692 if (pp[1] == '\\') *pp++ = '\\'; 3693 3694 /* Terminate the pattern at the delimiter, and save a copy of the pattern 3695 for callouts. */ 3696 3697 *pp++ = 0; 3698 strcpy((char *)pbuffer, (char *)p); 3699 3700 /* Look for modifiers and options after the final delimiter. */ 3701 3702 options = default_options; 3703 study_options = force_study_options; 3704 log_store = showstore; /* default from command line */ 3705 3706 while (*pp != 0) 3707 { 3708 /* Check to see whether this modifier has been locked out for this file. 3709 This is complicated for the multi-character options that begin with '<'. 3710 If there is no '>' in the lockout string, all multi-character modifiers are 3711 locked out. */ 3712 3713 if (strchr((char *)lockout, *pp) != NULL) 3714 { 3715 if (*pp == '<' && strchr((char *)lockout, '>') != NULL) 3716 { 3717 int x = check_mc_option(pp+1, outfile, FALSE, "modifier"); 3718 if (x == 0) goto SKIP_DATA; 3719 3720 for (ppp = lockout; *ppp != 0; ppp++) 3721 { 3722 if (*ppp == '<') 3723 { 3724 int y = check_mc_option(ppp+1, outfile, FALSE, "modifier"); 3725 if (y == 0) 3726 { 3727 printf("** Error in modifier forbid data - giving up.\n"); 3728 yield = 1; 3729 goto EXIT; 3730 } 3731 if (x == y) 3732 { 3733 ppp = pp; 3734 while (*ppp != '>') ppp++; 3735 printf("** The %.*s modifier is locked out - giving up.\n", 3736 (int)(ppp - pp + 1), pp); 3737 yield = 1; 3738 goto EXIT; 3739 } 3740 } 3741 } 3742 } 3743 3744 /* The single-character modifiers are straightforward. */ 3745 3746 else 3747 { 3748 printf("** The /%c modifier is locked out - giving up.\n", *pp); 3749 yield = 1; 3750 goto EXIT; 3751 } 3752 } 3753 3754 /* The modifier is not locked out; handle it. */ 3755 3756 switch (*pp++) 3757 { 3758 case 'f': options |= PCRE_FIRSTLINE; break; 3759 case 'g': do_g = 1; break; 3760 case 'i': options |= PCRE_CASELESS; break; 3761 case 'm': options |= PCRE_MULTILINE; break; 3762 case 's': options |= PCRE_DOTALL; break; 3763 case 'x': options |= PCRE_EXTENDED; break; 3764 3765 case '+': 3766 if (do_showrest) do_showcaprest = 1; else do_showrest = 1; 3767 break; 3768 3769 case '=': do_allcaps = 1; break; 3770 case 'A': options |= PCRE_ANCHORED; break; 3771 case 'B': do_debug = 1; break; 3772 case 'C': options |= PCRE_AUTO_CALLOUT; break; 3773 case 'D': do_debug = do_showinfo = 1; break; 3774 case 'E': options |= PCRE_DOLLAR_ENDONLY; break; 3775 case 'F': do_flip = 1; break; 3776 case 'G': do_G = 1; break; 3777 case 'I': do_showinfo = 1; break; 3778 case 'J': options |= PCRE_DUPNAMES; break; 3779 case 'K': do_mark = 1; break; 3780 case 'M': log_store = 1; break; 3781 case 'N': options |= PCRE_NO_AUTO_CAPTURE; break; 3782 case 'O': options |= PCRE_NO_AUTO_POSSESS; break; 3783 3784#if !defined NOPOSIX 3785 case 'P': do_posix = 1; break; 3786#endif 3787 3788 case 'Q': 3789 switch (*pp) 3790 { 3791 case '0': 3792 case '1': 3793 stack_guard_return = *pp++ - '0'; 3794 break; 3795 3796 default: 3797 fprintf(outfile, "** Missing 0 or 1 after /Q\n"); 3798 goto SKIP_DATA; 3799 } 3800 SET_PCRE_STACK_GUARD(stack_guard); 3801 break; 3802 3803 case 'S': 3804 do_study = 1; 3805 for (;;) 3806 { 3807 switch (*pp++) 3808 { 3809 case 'S': 3810 do_study = 0; 3811 no_force_study = 1; 3812 break; 3813 3814 case '!': 3815 study_options |= PCRE_STUDY_EXTRA_NEEDED; 3816 break; 3817 3818 case '+': 3819 if (*pp == '+') 3820 { 3821 verify_jit = TRUE; 3822 pp++; 3823 } 3824 if (*pp >= '1' && *pp <= '7') 3825 study_options |= jit_study_bits[*pp++ - '1']; 3826 else 3827 study_options |= jit_study_bits[6]; 3828 break; 3829 3830 case '-': 3831 study_options &= ~PCRE_STUDY_ALLJIT; 3832 break; 3833 3834 default: 3835 pp--; 3836 goto ENDLOOP; 3837 } 3838 } 3839 ENDLOOP: 3840 break; 3841 3842 case 'U': options |= PCRE_UNGREEDY; break; 3843 case 'W': options |= PCRE_UCP; break; 3844 case 'X': options |= PCRE_EXTRA; break; 3845 case 'Y': options |= PCRE_NO_START_OPTIMISE; break; 3846 case 'Z': debug_lengths = 0; break; 3847 case '8': options |= PCRE_UTF8; use_utf = 1; break; 3848 case '9': options |= PCRE_NEVER_UTF; break; 3849 case '?': options |= PCRE_NO_UTF8_CHECK; break; 3850 3851 case 'T': 3852 switch (*pp++) 3853 { 3854 case '0': tables = tables0; break; 3855 case '1': tables = tables1; break; 3856 3857 case '\r': 3858 case '\n': 3859 case ' ': 3860 case 0: 3861 fprintf(outfile, "** Missing table number after /T\n"); 3862 goto SKIP_DATA; 3863 3864 default: 3865 fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]); 3866 goto SKIP_DATA; 3867 } 3868 break; 3869 3870 case 'L': 3871 ppp = pp; 3872 /* The '\r' test here is so that it works on Windows. */ 3873 /* The '0' test is just in case this is an unterminated line. */ 3874 while (*ppp != 0 && *ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++; 3875 *ppp = 0; 3876 if (setlocale(LC_CTYPE, (const char *)pp) == NULL) 3877 { 3878 fprintf(outfile, "** Failed to set locale \"%s\"\n", pp); 3879 goto SKIP_DATA; 3880 } 3881 locale_set = 1; 3882 tables = PCRE_MAKETABLES; 3883 pp = ppp; 3884 break; 3885 3886 case '>': 3887 to_file = pp; 3888 while (*pp != 0) pp++; 3889 while (isspace(pp[-1])) pp--; 3890 *pp = 0; 3891 break; 3892 3893 case '<': 3894 { 3895 int x = check_mc_option(pp, outfile, FALSE, "modifier"); 3896 if (x == 0) goto SKIP_DATA; 3897 options |= x; 3898 while (*pp++ != '>'); 3899 } 3900 break; 3901 3902 case '\r': /* So that it works in Windows */ 3903 case '\n': 3904 case ' ': 3905 break; 3906 3907 default: 3908 fprintf(outfile, "** Unknown modifier '%c'\n", pp[-1]); 3909 goto SKIP_DATA; 3910 } 3911 } 3912 3913 /* Handle compiling via the POSIX interface, which doesn't support the 3914 timing, showing, or debugging options, nor the ability to pass over 3915 local character tables. Neither does it have 16-bit support. */ 3916 3917#if !defined NOPOSIX 3918 if (posix || do_posix) 3919 { 3920 int rc; 3921 int cflags = 0; 3922 3923 if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE; 3924 if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE; 3925 if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL; 3926 if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB; 3927 if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8; 3928 if ((options & PCRE_UCP) != 0) cflags |= REG_UCP; 3929 if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY; 3930 3931 rc = regcomp(&preg, (char *)p, cflags); 3932 3933 /* Compilation failed; go back for another re, skipping to blank line 3934 if non-interactive. */ 3935 3936 if (rc != 0) 3937 { 3938 (void)regerror(rc, &preg, (char *)buffer, buffer_size); 3939 fprintf(outfile, "Failed: POSIX code %d: %s\n", rc, buffer); 3940 goto SKIP_DATA; 3941 } 3942 } 3943 3944 /* Handle compiling via the native interface */ 3945 3946 else 3947#endif /* !defined NOPOSIX */ 3948 3949 { 3950 /* In 16- or 32-bit mode, convert the input. */ 3951 3952#ifdef SUPPORT_PCRE16 3953 if (pcre_mode == PCRE16_MODE) 3954 { 3955 switch(to16(FALSE, p, options & PCRE_UTF8, (int)strlen((char *)p))) 3956 { 3957 case -1: 3958 fprintf(outfile, "**Failed: invalid UTF-8 string cannot be " 3959 "converted to UTF-16\n"); 3960 goto SKIP_DATA; 3961 3962 case -2: 3963 fprintf(outfile, "**Failed: character value greater than 0x10ffff " 3964 "cannot be converted to UTF-16\n"); 3965 goto SKIP_DATA; 3966 3967 case -3: /* "Impossible error" when to16 is called arg1 FALSE */ 3968 fprintf(outfile, "**Failed: character value greater than 0xffff " 3969 "cannot be converted to 16-bit in non-UTF mode\n"); 3970 goto SKIP_DATA; 3971 3972 default: 3973 break; 3974 } 3975 p = (pcre_uint8 *)buffer16; 3976 } 3977#endif 3978 3979#ifdef SUPPORT_PCRE32 3980 if (pcre_mode == PCRE32_MODE) 3981 { 3982 switch(to32(FALSE, p, options & PCRE_UTF32, (int)strlen((char *)p))) 3983 { 3984 case -1: 3985 fprintf(outfile, "**Failed: invalid UTF-8 string cannot be " 3986 "converted to UTF-32\n"); 3987 goto SKIP_DATA; 3988 3989 case -2: 3990 fprintf(outfile, "**Failed: character value greater than 0x10ffff " 3991 "cannot be converted to UTF-32\n"); 3992 goto SKIP_DATA; 3993 3994 case -3: 3995 fprintf(outfile, "**Failed: character value is ill-formed UTF-32\n"); 3996 goto SKIP_DATA; 3997 3998 default: 3999 break; 4000 } 4001 p = (pcre_uint8 *)buffer32; 4002 } 4003#endif 4004 4005 /* Compile many times when timing */ 4006 4007 if (timeit > 0) 4008 { 4009 register int i; 4010 clock_t time_taken; 4011 clock_t start_time = clock(); 4012 for (i = 0; i < timeit; i++) 4013 { 4014 PCRE_COMPILE(re, p, options, &error, &erroroffset, tables); 4015 if (re != NULL) free(re); 4016 } 4017 total_compile_time += (time_taken = clock() - start_time); 4018 fprintf(outfile, "Compile time %.4f milliseconds\n", 4019 (((double)time_taken * 1000.0) / (double)timeit) / 4020 (double)CLOCKS_PER_SEC); 4021 } 4022 4023 PCRE_COMPILE(re, p, options, &error, &erroroffset, tables); 4024 4025 /* Compilation failed; go back for another re, skipping to blank line 4026 if non-interactive. */ 4027 4028 if (re == NULL) 4029 { 4030 fprintf(outfile, "Failed: %s at offset %d\n", error, erroroffset); 4031 SKIP_DATA: 4032 if (infile != stdin) 4033 { 4034 for (;;) 4035 { 4036 if (extend_inputline(infile, buffer, NULL) == NULL) 4037 { 4038 done = 1; 4039 goto CONTINUE; 4040 } 4041 len = (int)strlen((char *)buffer); 4042 while (len > 0 && isspace(buffer[len-1])) len--; 4043 if (len == 0) break; 4044 } 4045 fprintf(outfile, "\n"); 4046 } 4047 goto CONTINUE; 4048 } 4049 4050 /* Compilation succeeded. It is now possible to set the UTF-8 option from 4051 within the regex; check for this so that we know how to process the data 4052 lines. */ 4053 4054 if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0) 4055 goto SKIP_DATA; 4056 if ((get_options & PCRE_UTF8) != 0) use_utf = 1; 4057 4058 /* Extract the size for possible writing before possibly flipping it, 4059 and remember the store that was got. */ 4060 4061 true_size = REAL_PCRE_SIZE(re); 4062 4063 /* Output code size information if requested */ 4064 4065 if (log_store) 4066 { 4067 int name_count, name_entry_size, real_pcre_size; 4068 4069 new_info(re, NULL, PCRE_INFO_NAMECOUNT, &name_count); 4070 new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size); 4071 real_pcre_size = 0; 4072#ifdef SUPPORT_PCRE8 4073 if (REAL_PCRE_FLAGS(re) & PCRE_MODE8) 4074 real_pcre_size = sizeof(real_pcre); 4075#endif 4076#ifdef SUPPORT_PCRE16 4077 if (REAL_PCRE_FLAGS(re) & PCRE_MODE16) 4078 real_pcre_size = sizeof(real_pcre16); 4079#endif 4080#ifdef SUPPORT_PCRE32 4081 if (REAL_PCRE_FLAGS(re) & PCRE_MODE32) 4082 real_pcre_size = sizeof(real_pcre32); 4083#endif 4084 new_info(re, NULL, PCRE_INFO_SIZE, &size); 4085 fprintf(outfile, "Memory allocation (code space): %d\n", 4086 (int)(size - real_pcre_size - name_count * name_entry_size)); 4087 } 4088 4089 /* If -s or /S was present, study the regex to generate additional info to 4090 help with the matching, unless the pattern has the SS option, which 4091 suppresses the effect of /S (used for a few test patterns where studying is 4092 never sensible). */ 4093 4094 if (do_study || (force_study >= 0 && !no_force_study)) 4095 { 4096 if (timeit > 0) 4097 { 4098 register int i; 4099 clock_t time_taken; 4100 clock_t start_time = clock(); 4101 for (i = 0; i < timeit; i++) 4102 { 4103 PCRE_STUDY(extra, re, study_options, &error); 4104 } 4105 total_study_time = (time_taken = clock() - start_time); 4106 if (extra != NULL) 4107 { 4108 PCRE_FREE_STUDY(extra); 4109 } 4110 fprintf(outfile, " Study time %.4f milliseconds\n", 4111 (((double)time_taken * 1000.0) / (double)timeit) / 4112 (double)CLOCKS_PER_SEC); 4113 } 4114 PCRE_STUDY(extra, re, study_options, &error); 4115 if (error != NULL) 4116 fprintf(outfile, "Failed to study: %s\n", error); 4117 else if (extra != NULL) 4118 { 4119 true_study_size = ((pcre_study_data *)(extra->study_data))->size; 4120 if (log_store) 4121 { 4122 size_t jitsize; 4123 if (new_info(re, extra, PCRE_INFO_JITSIZE, &jitsize) == 0 && 4124 jitsize != 0) 4125 fprintf(outfile, "Memory allocation (JIT code): %d\n", (int)jitsize); 4126 } 4127 } 4128 } 4129 4130 /* If /K was present, we set up for handling MARK data. */ 4131 4132 if (do_mark) 4133 { 4134 if (extra == NULL) 4135 { 4136 extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 4137 extra->flags = 0; 4138 } 4139 extra->mark = &markptr; 4140 extra->flags |= PCRE_EXTRA_MARK; 4141 } 4142 4143 /* Extract and display information from the compiled data if required. */ 4144 4145 SHOW_INFO: 4146 4147 if (do_debug) 4148 { 4149 fprintf(outfile, "------------------------------------------------------------------\n"); 4150 PCRE_PRINTINT(re, outfile, debug_lengths); 4151 } 4152 4153 /* We already have the options in get_options (see above) */ 4154 4155 if (do_showinfo) 4156 { 4157 unsigned long int all_options; 4158 pcre_uint32 first_char, need_char; 4159 pcre_uint32 match_limit, recursion_limit; 4160 int count, backrefmax, first_char_set, need_char_set, okpartial, jchanged, 4161 hascrorlf, maxlookbehind, match_empty; 4162 int nameentrysize, namecount; 4163 const pcre_uint8 *nametable; 4164 4165 if (new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count) + 4166 new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax) + 4167 new_info(re, NULL, PCRE_INFO_FIRSTCHARACTER, &first_char) + 4168 new_info(re, NULL, PCRE_INFO_FIRSTCHARACTERFLAGS, &first_char_set) + 4169 new_info(re, NULL, PCRE_INFO_REQUIREDCHAR, &need_char) + 4170 new_info(re, NULL, PCRE_INFO_REQUIREDCHARFLAGS, &need_char_set) + 4171 new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize) + 4172 new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount) + 4173 new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable) + 4174 new_info(re, NULL, PCRE_INFO_OKPARTIAL, &okpartial) + 4175 new_info(re, NULL, PCRE_INFO_JCHANGED, &jchanged) + 4176 new_info(re, NULL, PCRE_INFO_HASCRORLF, &hascrorlf) + 4177 new_info(re, NULL, PCRE_INFO_MATCH_EMPTY, &match_empty) + 4178 new_info(re, NULL, PCRE_INFO_MAXLOOKBEHIND, &maxlookbehind) 4179 != 0) 4180 goto SKIP_DATA; 4181 4182 fprintf(outfile, "Capturing subpattern count = %d\n", count); 4183 4184 if (backrefmax > 0) 4185 fprintf(outfile, "Max back reference = %d\n", backrefmax); 4186 4187 if (maxlookbehind > 0) 4188 fprintf(outfile, "Max lookbehind = %d\n", maxlookbehind); 4189 4190 if (new_info(re, NULL, PCRE_INFO_MATCHLIMIT, &match_limit) == 0) 4191 fprintf(outfile, "Match limit = %u\n", match_limit); 4192 4193 if (new_info(re, NULL, PCRE_INFO_RECURSIONLIMIT, &recursion_limit) == 0) 4194 fprintf(outfile, "Recursion limit = %u\n", recursion_limit); 4195 4196 if (namecount > 0) 4197 { 4198 fprintf(outfile, "Named capturing subpatterns:\n"); 4199 while (namecount-- > 0) 4200 { 4201 int imm2_size = pcre_mode == PCRE8_MODE ? 2 : 1; 4202 int length = (int)STRLEN(nametable + imm2_size); 4203 fprintf(outfile, " "); 4204 PCHARSV(nametable, imm2_size, length, outfile); 4205 while (length++ < nameentrysize - imm2_size) putc(' ', outfile); 4206#ifdef SUPPORT_PCRE32 4207 if (pcre_mode == PCRE32_MODE) 4208 fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR32)nametable)[0])); 4209#endif 4210#ifdef SUPPORT_PCRE16 4211 if (pcre_mode == PCRE16_MODE) 4212 fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR16)nametable)[0])); 4213#endif 4214#ifdef SUPPORT_PCRE8 4215 if (pcre_mode == PCRE8_MODE) 4216 fprintf(outfile, "%3d\n", ((int)nametable[0] << 8) | (int)nametable[1]); 4217#endif 4218 nametable += nameentrysize * CHAR_SIZE; 4219 } 4220 } 4221 4222 if (!okpartial) fprintf(outfile, "Partial matching not supported\n"); 4223 if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n"); 4224 if (match_empty) fprintf(outfile, "May match empty string\n"); 4225 4226 all_options = REAL_PCRE_OPTIONS(re); 4227 if (do_flip) all_options = swap_uint32(all_options); 4228 4229 if (get_options == 0) fprintf(outfile, "No options\n"); 4230 else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 4231 ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "", 4232 ((get_options & PCRE_CASELESS) != 0)? " caseless" : "", 4233 ((get_options & PCRE_EXTENDED) != 0)? " extended" : "", 4234 ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "", 4235 ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "", 4236 ((get_options & PCRE_DOTALL) != 0)? " dotall" : "", 4237 ((get_options & PCRE_BSR_ANYCRLF) != 0)? " bsr_anycrlf" : "", 4238 ((get_options & PCRE_BSR_UNICODE) != 0)? " bsr_unicode" : "", 4239 ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "", 4240 ((get_options & PCRE_EXTRA) != 0)? " extra" : "", 4241 ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "", 4242 ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "", 4243 ((get_options & PCRE_NO_AUTO_POSSESS) != 0)? " no_auto_possessify" : "", 4244 ((get_options & PCRE_UTF8) != 0)? " utf" : "", 4245 ((get_options & PCRE_UCP) != 0)? " ucp" : "", 4246 ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf_check" : "", 4247 ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "", 4248 ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "", 4249 ((get_options & PCRE_NEVER_UTF) != 0)? " never_utf" : ""); 4250 4251 if (jchanged) fprintf(outfile, "Duplicate name status changes\n"); 4252 4253 switch (get_options & PCRE_NEWLINE_BITS) 4254 { 4255 case PCRE_NEWLINE_CR: 4256 fprintf(outfile, "Forced newline sequence: CR\n"); 4257 break; 4258 4259 case PCRE_NEWLINE_LF: 4260 fprintf(outfile, "Forced newline sequence: LF\n"); 4261 break; 4262 4263 case PCRE_NEWLINE_CRLF: 4264 fprintf(outfile, "Forced newline sequence: CRLF\n"); 4265 break; 4266 4267 case PCRE_NEWLINE_ANYCRLF: 4268 fprintf(outfile, "Forced newline sequence: ANYCRLF\n"); 4269 break; 4270 4271 case PCRE_NEWLINE_ANY: 4272 fprintf(outfile, "Forced newline sequence: ANY\n"); 4273 break; 4274 4275 default: 4276 break; 4277 } 4278 4279 if (first_char_set == 2) 4280 { 4281 fprintf(outfile, "First char at start or follows newline\n"); 4282 } 4283 else if (first_char_set == 1) 4284 { 4285 const char *caseless = 4286 ((REAL_PCRE_FLAGS(re) & PCRE_FCH_CASELESS) == 0)? 4287 "" : " (caseless)"; 4288 4289 if (PRINTOK(first_char)) 4290 fprintf(outfile, "First char = \'%c\'%s\n", first_char, caseless); 4291 else 4292 { 4293 fprintf(outfile, "First char = "); 4294 pchar(first_char, outfile); 4295 fprintf(outfile, "%s\n", caseless); 4296 } 4297 } 4298 else 4299 { 4300 fprintf(outfile, "No first char\n"); 4301 } 4302 4303 if (need_char_set == 0) 4304 { 4305 fprintf(outfile, "No need char\n"); 4306 } 4307 else 4308 { 4309 const char *caseless = 4310 ((REAL_PCRE_FLAGS(re) & PCRE_RCH_CASELESS) == 0)? 4311 "" : " (caseless)"; 4312 4313 if (PRINTOK(need_char)) 4314 fprintf(outfile, "Need char = \'%c\'%s\n", need_char, caseless); 4315 else 4316 { 4317 fprintf(outfile, "Need char = "); 4318 pchar(need_char, outfile); 4319 fprintf(outfile, "%s\n", caseless); 4320 } 4321 } 4322 4323 /* Don't output study size; at present it is in any case a fixed 4324 value, but it varies, depending on the computer architecture, and 4325 so messes up the test suite. (And with the /F option, it might be 4326 flipped.) If study was forced by an external -s, don't show this 4327 information unless -i or -d was also present. This means that, except 4328 when auto-callouts are involved, the output from runs with and without 4329 -s should be identical. */ 4330 4331 if (do_study || (force_study >= 0 && showinfo && !no_force_study)) 4332 { 4333 if (extra == NULL) 4334 fprintf(outfile, "Study returned NULL\n"); 4335 else 4336 { 4337 pcre_uint8 *start_bits = NULL; 4338 int minlength; 4339 4340 if (new_info(re, extra, PCRE_INFO_MINLENGTH, &minlength) == 0) 4341 fprintf(outfile, "Subject length lower bound = %d\n", minlength); 4342 4343 if (new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits) == 0) 4344 { 4345 if (start_bits == NULL) 4346 fprintf(outfile, "No starting char list\n"); 4347 else 4348 { 4349 int i; 4350 int c = 24; 4351 fprintf(outfile, "Starting chars: "); 4352 for (i = 0; i < 256; i++) 4353 { 4354 if ((start_bits[i/8] & (1<<(i&7))) != 0) 4355 { 4356 if (c > 75) 4357 { 4358 fprintf(outfile, "\n "); 4359 c = 2; 4360 } 4361 if (PRINTOK(i) && i != ' ') 4362 { 4363 fprintf(outfile, "%c ", i); 4364 c += 2; 4365 } 4366 else 4367 { 4368 fprintf(outfile, "\\x%02x ", i); 4369 c += 5; 4370 } 4371 } 4372 } 4373 fprintf(outfile, "\n"); 4374 } 4375 } 4376 } 4377 4378 /* Show this only if the JIT was set by /S, not by -s. */ 4379 4380 if ((study_options & PCRE_STUDY_ALLJIT) != 0 && 4381 (force_study_options & PCRE_STUDY_ALLJIT) == 0) 4382 { 4383 int jit; 4384 if (new_info(re, extra, PCRE_INFO_JIT, &jit) == 0) 4385 { 4386 if (jit) 4387 fprintf(outfile, "JIT study was successful\n"); 4388 else 4389#ifdef SUPPORT_JIT 4390 fprintf(outfile, "JIT study was not successful\n"); 4391#else 4392 fprintf(outfile, "JIT support is not available in this version of PCRE\n"); 4393#endif 4394 } 4395 } 4396 } 4397 } 4398 4399 /* If the '>' option was present, we write out the regex to a file, and 4400 that is all. The first 8 bytes of the file are the regex length and then 4401 the study length, in big-endian order. */ 4402 4403 if (to_file != NULL) 4404 { 4405 FILE *f = fopen((char *)to_file, "wb"); 4406 if (f == NULL) 4407 { 4408 fprintf(outfile, "Unable to open %s: %s\n", to_file, strerror(errno)); 4409 } 4410 else 4411 { 4412 pcre_uint8 sbuf[8]; 4413 4414 if (do_flip) regexflip(re, extra); 4415 sbuf[0] = (pcre_uint8)((true_size >> 24) & 255); 4416 sbuf[1] = (pcre_uint8)((true_size >> 16) & 255); 4417 sbuf[2] = (pcre_uint8)((true_size >> 8) & 255); 4418 sbuf[3] = (pcre_uint8)((true_size) & 255); 4419 sbuf[4] = (pcre_uint8)((true_study_size >> 24) & 255); 4420 sbuf[5] = (pcre_uint8)((true_study_size >> 16) & 255); 4421 sbuf[6] = (pcre_uint8)((true_study_size >> 8) & 255); 4422 sbuf[7] = (pcre_uint8)((true_study_size) & 255); 4423 4424 if (fwrite(sbuf, 1, 8, f) < 8 || 4425 fwrite(re, 1, true_size, f) < true_size) 4426 { 4427 fprintf(outfile, "Write error on %s: %s\n", to_file, strerror(errno)); 4428 } 4429 else 4430 { 4431 fprintf(outfile, "Compiled pattern written to %s\n", to_file); 4432 4433 /* If there is study data, write it. */ 4434 4435 if (extra != NULL) 4436 { 4437 if (fwrite(extra->study_data, 1, true_study_size, f) < 4438 true_study_size) 4439 { 4440 fprintf(outfile, "Write error on %s: %s\n", to_file, 4441 strerror(errno)); 4442 } 4443 else fprintf(outfile, "Study data written to %s\n", to_file); 4444 } 4445 } 4446 fclose(f); 4447 } 4448 4449 new_free(re); 4450 if (extra != NULL) 4451 { 4452 PCRE_FREE_STUDY(extra); 4453 } 4454 if (locale_set) 4455 { 4456 new_free((void *)tables); 4457 setlocale(LC_CTYPE, "C"); 4458 locale_set = 0; 4459 } 4460 continue; /* With next regex */ 4461 } 4462 } /* End of non-POSIX compile */ 4463 4464 /* Read data lines and test them */ 4465 4466 for (;;) 4467 { 4468#ifdef SUPPORT_PCRE8 4469 pcre_uint8 *q8; 4470#endif 4471#ifdef SUPPORT_PCRE16 4472 pcre_uint16 *q16; 4473#endif 4474#ifdef SUPPORT_PCRE32 4475 pcre_uint32 *q32; 4476#endif 4477 pcre_uint8 *bptr; 4478 int *use_offsets = offsets; 4479 int use_size_offsets = size_offsets; 4480 int callout_data = 0; 4481 int callout_data_set = 0; 4482 int count; 4483 pcre_uint32 c; 4484 int copystrings = 0; 4485 int find_match_limit = default_find_match_limit; 4486 int getstrings = 0; 4487 int getlist = 0; 4488 int gmatched = 0; 4489 int start_offset = 0; 4490 int start_offset_sign = 1; 4491 int g_notempty = 0; 4492 int use_dfa = 0; 4493 4494 *copynames = 0; 4495 *getnames = 0; 4496 4497#ifdef SUPPORT_PCRE32 4498 cn32ptr = copynames; 4499 gn32ptr = getnames; 4500#endif 4501#ifdef SUPPORT_PCRE16 4502 cn16ptr = copynames16; 4503 gn16ptr = getnames16; 4504#endif 4505#ifdef SUPPORT_PCRE8 4506 cn8ptr = copynames8; 4507 gn8ptr = getnames8; 4508#endif 4509 4510 SET_PCRE_CALLOUT(callout); 4511 first_callout = 1; 4512 last_callout_mark = NULL; 4513 callout_extra = 0; 4514 callout_count = 0; 4515 callout_fail_count = 999999; 4516 callout_fail_id = -1; 4517 show_malloc = 0; 4518 options = 0; 4519 4520 if (extra != NULL) extra->flags &= 4521 ~(PCRE_EXTRA_MATCH_LIMIT|PCRE_EXTRA_MATCH_LIMIT_RECURSION); 4522 4523 len = 0; 4524 for (;;) 4525 { 4526 if (extend_inputline(infile, buffer + len, "data> ") == NULL) 4527 { 4528 if (len > 0) /* Reached EOF without hitting a newline */ 4529 { 4530 fprintf(outfile, "\n"); 4531 break; 4532 } 4533 done = 1; 4534 goto CONTINUE; 4535 } 4536 if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); 4537 len = (int)strlen((char *)buffer); 4538 if (buffer[len-1] == '\n') break; 4539 } 4540 4541 while (len > 0 && isspace(buffer[len-1])) len--; 4542 buffer[len] = 0; 4543 if (len == 0) break; 4544 4545 p = buffer; 4546 while (isspace(*p)) p++; 4547 4548#ifndef NOUTF 4549 /* Check that the data is well-formed UTF-8 if we're in UTF mode. To create 4550 invalid input to pcre_exec, you must use \x?? or \x{} sequences. */ 4551 4552 if (use_utf) 4553 { 4554 pcre_uint8 *q; 4555 pcre_uint32 cc; 4556 int n = 1; 4557 4558 for (q = p; n > 0 && *q; q += n) n = utf82ord(q, &cc); 4559 if (n <= 0) 4560 { 4561 fprintf(outfile, "**Failed: invalid UTF-8 string cannot be used as input in UTF mode\n"); 4562 goto NEXT_DATA; 4563 } 4564 } 4565#endif 4566 4567#ifdef SUPPORT_VALGRIND 4568 /* Mark the dbuffer as addressable but undefined again. */ 4569 4570 if (dbuffer != NULL) 4571 { 4572 VALGRIND_MAKE_MEM_UNDEFINED(dbuffer, dbuffer_size * CHAR_SIZE); 4573 } 4574#endif 4575 4576 /* Allocate a buffer to hold the data line; len+1 is an upper bound on 4577 the number of pcre_uchar units that will be needed. */ 4578 4579 while (dbuffer == NULL || (size_t)len >= dbuffer_size) 4580 { 4581 dbuffer_size *= 2; 4582 dbuffer = (pcre_uint8 *)realloc(dbuffer, dbuffer_size * CHAR_SIZE); 4583 if (dbuffer == NULL) 4584 { 4585 fprintf(stderr, "pcretest: realloc(%d) failed\n", (int)dbuffer_size); 4586 exit(1); 4587 } 4588 } 4589 4590#ifdef SUPPORT_PCRE8 4591 q8 = (pcre_uint8 *) dbuffer; 4592#endif 4593#ifdef SUPPORT_PCRE16 4594 q16 = (pcre_uint16 *) dbuffer; 4595#endif 4596#ifdef SUPPORT_PCRE32 4597 q32 = (pcre_uint32 *) dbuffer; 4598#endif 4599 4600 while ((c = *p++) != 0) 4601 { 4602 int i = 0; 4603 int n = 0; 4604 4605 /* In UTF mode, input can be UTF-8, so just copy all non-backslash bytes. 4606 In non-UTF mode, allow the value of the byte to fall through to later, 4607 where values greater than 127 are turned into UTF-8 when running in 4608 16-bit or 32-bit mode. */ 4609 4610 if (c != '\\') 4611 { 4612#ifndef NOUTF 4613 if (use_utf && HASUTF8EXTRALEN(c)) { GETUTF8INC(c, p); } 4614#endif 4615 } 4616 4617 /* Handle backslash escapes */ 4618 4619 else switch ((c = *p++)) 4620 { 4621 case 'a': c = 7; break; 4622 case 'b': c = '\b'; break; 4623 case 'e': c = 27; break; 4624 case 'f': c = '\f'; break; 4625 case 'n': c = '\n'; break; 4626 case 'r': c = '\r'; break; 4627 case 't': c = '\t'; break; 4628 case 'v': c = '\v'; break; 4629 4630 case '0': case '1': case '2': case '3': 4631 case '4': case '5': case '6': case '7': 4632 c -= '0'; 4633 while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9') 4634 c = c * 8 + *p++ - '0'; 4635 break; 4636 4637 case 'o': 4638 if (*p == '{') 4639 { 4640 pcre_uint8 *pt = p; 4641 c = 0; 4642 for (pt++; isdigit(*pt) && *pt != '8' && *pt != '9'; pt++) 4643 { 4644 if (++i == 12) 4645 fprintf(outfile, "** Too many octal digits in \\o{...} item; " 4646 "using only the first twelve.\n"); 4647 else c = c * 8 + *pt - '0'; 4648 } 4649 if (*pt == '}') p = pt + 1; 4650 else fprintf(outfile, "** Missing } after \\o{ (assumed)\n"); 4651 } 4652 break; 4653 4654 case 'x': 4655 if (*p == '{') 4656 { 4657 pcre_uint8 *pt = p; 4658 c = 0; 4659 4660 /* We used to have "while (isxdigit(*(++pt)))" here, but it fails 4661 when isxdigit() is a macro that refers to its argument more than 4662 once. This is banned by the C Standard, but apparently happens in at 4663 least one MacOS environment. */ 4664 4665 for (pt++; isxdigit(*pt); pt++) 4666 { 4667 if (++i == 9) 4668 fprintf(outfile, "** Too many hex digits in \\x{...} item; " 4669 "using only the first eight.\n"); 4670 else c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'a' - 10); 4671 } 4672 if (*pt == '}') 4673 { 4674 p = pt + 1; 4675 break; 4676 } 4677 /* Not correct form for \x{...}; fall through */ 4678 } 4679 4680 /* \x without {} always defines just one byte in 8-bit mode. This 4681 allows UTF-8 characters to be constructed byte by byte, and also allows 4682 invalid UTF-8 sequences to be made. Just copy the byte in UTF mode. 4683 Otherwise, pass it down to later code so that it can be turned into 4684 UTF-8 when running in 16/32-bit mode. */ 4685 4686 c = 0; 4687 while (i++ < 2 && isxdigit(*p)) 4688 { 4689 c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'a' - 10); 4690 p++; 4691 } 4692#if !defined NOUTF && defined SUPPORT_PCRE8 4693 if (use_utf && (pcre_mode == PCRE8_MODE)) 4694 { 4695 *q8++ = c; 4696 continue; 4697 } 4698#endif 4699 break; 4700 4701 case 0: /* \ followed by EOF allows for an empty line */ 4702 p--; 4703 continue; 4704 4705 case '>': 4706 if (*p == '-') 4707 { 4708 start_offset_sign = -1; 4709 p++; 4710 } 4711 while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0'; 4712 start_offset *= start_offset_sign; 4713 continue; 4714 4715 case 'A': /* Option setting */ 4716 options |= PCRE_ANCHORED; 4717 continue; 4718 4719 case 'B': 4720 options |= PCRE_NOTBOL; 4721 continue; 4722 4723 case 'C': 4724 if (isdigit(*p)) /* Set copy string */ 4725 { 4726 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4727 copystrings |= 1 << n; 4728 } 4729 else if (isalnum(*p)) 4730 { 4731 READ_CAPTURE_NAME(p, &cn8ptr, &cn16ptr, &cn32ptr, re); 4732 } 4733 else if (*p == '+') 4734 { 4735 callout_extra = 1; 4736 p++; 4737 } 4738 else if (*p == '-') 4739 { 4740 SET_PCRE_CALLOUT(NULL); 4741 p++; 4742 } 4743 else if (*p == '!') 4744 { 4745 callout_fail_id = 0; 4746 p++; 4747 while(isdigit(*p)) 4748 callout_fail_id = callout_fail_id * 10 + *p++ - '0'; 4749 callout_fail_count = 0; 4750 if (*p == '!') 4751 { 4752 p++; 4753 while(isdigit(*p)) 4754 callout_fail_count = callout_fail_count * 10 + *p++ - '0'; 4755 } 4756 } 4757 else if (*p == '*') 4758 { 4759 int sign = 1; 4760 callout_data = 0; 4761 if (*(++p) == '-') { sign = -1; p++; } 4762 while(isdigit(*p)) 4763 callout_data = callout_data * 10 + *p++ - '0'; 4764 callout_data *= sign; 4765 callout_data_set = 1; 4766 } 4767 continue; 4768 4769#if !defined NODFA 4770 case 'D': 4771#if !defined NOPOSIX 4772 if (posix || do_posix) 4773 printf("** Can't use dfa matching in POSIX mode: \\D ignored\n"); 4774 else 4775#endif 4776 use_dfa = 1; 4777 continue; 4778#endif 4779 4780#if !defined NODFA 4781 case 'F': 4782 options |= PCRE_DFA_SHORTEST; 4783 continue; 4784#endif 4785 4786 case 'G': 4787 if (isdigit(*p)) 4788 { 4789 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4790 getstrings |= 1 << n; 4791 } 4792 else if (isalnum(*p)) 4793 { 4794 READ_CAPTURE_NAME(p, &gn8ptr, &gn16ptr, &gn32ptr, re); 4795 } 4796 continue; 4797 4798 case 'J': 4799 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4800 if (extra != NULL 4801 && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 4802 && extra->executable_jit != NULL) 4803 { 4804 if (jit_stack != NULL) { PCRE_JIT_STACK_FREE(jit_stack); } 4805 jit_stack = PCRE_JIT_STACK_ALLOC(1, n * 1024); 4806 PCRE_ASSIGN_JIT_STACK(extra, jit_callback, jit_stack); 4807 } 4808 continue; 4809 4810 case 'L': 4811 getlist = 1; 4812 continue; 4813 4814 case 'M': 4815 find_match_limit = 1; 4816 continue; 4817 4818 case 'N': 4819 if ((options & PCRE_NOTEMPTY) != 0) 4820 options = (options & ~PCRE_NOTEMPTY) | PCRE_NOTEMPTY_ATSTART; 4821 else 4822 options |= PCRE_NOTEMPTY; 4823 continue; 4824 4825 case 'O': 4826 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4827 if (n > size_offsets_max) 4828 { 4829 size_offsets_max = n; 4830 free(offsets); 4831 use_offsets = offsets = (int *)malloc(size_offsets_max * sizeof(int)); 4832 if (offsets == NULL) 4833 { 4834 printf("** Failed to get %d bytes of memory for offsets vector\n", 4835 (int)(size_offsets_max * sizeof(int))); 4836 yield = 1; 4837 goto EXIT; 4838 } 4839 } 4840 use_size_offsets = n; 4841 if (n == 0) use_offsets = NULL; /* Ensures it can't write to it */ 4842 else use_offsets = offsets + size_offsets_max - n; /* To catch overruns */ 4843 continue; 4844 4845 case 'P': 4846 options |= ((options & PCRE_PARTIAL_SOFT) == 0)? 4847 PCRE_PARTIAL_SOFT : PCRE_PARTIAL_HARD; 4848 continue; 4849 4850 case 'Q': 4851 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4852 if (extra == NULL) 4853 { 4854 extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 4855 extra->flags = 0; 4856 } 4857 extra->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION; 4858 extra->match_limit_recursion = n; 4859 continue; 4860 4861 case 'q': 4862 while(isdigit(*p)) n = n * 10 + *p++ - '0'; 4863 if (extra == NULL) 4864 { 4865 extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 4866 extra->flags = 0; 4867 } 4868 extra->flags |= PCRE_EXTRA_MATCH_LIMIT; 4869 extra->match_limit = n; 4870 continue; 4871 4872#if !defined NODFA 4873 case 'R': 4874 options |= PCRE_DFA_RESTART; 4875 continue; 4876#endif 4877 4878 case 'S': 4879 show_malloc = 1; 4880 continue; 4881 4882 case 'Y': 4883 options |= PCRE_NO_START_OPTIMIZE; 4884 continue; 4885 4886 case 'Z': 4887 options |= PCRE_NOTEOL; 4888 continue; 4889 4890 case '?': 4891 options |= PCRE_NO_UTF8_CHECK; 4892 continue; 4893 4894 case '<': 4895 { 4896 int x = check_mc_option(p, outfile, TRUE, "escape sequence"); 4897 if (x == 0) goto NEXT_DATA; 4898 options |= x; 4899 while (*p++ != '>'); 4900 } 4901 continue; 4902 } 4903 4904 /* We now have a character value in c that may be greater than 255. 4905 In 8-bit mode we convert to UTF-8 if we are in UTF mode. Values greater 4906 than 127 in UTF mode must have come from \x{...} or octal constructs 4907 because values from \x.. get this far only in non-UTF mode. */ 4908 4909#ifdef SUPPORT_PCRE8 4910 if (pcre_mode == PCRE8_MODE) 4911 { 4912#ifndef NOUTF 4913 if (use_utf) 4914 { 4915 if (c > 0x7fffffff) 4916 { 4917 fprintf(outfile, "** Character \\x{%x} is greater than 0x7fffffff " 4918 "and so cannot be converted to UTF-8\n", c); 4919 goto NEXT_DATA; 4920 } 4921 q8 += ord2utf8(c, q8); 4922 } 4923 else 4924#endif 4925 { 4926 if (c > 0xffu) 4927 { 4928 fprintf(outfile, "** Character \\x{%x} is greater than 255 " 4929 "and UTF-8 mode is not enabled.\n", c); 4930 fprintf(outfile, "** Truncation will probably give the wrong " 4931 "result.\n"); 4932 } 4933 *q8++ = c; 4934 } 4935 } 4936#endif 4937#ifdef SUPPORT_PCRE16 4938 if (pcre_mode == PCRE16_MODE) 4939 { 4940#ifndef NOUTF 4941 if (use_utf) 4942 { 4943 if (c > 0x10ffffu) 4944 { 4945 fprintf(outfile, "** Failed: character \\x{%x} is greater than " 4946 "0x10ffff and so cannot be converted to UTF-16\n", c); 4947 goto NEXT_DATA; 4948 } 4949 else if (c >= 0x10000u) 4950 { 4951 c-= 0x10000u; 4952 *q16++ = 0xD800 | (c >> 10); 4953 *q16++ = 0xDC00 | (c & 0x3ff); 4954 } 4955 else 4956 *q16++ = c; 4957 } 4958 else 4959#endif 4960 { 4961 if (c > 0xffffu) 4962 { 4963 fprintf(outfile, "** Character \\x{%x} is greater than 0xffff " 4964 "and UTF-16 mode is not enabled.\n", c); 4965 fprintf(outfile, "** Truncation will probably give the wrong " 4966 "result.\n"); 4967 } 4968 4969 *q16++ = c; 4970 } 4971 } 4972#endif 4973#ifdef SUPPORT_PCRE32 4974 if (pcre_mode == PCRE32_MODE) 4975 { 4976 *q32++ = c; 4977 } 4978#endif 4979 4980 } 4981 4982 /* Reached end of subject string */ 4983 4984#ifdef SUPPORT_PCRE8 4985 if (pcre_mode == PCRE8_MODE) 4986 { 4987 *q8 = 0; 4988 len = (int)(q8 - (pcre_uint8 *)dbuffer); 4989 } 4990#endif 4991#ifdef SUPPORT_PCRE16 4992 if (pcre_mode == PCRE16_MODE) 4993 { 4994 *q16 = 0; 4995 len = (int)(q16 - (pcre_uint16 *)dbuffer); 4996 } 4997#endif 4998#ifdef SUPPORT_PCRE32 4999 if (pcre_mode == PCRE32_MODE) 5000 { 5001 *q32 = 0; 5002 len = (int)(q32 - (pcre_uint32 *)dbuffer); 5003 } 5004#endif 5005 5006 /* If we're compiling with explicit valgrind support, Mark the data from after 5007 its end to the end of the buffer as unaddressable, so that a read over the end 5008 of the buffer will be seen by valgrind, even if it doesn't cause a crash. 5009 If we're not building with valgrind support, at least move the data to the end 5010 of the buffer so that it might at least cause a crash. 5011 If we are using the POSIX interface, we must include the terminating zero. */ 5012 5013 bptr = dbuffer; 5014 5015#if !defined NOPOSIX 5016 if (posix || do_posix) 5017 { 5018#ifdef SUPPORT_VALGRIND 5019 VALGRIND_MAKE_MEM_NOACCESS(dbuffer + len + 1, dbuffer_size - (len + 1)); 5020#else 5021 memmove(bptr + dbuffer_size - len - 1, bptr, len + 1); 5022 bptr += dbuffer_size - len - 1; 5023#endif 5024 } 5025 else 5026#endif 5027 { 5028#ifdef SUPPORT_VALGRIND 5029 VALGRIND_MAKE_MEM_NOACCESS(dbuffer + len * CHAR_SIZE, (dbuffer_size - len) * CHAR_SIZE); 5030#else 5031 bptr = memmove(bptr + (dbuffer_size - len) * CHAR_SIZE, bptr, len * CHAR_SIZE); 5032#endif 5033 } 5034 5035 if ((all_use_dfa || use_dfa) && find_match_limit) 5036 { 5037 printf("**Match limit not relevant for DFA matching: ignored\n"); 5038 find_match_limit = 0; 5039 } 5040 5041 /* Handle matching via the POSIX interface, which does not 5042 support timing or playing with the match limit or callout data. */ 5043 5044#if !defined NOPOSIX 5045 if (posix || do_posix) 5046 { 5047 int rc; 5048 int eflags = 0; 5049 regmatch_t *pmatch = NULL; 5050 if (use_size_offsets > 0) 5051 pmatch = (regmatch_t *)malloc(sizeof(regmatch_t) * use_size_offsets); 5052 if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL; 5053 if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL; 5054 if ((options & PCRE_NOTEMPTY) != 0) eflags |= REG_NOTEMPTY; 5055 5056 rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags); 5057 5058 if (rc != 0) 5059 { 5060 (void)regerror(rc, &preg, (char *)buffer, buffer_size); 5061 fprintf(outfile, "No match: POSIX code %d: %s\n", rc, buffer); 5062 } 5063 else if ((REAL_PCRE_OPTIONS(preg.re_pcre) & PCRE_NO_AUTO_CAPTURE) != 0) 5064 { 5065 fprintf(outfile, "Matched with REG_NOSUB\n"); 5066 } 5067 else 5068 { 5069 size_t i; 5070 for (i = 0; i < (size_t)use_size_offsets; i++) 5071 { 5072 if (pmatch[i].rm_so >= 0) 5073 { 5074 fprintf(outfile, "%2d: ", (int)i); 5075 PCHARSV(dbuffer, pmatch[i].rm_so, 5076 pmatch[i].rm_eo - pmatch[i].rm_so, outfile); 5077 fprintf(outfile, "\n"); 5078 if (do_showcaprest || (i == 0 && do_showrest)) 5079 { 5080 fprintf(outfile, "%2d+ ", (int)i); 5081 PCHARSV(dbuffer, pmatch[i].rm_eo, len - pmatch[i].rm_eo, 5082 outfile); 5083 fprintf(outfile, "\n"); 5084 } 5085 } 5086 } 5087 } 5088 free(pmatch); 5089 goto NEXT_DATA; 5090 } 5091 5092#endif /* !defined NOPOSIX */ 5093 5094 /* Handle matching via the native interface - repeats for /g and /G */ 5095 5096 /* Ensure that there is a JIT callback if we want to verify that JIT was 5097 actually used. If jit_stack == NULL, no stack has yet been assigned. */ 5098 5099 if (verify_jit && jit_stack == NULL && extra != NULL) 5100 { PCRE_ASSIGN_JIT_STACK(extra, jit_callback, jit_stack); } 5101 5102 for (;; gmatched++) /* Loop for /g or /G */ 5103 { 5104 markptr = NULL; 5105 jit_was_used = FALSE; 5106 5107 if (timeitm > 0) 5108 { 5109 register int i; 5110 clock_t time_taken; 5111 clock_t start_time = clock(); 5112 5113#if !defined NODFA 5114 if (all_use_dfa || use_dfa) 5115 { 5116 if ((options & PCRE_DFA_RESTART) != 0) 5117 { 5118 fprintf(outfile, "Timing DFA restarts is not supported\n"); 5119 break; 5120 } 5121 if (dfa_workspace == NULL) 5122 dfa_workspace = (int *)malloc(DFA_WS_DIMENSION*sizeof(int)); 5123 for (i = 0; i < timeitm; i++) 5124 { 5125 PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, 5126 (options | g_notempty), use_offsets, use_size_offsets, 5127 dfa_workspace, DFA_WS_DIMENSION); 5128 } 5129 } 5130 else 5131#endif 5132 5133 for (i = 0; i < timeitm; i++) 5134 { 5135 PCRE_EXEC(count, re, extra, bptr, len, start_offset, 5136 (options | g_notempty), use_offsets, use_size_offsets); 5137 } 5138 total_match_time += (time_taken = clock() - start_time); 5139 fprintf(outfile, "Execute time %.4f milliseconds\n", 5140 (((double)time_taken * 1000.0) / (double)timeitm) / 5141 (double)CLOCKS_PER_SEC); 5142 } 5143 5144 /* If find_match_limit is set, we want to do repeated matches with 5145 varying limits in order to find the minimum value for the match limit and 5146 for the recursion limit. The match limits are relevant only to the normal 5147 running of pcre_exec(), so disable the JIT optimization. This makes it 5148 possible to run the same set of tests with and without JIT externally 5149 requested. */ 5150 5151 if (find_match_limit) 5152 { 5153 if (extra != NULL) { PCRE_FREE_STUDY(extra); } 5154 extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 5155 extra->flags = 0; 5156 5157 (void)check_match_limit(re, extra, bptr, len, start_offset, 5158 options|g_notempty, use_offsets, use_size_offsets, 5159 PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit), 5160 PCRE_ERROR_MATCHLIMIT, "match()"); 5161 5162 count = check_match_limit(re, extra, bptr, len, start_offset, 5163 options|g_notempty, use_offsets, use_size_offsets, 5164 PCRE_EXTRA_MATCH_LIMIT_RECURSION, &(extra->match_limit_recursion), 5165 PCRE_ERROR_RECURSIONLIMIT, "match() recursion"); 5166 } 5167 5168 /* If callout_data is set, use the interface with additional data */ 5169 5170 else if (callout_data_set) 5171 { 5172 if (extra == NULL) 5173 { 5174 extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 5175 extra->flags = 0; 5176 } 5177 extra->flags |= PCRE_EXTRA_CALLOUT_DATA; 5178 extra->callout_data = &callout_data; 5179 PCRE_EXEC(count, re, extra, bptr, len, start_offset, 5180 options | g_notempty, use_offsets, use_size_offsets); 5181 extra->flags &= ~PCRE_EXTRA_CALLOUT_DATA; 5182 } 5183 5184 /* The normal case is just to do the match once, with the default 5185 value of match_limit. */ 5186 5187#if !defined NODFA 5188 else if (all_use_dfa || use_dfa) 5189 { 5190 if (dfa_workspace == NULL) 5191 dfa_workspace = (int *)malloc(DFA_WS_DIMENSION*sizeof(int)); 5192 if (dfa_matched++ == 0) 5193 dfa_workspace[0] = -1; /* To catch bad restart */ 5194 PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, 5195 (options | g_notempty), use_offsets, use_size_offsets, dfa_workspace, 5196 DFA_WS_DIMENSION); 5197 if (count == 0) 5198 { 5199 fprintf(outfile, "Matched, but offsets vector is too small to show all matches\n"); 5200 count = use_size_offsets/2; 5201 } 5202 } 5203#endif 5204 5205 else 5206 { 5207 PCRE_EXEC(count, re, extra, bptr, len, start_offset, 5208 options | g_notempty, use_offsets, use_size_offsets); 5209 if (count == 0) 5210 { 5211 fprintf(outfile, "Matched, but too many substrings\n"); 5212 /* 2 is a special case; match can be returned */ 5213 count = (use_size_offsets == 2)? 1 : use_size_offsets/3; 5214 } 5215 } 5216 5217 /* Matched */ 5218 5219 if (count >= 0) 5220 { 5221 int i, maxcount; 5222 void *cnptr, *gnptr; 5223 5224#if !defined NODFA 5225 if (all_use_dfa || use_dfa) maxcount = use_size_offsets/2; else 5226#endif 5227 /* 2 is a special case; match can be returned */ 5228 maxcount = (use_size_offsets == 2)? 1 : use_size_offsets/3; 5229 5230 /* This is a check against a lunatic return value. */ 5231 5232 if (count > maxcount) 5233 { 5234 fprintf(outfile, 5235 "** PCRE error: returned count %d is too big for offset size %d\n", 5236 count, use_size_offsets); 5237 count = use_size_offsets/3; 5238 if (do_g || do_G) 5239 { 5240 fprintf(outfile, "** /%c loop abandoned\n", do_g? 'g' : 'G'); 5241 do_g = do_G = FALSE; /* Break g/G loop */ 5242 } 5243 } 5244 5245 /* do_allcaps requests showing of all captures in the pattern, to check 5246 unset ones at the end. */ 5247 5248 if (do_allcaps) 5249 { 5250 if (new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count) < 0) 5251 goto SKIP_DATA; 5252 count++; /* Allow for full match */ 5253 if (count * 2 > use_size_offsets) count = use_size_offsets/2; 5254 } 5255 5256 /* Output the captured substrings. Note that, for the matched string, 5257 the use of \K in an assertion can make the start later than the end. */ 5258 5259 for (i = 0; i < count * 2; i += 2) 5260 { 5261 if (use_offsets[i] < 0) 5262 { 5263 if (use_offsets[i] != -1) 5264 fprintf(outfile, "ERROR: bad negative value %d for offset %d\n", 5265 use_offsets[i], i); 5266 if (use_offsets[i+1] != -1) 5267 fprintf(outfile, "ERROR: bad negative value %d for offset %d\n", 5268 use_offsets[i+1], i+1); 5269 fprintf(outfile, "%2d: <unset>\n", i/2); 5270 } 5271 else 5272 { 5273 int start = use_offsets[i]; 5274 int end = use_offsets[i+1]; 5275 5276 if (start > end) 5277 { 5278 start = use_offsets[i+1]; 5279 end = use_offsets[i]; 5280 fprintf(outfile, "Start of matched string is beyond its end - " 5281 "displaying from end to start.\n"); 5282 } 5283 5284 fprintf(outfile, "%2d: ", i/2); 5285 PCHARSV(bptr, start, end - start, outfile); 5286 if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 5287 fprintf(outfile, "\n"); 5288 5289 /* Note: don't use the start/end variables here because we want to 5290 show the text from what is reported as the end. */ 5291 5292 if (do_showcaprest || (i == 0 && do_showrest)) 5293 { 5294 fprintf(outfile, "%2d+ ", i/2); 5295 PCHARSV(bptr, use_offsets[i+1], len - use_offsets[i+1], 5296 outfile); 5297 fprintf(outfile, "\n"); 5298 } 5299 } 5300 } 5301 5302 if (markptr != NULL) 5303 { 5304 fprintf(outfile, "MK: "); 5305 PCHARSV(markptr, 0, -1, outfile); 5306 fprintf(outfile, "\n"); 5307 } 5308 5309 for (i = 0; i < 32; i++) 5310 { 5311 if ((copystrings & (1 << i)) != 0) 5312 { 5313 int rc; 5314 char copybuffer[256]; 5315 PCRE_COPY_SUBSTRING(rc, bptr, use_offsets, count, i, 5316 copybuffer, sizeof(copybuffer)); 5317 if (rc < 0) 5318 fprintf(outfile, "copy substring %d failed %d\n", i, rc); 5319 else 5320 { 5321 fprintf(outfile, "%2dC ", i); 5322 PCHARSV(copybuffer, 0, rc, outfile); 5323 fprintf(outfile, " (%d)\n", rc); 5324 } 5325 } 5326 } 5327 5328 cnptr = copynames; 5329 for (;;) 5330 { 5331 int rc; 5332 char copybuffer[256]; 5333 5334#ifdef SUPPORT_PCRE32 5335 if (pcre_mode == PCRE32_MODE) 5336 { 5337 if (*(pcre_uint32 *)cnptr == 0) break; 5338 } 5339#endif 5340#ifdef SUPPORT_PCRE16 5341 if (pcre_mode == PCRE16_MODE) 5342 { 5343 if (*(pcre_uint16 *)cnptr == 0) break; 5344 } 5345#endif 5346#ifdef SUPPORT_PCRE8 5347 if (pcre_mode == PCRE8_MODE) 5348 { 5349 if (*(pcre_uint8 *)cnptr == 0) break; 5350 } 5351#endif 5352 5353 PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, use_offsets, count, 5354 cnptr, copybuffer, sizeof(copybuffer)); 5355 5356 if (rc < 0) 5357 { 5358 fprintf(outfile, "copy substring "); 5359 PCHARSV(cnptr, 0, -1, outfile); 5360 fprintf(outfile, " failed %d\n", rc); 5361 } 5362 else 5363 { 5364 fprintf(outfile, " C "); 5365 PCHARSV(copybuffer, 0, rc, outfile); 5366 fprintf(outfile, " (%d) ", rc); 5367 PCHARSV(cnptr, 0, -1, outfile); 5368 putc('\n', outfile); 5369 } 5370 5371 cnptr = (char *)cnptr + (STRLEN(cnptr) + 1) * CHAR_SIZE; 5372 } 5373 5374 for (i = 0; i < 32; i++) 5375 { 5376 if ((getstrings & (1 << i)) != 0) 5377 { 5378 int rc; 5379 const char *substring; 5380 PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, &substring); 5381 if (rc < 0) 5382 fprintf(outfile, "get substring %d failed %d\n", i, rc); 5383 else 5384 { 5385 fprintf(outfile, "%2dG ", i); 5386 PCHARSV(substring, 0, rc, outfile); 5387 fprintf(outfile, " (%d)\n", rc); 5388 PCRE_FREE_SUBSTRING(substring); 5389 } 5390 } 5391 } 5392 5393 gnptr = getnames; 5394 for (;;) 5395 { 5396 int rc; 5397 const char *substring; 5398 5399#ifdef SUPPORT_PCRE32 5400 if (pcre_mode == PCRE32_MODE) 5401 { 5402 if (*(pcre_uint32 *)gnptr == 0) break; 5403 } 5404#endif 5405#ifdef SUPPORT_PCRE16 5406 if (pcre_mode == PCRE16_MODE) 5407 { 5408 if (*(pcre_uint16 *)gnptr == 0) break; 5409 } 5410#endif 5411#ifdef SUPPORT_PCRE8 5412 if (pcre_mode == PCRE8_MODE) 5413 { 5414 if (*(pcre_uint8 *)gnptr == 0) break; 5415 } 5416#endif 5417 5418 PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, use_offsets, count, 5419 gnptr, &substring); 5420 if (rc < 0) 5421 { 5422 fprintf(outfile, "get substring "); 5423 PCHARSV(gnptr, 0, -1, outfile); 5424 fprintf(outfile, " failed %d\n", rc); 5425 } 5426 else 5427 { 5428 fprintf(outfile, " G "); 5429 PCHARSV(substring, 0, rc, outfile); 5430 fprintf(outfile, " (%d) ", rc); 5431 PCHARSV(gnptr, 0, -1, outfile); 5432 PCRE_FREE_SUBSTRING(substring); 5433 putc('\n', outfile); 5434 } 5435 5436 gnptr = (char *)gnptr + (STRLEN(gnptr) + 1) * CHAR_SIZE; 5437 } 5438 5439 if (getlist) 5440 { 5441 int rc; 5442 const char **stringlist; 5443 PCRE_GET_SUBSTRING_LIST(rc, bptr, use_offsets, count, &stringlist); 5444 if (rc < 0) 5445 fprintf(outfile, "get substring list failed %d\n", rc); 5446 else 5447 { 5448 for (i = 0; i < count; i++) 5449 { 5450 fprintf(outfile, "%2dL ", i); 5451 PCHARSV(stringlist[i], 0, -1, outfile); 5452 putc('\n', outfile); 5453 } 5454 if (stringlist[i] != NULL) 5455 fprintf(outfile, "string list not terminated by NULL\n"); 5456 PCRE_FREE_SUBSTRING_LIST(stringlist); 5457 } 5458 } 5459 } 5460 5461 /* There was a partial match. If the bumpalong point is not the same as 5462 the first inspected character, show the offset explicitly. */ 5463 5464 else if (count == PCRE_ERROR_PARTIAL) 5465 { 5466 fprintf(outfile, "Partial match"); 5467 if (use_size_offsets > 2 && use_offsets[0] != use_offsets[2]) 5468 fprintf(outfile, " at offset %d", use_offsets[2]); 5469 if (markptr != NULL) 5470 { 5471 fprintf(outfile, ", mark="); 5472 PCHARSV(markptr, 0, -1, outfile); 5473 } 5474 if (use_size_offsets > 1) 5475 { 5476 fprintf(outfile, ": "); 5477 PCHARSV(bptr, use_offsets[0], use_offsets[1] - use_offsets[0], 5478 outfile); 5479 } 5480 if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 5481 fprintf(outfile, "\n"); 5482 break; /* Out of the /g loop */ 5483 } 5484 5485 /* Failed to match. If this is a /g or /G loop and we previously set 5486 g_notempty after a null match, this is not necessarily the end. We want 5487 to advance the start offset, and continue. We won't be at the end of the 5488 string - that was checked before setting g_notempty. 5489 5490 Complication arises in the case when the newline convention is "any", 5491 "crlf", or "anycrlf". If the previous match was at the end of a line 5492 terminated by CRLF, an advance of one character just passes the \r, 5493 whereas we should prefer the longer newline sequence, as does the code in 5494 pcre_exec(). Fudge the offset value to achieve this. We check for a 5495 newline setting in the pattern; if none was set, use PCRE_CONFIG() to 5496 find the default. 5497 5498 Otherwise, in the case of UTF-8 matching, the advance must be one 5499 character, not one byte. */ 5500 5501 else 5502 { 5503 if (g_notempty != 0) 5504 { 5505 int onechar = 1; 5506 unsigned int obits = REAL_PCRE_OPTIONS(re); 5507 use_offsets[0] = start_offset; 5508 if ((obits & PCRE_NEWLINE_BITS) == 0) 5509 { 5510 int d; 5511 (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &d); 5512 /* Note that these values are always the ASCII ones, even in 5513 EBCDIC environments. CR = 13, NL = 10. */ 5514 obits = (d == 13)? PCRE_NEWLINE_CR : 5515 (d == 10)? PCRE_NEWLINE_LF : 5516 (d == (13<<8 | 10))? PCRE_NEWLINE_CRLF : 5517 (d == -2)? PCRE_NEWLINE_ANYCRLF : 5518 (d == -1)? PCRE_NEWLINE_ANY : 0; 5519 } 5520 if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY || 5521 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF || 5522 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF) 5523 && 5524 start_offset < len - 1 && ( 5525#ifdef SUPPORT_PCRE8 5526 (pcre_mode == PCRE8_MODE && 5527 bptr[start_offset] == '\r' && 5528 bptr[start_offset + 1] == '\n') || 5529#endif 5530#ifdef SUPPORT_PCRE16 5531 (pcre_mode == PCRE16_MODE && 5532 ((PCRE_SPTR16)bptr)[start_offset] == '\r' && 5533 ((PCRE_SPTR16)bptr)[start_offset + 1] == '\n') || 5534#endif 5535#ifdef SUPPORT_PCRE32 5536 (pcre_mode == PCRE32_MODE && 5537 ((PCRE_SPTR32)bptr)[start_offset] == '\r' && 5538 ((PCRE_SPTR32)bptr)[start_offset + 1] == '\n') || 5539#endif 5540 0)) 5541 onechar++; 5542 else if (use_utf) 5543 { 5544 while (start_offset + onechar < len) 5545 { 5546 if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break; 5547 onechar++; 5548 } 5549 } 5550 use_offsets[1] = start_offset + onechar; 5551 } 5552 else 5553 { 5554 switch(count) 5555 { 5556 case PCRE_ERROR_NOMATCH: 5557 if (gmatched == 0) 5558 { 5559 if (markptr == NULL) 5560 { 5561 fprintf(outfile, "No match"); 5562 } 5563 else 5564 { 5565 fprintf(outfile, "No match, mark = "); 5566 PCHARSV(markptr, 0, -1, outfile); 5567 } 5568 if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 5569 putc('\n', outfile); 5570 } 5571 break; 5572 5573 case PCRE_ERROR_BADUTF8: 5574 case PCRE_ERROR_SHORTUTF8: 5575 fprintf(outfile, "Error %d (%s UTF-%d string)", count, 5576 (count == PCRE_ERROR_BADUTF8)? "bad" : "short", 5577 8 * CHAR_SIZE); 5578 if (use_size_offsets >= 2) 5579 fprintf(outfile, " offset=%d reason=%d", use_offsets[0], 5580 use_offsets[1]); 5581 fprintf(outfile, "\n"); 5582 break; 5583 5584 case PCRE_ERROR_BADUTF8_OFFSET: 5585 fprintf(outfile, "Error %d (bad UTF-%d offset)\n", count, 5586 8 * CHAR_SIZE); 5587 break; 5588 5589 default: 5590 if (count < 0 && 5591 (-count) < (int)(sizeof(errtexts)/sizeof(const char *))) 5592 fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]); 5593 else 5594 fprintf(outfile, "Error %d (Unexpected value)\n", count); 5595 break; 5596 } 5597 5598 break; /* Out of the /g loop */ 5599 } 5600 } 5601 5602 /* If not /g or /G we are done */ 5603 5604 if (!do_g && !do_G) break; 5605 5606 /* If we have matched an empty string, first check to see if we are at 5607 the end of the subject. If so, the /g loop is over. Otherwise, mimic what 5608 Perl's /g options does. This turns out to be rather cunning. First we set 5609 PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED and try the match again at the 5610 same point. If this fails (picked up above) we advance to the next 5611 character. */ 5612 5613 g_notempty = 0; 5614 5615 if (use_offsets[0] == use_offsets[1]) 5616 { 5617 if (use_offsets[0] == len) break; 5618 g_notempty = PCRE_NOTEMPTY_ATSTART | PCRE_ANCHORED; 5619 } 5620 5621 /* For /g, update the start offset, leaving the rest alone */ 5622 5623 if (do_g) start_offset = use_offsets[1]; 5624 5625 /* For /G, update the pointer and length */ 5626 5627 else 5628 { 5629 bptr += use_offsets[1] * CHAR_SIZE; 5630 len -= use_offsets[1]; 5631 } 5632 } /* End of loop for /g and /G */ 5633 5634 NEXT_DATA: continue; 5635 } /* End of loop for data lines */ 5636 5637 CONTINUE: 5638 5639#if !defined NOPOSIX 5640 if (posix || do_posix) regfree(&preg); 5641#endif 5642 5643 if (re != NULL) new_free(re); 5644 if (extra != NULL) 5645 { 5646 PCRE_FREE_STUDY(extra); 5647 } 5648 if (locale_set) 5649 { 5650 new_free((void *)tables); 5651 setlocale(LC_CTYPE, "C"); 5652 locale_set = 0; 5653 } 5654 if (jit_stack != NULL) 5655 { 5656 PCRE_JIT_STACK_FREE(jit_stack); 5657 jit_stack = NULL; 5658 } 5659 } 5660 5661if (infile == stdin) fprintf(outfile, "\n"); 5662 5663if (showtotaltimes) 5664 { 5665 fprintf(outfile, "--------------------------------------\n"); 5666 if (timeit > 0) 5667 { 5668 fprintf(outfile, "Total compile time %.4f milliseconds\n", 5669 (((double)total_compile_time * 1000.0) / (double)timeit) / 5670 (double)CLOCKS_PER_SEC); 5671 fprintf(outfile, "Total study time %.4f milliseconds\n", 5672 (((double)total_study_time * 1000.0) / (double)timeit) / 5673 (double)CLOCKS_PER_SEC); 5674 } 5675 fprintf(outfile, "Total execute time %.4f milliseconds\n", 5676 (((double)total_match_time * 1000.0) / (double)timeitm) / 5677 (double)CLOCKS_PER_SEC); 5678 } 5679 5680EXIT: 5681 5682if (infile != NULL && infile != stdin) fclose(infile); 5683if (outfile != NULL && outfile != stdout) fclose(outfile); 5684 5685free(buffer); 5686free(dbuffer); 5687free(pbuffer); 5688free(offsets); 5689 5690#ifdef SUPPORT_PCRE16 5691if (buffer16 != NULL) free(buffer16); 5692#endif 5693#ifdef SUPPORT_PCRE32 5694if (buffer32 != NULL) free(buffer32); 5695#endif 5696 5697#if !defined NODFA 5698if (dfa_workspace != NULL) 5699 free(dfa_workspace); 5700#endif 5701 5702#if defined(__VMS) 5703 yield = SS$_NORMAL; /* Return values via DCL symbols */ 5704#endif 5705 5706return yield; 5707} 5708 5709/* End of pcretest.c */ 5710