1 /************************************************* 2 * PCRE2 testing program * 3 *************************************************/ 4 5 /* PCRE2 is a library of functions to support regular expressions whose syntax 6 and semantics are as close as possible to those of the Perl 5 language. In 2014 7 the API was completely revised and '2' was added to the name, because the old 8 API, which had lasted for 16 years, could not accommodate new requirements. At 9 the same time, this testing program was re-designed because its original 10 hacked-up (non-) design had also run out of steam. 11 12 Written by Philip Hazel 13 Original code Copyright (c) 1997-2012 University of Cambridge 14 Rewritten code Copyright (c) 2016-2018 University of Cambridge 15 16 ----------------------------------------------------------------------------- 17 Redistribution and use in source and binary forms, with or without 18 modification, are permitted provided that the following conditions are met: 19 20 * Redistributions of source code must retain the above copyright notice, 21 this list of conditions and the following disclaimer. 22 23 * Redistributions in binary form must reproduce the above copyright 24 notice, this list of conditions and the following disclaimer in the 25 documentation and/or other materials provided with the distribution. 26 27 * Neither the name of the University of Cambridge nor the names of its 28 contributors may be used to endorse or promote products derived from 29 this software without specific prior written permission. 30 31 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 32 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 33 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 34 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 35 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 36 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 37 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 38 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 39 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 40 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 POSSIBILITY OF SUCH DAMAGE. 42 ----------------------------------------------------------------------------- 43 */ 44 45 46 /* This program supports testing of the 8-bit, 16-bit, and 32-bit PCRE2 47 libraries in a single program, though its input and output are always 8-bit. 48 It is different from modules such as pcre2_compile.c in the library itself, 49 which are compiled separately for each code unit width. If two widths are 50 enabled, for example, pcre2_compile.c is compiled twice. In contrast, 51 pcre2test.c is compiled only once, and linked with all the enabled libraries. 52 Therefore, it must not make use of any of the macros from pcre2.h or 53 pcre2_internal.h that depend on PCRE2_CODE_UNIT_WIDTH. It does, however, make 54 use of SUPPORT_PCRE2_8, SUPPORT_PCRE2_16, and SUPPORT_PCRE2_32, to ensure that 55 it references only the enabled library functions. */ 56 57 #ifdef HAVE_CONFIG_H 58 #include "config.h" 59 #endif 60 61 #include <ctype.h> 62 #include <stdio.h> 63 #include <string.h> 64 #include <stdlib.h> 65 #include <time.h> 66 #include <locale.h> 67 #include <errno.h> 68 69 #if defined NATIVE_ZOS 70 #include "pcrzoscs.h" 71 /* That header is not included in the main PCRE2 distribution because other 72 apparatus is needed to compile pcre2test for z/OS. The header can be found in 73 the special z/OS distribution, which is available from www.zaconsultants.net or 74 from www.cbttape.org. */ 75 #endif 76 77 #ifdef HAVE_UNISTD_H 78 #include <unistd.h> 79 #endif 80 81 /* Debugging code enabler */ 82 83 /* #define DEBUG_SHOW_MALLOC_ADDRESSES */ 84 85 /* Both libreadline and libedit are optionally supported. The user-supplied 86 original patch uses readline/readline.h for libedit, but in at least one system 87 it is installed as editline/readline.h, so the configuration code now looks for 88 that first, falling back to readline/readline.h. */ 89 90 #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 91 #if defined(SUPPORT_LIBREADLINE) 92 #include <readline/readline.h> 93 #include <readline/history.h> 94 #else 95 #if defined(HAVE_EDITLINE_READLINE_H) 96 #include <editline/readline.h> 97 #else 98 #include <readline/readline.h> 99 #endif 100 #endif 101 #endif 102 103 /* Put the test for interactive input into a macro so that it can be changed if 104 required for different environments. */ 105 106 #define INTERACTIVE(f) isatty(fileno(f)) 107 108 109 /* ---------------------- System-specific definitions ---------------------- */ 110 111 /* A number of things vary for Windows builds. Originally, pcretest opened its 112 input and output without "b"; then I was told that "b" was needed in some 113 environments, so it was added for release 5.0 to both the input and output. (It 114 makes no difference on Unix-like systems.) Later I was told that it is wrong 115 for the input on Windows. I've now abstracted the modes into macros that are 116 set here, to make it easier to fiddle with them, and removed "b" from the input 117 mode under Windows. The BINARY versions are used when saving/restoring compiled 118 patterns. */ 119 120 #if defined(_WIN32) || defined(WIN32) 121 #include <io.h> /* For _setmode() */ 122 #include <fcntl.h> /* For _O_BINARY */ 123 #define INPUT_MODE "r" 124 #define OUTPUT_MODE "wb" 125 #define BINARY_INPUT_MODE "rb" 126 #define BINARY_OUTPUT_MODE "wb" 127 128 #ifndef isatty 129 #define isatty _isatty /* This is what Windows calls them, I'm told, */ 130 #endif /* though in some environments they seem to */ 131 /* be already defined, hence the #ifndefs. */ 132 #ifndef fileno 133 #define fileno _fileno 134 #endif 135 136 /* A user sent this fix for Borland Builder 5 under Windows. */ 137 138 #ifdef __BORLANDC__ 139 #define _setmode(handle, mode) setmode(handle, mode) 140 #endif 141 142 /* Not Windows */ 143 144 #else 145 #include <sys/time.h> /* These two includes are needed */ 146 #include <sys/resource.h> /* for setrlimit(). */ 147 #if defined NATIVE_ZOS /* z/OS uses non-binary I/O */ 148 #define INPUT_MODE "r" 149 #define OUTPUT_MODE "w" 150 #define BINARY_INPUT_MODE "rb" 151 #define BINARY_OUTPUT_MODE "wb" 152 #else 153 #define INPUT_MODE "rb" 154 #define OUTPUT_MODE "wb" 155 #define BINARY_INPUT_MODE "rb" 156 #define BINARY_OUTPUT_MODE "wb" 157 #endif 158 #endif 159 160 #ifdef __VMS 161 #include <ssdef.h> 162 void vms_setsymbol( char *, char *, int ); 163 #endif 164 165 /* VC and older compilers don't support %td or %zu. */ 166 167 #if defined(_MSC_VER) || !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L 168 #define PTR_FORM "lu" 169 #define SIZ_FORM "lu" 170 #define SIZ_CAST (unsigned long int) 171 #else 172 #define PTR_FORM "td" 173 #define SIZ_FORM "zu" 174 #define SIZ_CAST 175 #endif 176 177 /* ------------------End of system-specific definitions -------------------- */ 178 179 /* Glueing macros that are used in several places below. */ 180 181 #define glue(a,b) a##b 182 #define G(a,b) glue(a,b) 183 184 /* Miscellaneous parameters and manifests */ 185 186 #ifndef CLOCKS_PER_SEC 187 #ifdef CLK_TCK 188 #define CLOCKS_PER_SEC CLK_TCK 189 #else 190 #define CLOCKS_PER_SEC 100 191 #endif 192 #endif 193 194 #define CFORE_UNSET UINT32_MAX /* Unset value for startend/cfail/cerror fields */ 195 #define CONVERT_UNSET UINT32_MAX /* Unset value for convert_type field */ 196 #define DFA_WS_DIMENSION 1000 /* Size of DFA workspace */ 197 #define DEFAULT_OVECCOUNT 15 /* Default ovector count */ 198 #define JUNK_OFFSET 0xdeadbeef /* For initializing ovector */ 199 #define LOCALESIZE 32 /* Size of locale name */ 200 #define LOOPREPEAT 500000 /* Default loop count for timing */ 201 #define MALLOCLISTSIZE 20 /* For remembering mallocs */ 202 #define PARENS_NEST_DEFAULT 220 /* Default parentheses nest limit */ 203 #define PATSTACKSIZE 20 /* Pattern stack for save/restore testing */ 204 #define REPLACE_MODSIZE 100 /* Field for reading 8-bit replacement */ 205 #define VERSION_SIZE 64 /* Size of buffer for the version strings */ 206 207 /* Make sure the buffer into which replacement strings are copied is big enough 208 to hold them as 32-bit code units. */ 209 210 #define REPLACE_BUFFSIZE 1024 /* This is a byte value */ 211 212 /* Execution modes */ 213 214 #define PCRE8_MODE 8 215 #define PCRE16_MODE 16 216 #define PCRE32_MODE 32 217 218 /* Processing returns */ 219 220 enum { PR_OK, PR_SKIP, PR_ABEND }; 221 222 /* The macro PRINTABLE determines whether to print an output character as-is or 223 as a hex value when showing compiled patterns. is We use it in cases when the 224 locale has not been explicitly changed, so as to get consistent output from 225 systems that differ in their output from isprint() even in the "C" locale. */ 226 227 #ifdef EBCDIC 228 #define PRINTABLE(c) ((c) >= 64 && (c) < 255) 229 #else 230 #define PRINTABLE(c) ((c) >= 32 && (c) < 127) 231 #endif 232 233 #define PRINTOK(c) ((use_tables != NULL && c < 256)? isprint(c) : PRINTABLE(c)) 234 235 /* We have to include some of the library source files because we need 236 to use some of the macros, internal structure definitions, and other internal 237 values - pcre2test has "inside information" compared to an application program 238 that strictly follows the PCRE2 API. 239 240 Before including pcre2_internal.h we define PRIV so that it does not get 241 defined therein. This ensures that PRIV names in the included files do not 242 clash with those in the libraries. Also, although pcre2_internal.h does itself 243 include pcre2.h, we explicitly include it beforehand, along with pcre2posix.h, 244 so that the PCRE2_EXP_xxx macros get set appropriately for an application, not 245 for building the library. */ 246 247 #define PRIV(name) name 248 #define PCRE2_CODE_UNIT_WIDTH 0 249 #include "pcre2.h" 250 #include "pcre2posix.h" 251 #include "pcre2_internal.h" 252 253 /* We need access to some of the data tables that PCRE2 uses. Defining 254 PCRE2_PCRETEST makes some minor changes in the files. The previous definition 255 of PRIV avoids name clashes. */ 256 257 #define PCRE2_PCRE2TEST 258 #include "pcre2_tables.c" 259 #include "pcre2_ucd.c" 260 261 /* 32-bit integer values in the input are read by strtoul() or strtol(). The 262 check needed for overflow depends on whether long ints are in fact longer than 263 ints. They are defined not to be shorter. */ 264 265 #if ULONG_MAX > UINT32_MAX 266 #define U32OVERFLOW(x) (x > UINT32_MAX) 267 #else 268 #define U32OVERFLOW(x) (x == UINT32_MAX) 269 #endif 270 271 #if LONG_MAX > INT32_MAX 272 #define S32OVERFLOW(x) (x > INT32_MAX || x < INT32_MIN) 273 #else 274 #define S32OVERFLOW(x) (x == INT32_MAX || x == INT32_MIN) 275 #endif 276 277 /* When PCRE2_CODE_UNIT_WIDTH is zero, pcre2_internal.h does not include 278 pcre2_intmodedep.h, which is where mode-dependent macros and structures are 279 defined. We can now include it for each supported code unit width. Because 280 PCRE2_CODE_UNIT_WIDTH was defined as zero before including pcre2.h, it will 281 have left PCRE2_SUFFIX defined as a no-op. We must re-define it appropriately 282 while including these files, and then restore it to a no-op. Because LINK_SIZE 283 may be changed in 16-bit mode and forced to 1 in 32-bit mode, the order of 284 these inclusions should not be changed. */ 285 286 #undef PCRE2_SUFFIX 287 #undef PCRE2_CODE_UNIT_WIDTH 288 289 #ifdef SUPPORT_PCRE2_8 290 #define PCRE2_CODE_UNIT_WIDTH 8 291 #define PCRE2_SUFFIX(a) G(a,8) 292 #include "pcre2_intmodedep.h" 293 #include "pcre2_printint.c" 294 #undef PCRE2_CODE_UNIT_WIDTH 295 #undef PCRE2_SUFFIX 296 #endif /* SUPPORT_PCRE2_8 */ 297 298 #ifdef SUPPORT_PCRE2_16 299 #define PCRE2_CODE_UNIT_WIDTH 16 300 #define PCRE2_SUFFIX(a) G(a,16) 301 #include "pcre2_intmodedep.h" 302 #include "pcre2_printint.c" 303 #undef PCRE2_CODE_UNIT_WIDTH 304 #undef PCRE2_SUFFIX 305 #endif /* SUPPORT_PCRE2_16 */ 306 307 #ifdef SUPPORT_PCRE2_32 308 #define PCRE2_CODE_UNIT_WIDTH 32 309 #define PCRE2_SUFFIX(a) G(a,32) 310 #include "pcre2_intmodedep.h" 311 #include "pcre2_printint.c" 312 #undef PCRE2_CODE_UNIT_WIDTH 313 #undef PCRE2_SUFFIX 314 #endif /* SUPPORT_PCRE2_32 */ 315 316 #define PCRE2_SUFFIX(a) a 317 318 /* We need to be able to check input text for UTF-8 validity, whatever code 319 widths are actually available, because the input to pcre2test is always in 320 8-bit code units. So we include the UTF validity checking function for 8-bit 321 code units. */ 322 323 extern int valid_utf(PCRE2_SPTR8, PCRE2_SIZE, PCRE2_SIZE *); 324 325 #define PCRE2_CODE_UNIT_WIDTH 8 326 #undef PCRE2_SPTR 327 #define PCRE2_SPTR PCRE2_SPTR8 328 #include "pcre2_valid_utf.c" 329 #undef PCRE2_CODE_UNIT_WIDTH 330 #undef PCRE2_SPTR 331 332 /* If we have 8-bit support, default to it; if there is also 16-or 32-bit 333 support, it can be selected by a command-line option. If there is no 8-bit 334 support, there must be 16-bit or 32-bit support, so default to one of them. The 335 config function, JIT stack, contexts, and version string are the same in all 336 modes, so use the form of the first that is available. */ 337 338 #if defined SUPPORT_PCRE2_8 339 #define DEFAULT_TEST_MODE PCRE8_MODE 340 #define VERSION_TYPE PCRE2_UCHAR8 341 #define PCRE2_CONFIG pcre2_config_8 342 #define PCRE2_JIT_STACK pcre2_jit_stack_8 343 #define PCRE2_REAL_GENERAL_CONTEXT pcre2_real_general_context_8 344 #define PCRE2_REAL_COMPILE_CONTEXT pcre2_real_compile_context_8 345 #define PCRE2_REAL_CONVERT_CONTEXT pcre2_real_convert_context_8 346 #define PCRE2_REAL_MATCH_CONTEXT pcre2_real_match_context_8 347 348 #elif defined SUPPORT_PCRE2_16 349 #define DEFAULT_TEST_MODE PCRE16_MODE 350 #define VERSION_TYPE PCRE2_UCHAR16 351 #define PCRE2_CONFIG pcre2_config_16 352 #define PCRE2_JIT_STACK pcre2_jit_stack_16 353 #define PCRE2_REAL_GENERAL_CONTEXT pcre2_real_general_context_16 354 #define PCRE2_REAL_COMPILE_CONTEXT pcre2_real_compile_context_16 355 #define PCRE2_REAL_CONVERT_CONTEXT pcre2_real_convert_context_16 356 #define PCRE2_REAL_MATCH_CONTEXT pcre2_real_match_context_16 357 358 #elif defined SUPPORT_PCRE2_32 359 #define DEFAULT_TEST_MODE PCRE32_MODE 360 #define VERSION_TYPE PCRE2_UCHAR32 361 #define PCRE2_CONFIG pcre2_config_32 362 #define PCRE2_JIT_STACK pcre2_jit_stack_32 363 #define PCRE2_REAL_GENERAL_CONTEXT pcre2_real_general_context_32 364 #define PCRE2_REAL_COMPILE_CONTEXT pcre2_real_compile_context_32 365 #define PCRE2_REAL_CONVERT_CONTEXT pcre2_real_convert_context_32 366 #define PCRE2_REAL_MATCH_CONTEXT pcre2_real_match_context_32 367 #endif 368 369 /* ------------- Structure and table for handling #-commands ------------- */ 370 371 typedef struct cmdstruct { 372 const char *name; 373 int value; 374 } cmdstruct; 375 376 enum { CMD_FORBID_UTF, CMD_LOAD, CMD_NEWLINE_DEFAULT, CMD_PATTERN, 377 CMD_PERLTEST, CMD_POP, CMD_POPCOPY, CMD_SAVE, CMD_SUBJECT, CMD_UNKNOWN }; 378 379 static cmdstruct cmdlist[] = { 380 { "forbid_utf", CMD_FORBID_UTF }, 381 { "load", CMD_LOAD }, 382 { "newline_default", CMD_NEWLINE_DEFAULT }, 383 { "pattern", CMD_PATTERN }, 384 { "perltest", CMD_PERLTEST }, 385 { "pop", CMD_POP }, 386 { "popcopy", CMD_POPCOPY }, 387 { "save", CMD_SAVE }, 388 { "subject", CMD_SUBJECT }}; 389 390 #define cmdlistcount (sizeof(cmdlist)/sizeof(cmdstruct)) 391 392 /* ------------- Structures and tables for handling modifiers -------------- */ 393 394 /* Table of names for newline types. Must be kept in step with the definitions 395 of PCRE2_NEWLINE_xx in pcre2.h. */ 396 397 static const char *newlines[] = { 398 "DEFAULT", "CR", "LF", "CRLF", "ANY", "ANYCRLF", "NUL" }; 399 400 /* Structure and table for handling pattern conversion types. */ 401 402 typedef struct convertstruct { 403 const char *name; 404 uint32_t option; 405 } convertstruct; 406 407 static convertstruct convertlist[] = { 408 { "glob", PCRE2_CONVERT_GLOB }, 409 { "glob_no_starstar", PCRE2_CONVERT_GLOB_NO_STARSTAR }, 410 { "glob_no_wild_separator", PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR }, 411 { "posix_basic", PCRE2_CONVERT_POSIX_BASIC }, 412 { "posix_extended", PCRE2_CONVERT_POSIX_EXTENDED }, 413 { "unset", CONVERT_UNSET }}; 414 415 #define convertlistcount (sizeof(convertlist)/sizeof(convertstruct)) 416 417 /* Modifier types and applicability */ 418 419 enum { MOD_CTC, /* Applies to a compile context */ 420 MOD_CTM, /* Applies to a match context */ 421 MOD_PAT, /* Applies to a pattern */ 422 MOD_PATP, /* Ditto, OK for Perl test */ 423 MOD_DAT, /* Applies to a data line */ 424 MOD_PD, /* Applies to a pattern or a data line */ 425 MOD_PDP, /* As MOD_PD, OK for Perl test */ 426 MOD_PND, /* As MOD_PD, but not for a default pattern */ 427 MOD_PNDP, /* As MOD_PND, OK for Perl test */ 428 MOD_CHR, /* Is a single character */ 429 MOD_CON, /* Is a "convert" type/options list */ 430 MOD_CTL, /* Is a control bit */ 431 MOD_BSR, /* Is a BSR value */ 432 MOD_IN2, /* Is one or two unsigned integers */ 433 MOD_INS, /* Is a signed integer */ 434 MOD_INT, /* Is an unsigned integer */ 435 MOD_IND, /* Is an unsigned integer, but no value => default */ 436 MOD_NL, /* Is a newline value */ 437 MOD_NN, /* Is a number or a name; more than one may occur */ 438 MOD_OPT, /* Is an option bit */ 439 MOD_SIZ, /* Is a PCRE2_SIZE value */ 440 MOD_STR }; /* Is a string */ 441 442 /* Control bits. Some apply to compiling, some to matching, but some can be set 443 either on a pattern or a data line, so they must all be distinct. There are now 444 so many of them that they are split into two fields. */ 445 446 #define CTL_AFTERTEXT 0x00000001u 447 #define CTL_ALLAFTERTEXT 0x00000002u 448 #define CTL_ALLCAPTURES 0x00000004u 449 #define CTL_ALLUSEDTEXT 0x00000008u 450 #define CTL_ALTGLOBAL 0x00000010u 451 #define CTL_BINCODE 0x00000020u 452 #define CTL_CALLOUT_CAPTURE 0x00000040u 453 #define CTL_CALLOUT_INFO 0x00000080u 454 #define CTL_CALLOUT_NONE 0x00000100u 455 #define CTL_DFA 0x00000200u 456 #define CTL_EXPAND 0x00000400u 457 #define CTL_FINDLIMITS 0x00000800u 458 #define CTL_FRAMESIZE 0x00001000u 459 #define CTL_FULLBINCODE 0x00002000u 460 #define CTL_GETALL 0x00004000u 461 #define CTL_GLOBAL 0x00008000u 462 #define CTL_HEXPAT 0x00010000u /* Same word as USE_LENGTH */ 463 #define CTL_INFO 0x00020000u 464 #define CTL_JITFAST 0x00040000u 465 #define CTL_JITVERIFY 0x00080000u 466 #define CTL_MARK 0x00100000u 467 #define CTL_MEMORY 0x00200000u 468 #define CTL_NULLCONTEXT 0x00400000u 469 #define CTL_POSIX 0x00800000u 470 #define CTL_POSIX_NOSUB 0x01000000u 471 #define CTL_PUSH 0x02000000u /* These three must be */ 472 #define CTL_PUSHCOPY 0x04000000u /* all in the same */ 473 #define CTL_PUSHTABLESCOPY 0x08000000u /* word. */ 474 #define CTL_STARTCHAR 0x10000000u 475 #define CTL_USE_LENGTH 0x20000000u /* Same word as HEXPAT */ 476 #define CTL_UTF8_INPUT 0x40000000u 477 #define CTL_ZERO_TERMINATE 0x80000000u 478 479 /* Combinations */ 480 481 #define CTL_DEBUG (CTL_FULLBINCODE|CTL_INFO) /* For setting */ 482 #define CTL_ANYINFO (CTL_DEBUG|CTL_BINCODE|CTL_CALLOUT_INFO) 483 #define CTL_ANYGLOB (CTL_ALTGLOBAL|CTL_GLOBAL) 484 485 /* Second control word */ 486 487 #define CTL2_SUBSTITUTE_EXTENDED 0x00000001u 488 #define CTL2_SUBSTITUTE_OVERFLOW_LENGTH 0x00000002u 489 #define CTL2_SUBSTITUTE_UNKNOWN_UNSET 0x00000004u 490 #define CTL2_SUBSTITUTE_UNSET_EMPTY 0x00000008u 491 #define CTL2_SUBJECT_LITERAL 0x00000010u 492 #define CTL2_CALLOUT_NO_WHERE 0x00000020u 493 #define CTL2_CALLOUT_EXTRA 0x00000040u 494 495 #define CTL2_NL_SET 0x40000000u /* Informational */ 496 #define CTL2_BSR_SET 0x80000000u /* Informational */ 497 498 /* These are the matching controls that may be set either on a pattern or on a 499 data line. They are copied from the pattern controls as initial settings for 500 data line controls. Note that CTL_MEMORY is not included here, because it does 501 different things in the two cases. */ 502 503 #define CTL_ALLPD (CTL_AFTERTEXT|\ 504 CTL_ALLAFTERTEXT|\ 505 CTL_ALLCAPTURES|\ 506 CTL_ALLUSEDTEXT|\ 507 CTL_ALTGLOBAL|\ 508 CTL_GLOBAL|\ 509 CTL_MARK|\ 510 CTL_STARTCHAR|\ 511 CTL_UTF8_INPUT) 512 513 #define CTL2_ALLPD (CTL2_SUBSTITUTE_EXTENDED|\ 514 CTL2_SUBSTITUTE_OVERFLOW_LENGTH|\ 515 CTL2_SUBSTITUTE_UNKNOWN_UNSET|\ 516 CTL2_SUBSTITUTE_UNSET_EMPTY) 517 518 /* Structures for holding modifier information for patterns and subject strings 519 (data). Fields containing modifiers that can be set either for a pattern or a 520 subject must be at the start and in the same order in both cases so that the 521 same offset in the big table below works for both. */ 522 523 typedef struct patctl { /* Structure for pattern modifiers. */ 524 uint32_t options; /* Must be in same position as datctl */ 525 uint32_t control; /* Must be in same position as datctl */ 526 uint32_t control2; /* Must be in same position as datctl */ 527 uint32_t jitstack; /* Must be in same position as datctl */ 528 uint8_t replacement[REPLACE_MODSIZE]; /* So must this */ 529 uint32_t jit; 530 uint32_t stackguard_test; 531 uint32_t tables_id; 532 uint32_t convert_type; 533 uint32_t convert_length; 534 uint32_t convert_glob_escape; 535 uint32_t convert_glob_separator; 536 uint32_t regerror_buffsize; 537 uint8_t locale[LOCALESIZE]; 538 } patctl; 539 540 #define MAXCPYGET 10 541 #define LENCPYGET 64 542 543 typedef struct datctl { /* Structure for data line modifiers. */ 544 uint32_t options; /* Must be in same position as patctl */ 545 uint32_t control; /* Must be in same position as patctl */ 546 uint32_t control2; /* Must be in same position as patctl */ 547 uint32_t jitstack; /* Must be in same position as patctl */ 548 uint8_t replacement[REPLACE_MODSIZE]; /* So must this */ 549 uint32_t startend[2]; 550 uint32_t cerror[2]; 551 uint32_t cfail[2]; 552 int32_t callout_data; 553 int32_t copy_numbers[MAXCPYGET]; 554 int32_t get_numbers[MAXCPYGET]; 555 uint32_t oveccount; 556 uint32_t offset; 557 uint8_t copy_names[LENCPYGET]; 558 uint8_t get_names[LENCPYGET]; 559 } datctl; 560 561 /* Ids for which context to modify. */ 562 563 enum { CTX_PAT, /* Active pattern context */ 564 CTX_POPPAT, /* Ditto, for a popped pattern */ 565 CTX_DEFPAT, /* Default pattern context */ 566 CTX_DAT, /* Active data (match) context */ 567 CTX_DEFDAT }; /* Default data (match) context */ 568 569 /* Macros to simplify the big table below. */ 570 571 #define CO(name) offsetof(PCRE2_REAL_COMPILE_CONTEXT, name) 572 #define MO(name) offsetof(PCRE2_REAL_MATCH_CONTEXT, name) 573 #define PO(name) offsetof(patctl, name) 574 #define PD(name) PO(name) 575 #define DO(name) offsetof(datctl, name) 576 577 /* Table of all long-form modifiers. Must be in collating sequence of modifier 578 name because it is searched by binary chop. */ 579 580 typedef struct modstruct { 581 const char *name; 582 uint16_t which; 583 uint16_t type; 584 uint32_t value; 585 PCRE2_SIZE offset; 586 } modstruct; 587 588 static modstruct modlist[] = { 589 { "aftertext", MOD_PNDP, MOD_CTL, CTL_AFTERTEXT, PO(control) }, 590 { "allaftertext", MOD_PNDP, MOD_CTL, CTL_ALLAFTERTEXT, PO(control) }, 591 { "allcaptures", MOD_PND, MOD_CTL, CTL_ALLCAPTURES, PO(control) }, 592 { "allow_empty_class", MOD_PAT, MOD_OPT, PCRE2_ALLOW_EMPTY_CLASS, PO(options) }, 593 { "allow_surrogate_escapes", MOD_CTC, MOD_OPT, PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES, CO(extra_options) }, 594 { "allusedtext", MOD_PNDP, MOD_CTL, CTL_ALLUSEDTEXT, PO(control) }, 595 { "alt_bsux", MOD_PAT, MOD_OPT, PCRE2_ALT_BSUX, PO(options) }, 596 { "alt_circumflex", MOD_PAT, MOD_OPT, PCRE2_ALT_CIRCUMFLEX, PO(options) }, 597 { "alt_verbnames", MOD_PAT, MOD_OPT, PCRE2_ALT_VERBNAMES, PO(options) }, 598 { "altglobal", MOD_PND, MOD_CTL, CTL_ALTGLOBAL, PO(control) }, 599 { "anchored", MOD_PD, MOD_OPT, PCRE2_ANCHORED, PD(options) }, 600 { "auto_callout", MOD_PAT, MOD_OPT, PCRE2_AUTO_CALLOUT, PO(options) }, 601 { "bad_escape_is_literal", MOD_CTC, MOD_OPT, PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL, CO(extra_options) }, 602 { "bincode", MOD_PAT, MOD_CTL, CTL_BINCODE, PO(control) }, 603 { "bsr", MOD_CTC, MOD_BSR, 0, CO(bsr_convention) }, 604 { "callout_capture", MOD_DAT, MOD_CTL, CTL_CALLOUT_CAPTURE, DO(control) }, 605 { "callout_data", MOD_DAT, MOD_INS, 0, DO(callout_data) }, 606 { "callout_error", MOD_DAT, MOD_IN2, 0, DO(cerror) }, 607 { "callout_extra", MOD_DAT, MOD_CTL, CTL2_CALLOUT_EXTRA, DO(control2) }, 608 { "callout_fail", MOD_DAT, MOD_IN2, 0, DO(cfail) }, 609 { "callout_info", MOD_PAT, MOD_CTL, CTL_CALLOUT_INFO, PO(control) }, 610 { "callout_no_where", MOD_DAT, MOD_CTL, CTL2_CALLOUT_NO_WHERE, DO(control2) }, 611 { "callout_none", MOD_DAT, MOD_CTL, CTL_CALLOUT_NONE, DO(control) }, 612 { "caseless", MOD_PATP, MOD_OPT, PCRE2_CASELESS, PO(options) }, 613 { "convert", MOD_PAT, MOD_CON, 0, PO(convert_type) }, 614 { "convert_glob_escape", MOD_PAT, MOD_CHR, 0, PO(convert_glob_escape) }, 615 { "convert_glob_separator", MOD_PAT, MOD_CHR, 0, PO(convert_glob_separator) }, 616 { "convert_length", MOD_PAT, MOD_INT, 0, PO(convert_length) }, 617 { "copy", MOD_DAT, MOD_NN, DO(copy_numbers), DO(copy_names) }, 618 { "debug", MOD_PAT, MOD_CTL, CTL_DEBUG, PO(control) }, 619 { "depth_limit", MOD_CTM, MOD_INT, 0, MO(depth_limit) }, 620 { "dfa", MOD_DAT, MOD_CTL, CTL_DFA, DO(control) }, 621 { "dfa_restart", MOD_DAT, MOD_OPT, PCRE2_DFA_RESTART, DO(options) }, 622 { "dfa_shortest", MOD_DAT, MOD_OPT, PCRE2_DFA_SHORTEST, DO(options) }, 623 { "dollar_endonly", MOD_PAT, MOD_OPT, PCRE2_DOLLAR_ENDONLY, PO(options) }, 624 { "dotall", MOD_PATP, MOD_OPT, PCRE2_DOTALL, PO(options) }, 625 { "dupnames", MOD_PATP, MOD_OPT, PCRE2_DUPNAMES, PO(options) }, 626 { "endanchored", MOD_PD, MOD_OPT, PCRE2_ENDANCHORED, PD(options) }, 627 { "expand", MOD_PAT, MOD_CTL, CTL_EXPAND, PO(control) }, 628 { "extended", MOD_PATP, MOD_OPT, PCRE2_EXTENDED, PO(options) }, 629 { "extended_more", MOD_PATP, MOD_OPT, PCRE2_EXTENDED_MORE, PO(options) }, 630 { "find_limits", MOD_DAT, MOD_CTL, CTL_FINDLIMITS, DO(control) }, 631 { "firstline", MOD_PAT, MOD_OPT, PCRE2_FIRSTLINE, PO(options) }, 632 { "framesize", MOD_PAT, MOD_CTL, CTL_FRAMESIZE, PO(control) }, 633 { "fullbincode", MOD_PAT, MOD_CTL, CTL_FULLBINCODE, PO(control) }, 634 { "get", MOD_DAT, MOD_NN, DO(get_numbers), DO(get_names) }, 635 { "getall", MOD_DAT, MOD_CTL, CTL_GETALL, DO(control) }, 636 { "global", MOD_PNDP, MOD_CTL, CTL_GLOBAL, PO(control) }, 637 { "heap_limit", MOD_CTM, MOD_INT, 0, MO(heap_limit) }, 638 { "hex", MOD_PAT, MOD_CTL, CTL_HEXPAT, PO(control) }, 639 { "info", MOD_PAT, MOD_CTL, CTL_INFO, PO(control) }, 640 { "jit", MOD_PAT, MOD_IND, 7, PO(jit) }, 641 { "jitfast", MOD_PAT, MOD_CTL, CTL_JITFAST, PO(control) }, 642 { "jitstack", MOD_PNDP, MOD_INT, 0, PO(jitstack) }, 643 { "jitverify", MOD_PAT, MOD_CTL, CTL_JITVERIFY, PO(control) }, 644 { "literal", MOD_PAT, MOD_OPT, PCRE2_LITERAL, PO(options) }, 645 { "locale", MOD_PAT, MOD_STR, LOCALESIZE, PO(locale) }, 646 { "mark", MOD_PNDP, MOD_CTL, CTL_MARK, PO(control) }, 647 { "match_limit", MOD_CTM, MOD_INT, 0, MO(match_limit) }, 648 { "match_line", MOD_CTC, MOD_OPT, PCRE2_EXTRA_MATCH_LINE, CO(extra_options) }, 649 { "match_unset_backref", MOD_PAT, MOD_OPT, PCRE2_MATCH_UNSET_BACKREF, PO(options) }, 650 { "match_word", MOD_CTC, MOD_OPT, PCRE2_EXTRA_MATCH_WORD, CO(extra_options) }, 651 { "max_pattern_length", MOD_CTC, MOD_SIZ, 0, CO(max_pattern_length) }, 652 { "memory", MOD_PD, MOD_CTL, CTL_MEMORY, PD(control) }, 653 { "multiline", MOD_PATP, MOD_OPT, PCRE2_MULTILINE, PO(options) }, 654 { "never_backslash_c", MOD_PAT, MOD_OPT, PCRE2_NEVER_BACKSLASH_C, PO(options) }, 655 { "never_ucp", MOD_PAT, MOD_OPT, PCRE2_NEVER_UCP, PO(options) }, 656 { "never_utf", MOD_PAT, MOD_OPT, PCRE2_NEVER_UTF, PO(options) }, 657 { "newline", MOD_CTC, MOD_NL, 0, CO(newline_convention) }, 658 { "no_auto_capture", MOD_PAT, MOD_OPT, PCRE2_NO_AUTO_CAPTURE, PO(options) }, 659 { "no_auto_possess", MOD_PATP, MOD_OPT, PCRE2_NO_AUTO_POSSESS, PO(options) }, 660 { "no_dotstar_anchor", MOD_PAT, MOD_OPT, PCRE2_NO_DOTSTAR_ANCHOR, PO(options) }, 661 { "no_jit", MOD_DAT, MOD_OPT, PCRE2_NO_JIT, DO(options) }, 662 { "no_start_optimize", MOD_PATP, MOD_OPT, PCRE2_NO_START_OPTIMIZE, PO(options) }, 663 { "no_utf_check", MOD_PD, MOD_OPT, PCRE2_NO_UTF_CHECK, PD(options) }, 664 { "notbol", MOD_DAT, MOD_OPT, PCRE2_NOTBOL, DO(options) }, 665 { "notempty", MOD_DAT, MOD_OPT, PCRE2_NOTEMPTY, DO(options) }, 666 { "notempty_atstart", MOD_DAT, MOD_OPT, PCRE2_NOTEMPTY_ATSTART, DO(options) }, 667 { "noteol", MOD_DAT, MOD_OPT, PCRE2_NOTEOL, DO(options) }, 668 { "null_context", MOD_PD, MOD_CTL, CTL_NULLCONTEXT, PO(control) }, 669 { "offset", MOD_DAT, MOD_INT, 0, DO(offset) }, 670 { "offset_limit", MOD_CTM, MOD_SIZ, 0, MO(offset_limit)}, 671 { "ovector", MOD_DAT, MOD_INT, 0, DO(oveccount) }, 672 { "parens_nest_limit", MOD_CTC, MOD_INT, 0, CO(parens_nest_limit) }, 673 { "partial_hard", MOD_DAT, MOD_OPT, PCRE2_PARTIAL_HARD, DO(options) }, 674 { "partial_soft", MOD_DAT, MOD_OPT, PCRE2_PARTIAL_SOFT, DO(options) }, 675 { "ph", MOD_DAT, MOD_OPT, PCRE2_PARTIAL_HARD, DO(options) }, 676 { "posix", MOD_PAT, MOD_CTL, CTL_POSIX, PO(control) }, 677 { "posix_nosub", MOD_PAT, MOD_CTL, CTL_POSIX|CTL_POSIX_NOSUB, PO(control) }, 678 { "posix_startend", MOD_DAT, MOD_IN2, 0, DO(startend) }, 679 { "ps", MOD_DAT, MOD_OPT, PCRE2_PARTIAL_SOFT, DO(options) }, 680 { "push", MOD_PAT, MOD_CTL, CTL_PUSH, PO(control) }, 681 { "pushcopy", MOD_PAT, MOD_CTL, CTL_PUSHCOPY, PO(control) }, 682 { "pushtablescopy", MOD_PAT, MOD_CTL, CTL_PUSHTABLESCOPY, PO(control) }, 683 { "recursion_limit", MOD_CTM, MOD_INT, 0, MO(depth_limit) }, /* Obsolete synonym */ 684 { "regerror_buffsize", MOD_PAT, MOD_INT, 0, PO(regerror_buffsize) }, 685 { "replace", MOD_PND, MOD_STR, REPLACE_MODSIZE, PO(replacement) }, 686 { "stackguard", MOD_PAT, MOD_INT, 0, PO(stackguard_test) }, 687 { "startchar", MOD_PND, MOD_CTL, CTL_STARTCHAR, PO(control) }, 688 { "startoffset", MOD_DAT, MOD_INT, 0, DO(offset) }, 689 { "subject_literal", MOD_PATP, MOD_CTL, CTL2_SUBJECT_LITERAL, PO(control2) }, 690 { "substitute_extended", MOD_PND, MOD_CTL, CTL2_SUBSTITUTE_EXTENDED, PO(control2) }, 691 { "substitute_overflow_length", MOD_PND, MOD_CTL, CTL2_SUBSTITUTE_OVERFLOW_LENGTH, PO(control2) }, 692 { "substitute_unknown_unset", MOD_PND, MOD_CTL, CTL2_SUBSTITUTE_UNKNOWN_UNSET, PO(control2) }, 693 { "substitute_unset_empty", MOD_PND, MOD_CTL, CTL2_SUBSTITUTE_UNSET_EMPTY, PO(control2) }, 694 { "tables", MOD_PAT, MOD_INT, 0, PO(tables_id) }, 695 { "ucp", MOD_PATP, MOD_OPT, PCRE2_UCP, PO(options) }, 696 { "ungreedy", MOD_PAT, MOD_OPT, PCRE2_UNGREEDY, PO(options) }, 697 { "use_length", MOD_PAT, MOD_CTL, CTL_USE_LENGTH, PO(control) }, 698 { "use_offset_limit", MOD_PAT, MOD_OPT, PCRE2_USE_OFFSET_LIMIT, PO(options) }, 699 { "utf", MOD_PATP, MOD_OPT, PCRE2_UTF, PO(options) }, 700 { "utf8_input", MOD_PAT, MOD_CTL, CTL_UTF8_INPUT, PO(control) }, 701 { "zero_terminate", MOD_DAT, MOD_CTL, CTL_ZERO_TERMINATE, DO(control) } 702 }; 703 704 #define MODLISTCOUNT sizeof(modlist)/sizeof(modstruct) 705 706 /* Controls and options that are supported for use with the POSIX interface. */ 707 708 #define POSIX_SUPPORTED_COMPILE_OPTIONS ( \ 709 PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_LITERAL|PCRE2_MULTILINE|PCRE2_UCP| \ 710 PCRE2_UTF|PCRE2_UNGREEDY) 711 712 #define POSIX_SUPPORTED_COMPILE_EXTRA_OPTIONS (0) 713 714 #define POSIX_SUPPORTED_COMPILE_CONTROLS ( \ 715 CTL_AFTERTEXT|CTL_ALLAFTERTEXT|CTL_EXPAND|CTL_HEXPAT|CTL_POSIX| \ 716 CTL_POSIX_NOSUB|CTL_USE_LENGTH) 717 718 #define POSIX_SUPPORTED_COMPILE_CONTROLS2 (0) 719 720 #define POSIX_SUPPORTED_MATCH_OPTIONS ( \ 721 PCRE2_NOTBOL|PCRE2_NOTEMPTY|PCRE2_NOTEOL) 722 723 #define POSIX_SUPPORTED_MATCH_CONTROLS (CTL_AFTERTEXT|CTL_ALLAFTERTEXT) 724 #define POSIX_SUPPORTED_MATCH_CONTROLS2 (0) 725 726 /* Control bits that are not ignored with 'push'. */ 727 728 #define PUSH_SUPPORTED_COMPILE_CONTROLS ( \ 729 CTL_BINCODE|CTL_CALLOUT_INFO|CTL_FULLBINCODE|CTL_HEXPAT|CTL_INFO| \ 730 CTL_JITVERIFY|CTL_MEMORY|CTL_FRAMESIZE|CTL_PUSH|CTL_PUSHCOPY| \ 731 CTL_PUSHTABLESCOPY|CTL_USE_LENGTH) 732 733 #define PUSH_SUPPORTED_COMPILE_CONTROLS2 (CTL2_BSR_SET|CTL2_NL_SET) 734 735 /* Controls that apply only at compile time with 'push'. */ 736 737 #define PUSH_COMPILE_ONLY_CONTROLS CTL_JITVERIFY 738 #define PUSH_COMPILE_ONLY_CONTROLS2 (0) 739 740 /* Controls that are forbidden with #pop or #popcopy. */ 741 742 #define NOTPOP_CONTROLS (CTL_HEXPAT|CTL_POSIX|CTL_POSIX_NOSUB|CTL_PUSH| \ 743 CTL_PUSHCOPY|CTL_PUSHTABLESCOPY|CTL_USE_LENGTH) 744 745 /* Pattern controls that are mutually exclusive. At present these are all in 746 the first control word. Note that CTL_POSIX_NOSUB is always accompanied by 747 CTL_POSIX, so it doesn't need its own entries. */ 748 749 static uint32_t exclusive_pat_controls[] = { 750 CTL_POSIX | CTL_PUSH, 751 CTL_POSIX | CTL_PUSHCOPY, 752 CTL_POSIX | CTL_PUSHTABLESCOPY, 753 CTL_PUSH | CTL_PUSHCOPY, 754 CTL_PUSH | CTL_PUSHTABLESCOPY, 755 CTL_PUSHCOPY | CTL_PUSHTABLESCOPY, 756 CTL_EXPAND | CTL_HEXPAT }; 757 758 /* Data controls that are mutually exclusive. At present these are all in the 759 first control word. */ 760 761 static uint32_t exclusive_dat_controls[] = { 762 CTL_ALLUSEDTEXT | CTL_STARTCHAR, 763 CTL_FINDLIMITS | CTL_NULLCONTEXT }; 764 765 /* Table of single-character abbreviated modifiers. The index field is 766 initialized to -1, but the first time the modifier is encountered, it is filled 767 in with the index of the full entry in modlist, to save repeated searching when 768 processing multiple test items. This short list is searched serially, so its 769 order does not matter. */ 770 771 typedef struct c1modstruct { 772 const char *fullname; 773 uint32_t onechar; 774 int index; 775 } c1modstruct; 776 777 static c1modstruct c1modlist[] = { 778 { "bincode", 'B', -1 }, 779 { "info", 'I', -1 }, 780 { "global", 'g', -1 }, 781 { "caseless", 'i', -1 }, 782 { "multiline", 'm', -1 }, 783 { "no_auto_capture", 'n', -1 }, 784 { "dotall", 's', -1 }, 785 { "extended", 'x', -1 } 786 }; 787 788 #define C1MODLISTCOUNT sizeof(c1modlist)/sizeof(c1modstruct) 789 790 /* Table of arguments for the -C command line option. Use macros to make the 791 table itself easier to read. */ 792 793 #if defined SUPPORT_PCRE2_8 794 #define SUPPORT_8 1 795 #endif 796 #if defined SUPPORT_PCRE2_16 797 #define SUPPORT_16 1 798 #endif 799 #if defined SUPPORT_PCRE2_32 800 #define SUPPORT_32 1 801 #endif 802 803 #ifndef SUPPORT_8 804 #define SUPPORT_8 0 805 #endif 806 #ifndef SUPPORT_16 807 #define SUPPORT_16 0 808 #endif 809 #ifndef SUPPORT_32 810 #define SUPPORT_32 0 811 #endif 812 813 #ifdef EBCDIC 814 #define SUPPORT_EBCDIC 1 815 #define EBCDIC_NL CHAR_LF 816 #else 817 #define SUPPORT_EBCDIC 0 818 #define EBCDIC_NL 0 819 #endif 820 821 #ifdef NEVER_BACKSLASH_C 822 #define BACKSLASH_C 0 823 #else 824 #define BACKSLASH_C 1 825 #endif 826 827 typedef struct coptstruct { 828 const char *name; 829 uint32_t type; 830 uint32_t value; 831 } coptstruct; 832 833 enum { CONF_BSR, 834 CONF_FIX, 835 CONF_FIZ, 836 CONF_INT, 837 CONF_NL 838 }; 839 840 static coptstruct coptlist[] = { 841 { "backslash-C", CONF_FIX, BACKSLASH_C }, 842 { "bsr", CONF_BSR, PCRE2_CONFIG_BSR }, 843 { "ebcdic", CONF_FIX, SUPPORT_EBCDIC }, 844 { "ebcdic-nl", CONF_FIZ, EBCDIC_NL }, 845 { "jit", CONF_INT, PCRE2_CONFIG_JIT }, 846 { "linksize", CONF_INT, PCRE2_CONFIG_LINKSIZE }, 847 { "newline", CONF_NL, PCRE2_CONFIG_NEWLINE }, 848 { "pcre2-16", CONF_FIX, SUPPORT_16 }, 849 { "pcre2-32", CONF_FIX, SUPPORT_32 }, 850 { "pcre2-8", CONF_FIX, SUPPORT_8 }, 851 { "unicode", CONF_INT, PCRE2_CONFIG_UNICODE } 852 }; 853 854 #define COPTLISTCOUNT sizeof(coptlist)/sizeof(coptstruct) 855 856 #undef SUPPORT_8 857 #undef SUPPORT_16 858 #undef SUPPORT_32 859 #undef SUPPORT_EBCDIC 860 861 862 /* ----------------------- Static variables ------------------------ */ 863 864 static FILE *infile; 865 static FILE *outfile; 866 867 static const void *last_callout_mark; 868 static PCRE2_JIT_STACK *jit_stack = NULL; 869 static size_t jit_stack_size = 0; 870 871 static BOOL first_callout; 872 static BOOL jit_was_used; 873 static BOOL restrict_for_perl_test = FALSE; 874 static BOOL show_memory = FALSE; 875 876 static int code_unit_size; /* Bytes */ 877 static int jitrc; /* Return from JIT compile */ 878 static int test_mode = DEFAULT_TEST_MODE; 879 static int timeit = 0; 880 static int timeitm = 0; 881 882 clock_t total_compile_time = 0; 883 clock_t total_jit_compile_time = 0; 884 clock_t total_match_time = 0; 885 886 static uint32_t dfa_matched; 887 static uint32_t forbid_utf = 0; 888 static uint32_t maxlookbehind; 889 static uint32_t max_oveccount; 890 static uint32_t callout_count; 891 892 static uint16_t local_newline_default = 0; 893 894 static VERSION_TYPE jittarget[VERSION_SIZE]; 895 static VERSION_TYPE version[VERSION_SIZE]; 896 static VERSION_TYPE uversion[VERSION_SIZE]; 897 898 static patctl def_patctl; 899 static patctl pat_patctl; 900 static datctl def_datctl; 901 static datctl dat_datctl; 902 903 static void *patstack[PATSTACKSIZE]; 904 static int patstacknext = 0; 905 906 static void *malloclist[MALLOCLISTSIZE]; 907 static PCRE2_SIZE malloclistlength[MALLOCLISTSIZE]; 908 static uint32_t malloclistptr = 0; 909 910 #ifdef SUPPORT_PCRE2_8 911 static regex_t preg = { NULL, NULL, 0, 0, 0, 0 }; 912 #endif 913 914 static int *dfa_workspace = NULL; 915 static const uint8_t *locale_tables = NULL; 916 static const uint8_t *use_tables = NULL; 917 static uint8_t locale_name[32]; 918 919 /* We need buffers for building 16/32-bit strings; 8-bit strings don't need 920 rebuilding, but set up the same naming scheme for use in macros. The "buffer" 921 buffer is where all input lines are read. Its size is the same as pbuffer8. 922 Pattern lines are always copied to pbuffer8 for use in callouts, even if they 923 are actually compiled from pbuffer16 or pbuffer32. */ 924 925 static size_t pbuffer8_size = 50000; /* Initial size, bytes */ 926 static uint8_t *pbuffer8 = NULL; 927 static uint8_t *buffer = NULL; 928 929 /* The dbuffer is where all processed data lines are put. In non-8-bit modes it 930 is cast as needed. For long data lines it grows as necessary. */ 931 932 static size_t dbuffer_size = 1u << 14; /* Initial size, bytes */ 933 static uint8_t *dbuffer = NULL; 934 935 936 /* ---------------- Mode-dependent variables -------------------*/ 937 938 #ifdef SUPPORT_PCRE2_8 939 static pcre2_code_8 *compiled_code8; 940 static pcre2_general_context_8 *general_context8, *general_context_copy8; 941 static pcre2_compile_context_8 *pat_context8, *default_pat_context8; 942 static pcre2_convert_context_8 *con_context8, *default_con_context8; 943 static pcre2_match_context_8 *dat_context8, *default_dat_context8; 944 static pcre2_match_data_8 *match_data8; 945 #endif 946 947 #ifdef SUPPORT_PCRE2_16 948 static pcre2_code_16 *compiled_code16; 949 static pcre2_general_context_16 *general_context16, *general_context_copy16; 950 static pcre2_compile_context_16 *pat_context16, *default_pat_context16; 951 static pcre2_convert_context_16 *con_context16, *default_con_context16; 952 static pcre2_match_context_16 *dat_context16, *default_dat_context16; 953 static pcre2_match_data_16 *match_data16; 954 static PCRE2_SIZE pbuffer16_size = 0; /* Set only when needed */ 955 static uint16_t *pbuffer16 = NULL; 956 #endif 957 958 #ifdef SUPPORT_PCRE2_32 959 static pcre2_code_32 *compiled_code32; 960 static pcre2_general_context_32 *general_context32, *general_context_copy32; 961 static pcre2_compile_context_32 *pat_context32, *default_pat_context32; 962 static pcre2_convert_context_32 *con_context32, *default_con_context32; 963 static pcre2_match_context_32 *dat_context32, *default_dat_context32; 964 static pcre2_match_data_32 *match_data32; 965 static PCRE2_SIZE pbuffer32_size = 0; /* Set only when needed */ 966 static uint32_t *pbuffer32 = NULL; 967 #endif 968 969 970 /* ---------------- Macros that work in all modes ----------------- */ 971 972 #define CAST8VAR(x) CASTVAR(uint8_t *, x) 973 #define SET(x,y) SETOP(x,y,=) 974 #define SETPLUS(x,y) SETOP(x,y,+=) 975 #define strlen8(x) strlen((char *)x) 976 977 978 /* ---------------- Mode-dependent, runtime-testing macros ------------------*/ 979 980 /* Define macros for variables and functions that must be selected dynamically 981 depending on the mode setting (8, 16, 32). These are dependent on which modes 982 are supported. */ 983 984 #if (defined (SUPPORT_PCRE2_8) + defined (SUPPORT_PCRE2_16) + \ 985 defined (SUPPORT_PCRE2_32)) >= 2 986 987 /* ----- All three modes supported ----- */ 988 989 #if defined(SUPPORT_PCRE2_8) && defined(SUPPORT_PCRE2_16) && defined(SUPPORT_PCRE2_32) 990 991 #define CASTFLD(t,a,b) ((test_mode == PCRE8_MODE)? (t)(G(a,8)->b) : \ 992 (test_mode == PCRE16_MODE)? (t)(G(a,16)->b) : (t)(G(a,32)->b)) 993 994 #define CASTVAR(t,x) ( \ 995 (test_mode == PCRE8_MODE)? (t)G(x,8) : \ 996 (test_mode == PCRE16_MODE)? (t)G(x,16) : (t)G(x,32)) 997 998 #define CODE_UNIT(a,b) ( \ 999 (test_mode == PCRE8_MODE)? (uint32_t)(((PCRE2_SPTR8)(a))[b]) : \ 1000 (test_mode == PCRE16_MODE)? (uint32_t)(((PCRE2_SPTR16)(a))[b]) : \ 1001 (uint32_t)(((PCRE2_SPTR32)(a))[b])) 1002 1003 #define CONCTXCPY(a,b) \ 1004 if (test_mode == PCRE8_MODE) \ 1005 memcpy(G(a,8),G(b,8),sizeof(pcre2_convert_context_8)); \ 1006 else if (test_mode == PCRE16_MODE) \ 1007 memcpy(G(a,16),G(b,16),sizeof(pcre2_convert_context_16)); \ 1008 else memcpy(G(a,32),G(b,32),sizeof(pcre2_convert_context_32)) 1009 1010 #define CONVERT_COPY(a,b,c) \ 1011 if (test_mode == PCRE8_MODE) \ 1012 memcpy(G(a,8),(char *)b,c); \ 1013 else if (test_mode == PCRE16_MODE) \ 1014 memcpy(G(a,16),(char *)b,(c)*2); \ 1015 else if (test_mode == PCRE32_MODE) \ 1016 memcpy(G(a,32),(char *)b,(c)*4) 1017 1018 #define DATCTXCPY(a,b) \ 1019 if (test_mode == PCRE8_MODE) \ 1020 memcpy(G(a,8),G(b,8),sizeof(pcre2_match_context_8)); \ 1021 else if (test_mode == PCRE16_MODE) \ 1022 memcpy(G(a,16),G(b,16),sizeof(pcre2_match_context_16)); \ 1023 else memcpy(G(a,32),G(b,32),sizeof(pcre2_match_context_32)) 1024 1025 #define FLD(a,b) ((test_mode == PCRE8_MODE)? G(a,8)->b : \ 1026 (test_mode == PCRE16_MODE)? G(a,16)->b : G(a,32)->b) 1027 1028 #define PATCTXCPY(a,b) \ 1029 if (test_mode == PCRE8_MODE) \ 1030 memcpy(G(a,8),G(b,8),sizeof(pcre2_compile_context_8)); \ 1031 else if (test_mode == PCRE16_MODE) \ 1032 memcpy(G(a,16),G(b,16),sizeof(pcre2_compile_context_16)); \ 1033 else memcpy(G(a,32),G(b,32),sizeof(pcre2_compile_context_32)) 1034 1035 #define PCHARS(lv, p, offset, len, utf, f) \ 1036 if (test_mode == PCRE32_MODE) \ 1037 lv = pchars32((PCRE2_SPTR32)(p)+offset, len, utf, f); \ 1038 else if (test_mode == PCRE16_MODE) \ 1039 lv = pchars16((PCRE2_SPTR16)(p)+offset, len, utf, f); \ 1040 else \ 1041 lv = pchars8((PCRE2_SPTR8)(p)+offset, len, utf, f) 1042 1043 #define PCHARSV(p, offset, len, utf, f) \ 1044 if (test_mode == PCRE32_MODE) \ 1045 (void)pchars32((PCRE2_SPTR32)(p)+offset, len, utf, f); \ 1046 else if (test_mode == PCRE16_MODE) \ 1047 (void)pchars16((PCRE2_SPTR16)(p)+offset, len, utf, f); \ 1048 else \ 1049 (void)pchars8((PCRE2_SPTR8)(p)+offset, len, utf, f) 1050 1051 #define PCRE2_CALLOUT_ENUMERATE(a,b,c) \ 1052 if (test_mode == PCRE8_MODE) \ 1053 a = pcre2_callout_enumerate_8(compiled_code8, \ 1054 (int (*)(struct pcre2_callout_enumerate_block_8 *, void *))b,c); \ 1055 else if (test_mode == PCRE16_MODE) \ 1056 a = pcre2_callout_enumerate_16(compiled_code16, \ 1057 (int(*)(struct pcre2_callout_enumerate_block_16 *, void *))b,c); \ 1058 else \ 1059 a = pcre2_callout_enumerate_32(compiled_code32, \ 1060 (int (*)(struct pcre2_callout_enumerate_block_32 *, void *))b,c) 1061 1062 #define PCRE2_CODE_COPY_FROM_VOID(a,b) \ 1063 if (test_mode == PCRE8_MODE) \ 1064 G(a,8) = pcre2_code_copy_8(b); \ 1065 else if (test_mode == PCRE16_MODE) \ 1066 G(a,16) = pcre2_code_copy_16(b); \ 1067 else \ 1068 G(a,32) = pcre2_code_copy_32(b) 1069 1070 #define PCRE2_CODE_COPY_TO_VOID(a,b) \ 1071 if (test_mode == PCRE8_MODE) \ 1072 a = (void *)pcre2_code_copy_8(G(b,8)); \ 1073 else if (test_mode == PCRE16_MODE) \ 1074 a = (void *)pcre2_code_copy_16(G(b,16)); \ 1075 else \ 1076 a = (void *)pcre2_code_copy_32(G(b,32)) 1077 1078 #define PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(a,b) \ 1079 if (test_mode == PCRE8_MODE) \ 1080 a = (void *)pcre2_code_copy_with_tables_8(G(b,8)); \ 1081 else if (test_mode == PCRE16_MODE) \ 1082 a = (void *)pcre2_code_copy_with_tables_16(G(b,16)); \ 1083 else \ 1084 a = (void *)pcre2_code_copy_with_tables_32(G(b,32)) 1085 1086 #define PCRE2_COMPILE(a,b,c,d,e,f,g) \ 1087 if (test_mode == PCRE8_MODE) \ 1088 G(a,8) = pcre2_compile_8(G(b,8),c,d,e,f,g); \ 1089 else if (test_mode == PCRE16_MODE) \ 1090 G(a,16) = pcre2_compile_16(G(b,16),c,d,e,f,g); \ 1091 else \ 1092 G(a,32) = pcre2_compile_32(G(b,32),c,d,e,f,g) 1093 1094 #define PCRE2_CONVERTED_PATTERN_FREE(a) \ 1095 if (test_mode == PCRE8_MODE) pcre2_converted_pattern_free_8((PCRE2_UCHAR8 *)a); \ 1096 else if (test_mode == PCRE16_MODE) pcre2_converted_pattern_free_16((PCRE2_UCHAR16 *)a); \ 1097 else pcre2_converted_pattern_free_32((PCRE2_UCHAR32 *)a) 1098 1099 #define PCRE2_DFA_MATCH(a,b,c,d,e,f,g,h,i,j) \ 1100 if (test_mode == PCRE8_MODE) \ 1101 a = pcre2_dfa_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h,i,j); \ 1102 else if (test_mode == PCRE16_MODE) \ 1103 a = pcre2_dfa_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h,i,j); \ 1104 else \ 1105 a = pcre2_dfa_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h,i,j) 1106 1107 #define PCRE2_GET_ERROR_MESSAGE(r,a,b) \ 1108 if (test_mode == PCRE8_MODE) \ 1109 r = pcre2_get_error_message_8(a,G(b,8),G(G(b,8),_size)); \ 1110 else if (test_mode == PCRE16_MODE) \ 1111 r = pcre2_get_error_message_16(a,G(b,16),G(G(b,16),_size/2)); \ 1112 else \ 1113 r = pcre2_get_error_message_32(a,G(b,32),G(G(b,32),_size/4)) 1114 1115 #define PCRE2_GET_OVECTOR_COUNT(a,b) \ 1116 if (test_mode == PCRE8_MODE) \ 1117 a = pcre2_get_ovector_count_8(G(b,8)); \ 1118 else if (test_mode == PCRE16_MODE) \ 1119 a = pcre2_get_ovector_count_16(G(b,16)); \ 1120 else \ 1121 a = pcre2_get_ovector_count_32(G(b,32)) 1122 1123 #define PCRE2_GET_STARTCHAR(a,b) \ 1124 if (test_mode == PCRE8_MODE) \ 1125 a = pcre2_get_startchar_8(G(b,8)); \ 1126 else if (test_mode == PCRE16_MODE) \ 1127 a = pcre2_get_startchar_16(G(b,16)); \ 1128 else \ 1129 a = pcre2_get_startchar_32(G(b,32)) 1130 1131 #define PCRE2_JIT_COMPILE(r,a,b) \ 1132 if (test_mode == PCRE8_MODE) r = pcre2_jit_compile_8(G(a,8),b); \ 1133 else if (test_mode == PCRE16_MODE) r = pcre2_jit_compile_16(G(a,16),b); \ 1134 else r = pcre2_jit_compile_32(G(a,32),b) 1135 1136 #define PCRE2_JIT_FREE_UNUSED_MEMORY(a) \ 1137 if (test_mode == PCRE8_MODE) pcre2_jit_free_unused_memory_8(G(a,8)); \ 1138 else if (test_mode == PCRE16_MODE) pcre2_jit_free_unused_memory_16(G(a,16)); \ 1139 else pcre2_jit_free_unused_memory_32(G(a,32)) 1140 1141 #define PCRE2_JIT_MATCH(a,b,c,d,e,f,g,h) \ 1142 if (test_mode == PCRE8_MODE) \ 1143 a = pcre2_jit_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h); \ 1144 else if (test_mode == PCRE16_MODE) \ 1145 a = pcre2_jit_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h); \ 1146 else \ 1147 a = pcre2_jit_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h) 1148 1149 #define PCRE2_JIT_STACK_CREATE(a,b,c,d) \ 1150 if (test_mode == PCRE8_MODE) \ 1151 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_8(b,c,d); \ 1152 else if (test_mode == PCRE16_MODE) \ 1153 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_16(b,c,d); \ 1154 else \ 1155 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_32(b,c,d); 1156 1157 #define PCRE2_JIT_STACK_ASSIGN(a,b,c) \ 1158 if (test_mode == PCRE8_MODE) \ 1159 pcre2_jit_stack_assign_8(G(a,8),(pcre2_jit_callback_8)b,c); \ 1160 else if (test_mode == PCRE16_MODE) \ 1161 pcre2_jit_stack_assign_16(G(a,16),(pcre2_jit_callback_16)b,c); \ 1162 else \ 1163 pcre2_jit_stack_assign_32(G(a,32),(pcre2_jit_callback_32)b,c); 1164 1165 #define PCRE2_JIT_STACK_FREE(a) \ 1166 if (test_mode == PCRE8_MODE) \ 1167 pcre2_jit_stack_free_8((pcre2_jit_stack_8 *)a); \ 1168 else if (test_mode == PCRE16_MODE) \ 1169 pcre2_jit_stack_free_16((pcre2_jit_stack_16 *)a); \ 1170 else \ 1171 pcre2_jit_stack_free_32((pcre2_jit_stack_32 *)a); 1172 1173 #define PCRE2_MAKETABLES(a) \ 1174 if (test_mode == PCRE8_MODE) a = pcre2_maketables_8(NULL); \ 1175 else if (test_mode == PCRE16_MODE) a = pcre2_maketables_16(NULL); \ 1176 else a = pcre2_maketables_32(NULL) 1177 1178 #define PCRE2_MATCH(a,b,c,d,e,f,g,h) \ 1179 if (test_mode == PCRE8_MODE) \ 1180 a = pcre2_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h); \ 1181 else if (test_mode == PCRE16_MODE) \ 1182 a = pcre2_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h); \ 1183 else \ 1184 a = pcre2_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h) 1185 1186 #define PCRE2_MATCH_DATA_CREATE(a,b,c) \ 1187 if (test_mode == PCRE8_MODE) \ 1188 G(a,8) = pcre2_match_data_create_8(b,c); \ 1189 else if (test_mode == PCRE16_MODE) \ 1190 G(a,16) = pcre2_match_data_create_16(b,c); \ 1191 else \ 1192 G(a,32) = pcre2_match_data_create_32(b,c) 1193 1194 #define PCRE2_MATCH_DATA_CREATE_FROM_PATTERN(a,b,c) \ 1195 if (test_mode == PCRE8_MODE) \ 1196 G(a,8) = pcre2_match_data_create_from_pattern_8(G(b,8),c); \ 1197 else if (test_mode == PCRE16_MODE) \ 1198 G(a,16) = pcre2_match_data_create_from_pattern_16(G(b,16),c); \ 1199 else \ 1200 G(a,32) = pcre2_match_data_create_from_pattern_32(G(b,32),c) 1201 1202 #define PCRE2_MATCH_DATA_FREE(a) \ 1203 if (test_mode == PCRE8_MODE) \ 1204 pcre2_match_data_free_8(G(a,8)); \ 1205 else if (test_mode == PCRE16_MODE) \ 1206 pcre2_match_data_free_16(G(a,16)); \ 1207 else \ 1208 pcre2_match_data_free_32(G(a,32)) 1209 1210 #define PCRE2_PATTERN_CONVERT(a,b,c,d,e,f,g) \ 1211 if (test_mode == PCRE8_MODE) \ 1212 a = pcre2_pattern_convert_8(G(b,8),c,d,(PCRE2_UCHAR8 **)e,f,G(g,8)); \ 1213 else if (test_mode == PCRE16_MODE) \ 1214 a = pcre2_pattern_convert_16(G(b,16),c,d,(PCRE2_UCHAR16 **)e,f,G(g,16)); \ 1215 else \ 1216 a = pcre2_pattern_convert_32(G(b,32),c,d,(PCRE2_UCHAR32 **)e,f,G(g,32)) 1217 1218 #define PCRE2_PATTERN_INFO(a,b,c,d) \ 1219 if (test_mode == PCRE8_MODE) \ 1220 a = pcre2_pattern_info_8(G(b,8),c,d); \ 1221 else if (test_mode == PCRE16_MODE) \ 1222 a = pcre2_pattern_info_16(G(b,16),c,d); \ 1223 else \ 1224 a = pcre2_pattern_info_32(G(b,32),c,d) 1225 1226 #define PCRE2_PRINTINT(a) \ 1227 if (test_mode == PCRE8_MODE) \ 1228 pcre2_printint_8(compiled_code8,outfile,a); \ 1229 else if (test_mode == PCRE16_MODE) \ 1230 pcre2_printint_16(compiled_code16,outfile,a); \ 1231 else \ 1232 pcre2_printint_32(compiled_code32,outfile,a) 1233 1234 #define PCRE2_SERIALIZE_DECODE(r,a,b,c,d) \ 1235 if (test_mode == PCRE8_MODE) \ 1236 r = pcre2_serialize_decode_8((pcre2_code_8 **)a,b,c,G(d,8)); \ 1237 else if (test_mode == PCRE16_MODE) \ 1238 r = pcre2_serialize_decode_16((pcre2_code_16 **)a,b,c,G(d,16)); \ 1239 else \ 1240 r = pcre2_serialize_decode_32((pcre2_code_32 **)a,b,c,G(d,32)) 1241 1242 #define PCRE2_SERIALIZE_ENCODE(r,a,b,c,d,e) \ 1243 if (test_mode == PCRE8_MODE) \ 1244 r = pcre2_serialize_encode_8((const pcre2_code_8 **)a,b,c,d,G(e,8)); \ 1245 else if (test_mode == PCRE16_MODE) \ 1246 r = pcre2_serialize_encode_16((const pcre2_code_16 **)a,b,c,d,G(e,16)); \ 1247 else \ 1248 r = pcre2_serialize_encode_32((const pcre2_code_32 **)a,b,c,d,G(e,32)) 1249 1250 #define PCRE2_SERIALIZE_FREE(a) \ 1251 if (test_mode == PCRE8_MODE) \ 1252 pcre2_serialize_free_8(a); \ 1253 else if (test_mode == PCRE16_MODE) \ 1254 pcre2_serialize_free_16(a); \ 1255 else \ 1256 pcre2_serialize_free_32(a) 1257 1258 #define PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(r,a) \ 1259 if (test_mode == PCRE8_MODE) \ 1260 r = pcre2_serialize_get_number_of_codes_8(a); \ 1261 else if (test_mode == PCRE16_MODE) \ 1262 r = pcre2_serialize_get_number_of_codes_16(a); \ 1263 else \ 1264 r = pcre2_serialize_get_number_of_codes_32(a); \ 1265 1266 #define PCRE2_SET_CALLOUT(a,b,c) \ 1267 if (test_mode == PCRE8_MODE) \ 1268 pcre2_set_callout_8(G(a,8),(int (*)(pcre2_callout_block_8 *, void *))b,c); \ 1269 else if (test_mode == PCRE16_MODE) \ 1270 pcre2_set_callout_16(G(a,16),(int (*)(pcre2_callout_block_16 *, void *))b,c); \ 1271 else \ 1272 pcre2_set_callout_32(G(a,32),(int (*)(pcre2_callout_block_32 *, void *))b,c); 1273 1274 #define PCRE2_SET_CHARACTER_TABLES(a,b) \ 1275 if (test_mode == PCRE8_MODE) \ 1276 pcre2_set_character_tables_8(G(a,8),b); \ 1277 else if (test_mode == PCRE16_MODE) \ 1278 pcre2_set_character_tables_16(G(a,16),b); \ 1279 else \ 1280 pcre2_set_character_tables_32(G(a,32),b) 1281 1282 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \ 1283 if (test_mode == PCRE8_MODE) \ 1284 pcre2_set_compile_recursion_guard_8(G(a,8),b,c); \ 1285 else if (test_mode == PCRE16_MODE) \ 1286 pcre2_set_compile_recursion_guard_16(G(a,16),b,c); \ 1287 else \ 1288 pcre2_set_compile_recursion_guard_32(G(a,32),b,c) 1289 1290 #define PCRE2_SET_DEPTH_LIMIT(a,b) \ 1291 if (test_mode == PCRE8_MODE) \ 1292 pcre2_set_depth_limit_8(G(a,8),b); \ 1293 else if (test_mode == PCRE16_MODE) \ 1294 pcre2_set_depth_limit_16(G(a,16),b); \ 1295 else \ 1296 pcre2_set_depth_limit_32(G(a,32),b) 1297 1298 #define PCRE2_SET_GLOB_SEPARATOR(r,a,b) \ 1299 if (test_mode == PCRE8_MODE) \ 1300 r = pcre2_set_glob_separator_8(G(a,8),b); \ 1301 else if (test_mode == PCRE16_MODE) \ 1302 r = pcre2_set_glob_separator_16(G(a,16),b); \ 1303 else \ 1304 r = pcre2_set_glob_separator_32(G(a,32),b) 1305 1306 #define PCRE2_SET_GLOB_ESCAPE(r,a,b) \ 1307 if (test_mode == PCRE8_MODE) \ 1308 r = pcre2_set_glob_escape_8(G(a,8),b); \ 1309 else if (test_mode == PCRE16_MODE) \ 1310 r = pcre2_set_glob_escape_16(G(a,16),b); \ 1311 else \ 1312 r = pcre2_set_glob_escape_32(G(a,32),b) 1313 1314 #define PCRE2_SET_HEAP_LIMIT(a,b) \ 1315 if (test_mode == PCRE8_MODE) \ 1316 pcre2_set_heap_limit_8(G(a,8),b); \ 1317 else if (test_mode == PCRE16_MODE) \ 1318 pcre2_set_heap_limit_16(G(a,16),b); \ 1319 else \ 1320 pcre2_set_heap_limit_32(G(a,32),b) 1321 1322 #define PCRE2_SET_MATCH_LIMIT(a,b) \ 1323 if (test_mode == PCRE8_MODE) \ 1324 pcre2_set_match_limit_8(G(a,8),b); \ 1325 else if (test_mode == PCRE16_MODE) \ 1326 pcre2_set_match_limit_16(G(a,16),b); \ 1327 else \ 1328 pcre2_set_match_limit_32(G(a,32),b) 1329 1330 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) \ 1331 if (test_mode == PCRE8_MODE) \ 1332 pcre2_set_max_pattern_length_8(G(a,8),b); \ 1333 else if (test_mode == PCRE16_MODE) \ 1334 pcre2_set_max_pattern_length_16(G(a,16),b); \ 1335 else \ 1336 pcre2_set_max_pattern_length_32(G(a,32),b) 1337 1338 #define PCRE2_SET_OFFSET_LIMIT(a,b) \ 1339 if (test_mode == PCRE8_MODE) \ 1340 pcre2_set_offset_limit_8(G(a,8),b); \ 1341 else if (test_mode == PCRE16_MODE) \ 1342 pcre2_set_offset_limit_16(G(a,16),b); \ 1343 else \ 1344 pcre2_set_offset_limit_32(G(a,32),b) 1345 1346 #define PCRE2_SET_PARENS_NEST_LIMIT(a,b) \ 1347 if (test_mode == PCRE8_MODE) \ 1348 pcre2_set_parens_nest_limit_8(G(a,8),b); \ 1349 else if (test_mode == PCRE16_MODE) \ 1350 pcre2_set_parens_nest_limit_16(G(a,16),b); \ 1351 else \ 1352 pcre2_set_parens_nest_limit_32(G(a,32),b) 1353 1354 #define PCRE2_SUBSTITUTE(a,b,c,d,e,f,g,h,i,j,k,l) \ 1355 if (test_mode == PCRE8_MODE) \ 1356 a = pcre2_substitute_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),G(h,8), \ 1357 (PCRE2_SPTR8)i,j,(PCRE2_UCHAR8 *)k,l); \ 1358 else if (test_mode == PCRE16_MODE) \ 1359 a = pcre2_substitute_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),G(h,16), \ 1360 (PCRE2_SPTR16)i,j,(PCRE2_UCHAR16 *)k,l); \ 1361 else \ 1362 a = pcre2_substitute_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),G(h,32), \ 1363 (PCRE2_SPTR32)i,j,(PCRE2_UCHAR32 *)k,l) 1364 1365 #define PCRE2_SUBSTRING_COPY_BYNAME(a,b,c,d,e) \ 1366 if (test_mode == PCRE8_MODE) \ 1367 a = pcre2_substring_copy_byname_8(G(b,8),G(c,8),(PCRE2_UCHAR8 *)d,e); \ 1368 else if (test_mode == PCRE16_MODE) \ 1369 a = pcre2_substring_copy_byname_16(G(b,16),G(c,16),(PCRE2_UCHAR16 *)d,e); \ 1370 else \ 1371 a = pcre2_substring_copy_byname_32(G(b,32),G(c,32),(PCRE2_UCHAR32 *)d,e) 1372 1373 #define PCRE2_SUBSTRING_COPY_BYNUMBER(a,b,c,d,e) \ 1374 if (test_mode == PCRE8_MODE) \ 1375 a = pcre2_substring_copy_bynumber_8(G(b,8),c,(PCRE2_UCHAR8 *)d,e); \ 1376 else if (test_mode == PCRE16_MODE) \ 1377 a = pcre2_substring_copy_bynumber_16(G(b,16),c,(PCRE2_UCHAR16 *)d,e); \ 1378 else \ 1379 a = pcre2_substring_copy_bynumber_32(G(b,32),c,(PCRE2_UCHAR32 *)d,e) 1380 1381 #define PCRE2_SUBSTRING_FREE(a) \ 1382 if (test_mode == PCRE8_MODE) pcre2_substring_free_8((PCRE2_UCHAR8 *)a); \ 1383 else if (test_mode == PCRE16_MODE) \ 1384 pcre2_substring_free_16((PCRE2_UCHAR16 *)a); \ 1385 else pcre2_substring_free_32((PCRE2_UCHAR32 *)a) 1386 1387 #define PCRE2_SUBSTRING_GET_BYNAME(a,b,c,d,e) \ 1388 if (test_mode == PCRE8_MODE) \ 1389 a = pcre2_substring_get_byname_8(G(b,8),G(c,8),(PCRE2_UCHAR8 **)d,e); \ 1390 else if (test_mode == PCRE16_MODE) \ 1391 a = pcre2_substring_get_byname_16(G(b,16),G(c,16),(PCRE2_UCHAR16 **)d,e); \ 1392 else \ 1393 a = pcre2_substring_get_byname_32(G(b,32),G(c,32),(PCRE2_UCHAR32 **)d,e) 1394 1395 #define PCRE2_SUBSTRING_GET_BYNUMBER(a,b,c,d,e) \ 1396 if (test_mode == PCRE8_MODE) \ 1397 a = pcre2_substring_get_bynumber_8(G(b,8),c,(PCRE2_UCHAR8 **)d,e); \ 1398 else if (test_mode == PCRE16_MODE) \ 1399 a = pcre2_substring_get_bynumber_16(G(b,16),c,(PCRE2_UCHAR16 **)d,e); \ 1400 else \ 1401 a = pcre2_substring_get_bynumber_32(G(b,32),c,(PCRE2_UCHAR32 **)d,e) 1402 1403 #define PCRE2_SUBSTRING_LENGTH_BYNAME(a,b,c,d) \ 1404 if (test_mode == PCRE8_MODE) \ 1405 a = pcre2_substring_length_byname_8(G(b,8),G(c,8),d); \ 1406 else if (test_mode == PCRE16_MODE) \ 1407 a = pcre2_substring_length_byname_16(G(b,16),G(c,16),d); \ 1408 else \ 1409 a = pcre2_substring_length_byname_32(G(b,32),G(c,32),d) 1410 1411 #define PCRE2_SUBSTRING_LENGTH_BYNUMBER(a,b,c,d) \ 1412 if (test_mode == PCRE8_MODE) \ 1413 a = pcre2_substring_length_bynumber_8(G(b,8),c,d); \ 1414 else if (test_mode == PCRE16_MODE) \ 1415 a = pcre2_substring_length_bynumber_16(G(b,16),c,d); \ 1416 else \ 1417 a = pcre2_substring_length_bynumber_32(G(b,32),c,d) 1418 1419 #define PCRE2_SUBSTRING_LIST_GET(a,b,c,d) \ 1420 if (test_mode == PCRE8_MODE) \ 1421 a = pcre2_substring_list_get_8(G(b,8),(PCRE2_UCHAR8 ***)c,d); \ 1422 else if (test_mode == PCRE16_MODE) \ 1423 a = pcre2_substring_list_get_16(G(b,16),(PCRE2_UCHAR16 ***)c,d); \ 1424 else \ 1425 a = pcre2_substring_list_get_32(G(b,32),(PCRE2_UCHAR32 ***)c,d) 1426 1427 #define PCRE2_SUBSTRING_LIST_FREE(a) \ 1428 if (test_mode == PCRE8_MODE) \ 1429 pcre2_substring_list_free_8((PCRE2_SPTR8 *)a); \ 1430 else if (test_mode == PCRE16_MODE) \ 1431 pcre2_substring_list_free_16((PCRE2_SPTR16 *)a); \ 1432 else \ 1433 pcre2_substring_list_free_32((PCRE2_SPTR32 *)a) 1434 1435 #define PCRE2_SUBSTRING_NUMBER_FROM_NAME(a,b,c) \ 1436 if (test_mode == PCRE8_MODE) \ 1437 a = pcre2_substring_number_from_name_8(G(b,8),G(c,8)); \ 1438 else if (test_mode == PCRE16_MODE) \ 1439 a = pcre2_substring_number_from_name_16(G(b,16),G(c,16)); \ 1440 else \ 1441 a = pcre2_substring_number_from_name_32(G(b,32),G(c,32)) 1442 1443 #define PTR(x) ( \ 1444 (test_mode == PCRE8_MODE)? (void *)G(x,8) : \ 1445 (test_mode == PCRE16_MODE)? (void *)G(x,16) : \ 1446 (void *)G(x,32)) 1447 1448 #define SETFLD(x,y,z) \ 1449 if (test_mode == PCRE8_MODE) G(x,8)->y = z; \ 1450 else if (test_mode == PCRE16_MODE) G(x,16)->y = z; \ 1451 else G(x,32)->y = z 1452 1453 #define SETFLDVEC(x,y,v,z) \ 1454 if (test_mode == PCRE8_MODE) G(x,8)->y[v] = z; \ 1455 else if (test_mode == PCRE16_MODE) G(x,16)->y[v] = z; \ 1456 else G(x,32)->y[v] = z 1457 1458 #define SETOP(x,y,z) \ 1459 if (test_mode == PCRE8_MODE) G(x,8) z y; \ 1460 else if (test_mode == PCRE16_MODE) G(x,16) z y; \ 1461 else G(x,32) z y 1462 1463 #define SETCASTPTR(x,y) \ 1464 if (test_mode == PCRE8_MODE) \ 1465 G(x,8) = (uint8_t *)(y); \ 1466 else if (test_mode == PCRE16_MODE) \ 1467 G(x,16) = (uint16_t *)(y); \ 1468 else \ 1469 G(x,32) = (uint32_t *)(y) 1470 1471 #define STRLEN(p) ((test_mode == PCRE8_MODE)? ((int)strlen((char *)p)) : \ 1472 (test_mode == PCRE16_MODE)? ((int)strlen16((PCRE2_SPTR16)p)) : \ 1473 ((int)strlen32((PCRE2_SPTR32)p))) 1474 1475 #define SUB1(a,b) \ 1476 if (test_mode == PCRE8_MODE) G(a,8)(G(b,8)); \ 1477 else if (test_mode == PCRE16_MODE) G(a,16)(G(b,16)); \ 1478 else G(a,32)(G(b,32)) 1479 1480 #define SUB2(a,b,c) \ 1481 if (test_mode == PCRE8_MODE) G(a,8)(G(b,8),G(c,8)); \ 1482 else if (test_mode == PCRE16_MODE) G(a,16)(G(b,16),G(c,16)); \ 1483 else G(a,32)(G(b,32),G(c,32)) 1484 1485 #define TEST(x,r,y) ( \ 1486 (test_mode == PCRE8_MODE && G(x,8) r (y)) || \ 1487 (test_mode == PCRE16_MODE && G(x,16) r (y)) || \ 1488 (test_mode == PCRE32_MODE && G(x,32) r (y))) 1489 1490 #define TESTFLD(x,f,r,y) ( \ 1491 (test_mode == PCRE8_MODE && G(x,8)->f r (y)) || \ 1492 (test_mode == PCRE16_MODE && G(x,16)->f r (y)) || \ 1493 (test_mode == PCRE32_MODE && G(x,32)->f r (y))) 1494 1495 1496 /* ----- Two out of three modes are supported ----- */ 1497 1498 #else 1499 1500 /* We can use some macro trickery to make a single set of definitions work in 1501 the three different cases. */ 1502 1503 /* ----- 32-bit and 16-bit but not 8-bit supported ----- */ 1504 1505 #if defined(SUPPORT_PCRE2_32) && defined(SUPPORT_PCRE2_16) 1506 #define BITONE 32 1507 #define BITTWO 16 1508 1509 /* ----- 32-bit and 8-bit but not 16-bit supported ----- */ 1510 1511 #elif defined(SUPPORT_PCRE2_32) && defined(SUPPORT_PCRE2_8) 1512 #define BITONE 32 1513 #define BITTWO 8 1514 1515 /* ----- 16-bit and 8-bit but not 32-bit supported ----- */ 1516 1517 #else 1518 #define BITONE 16 1519 #define BITTWO 8 1520 #endif 1521 1522 1523 /* ----- Common macros for two-mode cases ----- */ 1524 1525 #define BYTEONE (BITONE/8) 1526 #define BYTETWO (BITTWO/8) 1527 1528 #define CASTFLD(t,a,b) \ 1529 ((test_mode == G(G(PCRE,BITONE),_MODE))? (t)(G(a,BITONE)->b) : \ 1530 (t)(G(a,BITTWO)->b)) 1531 1532 #define CASTVAR(t,x) ( \ 1533 (test_mode == G(G(PCRE,BITONE),_MODE))? \ 1534 (t)G(x,BITONE) : (t)G(x,BITTWO)) 1535 1536 #define CODE_UNIT(a,b) ( \ 1537 (test_mode == G(G(PCRE,BITONE),_MODE))? \ 1538 (uint32_t)(((G(PCRE2_SPTR,BITONE))(a))[b]) : \ 1539 (uint32_t)(((G(PCRE2_SPTR,BITTWO))(a))[b])) 1540 1541 #define CONCTXCPY(a,b) \ 1542 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1543 memcpy(G(a,BITONE),G(b,BITONE),sizeof(G(pcre2_convert_context_,BITONE))); \ 1544 else \ 1545 memcpy(G(a,BITTWO),G(b,BITTWO),sizeof(G(pcre2_convert_context_,BITTWO))) 1546 1547 #define CONVERT_COPY(a,b,c) \ 1548 (test_mode == G(G(PCRE,BITONE),_MODE))? \ 1549 memcpy(G(a,BITONE),(char *)b,(c)*BYTEONE) : \ 1550 memcpy(G(a,BITTWO),(char *)b,(c)*BYTETWO) 1551 1552 #define DATCTXCPY(a,b) \ 1553 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1554 memcpy(G(a,BITONE),G(b,BITONE),sizeof(G(pcre2_match_context_,BITONE))); \ 1555 else \ 1556 memcpy(G(a,BITTWO),G(b,BITTWO),sizeof(G(pcre2_match_context_,BITTWO))) 1557 1558 #define FLD(a,b) \ 1559 ((test_mode == G(G(PCRE,BITONE),_MODE))? G(a,BITONE)->b : G(a,BITTWO)->b) 1560 1561 #define PATCTXCPY(a,b) \ 1562 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1563 memcpy(G(a,BITONE),G(b,BITONE),sizeof(G(pcre2_compile_context_,BITONE))); \ 1564 else \ 1565 memcpy(G(a,BITTWO),G(b,BITTWO),sizeof(G(pcre2_compile_context_,BITTWO))) 1566 1567 #define PCHARS(lv, p, offset, len, utf, f) \ 1568 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1569 lv = G(pchars,BITONE)((G(PCRE2_SPTR,BITONE))(p)+offset, len, utf, f); \ 1570 else \ 1571 lv = G(pchars,BITTWO)((G(PCRE2_SPTR,BITTWO))(p)+offset, len, utf, f) 1572 1573 #define PCHARSV(p, offset, len, utf, f) \ 1574 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1575 (void)G(pchars,BITONE)((G(PCRE2_SPTR,BITONE))(p)+offset, len, utf, f); \ 1576 else \ 1577 (void)G(pchars,BITTWO)((G(PCRE2_SPTR,BITTWO))(p)+offset, len, utf, f) 1578 1579 #define PCRE2_CALLOUT_ENUMERATE(a,b,c) \ 1580 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1581 a = G(pcre2_callout_enumerate,BITONE)(G(compiled_code,BITONE), \ 1582 (int (*)(struct G(pcre2_callout_enumerate_block_,BITONE) *, void *))b,c); \ 1583 else \ 1584 a = G(pcre2_callout_enumerate,BITTWO)(G(compiled_code,BITTWO), \ 1585 (int (*)(struct G(pcre2_callout_enumerate_block_,BITTWO) *, void *))b,c) 1586 1587 #define PCRE2_CODE_COPY_FROM_VOID(a,b) \ 1588 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1589 G(a,BITONE) = G(pcre2_code_copy_,BITONE)(b); \ 1590 else \ 1591 G(a,BITTWO) = G(pcre2_code_copy_,BITTWO)(b) 1592 1593 #define PCRE2_CODE_COPY_TO_VOID(a,b) \ 1594 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1595 a = (void *)G(pcre2_code_copy_,BITONE)(G(b,BITONE)); \ 1596 else \ 1597 a = (void *)G(pcre2_code_copy_,BITTWO)(G(b,BITTWO)) 1598 1599 #define PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(a,b) \ 1600 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1601 a = (void *)G(pcre2_code_copy_with_tables_,BITONE)(G(b,BITONE)); \ 1602 else \ 1603 a = (void *)G(pcre2_code_copy_with_tables_,BITTWO)(G(b,BITTWO)) 1604 1605 #define PCRE2_COMPILE(a,b,c,d,e,f,g) \ 1606 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1607 G(a,BITONE) = G(pcre2_compile_,BITONE)(G(b,BITONE),c,d,e,f,g); \ 1608 else \ 1609 G(a,BITTWO) = G(pcre2_compile_,BITTWO)(G(b,BITTWO),c,d,e,f,g) 1610 1611 #define PCRE2_CONVERTED_PATTERN_FREE(a) \ 1612 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1613 G(pcre2_converted_pattern_free_,BITONE)((G(PCRE2_UCHAR,BITONE) *)a); \ 1614 else \ 1615 G(pcre2_converted_pattern_free_,BITTWO)((G(PCRE2_UCHAR,BITTWO) *)a) 1616 1617 #define PCRE2_DFA_MATCH(a,b,c,d,e,f,g,h,i,j) \ 1618 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1619 a = G(pcre2_dfa_match_,BITONE)(G(b,BITONE),(G(PCRE2_SPTR,BITONE))c,d,e,f, \ 1620 G(g,BITONE),h,i,j); \ 1621 else \ 1622 a = G(pcre2_dfa_match_,BITTWO)(G(b,BITTWO),(G(PCRE2_SPTR,BITTWO))c,d,e,f, \ 1623 G(g,BITTWO),h,i,j) 1624 1625 #define PCRE2_GET_ERROR_MESSAGE(r,a,b) \ 1626 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1627 r = G(pcre2_get_error_message_,BITONE)(a,G(b,BITONE),G(G(b,BITONE),_size/BYTEONE)); \ 1628 else \ 1629 r = G(pcre2_get_error_message_,BITTWO)(a,G(b,BITTWO),G(G(b,BITTWO),_size/BYTETWO)) 1630 1631 #define PCRE2_GET_OVECTOR_COUNT(a,b) \ 1632 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1633 a = G(pcre2_get_ovector_count_,BITONE)(G(b,BITONE)); \ 1634 else \ 1635 a = G(pcre2_get_ovector_count_,BITTWO)(G(b,BITTWO)) 1636 1637 #define PCRE2_GET_STARTCHAR(a,b) \ 1638 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1639 a = G(pcre2_get_startchar_,BITONE)(G(b,BITONE)); \ 1640 else \ 1641 a = G(pcre2_get_startchar_,BITTWO)(G(b,BITTWO)) 1642 1643 #define PCRE2_JIT_COMPILE(r,a,b) \ 1644 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1645 r = G(pcre2_jit_compile_,BITONE)(G(a,BITONE),b); \ 1646 else \ 1647 r = G(pcre2_jit_compile_,BITTWO)(G(a,BITTWO),b) 1648 1649 #define PCRE2_JIT_FREE_UNUSED_MEMORY(a) \ 1650 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1651 G(pcre2_jit_free_unused_memory_,BITONE)(G(a,BITONE)); \ 1652 else \ 1653 G(pcre2_jit_free_unused_memory_,BITTWO)(G(a,BITTWO)) 1654 1655 #define PCRE2_JIT_MATCH(a,b,c,d,e,f,g,h) \ 1656 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1657 a = G(pcre2_jit_match_,BITONE)(G(b,BITONE),(G(PCRE2_SPTR,BITONE))c,d,e,f, \ 1658 G(g,BITONE),h); \ 1659 else \ 1660 a = G(pcre2_jit_match_,BITTWO)(G(b,BITTWO),(G(PCRE2_SPTR,BITTWO))c,d,e,f, \ 1661 G(g,BITTWO),h) 1662 1663 #define PCRE2_JIT_STACK_CREATE(a,b,c,d) \ 1664 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1665 a = (PCRE2_JIT_STACK *)G(pcre2_jit_stack_create_,BITONE)(b,c,d); \ 1666 else \ 1667 a = (PCRE2_JIT_STACK *)G(pcre2_jit_stack_create_,BITTWO)(b,c,d); \ 1668 1669 #define PCRE2_JIT_STACK_ASSIGN(a,b,c) \ 1670 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1671 G(pcre2_jit_stack_assign_,BITONE)(G(a,BITONE),(G(pcre2_jit_callback_,BITONE))b,c); \ 1672 else \ 1673 G(pcre2_jit_stack_assign_,BITTWO)(G(a,BITTWO),(G(pcre2_jit_callback_,BITTWO))b,c); 1674 1675 #define PCRE2_JIT_STACK_FREE(a) \ 1676 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1677 G(pcre2_jit_stack_free_,BITONE)((G(pcre2_jit_stack_,BITONE) *)a); \ 1678 else \ 1679 G(pcre2_jit_stack_free_,BITTWO)((G(pcre2_jit_stack_,BITTWO) *)a); 1680 1681 #define PCRE2_MAKETABLES(a) \ 1682 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1683 a = G(pcre2_maketables_,BITONE)(NULL); \ 1684 else \ 1685 a = G(pcre2_maketables_,BITTWO)(NULL) 1686 1687 #define PCRE2_MATCH(a,b,c,d,e,f,g,h) \ 1688 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1689 a = G(pcre2_match_,BITONE)(G(b,BITONE),(G(PCRE2_SPTR,BITONE))c,d,e,f, \ 1690 G(g,BITONE),h); \ 1691 else \ 1692 a = G(pcre2_match_,BITTWO)(G(b,BITTWO),(G(PCRE2_SPTR,BITTWO))c,d,e,f, \ 1693 G(g,BITTWO),h) 1694 1695 #define PCRE2_MATCH_DATA_CREATE(a,b,c) \ 1696 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1697 G(a,BITONE) = G(pcre2_match_data_create_,BITONE)(b,c); \ 1698 else \ 1699 G(a,BITTWO) = G(pcre2_match_data_create_,BITTWO)(b,c) 1700 1701 #define PCRE2_MATCH_DATA_CREATE_FROM_PATTERN(a,b,c) \ 1702 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1703 G(a,BITONE) = G(pcre2_match_data_create_from_pattern_,BITONE)(G(b,BITONE),c); \ 1704 else \ 1705 G(a,BITTWO) = G(pcre2_match_data_create_from_pattern_,BITTWO)(G(b,BITTWO),c) 1706 1707 #define PCRE2_MATCH_DATA_FREE(a) \ 1708 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1709 G(pcre2_match_data_free_,BITONE)(G(a,BITONE)); \ 1710 else \ 1711 G(pcre2_match_data_free_,BITTWO)(G(a,BITTWO)) 1712 1713 #define PCRE2_PATTERN_CONVERT(a,b,c,d,e,f,g) \ 1714 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1715 a = G(pcre2_pattern_convert_,BITONE)(G(b,BITONE),c,d,(G(PCRE2_UCHAR,BITONE) **)e,f,G(g,BITONE)); \ 1716 else \ 1717 a = G(pcre2_pattern_convert_,BITTWO)(G(b,BITTWO),c,d,(G(PCRE2_UCHAR,BITTWO) **)e,f,G(g,BITTWO)) 1718 1719 #define PCRE2_PATTERN_INFO(a,b,c,d) \ 1720 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1721 a = G(pcre2_pattern_info_,BITONE)(G(b,BITONE),c,d); \ 1722 else \ 1723 a = G(pcre2_pattern_info_,BITTWO)(G(b,BITTWO),c,d) 1724 1725 #define PCRE2_PRINTINT(a) \ 1726 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1727 G(pcre2_printint_,BITONE)(G(compiled_code,BITONE),outfile,a); \ 1728 else \ 1729 G(pcre2_printint_,BITTWO)(G(compiled_code,BITTWO),outfile,a) 1730 1731 #define PCRE2_SERIALIZE_DECODE(r,a,b,c,d) \ 1732 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1733 r = G(pcre2_serialize_decode_,BITONE)((G(pcre2_code_,BITONE) **)a,b,c,G(d,BITONE)); \ 1734 else \ 1735 r = G(pcre2_serialize_decode_,BITTWO)((G(pcre2_code_,BITTWO) **)a,b,c,G(d,BITTWO)) 1736 1737 #define PCRE2_SERIALIZE_ENCODE(r,a,b,c,d,e) \ 1738 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1739 r = G(pcre2_serialize_encode_,BITONE)((G(const pcre2_code_,BITONE) **)a,b,c,d,G(e,BITONE)); \ 1740 else \ 1741 r = G(pcre2_serialize_encode_,BITTWO)((G(const pcre2_code_,BITTWO) **)a,b,c,d,G(e,BITTWO)) 1742 1743 #define PCRE2_SERIALIZE_FREE(a) \ 1744 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1745 G(pcre2_serialize_free_,BITONE)(a); \ 1746 else \ 1747 G(pcre2_serialize_free_,BITTWO)(a) 1748 1749 #define PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(r,a) \ 1750 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1751 r = G(pcre2_serialize_get_number_of_codes_,BITONE)(a); \ 1752 else \ 1753 r = G(pcre2_serialize_get_number_of_codes_,BITTWO)(a) 1754 1755 #define PCRE2_SET_CALLOUT(a,b,c) \ 1756 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1757 G(pcre2_set_callout_,BITONE)(G(a,BITONE), \ 1758 (int (*)(G(pcre2_callout_block_,BITONE) *, void *))b,c); \ 1759 else \ 1760 G(pcre2_set_callout_,BITTWO)(G(a,BITTWO), \ 1761 (int (*)(G(pcre2_callout_block_,BITTWO) *, void *))b,c); 1762 1763 #define PCRE2_SET_CHARACTER_TABLES(a,b) \ 1764 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1765 G(pcre2_set_character_tables_,BITONE)(G(a,BITONE),b); \ 1766 else \ 1767 G(pcre2_set_character_tables_,BITTWO)(G(a,BITTWO),b) 1768 1769 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \ 1770 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1771 G(pcre2_set_compile_recursion_guard_,BITONE)(G(a,BITONE),b,c); \ 1772 else \ 1773 G(pcre2_set_compile_recursion_guard_,BITTWO)(G(a,BITTWO),b,c) 1774 1775 #define PCRE2_SET_DEPTH_LIMIT(a,b) \ 1776 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1777 G(pcre2_set_depth_limit_,BITONE)(G(a,BITONE),b); \ 1778 else \ 1779 G(pcre2_set_depth_limit_,BITTWO)(G(a,BITTWO),b) 1780 1781 #define PCRE2_SET_GLOB_ESCAPE(r,a,b) \ 1782 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1783 r = G(pcre2_set_glob_escape_,BITONE)(G(a,BITONE),b); \ 1784 else \ 1785 r = G(pcre2_set_glob_escape_,BITTWO)(G(a,BITTWO),b) 1786 1787 #define PCRE2_SET_GLOB_SEPARATOR(r,a,b) \ 1788 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1789 r = G(pcre2_set_glob_separator_,BITONE)(G(a,BITONE),b); \ 1790 else \ 1791 r = G(pcre2_set_glob_separator_,BITTWO)(G(a,BITTWO),b) 1792 1793 #define PCRE2_SET_HEAP_LIMIT(a,b) \ 1794 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1795 G(pcre2_set_heap_limit_,BITONE)(G(a,BITONE),b); \ 1796 else \ 1797 G(pcre2_set_heap_limit_,BITTWO)(G(a,BITTWO),b) 1798 1799 #define PCRE2_SET_MATCH_LIMIT(a,b) \ 1800 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1801 G(pcre2_set_match_limit_,BITONE)(G(a,BITONE),b); \ 1802 else \ 1803 G(pcre2_set_match_limit_,BITTWO)(G(a,BITTWO),b) 1804 1805 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) \ 1806 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1807 G(pcre2_set_max_pattern_length_,BITONE)(G(a,BITONE),b); \ 1808 else \ 1809 G(pcre2_set_max_pattern_length_,BITTWO)(G(a,BITTWO),b) 1810 1811 #define PCRE2_SET_OFFSET_LIMIT(a,b) \ 1812 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1813 G(pcre2_set_offset_limit_,BITONE)(G(a,BITONE),b); \ 1814 else \ 1815 G(pcre2_set_offset_limit_,BITTWO)(G(a,BITTWO),b) 1816 1817 #define PCRE2_SET_PARENS_NEST_LIMIT(a,b) \ 1818 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1819 G(pcre2_set_parens_nest_limit_,BITONE)(G(a,BITONE),b); \ 1820 else \ 1821 G(pcre2_set_parens_nest_limit_,BITTWO)(G(a,BITTWO),b) 1822 1823 #define PCRE2_SUBSTITUTE(a,b,c,d,e,f,g,h,i,j,k,l) \ 1824 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1825 a = G(pcre2_substitute_,BITONE)(G(b,BITONE),(G(PCRE2_SPTR,BITONE))c,d,e,f, \ 1826 G(g,BITONE),G(h,BITONE),(G(PCRE2_SPTR,BITONE))i,j, \ 1827 (G(PCRE2_UCHAR,BITONE) *)k,l); \ 1828 else \ 1829 a = G(pcre2_substitute_,BITTWO)(G(b,BITTWO),(G(PCRE2_SPTR,BITTWO))c,d,e,f, \ 1830 G(g,BITTWO),G(h,BITTWO),(G(PCRE2_SPTR,BITTWO))i,j, \ 1831 (G(PCRE2_UCHAR,BITTWO) *)k,l) 1832 1833 #define PCRE2_SUBSTRING_COPY_BYNAME(a,b,c,d,e) \ 1834 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1835 a = G(pcre2_substring_copy_byname_,BITONE)(G(b,BITONE),G(c,BITONE),\ 1836 (G(PCRE2_UCHAR,BITONE) *)d,e); \ 1837 else \ 1838 a = G(pcre2_substring_copy_byname_,BITTWO)(G(b,BITTWO),G(c,BITTWO),\ 1839 (G(PCRE2_UCHAR,BITTWO) *)d,e) 1840 1841 #define PCRE2_SUBSTRING_COPY_BYNUMBER(a,b,c,d,e) \ 1842 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1843 a = G(pcre2_substring_copy_bynumber_,BITONE)(G(b,BITONE),c,\ 1844 (G(PCRE2_UCHAR,BITONE) *)d,e); \ 1845 else \ 1846 a = G(pcre2_substring_copy_bynumber_,BITTWO)(G(b,BITTWO),c,\ 1847 (G(PCRE2_UCHAR,BITTWO) *)d,e) 1848 1849 #define PCRE2_SUBSTRING_FREE(a) \ 1850 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1851 G(pcre2_substring_free_,BITONE)((G(PCRE2_UCHAR,BITONE) *)a); \ 1852 else G(pcre2_substring_free_,BITTWO)((G(PCRE2_UCHAR,BITTWO) *)a) 1853 1854 #define PCRE2_SUBSTRING_GET_BYNAME(a,b,c,d,e) \ 1855 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1856 a = G(pcre2_substring_get_byname_,BITONE)(G(b,BITONE),G(c,BITONE),\ 1857 (G(PCRE2_UCHAR,BITONE) **)d,e); \ 1858 else \ 1859 a = G(pcre2_substring_get_byname_,BITTWO)(G(b,BITTWO),G(c,BITTWO),\ 1860 (G(PCRE2_UCHAR,BITTWO) **)d,e) 1861 1862 #define PCRE2_SUBSTRING_GET_BYNUMBER(a,b,c,d,e) \ 1863 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1864 a = G(pcre2_substring_get_bynumber_,BITONE)(G(b,BITONE),c,\ 1865 (G(PCRE2_UCHAR,BITONE) **)d,e); \ 1866 else \ 1867 a = G(pcre2_substring_get_bynumber_,BITTWO)(G(b,BITTWO),c,\ 1868 (G(PCRE2_UCHAR,BITTWO) **)d,e) 1869 1870 #define PCRE2_SUBSTRING_LENGTH_BYNAME(a,b,c,d) \ 1871 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1872 a = G(pcre2_substring_length_byname_,BITONE)(G(b,BITONE),G(c,BITONE),d); \ 1873 else \ 1874 a = G(pcre2_substring_length_byname_,BITTWO)(G(b,BITTWO),G(c,BITTWO),d) 1875 1876 #define PCRE2_SUBSTRING_LENGTH_BYNUMBER(a,b,c,d) \ 1877 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1878 a = G(pcre2_substring_length_bynumber_,BITONE)(G(b,BITONE),c,d); \ 1879 else \ 1880 a = G(pcre2_substring_length_bynumber_,BITTWO)(G(b,BITTWO),c,d) 1881 1882 #define PCRE2_SUBSTRING_LIST_GET(a,b,c,d) \ 1883 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1884 a = G(pcre2_substring_list_get_,BITONE)(G(b,BITONE), \ 1885 (G(PCRE2_UCHAR,BITONE) ***)c,d); \ 1886 else \ 1887 a = G(pcre2_substring_list_get_,BITTWO)(G(b,BITTWO), \ 1888 (G(PCRE2_UCHAR,BITTWO) ***)c,d) 1889 1890 #define PCRE2_SUBSTRING_LIST_FREE(a) \ 1891 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1892 G(pcre2_substring_list_free_,BITONE)((G(PCRE2_SPTR,BITONE) *)a); \ 1893 else \ 1894 G(pcre2_substring_list_free_,BITTWO)((G(PCRE2_SPTR,BITTWO) *)a) 1895 1896 #define PCRE2_SUBSTRING_NUMBER_FROM_NAME(a,b,c) \ 1897 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1898 a = G(pcre2_substring_number_from_name_,BITONE)(G(b,BITONE),G(c,BITONE)); \ 1899 else \ 1900 a = G(pcre2_substring_number_from_name_,BITTWO)(G(b,BITTWO),G(c,BITTWO)) 1901 1902 #define PTR(x) ( \ 1903 (test_mode == G(G(PCRE,BITONE),_MODE))? (void *)G(x,BITONE) : \ 1904 (void *)G(x,BITTWO)) 1905 1906 #define SETFLD(x,y,z) \ 1907 if (test_mode == G(G(PCRE,BITONE),_MODE)) G(x,BITONE)->y = z; \ 1908 else G(x,BITTWO)->y = z 1909 1910 #define SETFLDVEC(x,y,v,z) \ 1911 if (test_mode == G(G(PCRE,BITONE),_MODE)) G(x,BITONE)->y[v] = z; \ 1912 else G(x,BITTWO)->y[v] = z 1913 1914 #define SETOP(x,y,z) \ 1915 if (test_mode == G(G(PCRE,BITONE),_MODE)) G(x,BITONE) z y; \ 1916 else G(x,BITTWO) z y 1917 1918 #define SETCASTPTR(x,y) \ 1919 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1920 G(x,BITONE) = (G(G(uint,BITONE),_t) *)(y); \ 1921 else \ 1922 G(x,BITTWO) = (G(G(uint,BITTWO),_t) *)(y) 1923 1924 #define STRLEN(p) ((test_mode == G(G(PCRE,BITONE),_MODE))? \ 1925 G(strlen,BITONE)((G(PCRE2_SPTR,BITONE))p) : \ 1926 G(strlen,BITTWO)((G(PCRE2_SPTR,BITTWO))p)) 1927 1928 #define SUB1(a,b) \ 1929 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1930 G(a,BITONE)(G(b,BITONE)); \ 1931 else \ 1932 G(a,BITTWO)(G(b,BITTWO)) 1933 1934 #define SUB2(a,b,c) \ 1935 if (test_mode == G(G(PCRE,BITONE),_MODE)) \ 1936 G(a,BITONE))(G(b,BITONE),G(c,BITONE)); \ 1937 else \ 1938 G(a,BITTWO))(G(b,BITTWO),G(c,BITTWO)) 1939 1940 #define TEST(x,r,y) ( \ 1941 (test_mode == G(G(PCRE,BITONE),_MODE) && G(x,BITONE) r (y)) || \ 1942 (test_mode == G(G(PCRE,BITTWO),_MODE) && G(x,BITTWO) r (y))) 1943 1944 #define TESTFLD(x,f,r,y) ( \ 1945 (test_mode == G(G(PCRE,BITONE),_MODE) && G(x,BITONE)->f r (y)) || \ 1946 (test_mode == G(G(PCRE,BITTWO),_MODE) && G(x,BITTWO)->f r (y))) 1947 1948 1949 #endif /* Two out of three modes */ 1950 1951 /* ----- End of cases where more than one mode is supported ----- */ 1952 1953 1954 /* ----- Only 8-bit mode is supported ----- */ 1955 1956 #elif defined SUPPORT_PCRE2_8 1957 #define CASTFLD(t,a,b) (t)(G(a,8)->b) 1958 #define CASTVAR(t,x) (t)G(x,8) 1959 #define CODE_UNIT(a,b) (uint32_t)(((PCRE2_SPTR8)(a))[b]) 1960 #define CONCTXCPY(a,b) memcpy(G(a,8),G(b,8),sizeof(pcre2_convert_context_8)) 1961 #define CONVERT_COPY(a,b,c) memcpy(G(a,8),(char *)b, c) 1962 #define DATCTXCPY(a,b) memcpy(G(a,8),G(b,8),sizeof(pcre2_match_context_8)) 1963 #define FLD(a,b) G(a,8)->b 1964 #define PATCTXCPY(a,b) memcpy(G(a,8),G(b,8),sizeof(pcre2_compile_context_8)) 1965 #define PCHARS(lv, p, offset, len, utf, f) \ 1966 lv = pchars8((PCRE2_SPTR8)(p)+offset, len, utf, f) 1967 #define PCHARSV(p, offset, len, utf, f) \ 1968 (void)pchars8((PCRE2_SPTR8)(p)+offset, len, utf, f) 1969 #define PCRE2_CALLOUT_ENUMERATE(a,b,c) \ 1970 a = pcre2_callout_enumerate_8(compiled_code8, \ 1971 (int (*)(struct pcre2_callout_enumerate_block_8 *, void *))b,c) 1972 #define PCRE2_CODE_COPY_FROM_VOID(a,b) G(a,8) = pcre2_code_copy_8(b) 1973 #define PCRE2_CODE_COPY_TO_VOID(a,b) a = (void *)pcre2_code_copy_8(G(b,8)) 1974 #define PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(a,b) a = (void *)pcre2_code_copy_with_tables_8(G(b,8)) 1975 #define PCRE2_COMPILE(a,b,c,d,e,f,g) \ 1976 G(a,8) = pcre2_compile_8(G(b,8),c,d,e,f,g) 1977 #define PCRE2_CONVERTED_PATTERN_FREE(a) \ 1978 pcre2_converted_pattern_free_8((PCRE2_UCHAR8 *)a) 1979 #define PCRE2_DFA_MATCH(a,b,c,d,e,f,g,h,i,j) \ 1980 a = pcre2_dfa_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h,i,j) 1981 #define PCRE2_GET_ERROR_MESSAGE(r,a,b) \ 1982 r = pcre2_get_error_message_8(a,G(b,8),G(G(b,8),_size)) 1983 #define PCRE2_GET_OVECTOR_COUNT(a,b) a = pcre2_get_ovector_count_8(G(b,8)) 1984 #define PCRE2_GET_STARTCHAR(a,b) a = pcre2_get_startchar_8(G(b,8)) 1985 #define PCRE2_JIT_COMPILE(r,a,b) r = pcre2_jit_compile_8(G(a,8),b) 1986 #define PCRE2_JIT_FREE_UNUSED_MEMORY(a) pcre2_jit_free_unused_memory_8(G(a,8)) 1987 #define PCRE2_JIT_MATCH(a,b,c,d,e,f,g,h) \ 1988 a = pcre2_jit_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h) 1989 #define PCRE2_JIT_STACK_CREATE(a,b,c,d) \ 1990 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_8(b,c,d); 1991 #define PCRE2_JIT_STACK_ASSIGN(a,b,c) \ 1992 pcre2_jit_stack_assign_8(G(a,8),(pcre2_jit_callback_8)b,c); 1993 #define PCRE2_JIT_STACK_FREE(a) pcre2_jit_stack_free_8((pcre2_jit_stack_8 *)a); 1994 #define PCRE2_MAKETABLES(a) a = pcre2_maketables_8(NULL) 1995 #define PCRE2_MATCH(a,b,c,d,e,f,g,h) \ 1996 a = pcre2_match_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),h) 1997 #define PCRE2_MATCH_DATA_CREATE(a,b,c) G(a,8) = pcre2_match_data_create_8(b,c) 1998 #define PCRE2_MATCH_DATA_CREATE_FROM_PATTERN(a,b,c) \ 1999 G(a,8) = pcre2_match_data_create_from_pattern_8(G(b,8),c) 2000 #define PCRE2_MATCH_DATA_FREE(a) pcre2_match_data_free_8(G(a,8)) 2001 #define PCRE2_PATTERN_CONVERT(a,b,c,d,e,f,g) a = pcre2_pattern_convert_8(G(b,8),c,d,(PCRE2_UCHAR8 **)e,f,G(g,8)) 2002 #define PCRE2_PATTERN_INFO(a,b,c,d) a = pcre2_pattern_info_8(G(b,8),c,d) 2003 #define PCRE2_PRINTINT(a) pcre2_printint_8(compiled_code8,outfile,a) 2004 #define PCRE2_SERIALIZE_DECODE(r,a,b,c,d) \ 2005 r = pcre2_serialize_decode_8((pcre2_code_8 **)a,b,c,G(d,8)) 2006 #define PCRE2_SERIALIZE_ENCODE(r,a,b,c,d,e) \ 2007 r = pcre2_serialize_encode_8((const pcre2_code_8 **)a,b,c,d,G(e,8)) 2008 #define PCRE2_SERIALIZE_FREE(a) pcre2_serialize_free_8(a) 2009 #define PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(r,a) \ 2010 r = pcre2_serialize_get_number_of_codes_8(a) 2011 #define PCRE2_SET_CALLOUT(a,b,c) \ 2012 pcre2_set_callout_8(G(a,8),(int (*)(pcre2_callout_block_8 *, void *))b,c) 2013 #define PCRE2_SET_CHARACTER_TABLES(a,b) pcre2_set_character_tables_8(G(a,8),b) 2014 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \ 2015 pcre2_set_compile_recursion_guard_8(G(a,8),b,c) 2016 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_8(G(a,8),b) 2017 #define PCRE2_SET_GLOB_ESCAPE(r,a,b) r = pcre2_set_glob_escape_8(G(a,8),b) 2018 #define PCRE2_SET_GLOB_SEPARATOR(r,a,b) r = pcre2_set_glob_separator_8(G(a,8),b) 2019 #define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_8(G(a,8),b) 2020 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_8(G(a,8),b) 2021 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_8(G(a,8),b) 2022 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_8(G(a,8),b) 2023 #define PCRE2_SET_PARENS_NEST_LIMIT(a,b) pcre2_set_parens_nest_limit_8(G(a,8),b) 2024 #define PCRE2_SUBSTITUTE(a,b,c,d,e,f,g,h,i,j,k,l) \ 2025 a = pcre2_substitute_8(G(b,8),(PCRE2_SPTR8)c,d,e,f,G(g,8),G(h,8), \ 2026 (PCRE2_SPTR8)i,j,(PCRE2_UCHAR8 *)k,l) 2027 #define PCRE2_SUBSTRING_COPY_BYNAME(a,b,c,d,e) \ 2028 a = pcre2_substring_copy_byname_8(G(b,8),G(c,8),(PCRE2_UCHAR8 *)d,e) 2029 #define PCRE2_SUBSTRING_COPY_BYNUMBER(a,b,c,d,e) \ 2030 a = pcre2_substring_copy_bynumber_8(G(b,8),c,(PCRE2_UCHAR8 *)d,e) 2031 #define PCRE2_SUBSTRING_FREE(a) pcre2_substring_free_8((PCRE2_UCHAR8 *)a) 2032 #define PCRE2_SUBSTRING_GET_BYNAME(a,b,c,d,e) \ 2033 a = pcre2_substring_get_byname_8(G(b,8),G(c,8),(PCRE2_UCHAR8 **)d,e) 2034 #define PCRE2_SUBSTRING_GET_BYNUMBER(a,b,c,d,e) \ 2035 a = pcre2_substring_get_bynumber_8(G(b,8),c,(PCRE2_UCHAR8 **)d,e) 2036 #define PCRE2_SUBSTRING_LENGTH_BYNAME(a,b,c,d) \ 2037 a = pcre2_substring_length_byname_8(G(b,8),G(c,8),d) 2038 #define PCRE2_SUBSTRING_LENGTH_BYNUMBER(a,b,c,d) \ 2039 a = pcre2_substring_length_bynumber_8(G(b,8),c,d) 2040 #define PCRE2_SUBSTRING_LIST_GET(a,b,c,d) \ 2041 a = pcre2_substring_list_get_8(G(b,8),(PCRE2_UCHAR8 ***)c,d) 2042 #define PCRE2_SUBSTRING_LIST_FREE(a) \ 2043 pcre2_substring_list_free_8((PCRE2_SPTR8 *)a) 2044 #define PCRE2_SUBSTRING_NUMBER_FROM_NAME(a,b,c) \ 2045 a = pcre2_substring_number_from_name_8(G(b,8),G(c,8)); 2046 #define PTR(x) (void *)G(x,8) 2047 #define SETFLD(x,y,z) G(x,8)->y = z 2048 #define SETFLDVEC(x,y,v,z) G(x,8)->y[v] = z 2049 #define SETOP(x,y,z) G(x,8) z y 2050 #define SETCASTPTR(x,y) G(x,8) = (uint8_t *)(y) 2051 #define STRLEN(p) (int)strlen((char *)p) 2052 #define SUB1(a,b) G(a,8)(G(b,8)) 2053 #define SUB2(a,b,c) G(a,8)(G(b,8),G(c,8)) 2054 #define TEST(x,r,y) (G(x,8) r (y)) 2055 #define TESTFLD(x,f,r,y) (G(x,8)->f r (y)) 2056 2057 2058 /* ----- Only 16-bit mode is supported ----- */ 2059 2060 #elif defined SUPPORT_PCRE2_16 2061 #define CASTFLD(t,a,b) (t)(G(a,16)->b) 2062 #define CASTVAR(t,x) (t)G(x,16) 2063 #define CODE_UNIT(a,b) (uint32_t)(((PCRE2_SPTR16)(a))[b]) 2064 #define CONCTXCPY(a,b) memcpy(G(a,16),G(b,16),sizeof(pcre2_convert_context_16)) 2065 #define CONVERT_COPY(a,b,c) memcpy(G(a,16),(char *)b, (c)*2) 2066 #define DATCTXCPY(a,b) memcpy(G(a,16),G(b,16),sizeof(pcre2_match_context_16)) 2067 #define FLD(a,b) G(a,16)->b 2068 #define PATCTXCPY(a,b) memcpy(G(a,16),G(b,16),sizeof(pcre2_compile_context_16)) 2069 #define PCHARS(lv, p, offset, len, utf, f) \ 2070 lv = pchars16((PCRE2_SPTR16)(p)+offset, len, utf, f) 2071 #define PCHARSV(p, offset, len, utf, f) \ 2072 (void)pchars16((PCRE2_SPTR16)(p)+offset, len, utf, f) 2073 #define PCRE2_CALLOUT_ENUMERATE(a,b,c) \ 2074 a = pcre2_callout_enumerate_16(compiled_code16, \ 2075 (int (*)(struct pcre2_callout_enumerate_block_16 *, void *))b,c) 2076 #define PCRE2_CODE_COPY_FROM_VOID(a,b) G(a,16) = pcre2_code_copy_16(b) 2077 #define PCRE2_CODE_COPY_TO_VOID(a,b) a = (void *)pcre2_code_copy_16(G(b,16)) 2078 #define PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(a,b) a = (void *)pcre2_code_copy_with_tables_16(G(b,16)) 2079 #define PCRE2_COMPILE(a,b,c,d,e,f,g) \ 2080 G(a,16) = pcre2_compile_16(G(b,16),c,d,e,f,g) 2081 #define PCRE2_CONVERTED_PATTERN_FREE(a) \ 2082 pcre2_converted_pattern_free_16((PCRE2_UCHAR16 *)a) 2083 #define PCRE2_DFA_MATCH(a,b,c,d,e,f,g,h,i,j) \ 2084 a = pcre2_dfa_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h,i,j) 2085 #define PCRE2_GET_ERROR_MESSAGE(r,a,b) \ 2086 r = pcre2_get_error_message_16(a,G(b,16),G(G(b,16),_size/2)) 2087 #define PCRE2_GET_OVECTOR_COUNT(a,b) a = pcre2_get_ovector_count_16(G(b,16)) 2088 #define PCRE2_GET_STARTCHAR(a,b) a = pcre2_get_startchar_16(G(b,16)) 2089 #define PCRE2_JIT_COMPILE(r,a,b) r = pcre2_jit_compile_16(G(a,16),b) 2090 #define PCRE2_JIT_FREE_UNUSED_MEMORY(a) pcre2_jit_free_unused_memory_16(G(a,16)) 2091 #define PCRE2_JIT_MATCH(a,b,c,d,e,f,g,h) \ 2092 a = pcre2_jit_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h) 2093 #define PCRE2_JIT_STACK_CREATE(a,b,c,d) \ 2094 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_16(b,c,d); 2095 #define PCRE2_JIT_STACK_ASSIGN(a,b,c) \ 2096 pcre2_jit_stack_assign_16(G(a,16),(pcre2_jit_callback_16)b,c); 2097 #define PCRE2_JIT_STACK_FREE(a) pcre2_jit_stack_free_16((pcre2_jit_stack_16 *)a); 2098 #define PCRE2_MAKETABLES(a) a = pcre2_maketables_16(NULL) 2099 #define PCRE2_MATCH(a,b,c,d,e,f,g,h) \ 2100 a = pcre2_match_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),h) 2101 #define PCRE2_MATCH_DATA_CREATE(a,b,c) G(a,16) = pcre2_match_data_create_16(b,c) 2102 #define PCRE2_MATCH_DATA_CREATE_FROM_PATTERN(a,b,c) \ 2103 G(a,16) = pcre2_match_data_create_from_pattern_16(G(b,16),c) 2104 #define PCRE2_MATCH_DATA_FREE(a) pcre2_match_data_free_16(G(a,16)) 2105 #define PCRE2_PATTERN_CONVERT(a,b,c,d,e,f,g) a = pcre2_pattern_convert_16(G(b,16),c,d,(PCRE2_UCHAR16 **)e,f,G(g,16)) 2106 #define PCRE2_PATTERN_INFO(a,b,c,d) a = pcre2_pattern_info_16(G(b,16),c,d) 2107 #define PCRE2_PRINTINT(a) pcre2_printint_16(compiled_code16,outfile,a) 2108 #define PCRE2_SERIALIZE_DECODE(r,a,b,c,d) \ 2109 r = pcre2_serialize_decode_16((pcre2_code_16 **)a,b,c,G(d,16)) 2110 #define PCRE2_SERIALIZE_ENCODE(r,a,b,c,d,e) \ 2111 r = pcre2_serialize_encode_16((const pcre2_code_16 **)a,b,c,d,G(e,16)) 2112 #define PCRE2_SERIALIZE_FREE(a) pcre2_serialize_free_16(a) 2113 #define PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(r,a) \ 2114 r = pcre2_serialize_get_number_of_codes_16(a) 2115 #define PCRE2_SET_CALLOUT(a,b,c) \ 2116 pcre2_set_callout_16(G(a,16),(int (*)(pcre2_callout_block_16 *, void *))b,c); 2117 #define PCRE2_SET_CHARACTER_TABLES(a,b) pcre2_set_character_tables_16(G(a,16),b) 2118 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \ 2119 pcre2_set_compile_recursion_guard_16(G(a,16),b,c) 2120 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_16(G(a,16),b) 2121 #define PCRE2_SET_GLOB_ESCAPE(r,a,b) r = pcre2_set_glob_escape_16(G(a,16),b) 2122 #define PCRE2_SET_GLOB_SEPARATOR(r,a,b) r = pcre2_set_glob_separator_16(G(a,16),b) 2123 #define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_16(G(a,16),b) 2124 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_16(G(a,16),b) 2125 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_16(G(a,16),b) 2126 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_16(G(a,16),b) 2127 #define PCRE2_SET_PARENS_NEST_LIMIT(a,b) pcre2_set_parens_nest_limit_16(G(a,16),b) 2128 #define PCRE2_SUBSTITUTE(a,b,c,d,e,f,g,h,i,j,k,l) \ 2129 a = pcre2_substitute_16(G(b,16),(PCRE2_SPTR16)c,d,e,f,G(g,16),G(h,16), \ 2130 (PCRE2_SPTR16)i,j,(PCRE2_UCHAR16 *)k,l) 2131 #define PCRE2_SUBSTRING_COPY_BYNAME(a,b,c,d,e) \ 2132 a = pcre2_substring_copy_byname_16(G(b,16),G(c,16),(PCRE2_UCHAR16 *)d,e) 2133 #define PCRE2_SUBSTRING_COPY_BYNUMBER(a,b,c,d,e) \ 2134 a = pcre2_substring_copy_bynumber_16(G(b,16),c,(PCRE2_UCHAR16 *)d,e) 2135 #define PCRE2_SUBSTRING_FREE(a) pcre2_substring_free_16((PCRE2_UCHAR16 *)a) 2136 #define PCRE2_SUBSTRING_GET_BYNAME(a,b,c,d,e) \ 2137 a = pcre2_substring_get_byname_16(G(b,16),G(c,16),(PCRE2_UCHAR16 **)d,e) 2138 #define PCRE2_SUBSTRING_GET_BYNUMBER(a,b,c,d,e) \ 2139 a = pcre2_substring_get_bynumber_16(G(b,16),c,(PCRE2_UCHAR16 **)d,e) 2140 #define PCRE2_SUBSTRING_LENGTH_BYNAME(a,b,c,d) \ 2141 a = pcre2_substring_length_byname_16(G(b,16),G(c,16),d) 2142 #define PCRE2_SUBSTRING_LENGTH_BYNUMBER(a,b,c,d) \ 2143 a = pcre2_substring_length_bynumber_16(G(b,16),c,d) 2144 #define PCRE2_SUBSTRING_LIST_GET(a,b,c,d) \ 2145 a = pcre2_substring_list_get_16(G(b,16),(PCRE2_UCHAR16 ***)c,d) 2146 #define PCRE2_SUBSTRING_LIST_FREE(a) \ 2147 pcre2_substring_list_free_16((PCRE2_SPTR16 *)a) 2148 #define PCRE2_SUBSTRING_NUMBER_FROM_NAME(a,b,c) \ 2149 a = pcre2_substring_number_from_name_16(G(b,16),G(c,16)); 2150 #define PTR(x) (void *)G(x,16) 2151 #define SETFLD(x,y,z) G(x,16)->y = z 2152 #define SETFLDVEC(x,y,v,z) G(x,16)->y[v] = z 2153 #define SETOP(x,y,z) G(x,16) z y 2154 #define SETCASTPTR(x,y) G(x,16) = (uint16_t *)(y) 2155 #define STRLEN(p) (int)strlen16((PCRE2_SPTR16)p) 2156 #define SUB1(a,b) G(a,16)(G(b,16)) 2157 #define SUB2(a,b,c) G(a,16)(G(b,16),G(c,16)) 2158 #define TEST(x,r,y) (G(x,16) r (y)) 2159 #define TESTFLD(x,f,r,y) (G(x,16)->f r (y)) 2160 2161 2162 /* ----- Only 32-bit mode is supported ----- */ 2163 2164 #elif defined SUPPORT_PCRE2_32 2165 #define CASTFLD(t,a,b) (t)(G(a,32)->b) 2166 #define CASTVAR(t,x) (t)G(x,32) 2167 #define CODE_UNIT(a,b) (uint32_t)(((PCRE2_SPTR32)(a))[b]) 2168 #define CONCTXCPY(a,b) memcpy(G(a,32),G(b,32),sizeof(pcre2_convert_context_32)) 2169 #define CONVERT_COPY(a,b,c) memcpy(G(a,32),(char *)b, (c)*4) 2170 #define DATCTXCPY(a,b) memcpy(G(a,32),G(b,32),sizeof(pcre2_match_context_32)) 2171 #define FLD(a,b) G(a,32)->b 2172 #define PATCTXCPY(a,b) memcpy(G(a,32),G(b,32),sizeof(pcre2_compile_context_32)) 2173 #define PCHARS(lv, p, offset, len, utf, f) \ 2174 lv = pchars32((PCRE2_SPTR32)(p)+offset, len, utf, f) 2175 #define PCHARSV(p, offset, len, utf, f) \ 2176 (void)pchars32((PCRE2_SPTR32)(p)+offset, len, utf, f) 2177 #define PCRE2_CALLOUT_ENUMERATE(a,b,c) \ 2178 a = pcre2_callout_enumerate_32(compiled_code32, \ 2179 (int (*)(struct pcre2_callout_enumerate_block_32 *, void *))b,c) 2180 #define PCRE2_CODE_COPY_FROM_VOID(a,b) G(a,32) = pcre2_code_copy_32(b) 2181 #define PCRE2_CODE_COPY_TO_VOID(a,b) a = (void *)pcre2_code_copy_32(G(b,32)) 2182 #define PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(a,b) a = (void *)pcre2_code_copy_with_tables_32(G(b,32)) 2183 #define PCRE2_COMPILE(a,b,c,d,e,f,g) \ 2184 G(a,32) = pcre2_compile_32(G(b,32),c,d,e,f,g) 2185 #define PCRE2_CONVERTED_PATTERN_FREE(a) \ 2186 pcre2_converted_pattern_free_32((PCRE2_UCHAR32 *)a) 2187 #define PCRE2_DFA_MATCH(a,b,c,d,e,f,g,h,i,j) \ 2188 a = pcre2_dfa_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h,i,j) 2189 #define PCRE2_GET_ERROR_MESSAGE(r,a,b) \ 2190 r = pcre2_get_error_message_32(a,G(b,32),G(G(b,32),_size/4)) 2191 #define PCRE2_GET_OVECTOR_COUNT(a,b) a = pcre2_get_ovector_count_32(G(b,32)) 2192 #define PCRE2_GET_STARTCHAR(a,b) a = pcre2_get_startchar_32(G(b,32)) 2193 #define PCRE2_JIT_COMPILE(r,a,b) r = pcre2_jit_compile_32(G(a,32),b) 2194 #define PCRE2_JIT_FREE_UNUSED_MEMORY(a) pcre2_jit_free_unused_memory_32(G(a,32)) 2195 #define PCRE2_JIT_MATCH(a,b,c,d,e,f,g,h) \ 2196 a = pcre2_jit_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h) 2197 #define PCRE2_JIT_STACK_CREATE(a,b,c,d) \ 2198 a = (PCRE2_JIT_STACK *)pcre2_jit_stack_create_32(b,c,d); 2199 #define PCRE2_JIT_STACK_ASSIGN(a,b,c) \ 2200 pcre2_jit_stack_assign_32(G(a,32),(pcre2_jit_callback_32)b,c); 2201 #define PCRE2_JIT_STACK_FREE(a) pcre2_jit_stack_free_32((pcre2_jit_stack_32 *)a); 2202 #define PCRE2_MAKETABLES(a) a = pcre2_maketables_32(NULL) 2203 #define PCRE2_MATCH(a,b,c,d,e,f,g,h) \ 2204 a = pcre2_match_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),h) 2205 #define PCRE2_MATCH_DATA_CREATE(a,b,c) G(a,32) = pcre2_match_data_create_32(b,c) 2206 #define PCRE2_MATCH_DATA_CREATE_FROM_PATTERN(a,b,c) \ 2207 G(a,32) = pcre2_match_data_create_from_pattern_32(G(b,32),c) 2208 #define PCRE2_MATCH_DATA_FREE(a) pcre2_match_data_free_32(G(a,32)) 2209 #define PCRE2_PATTERN_CONVERT(a,b,c,d,e,f,g) a = pcre2_pattern_convert_32(G(b,32),c,d,(PCRE2_UCHAR32 **)e,f,G(g,32)) 2210 #define PCRE2_PATTERN_INFO(a,b,c,d) a = pcre2_pattern_info_32(G(b,32),c,d) 2211 #define PCRE2_PRINTINT(a) pcre2_printint_32(compiled_code32,outfile,a) 2212 #define PCRE2_SERIALIZE_DECODE(r,a,b,c,d) \ 2213 r = pcre2_serialize_decode_32((pcre2_code_32 **)a,b,c,G(d,32)) 2214 #define PCRE2_SERIALIZE_ENCODE(r,a,b,c,d,e) \ 2215 r = pcre2_serialize_encode_32((const pcre2_code_32 **)a,b,c,d,G(e,32)) 2216 #define PCRE2_SERIALIZE_FREE(a) pcre2_serialize_free_32(a) 2217 #define PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(r,a) \ 2218 r = pcre2_serialize_get_number_of_codes_32(a) 2219 #define PCRE2_SET_CALLOUT(a,b,c) \ 2220 pcre2_set_callout_32(G(a,32),(int (*)(pcre2_callout_block_32 *, void *))b,c); 2221 #define PCRE2_SET_CHARACTER_TABLES(a,b) pcre2_set_character_tables_32(G(a,32),b) 2222 #define PCRE2_SET_COMPILE_RECURSION_GUARD(a,b,c) \ 2223 pcre2_set_compile_recursion_guard_32(G(a,32),b,c) 2224 #define PCRE2_SET_DEPTH_LIMIT(a,b) pcre2_set_depth_limit_32(G(a,32),b) 2225 #define PCRE2_SET_GLOB_ESCAPE(r,a,b) r = pcre2_set_glob_escape_32(G(a,32),b) 2226 #define PCRE2_SET_GLOB_SEPARATOR(r,a,b) r = pcre2_set_glob_separator_32(G(a,32),b) 2227 #define PCRE2_SET_HEAP_LIMIT(a,b) pcre2_set_heap_limit_32(G(a,32),b) 2228 #define PCRE2_SET_MATCH_LIMIT(a,b) pcre2_set_match_limit_32(G(a,32),b) 2229 #define PCRE2_SET_MAX_PATTERN_LENGTH(a,b) pcre2_set_max_pattern_length_32(G(a,32),b) 2230 #define PCRE2_SET_OFFSET_LIMIT(a,b) pcre2_set_offset_limit_32(G(a,32),b) 2231 #define PCRE2_SET_PARENS_NEST_LIMIT(a,b) pcre2_set_parens_nest_limit_32(G(a,32),b) 2232 #define PCRE2_SUBSTITUTE(a,b,c,d,e,f,g,h,i,j,k,l) \ 2233 a = pcre2_substitute_32(G(b,32),(PCRE2_SPTR32)c,d,e,f,G(g,32),G(h,32), \ 2234 (PCRE2_SPTR32)i,j,(PCRE2_UCHAR32 *)k,l) 2235 #define PCRE2_SUBSTRING_COPY_BYNAME(a,b,c,d,e) \ 2236 a = pcre2_substring_copy_byname_32(G(b,32),G(c,32),(PCRE2_UCHAR32 *)d,e) 2237 #define PCRE2_SUBSTRING_COPY_BYNUMBER(a,b,c,d,e) \ 2238 a = pcre2_substring_copy_bynumber_32(G(b,32),c,(PCRE2_UCHAR32 *)d,e); 2239 #define PCRE2_SUBSTRING_FREE(a) pcre2_substring_free_32((PCRE2_UCHAR32 *)a) 2240 #define PCRE2_SUBSTRING_GET_BYNAME(a,b,c,d,e) \ 2241 a = pcre2_substring_get_byname_32(G(b,32),G(c,32),(PCRE2_UCHAR32 **)d,e) 2242 #define PCRE2_SUBSTRING_GET_BYNUMBER(a,b,c,d,e) \ 2243 a = pcre2_substring_get_bynumber_32(G(b,32),c,(PCRE2_UCHAR32 **)d,e) 2244 #define PCRE2_SUBSTRING_LENGTH_BYNAME(a,b,c,d) \ 2245 a = pcre2_substring_length_byname_32(G(b,32),G(c,32),d) 2246 #define PCRE2_SUBSTRING_LENGTH_BYNUMBER(a,b,c,d) \ 2247 a = pcre2_substring_length_bynumber_32(G(b,32),c,d) 2248 #define PCRE2_SUBSTRING_LIST_GET(a,b,c,d) \ 2249 a = pcre2_substring_list_get_32(G(b,32),(PCRE2_UCHAR32 ***)c,d) 2250 #define PCRE2_SUBSTRING_LIST_FREE(a) \ 2251 pcre2_substring_list_free_32((PCRE2_SPTR32 *)a) 2252 #define PCRE2_SUBSTRING_NUMBER_FROM_NAME(a,b,c) \ 2253 a = pcre2_substring_number_from_name_32(G(b,32),G(c,32)); 2254 #define PTR(x) (void *)G(x,32) 2255 #define SETFLD(x,y,z) G(x,32)->y = z 2256 #define SETFLDVEC(x,y,v,z) G(x,32)->y[v] = z 2257 #define SETOP(x,y,z) G(x,32) z y 2258 #define SETCASTPTR(x,y) G(x,32) = (uint32_t *)(y) 2259 #define STRLEN(p) (int)strlen32((PCRE2_SPTR32)p) 2260 #define SUB1(a,b) G(a,32)(G(b,32)) 2261 #define SUB2(a,b,c) G(a,32)(G(b,32),G(c,32)) 2262 #define TEST(x,r,y) (G(x,32) r (y)) 2263 #define TESTFLD(x,f,r,y) (G(x,32)->f r (y)) 2264 2265 #endif 2266 2267 /* ----- End of mode-specific function call macros ----- */ 2268 2269 2270 2271 2272 /************************************************* 2273 * Alternate character tables * 2274 *************************************************/ 2275 2276 /* By default, the "tables" pointer in the compile context when calling 2277 pcre2_compile() is not set (= NULL), thereby using the default tables of the 2278 library. However, the tables modifier can be used to select alternate sets of 2279 tables, for different kinds of testing. Note that the locale modifier also 2280 adjusts the tables. */ 2281 2282 /* This is the set of tables distributed as default with PCRE2. It recognizes 2283 only ASCII characters. */ 2284 2285 static const uint8_t tables1[] = { 2286 2287 /* This table is a lower casing table. */ 2288 2289 0, 1, 2, 3, 4, 5, 6, 7, 2290 8, 9, 10, 11, 12, 13, 14, 15, 2291 16, 17, 18, 19, 20, 21, 22, 23, 2292 24, 25, 26, 27, 28, 29, 30, 31, 2293 32, 33, 34, 35, 36, 37, 38, 39, 2294 40, 41, 42, 43, 44, 45, 46, 47, 2295 48, 49, 50, 51, 52, 53, 54, 55, 2296 56, 57, 58, 59, 60, 61, 62, 63, 2297 64, 97, 98, 99,100,101,102,103, 2298 104,105,106,107,108,109,110,111, 2299 112,113,114,115,116,117,118,119, 2300 120,121,122, 91, 92, 93, 94, 95, 2301 96, 97, 98, 99,100,101,102,103, 2302 104,105,106,107,108,109,110,111, 2303 112,113,114,115,116,117,118,119, 2304 120,121,122,123,124,125,126,127, 2305 128,129,130,131,132,133,134,135, 2306 136,137,138,139,140,141,142,143, 2307 144,145,146,147,148,149,150,151, 2308 152,153,154,155,156,157,158,159, 2309 160,161,162,163,164,165,166,167, 2310 168,169,170,171,172,173,174,175, 2311 176,177,178,179,180,181,182,183, 2312 184,185,186,187,188,189,190,191, 2313 192,193,194,195,196,197,198,199, 2314 200,201,202,203,204,205,206,207, 2315 208,209,210,211,212,213,214,215, 2316 216,217,218,219,220,221,222,223, 2317 224,225,226,227,228,229,230,231, 2318 232,233,234,235,236,237,238,239, 2319 240,241,242,243,244,245,246,247, 2320 248,249,250,251,252,253,254,255, 2321 2322 /* This table is a case flipping table. */ 2323 2324 0, 1, 2, 3, 4, 5, 6, 7, 2325 8, 9, 10, 11, 12, 13, 14, 15, 2326 16, 17, 18, 19, 20, 21, 22, 23, 2327 24, 25, 26, 27, 28, 29, 30, 31, 2328 32, 33, 34, 35, 36, 37, 38, 39, 2329 40, 41, 42, 43, 44, 45, 46, 47, 2330 48, 49, 50, 51, 52, 53, 54, 55, 2331 56, 57, 58, 59, 60, 61, 62, 63, 2332 64, 97, 98, 99,100,101,102,103, 2333 104,105,106,107,108,109,110,111, 2334 112,113,114,115,116,117,118,119, 2335 120,121,122, 91, 92, 93, 94, 95, 2336 96, 65, 66, 67, 68, 69, 70, 71, 2337 72, 73, 74, 75, 76, 77, 78, 79, 2338 80, 81, 82, 83, 84, 85, 86, 87, 2339 88, 89, 90,123,124,125,126,127, 2340 128,129,130,131,132,133,134,135, 2341 136,137,138,139,140,141,142,143, 2342 144,145,146,147,148,149,150,151, 2343 152,153,154,155,156,157,158,159, 2344 160,161,162,163,164,165,166,167, 2345 168,169,170,171,172,173,174,175, 2346 176,177,178,179,180,181,182,183, 2347 184,185,186,187,188,189,190,191, 2348 192,193,194,195,196,197,198,199, 2349 200,201,202,203,204,205,206,207, 2350 208,209,210,211,212,213,214,215, 2351 216,217,218,219,220,221,222,223, 2352 224,225,226,227,228,229,230,231, 2353 232,233,234,235,236,237,238,239, 2354 240,241,242,243,244,245,246,247, 2355 248,249,250,251,252,253,254,255, 2356 2357 /* This table contains bit maps for various character classes. Each map is 32 2358 bytes long and the bits run from the least significant end of each byte. The 2359 classes that have their own maps are: space, xdigit, digit, upper, lower, word, 2360 graph, print, punct, and cntrl. Other classes are built from combinations. */ 2361 2362 0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00, 2363 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2364 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2365 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2366 2367 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 2368 0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00, 2369 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2370 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2371 2372 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 2373 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2374 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2375 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2376 2377 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2378 0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00, 2379 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2380 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2381 2382 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2383 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07, 2384 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2385 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2386 2387 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 2388 0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07, 2389 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2390 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2391 2392 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff, 2393 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 2394 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2395 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2396 2397 0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff, 2398 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 2399 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2400 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2401 2402 0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc, 2403 0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78, 2404 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2405 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2406 2407 0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00, 2408 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80, 2409 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2410 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 2411 2412 /* This table identifies various classes of character by individual bits: 2413 0x01 white space character 2414 0x02 letter 2415 0x04 decimal digit 2416 0x08 hexadecimal digit 2417 0x10 alphanumeric or '_' 2418 0x80 regular expression metacharacter or binary zero 2419 */ 2420 2421 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */ 2422 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */ 2423 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */ 2424 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */ 2425 0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */ 2426 0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /* ( - / */ 2427 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */ 2428 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /* 8 - ? */ 2429 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* @ - G */ 2430 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* H - O */ 2431 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* P - W */ 2432 0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /* X - _ */ 2433 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* ` - g */ 2434 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* h - o */ 2435 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* p - w */ 2436 0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /* x -127 */ 2437 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */ 2438 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */ 2439 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */ 2440 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */ 2441 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */ 2442 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */ 2443 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */ 2444 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */ 2445 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */ 2446 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */ 2447 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */ 2448 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */ 2449 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */ 2450 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */ 2451 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */ 2452 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */ 2453 2454 /* This is a set of tables that came originally from a Windows user. It seems 2455 to be at least an approximation of ISO 8859. In particular, there are 2456 characters greater than 128 that are marked as spaces, letters, etc. */ 2457 2458 static const uint8_t tables2[] = { 2459 0,1,2,3,4,5,6,7, 2460 8,9,10,11,12,13,14,15, 2461 16,17,18,19,20,21,22,23, 2462 24,25,26,27,28,29,30,31, 2463 32,33,34,35,36,37,38,39, 2464 40,41,42,43,44,45,46,47, 2465 48,49,50,51,52,53,54,55, 2466 56,57,58,59,60,61,62,63, 2467 64,97,98,99,100,101,102,103, 2468 104,105,106,107,108,109,110,111, 2469 112,113,114,115,116,117,118,119, 2470 120,121,122,91,92,93,94,95, 2471 96,97,98,99,100,101,102,103, 2472 104,105,106,107,108,109,110,111, 2473 112,113,114,115,116,117,118,119, 2474 120,121,122,123,124,125,126,127, 2475 128,129,130,131,132,133,134,135, 2476 136,137,138,139,140,141,142,143, 2477 144,145,146,147,148,149,150,151, 2478 152,153,154,155,156,157,158,159, 2479 160,161,162,163,164,165,166,167, 2480 168,169,170,171,172,173,174,175, 2481 176,177,178,179,180,181,182,183, 2482 184,185,186,187,188,189,190,191, 2483 224,225,226,227,228,229,230,231, 2484 232,233,234,235,236,237,238,239, 2485 240,241,242,243,244,245,246,215, 2486 248,249,250,251,252,253,254,223, 2487 224,225,226,227,228,229,230,231, 2488 232,233,234,235,236,237,238,239, 2489 240,241,242,243,244,245,246,247, 2490 248,249,250,251,252,253,254,255, 2491 0,1,2,3,4,5,6,7, 2492 8,9,10,11,12,13,14,15, 2493 16,17,18,19,20,21,22,23, 2494 24,25,26,27,28,29,30,31, 2495 32,33,34,35,36,37,38,39, 2496 40,41,42,43,44,45,46,47, 2497 48,49,50,51,52,53,54,55, 2498 56,57,58,59,60,61,62,63, 2499 64,97,98,99,100,101,102,103, 2500 104,105,106,107,108,109,110,111, 2501 112,113,114,115,116,117,118,119, 2502 120,121,122,91,92,93,94,95, 2503 96,65,66,67,68,69,70,71, 2504 72,73,74,75,76,77,78,79, 2505 80,81,82,83,84,85,86,87, 2506 88,89,90,123,124,125,126,127, 2507 128,129,130,131,132,133,134,135, 2508 136,137,138,139,140,141,142,143, 2509 144,145,146,147,148,149,150,151, 2510 152,153,154,155,156,157,158,159, 2511 160,161,162,163,164,165,166,167, 2512 168,169,170,171,172,173,174,175, 2513 176,177,178,179,180,181,182,183, 2514 184,185,186,187,188,189,190,191, 2515 224,225,226,227,228,229,230,231, 2516 232,233,234,235,236,237,238,239, 2517 240,241,242,243,244,245,246,215, 2518 248,249,250,251,252,253,254,223, 2519 192,193,194,195,196,197,198,199, 2520 200,201,202,203,204,205,206,207, 2521 208,209,210,211,212,213,214,247, 2522 216,217,218,219,220,221,222,255, 2523 0,62,0,0,1,0,0,0, 2524 0,0,0,0,0,0,0,0, 2525 32,0,0,0,1,0,0,0, 2526 0,0,0,0,0,0,0,0, 2527 0,0,0,0,0,0,255,3, 2528 126,0,0,0,126,0,0,0, 2529 0,0,0,0,0,0,0,0, 2530 0,0,0,0,0,0,0,0, 2531 0,0,0,0,0,0,255,3, 2532 0,0,0,0,0,0,0,0, 2533 0,0,0,0,0,0,12,2, 2534 0,0,0,0,0,0,0,0, 2535 0,0,0,0,0,0,0,0, 2536 254,255,255,7,0,0,0,0, 2537 0,0,0,0,0,0,0,0, 2538 255,255,127,127,0,0,0,0, 2539 0,0,0,0,0,0,0,0, 2540 0,0,0,0,254,255,255,7, 2541 0,0,0,0,0,4,32,4, 2542 0,0,0,128,255,255,127,255, 2543 0,0,0,0,0,0,255,3, 2544 254,255,255,135,254,255,255,7, 2545 0,0,0,0,0,4,44,6, 2546 255,255,127,255,255,255,127,255, 2547 0,0,0,0,254,255,255,255, 2548 255,255,255,255,255,255,255,127, 2549 0,0,0,0,254,255,255,255, 2550 255,255,255,255,255,255,255,255, 2551 0,2,0,0,255,255,255,255, 2552 255,255,255,255,255,255,255,127, 2553 0,0,0,0,255,255,255,255, 2554 255,255,255,255,255,255,255,255, 2555 0,0,0,0,254,255,0,252, 2556 1,0,0,248,1,0,0,120, 2557 0,0,0,0,254,255,255,255, 2558 0,0,128,0,0,0,128,0, 2559 255,255,255,255,0,0,0,0, 2560 0,0,0,0,0,0,0,128, 2561 255,255,255,255,0,0,0,0, 2562 0,0,0,0,0,0,0,0, 2563 128,0,0,0,0,0,0,0, 2564 0,1,1,0,1,1,0,0, 2565 0,0,0,0,0,0,0,0, 2566 0,0,0,0,0,0,0,0, 2567 1,0,0,0,128,0,0,0, 2568 128,128,128,128,0,0,128,0, 2569 28,28,28,28,28,28,28,28, 2570 28,28,0,0,0,0,0,128, 2571 0,26,26,26,26,26,26,18, 2572 18,18,18,18,18,18,18,18, 2573 18,18,18,18,18,18,18,18, 2574 18,18,18,128,128,0,128,16, 2575 0,26,26,26,26,26,26,18, 2576 18,18,18,18,18,18,18,18, 2577 18,18,18,18,18,18,18,18, 2578 18,18,18,128,128,0,0,0, 2579 0,0,0,0,0,1,0,0, 2580 0,0,0,0,0,0,0,0, 2581 0,0,0,0,0,0,0,0, 2582 0,0,0,0,0,0,0,0, 2583 1,0,0,0,0,0,0,0, 2584 0,0,18,0,0,0,0,0, 2585 0,0,20,20,0,18,0,0, 2586 0,20,18,0,0,0,0,0, 2587 18,18,18,18,18,18,18,18, 2588 18,18,18,18,18,18,18,18, 2589 18,18,18,18,18,18,18,0, 2590 18,18,18,18,18,18,18,18, 2591 18,18,18,18,18,18,18,18, 2592 18,18,18,18,18,18,18,18, 2593 18,18,18,18,18,18,18,0, 2594 18,18,18,18,18,18,18,18 2595 }; 2596 2597 2598 2599 #if !defined(VPCOMPAT) && !defined(HAVE_MEMMOVE) 2600 /************************************************* 2601 * Emulated memmove() for systems without it * 2602 *************************************************/ 2603 2604 /* This function can make use of bcopy() if it is available. Otherwise do it by 2605 steam, as there are some non-Unix environments that lack both memmove() and 2606 bcopy(). */ 2607 2608 static void * 2609 emulated_memmove(void *d, const void *s, size_t n) 2610 { 2611 #ifdef HAVE_BCOPY 2612 bcopy(s, d, n); 2613 return d; 2614 #else 2615 size_t i; 2616 unsigned char *dest = (unsigned char *)d; 2617 const unsigned char *src = (const unsigned char *)s; 2618 if (dest > src) 2619 { 2620 dest += n; 2621 src += n; 2622 for (i = 0; i < n; ++i) *(--dest) = *(--src); 2623 return (void *)dest; 2624 } 2625 else 2626 { 2627 for (i = 0; i < n; ++i) *dest++ = *src++; 2628 return (void *)(dest - n); 2629 } 2630 #endif /* not HAVE_BCOPY */ 2631 } 2632 #undef memmove 2633 #define memmove(d,s,n) emulated_memmove(d,s,n) 2634 #endif /* not VPCOMPAT && not HAVE_MEMMOVE */ 2635 2636 2637 2638 #ifndef HAVE_STRERROR 2639 /************************************************* 2640 * Provide strerror() for non-ANSI libraries * 2641 *************************************************/ 2642 2643 /* Some old-fashioned systems (e.g. SunOS4) didn't have strerror() in their 2644 libraries. They may no longer be around, but just in case, we can try to 2645 provide the same facility by this simple alternative function. */ 2646 2647 extern int sys_nerr; 2648 extern char *sys_errlist[]; 2649 2650 char * 2651 strerror(int n) 2652 { 2653 if (n < 0 || n >= sys_nerr) return "unknown error number"; 2654 return sys_errlist[n]; 2655 } 2656 #endif /* HAVE_STRERROR */ 2657 2658 2659 2660 /************************************************* 2661 * Local memory functions * 2662 *************************************************/ 2663 2664 /* Alternative memory functions, to test functionality. */ 2665 2666 static void *my_malloc(PCRE2_SIZE size, void *data) 2667 { 2668 void *block = malloc(size); 2669 (void)data; 2670 if (show_memory) 2671 { 2672 if (block == NULL) 2673 { 2674 fprintf(outfile, "** malloc() failed for %" SIZ_FORM "\n", SIZ_CAST size); 2675 } 2676 else 2677 { 2678 fprintf(outfile, "malloc %5" SIZ_FORM, SIZ_CAST size); 2679 #ifdef DEBUG_SHOW_MALLOC_ADDRESSES 2680 fprintf(outfile, " %p", block); /* Not portable */ 2681 #endif 2682 if (malloclistptr < MALLOCLISTSIZE) 2683 { 2684 malloclist[malloclistptr] = block; 2685 malloclistlength[malloclistptr++] = size; 2686 } 2687 else 2688 fprintf(outfile, " (not remembered)"); 2689 fprintf(outfile, "\n"); 2690 } 2691 } 2692 return block; 2693 } 2694 2695 static void my_free(void *block, void *data) 2696 { 2697 (void)data; 2698 if (show_memory) 2699 { 2700 uint32_t i, j; 2701 BOOL found = FALSE; 2702 2703 fprintf(outfile, "free"); 2704 for (i = 0; i < malloclistptr; i++) 2705 { 2706 if (block == malloclist[i]) 2707 { 2708 fprintf(outfile, " %5" SIZ_FORM, SIZ_CAST malloclistlength[i]); 2709 malloclistptr--; 2710 for (j = i; j < malloclistptr; j++) 2711 { 2712 malloclist[j] = malloclist[j+1]; 2713 malloclistlength[j] = malloclistlength[j+1]; 2714 } 2715 found = TRUE; 2716 break; 2717 } 2718 } 2719 if (!found) fprintf(outfile, " unremembered block"); 2720 #ifdef DEBUG_SHOW_MALLOC_ADDRESSES 2721 fprintf(outfile, " %p", block); /* Not portable */ 2722 #endif 2723 fprintf(outfile, "\n"); 2724 } 2725 free(block); 2726 } 2727 2728 2729 2730 /************************************************* 2731 * Callback function for stack guard * 2732 *************************************************/ 2733 2734 /* This is set up to be called from pcre2_compile() when the stackguard=n 2735 modifier sets a value greater than zero. The test we do is whether the 2736 parenthesis nesting depth is greater than the value set by the modifier. 2737 2738 Argument: the current parenthesis nesting depth 2739 Returns: non-zero to kill the compilation 2740 */ 2741 2742 static int 2743 stack_guard(uint32_t depth, void *user_data) 2744 { 2745 (void)user_data; 2746 return depth > pat_patctl.stackguard_test; 2747 } 2748 2749 2750 /************************************************* 2751 * JIT memory callback * 2752 *************************************************/ 2753 2754 static PCRE2_JIT_STACK* 2755 jit_callback(void *arg) 2756 { 2757 jit_was_used = TRUE; 2758 return (PCRE2_JIT_STACK *)arg; 2759 } 2760 2761 2762 /************************************************* 2763 * Convert UTF-8 character to code point * 2764 *************************************************/ 2765 2766 /* This function reads one or more bytes that represent a UTF-8 character, 2767 and returns the codepoint of that character. Note that the function supports 2768 the original UTF-8 definition of RFC 2279, allowing for values in the range 0 2769 to 0x7fffffff, up to 6 bytes long. This makes it possible to generate 2770 codepoints greater than 0x10ffff which are useful for testing PCRE2's error 2771 checking, and also for generating 32-bit non-UTF data values above the UTF 2772 limit. 2773 2774 Argument: 2775 utf8bytes a pointer to the byte vector 2776 vptr a pointer to an int to receive the value 2777 2778 Returns: > 0 => the number of bytes consumed 2779 -6 to 0 => malformed UTF-8 character at offset = (-return) 2780 */ 2781 2782 static int 2783 utf82ord(PCRE2_SPTR8 utf8bytes, uint32_t *vptr) 2784 { 2785 uint32_t c = *utf8bytes++; 2786 uint32_t d = c; 2787 int i, j, s; 2788 2789 for (i = -1; i < 6; i++) /* i is number of additional bytes */ 2790 { 2791 if ((d & 0x80) == 0) break; 2792 d <<= 1; 2793 } 2794 2795 if (i == -1) { *vptr = c; return 1; } /* ascii character */ 2796 if (i == 0 || i == 6) return 0; /* invalid UTF-8 */ 2797 2798 /* i now has a value in the range 1-5 */ 2799 2800 s = 6*i; 2801 d = (c & utf8_table3[i]) << s; 2802 2803 for (j = 0; j < i; j++) 2804 { 2805 c = *utf8bytes++; 2806 if ((c & 0xc0) != 0x80) return -(j+1); 2807 s -= 6; 2808 d |= (c & 0x3f) << s; 2809 } 2810 2811 /* Check that encoding was the correct unique one */ 2812 2813 for (j = 0; j < utf8_table1_size; j++) 2814 if (d <= (uint32_t)utf8_table1[j]) break; 2815 if (j != i) return -(i+1); 2816 2817 /* Valid value */ 2818 2819 *vptr = d; 2820 return i+1; 2821 } 2822 2823 2824 2825 /************************************************* 2826 * Print one character * 2827 *************************************************/ 2828 2829 /* Print a single character either literally, or as a hex escape, and count how 2830 many printed characters are used. 2831 2832 Arguments: 2833 c the character 2834 utf TRUE in UTF mode 2835 f the FILE to print to, or NULL just to count characters 2836 2837 Returns: number of characters written 2838 */ 2839 2840 static int 2841 pchar(uint32_t c, BOOL utf, FILE *f) 2842 { 2843 int n = 0; 2844 char tempbuffer[16]; 2845 2846 if (PRINTOK(c)) 2847 { 2848 if (f != NULL) fprintf(f, "%c", c); 2849 return 1; 2850 } 2851 2852 if (c < 0x100) 2853 { 2854 if (utf) 2855 { 2856 if (f != NULL) fprintf(f, "\\x{%02x}", c); 2857 return 6; 2858 } 2859 else 2860 { 2861 if (f != NULL) fprintf(f, "\\x%02x", c); 2862 return 4; 2863 } 2864 } 2865 2866 if (f != NULL) n = fprintf(f, "\\x{%02x}", c); 2867 else n = sprintf(tempbuffer, "\\x{%02x}", c); 2868 2869 return n >= 0 ? n : 0; 2870 } 2871 2872 2873 2874 #ifdef SUPPORT_PCRE2_16 2875 /************************************************* 2876 * Find length of 0-terminated 16-bit string * 2877 *************************************************/ 2878 2879 static size_t strlen16(PCRE2_SPTR16 p) 2880 { 2881 PCRE2_SPTR16 pp = p; 2882 while (*pp != 0) pp++; 2883 return (int)(pp - p); 2884 } 2885 #endif /* SUPPORT_PCRE2_16 */ 2886 2887 2888 2889 #ifdef SUPPORT_PCRE2_32 2890 /************************************************* 2891 * Find length of 0-terminated 32-bit string * 2892 *************************************************/ 2893 2894 static size_t strlen32(PCRE2_SPTR32 p) 2895 { 2896 PCRE2_SPTR32 pp = p; 2897 while (*pp != 0) pp++; 2898 return (int)(pp - p); 2899 } 2900 #endif /* SUPPORT_PCRE2_32 */ 2901 2902 2903 #ifdef SUPPORT_PCRE2_8 2904 /************************************************* 2905 * Print 8-bit character string * 2906 *************************************************/ 2907 2908 /* Must handle UTF-8 strings in utf8 mode. Yields number of characters printed. 2909 For printing *MARK strings, a negative length is given. If handed a NULL file, 2910 just counts chars without printing (because pchar() does that). */ 2911 2912 static int pchars8(PCRE2_SPTR8 p, int length, BOOL utf, FILE *f) 2913 { 2914 uint32_t c = 0; 2915 int yield = 0; 2916 2917 if (length < 0) length = p[-1]; 2918 while (length-- > 0) 2919 { 2920 if (utf) 2921 { 2922 int rc = utf82ord(p, &c); 2923 if (rc > 0 && rc <= length + 1) /* Mustn't run over the end */ 2924 { 2925 length -= rc - 1; 2926 p += rc; 2927 yield += pchar(c, utf, f); 2928 continue; 2929 } 2930 } 2931 c = *p++; 2932 yield += pchar(c, utf, f); 2933 } 2934 2935 return yield; 2936 } 2937 #endif 2938 2939 2940 #ifdef SUPPORT_PCRE2_16 2941 /************************************************* 2942 * Print 16-bit character string * 2943 *************************************************/ 2944 2945 /* Must handle UTF-16 strings in utf mode. Yields number of characters printed. 2946 For printing *MARK strings, a negative length is given. If handed a NULL file, 2947 just counts chars without printing. */ 2948 2949 static int pchars16(PCRE2_SPTR16 p, int length, BOOL utf, FILE *f) 2950 { 2951 int yield = 0; 2952 if (length < 0) length = p[-1]; 2953 while (length-- > 0) 2954 { 2955 uint32_t c = *p++ & 0xffff; 2956 if (utf && c >= 0xD800 && c < 0xDC00 && length > 0) 2957 { 2958 int d = *p & 0xffff; 2959 if (d >= 0xDC00 && d <= 0xDFFF) 2960 { 2961 c = ((c & 0x3ff) << 10) + (d & 0x3ff) + 0x10000; 2962 length--; 2963 p++; 2964 } 2965 } 2966 yield += pchar(c, utf, f); 2967 } 2968 return yield; 2969 } 2970 #endif /* SUPPORT_PCRE2_16 */ 2971 2972 2973 2974 #ifdef SUPPORT_PCRE2_32 2975 /************************************************* 2976 * Print 32-bit character string * 2977 *************************************************/ 2978 2979 /* Must handle UTF-32 strings in utf mode. Yields number of characters printed. 2980 For printing *MARK strings, a negative length is given. If handed a NULL file, 2981 just counts chars without printing. */ 2982 2983 static int pchars32(PCRE2_SPTR32 p, int length, BOOL utf, FILE *f) 2984 { 2985 int yield = 0; 2986 (void)(utf); /* Avoid compiler warning */ 2987 2988 if (length < 0) length = p[-1]; 2989 while (length-- > 0) 2990 { 2991 uint32_t c = *p++; 2992 yield += pchar(c, utf, f); 2993 } 2994 return yield; 2995 } 2996 #endif /* SUPPORT_PCRE2_32 */ 2997 2998 2999 3000 3001 #ifdef SUPPORT_PCRE2_8 3002 /************************************************* 3003 * Convert character value to UTF-8 * 3004 *************************************************/ 3005 3006 /* This function takes an integer value in the range 0 - 0x7fffffff 3007 and encodes it as a UTF-8 character in 0 to 6 bytes. 3008 3009 Arguments: 3010 cvalue the character value 3011 utf8bytes pointer to buffer for result - at least 6 bytes long 3012 3013 Returns: number of characters placed in the buffer 3014 */ 3015 3016 static int 3017 ord2utf8(uint32_t cvalue, uint8_t *utf8bytes) 3018 { 3019 int i, j; 3020 if (cvalue > 0x7fffffffu) 3021 return -1; 3022 for (i = 0; i < utf8_table1_size; i++) 3023 if (cvalue <= (uint32_t)utf8_table1[i]) break; 3024 utf8bytes += i; 3025 for (j = i; j > 0; j--) 3026 { 3027 *utf8bytes-- = 0x80 | (cvalue & 0x3f); 3028 cvalue >>= 6; 3029 } 3030 *utf8bytes = utf8_table2[i] | cvalue; 3031 return i + 1; 3032 } 3033 #endif /* SUPPORT_PCRE2_8 */ 3034 3035 3036 3037 #ifdef SUPPORT_PCRE2_16 3038 /************************************************* 3039 * Convert string to 16-bit * 3040 *************************************************/ 3041 3042 /* In UTF mode the input is always interpreted as a string of UTF-8 bytes using 3043 the original UTF-8 definition of RFC 2279, which allows for up to 6 bytes, and 3044 code values from 0 to 0x7fffffff. However, values greater than the later UTF 3045 limit of 0x10ffff cause an error. In non-UTF mode the input is interpreted as 3046 UTF-8 if the utf8_input modifier is set, but an error is generated for values 3047 greater than 0xffff. 3048 3049 If all the input bytes are ASCII, the space needed for a 16-bit string is 3050 exactly double the 8-bit size. Otherwise, the size needed for a 16-bit string 3051 is no more than double, because up to 0xffff uses no more than 3 bytes in UTF-8 3052 but possibly 4 in UTF-16. Higher values use 4 bytes in UTF-8 and up to 4 bytes 3053 in UTF-16. The result is always left in pbuffer16. Impose a minimum size to 3054 save repeated re-sizing. 3055 3056 Note that this function does not object to surrogate values. This is 3057 deliberate; it makes it possible to construct UTF-16 strings that are invalid, 3058 for the purpose of testing that they are correctly faulted. 3059 3060 Arguments: 3061 p points to a byte string 3062 utf true in UTF mode 3063 lenptr points to number of bytes in the string (excluding trailing zero) 3064 3065 Returns: 0 on success, with the length updated to the number of 16-bit 3066 data items used (excluding the trailing zero) 3067 OR -1 if a UTF-8 string is malformed 3068 OR -2 if a value > 0x10ffff is encountered in UTF mode 3069 OR -3 if a value > 0xffff is encountered when not in UTF mode 3070 */ 3071 3072 static PCRE2_SIZE 3073 to16(uint8_t *p, int utf, PCRE2_SIZE *lenptr) 3074 { 3075 uint16_t *pp; 3076 PCRE2_SIZE len = *lenptr; 3077 3078 if (pbuffer16_size < 2*len + 2) 3079 { 3080 if (pbuffer16 != NULL) free(pbuffer16); 3081 pbuffer16_size = 2*len + 2; 3082 if (pbuffer16_size < 4096) pbuffer16_size = 4096; 3083 pbuffer16 = (uint16_t *)malloc(pbuffer16_size); 3084 if (pbuffer16 == NULL) 3085 { 3086 fprintf(stderr, "pcre2test: malloc(%" SIZ_FORM ") failed for pbuffer16\n", 3087 SIZ_CAST pbuffer16_size); 3088 exit(1); 3089 } 3090 } 3091 3092 pp = pbuffer16; 3093 if (!utf && (pat_patctl.control & CTL_UTF8_INPUT) == 0) 3094 { 3095 for (; len > 0; len--) *pp++ = *p++; 3096 } 3097 else while (len > 0) 3098 { 3099 uint32_t c; 3100 int chlen = utf82ord(p, &c); 3101 if (chlen <= 0) return -1; 3102 if (!utf && c > 0xffff) return -3; 3103 if (c > 0x10ffff) return -2; 3104 p += chlen; 3105 len -= chlen; 3106 if (c < 0x10000) *pp++ = c; else 3107 { 3108 c -= 0x10000; 3109 *pp++ = 0xD800 | (c >> 10); 3110 *pp++ = 0xDC00 | (c & 0x3ff); 3111 } 3112 } 3113 3114 *pp = 0; 3115 *lenptr = pp - pbuffer16; 3116 return 0; 3117 } 3118 #endif 3119 3120 3121 3122 #ifdef SUPPORT_PCRE2_32 3123 /************************************************* 3124 * Convert string to 32-bit * 3125 *************************************************/ 3126 3127 /* In UTF mode the input is always interpreted as a string of UTF-8 bytes using 3128 the original UTF-8 definition of RFC 2279, which allows for up to 6 bytes, and 3129 code values from 0 to 0x7fffffff. However, values greater than the later UTF 3130 limit of 0x10ffff cause an error. 3131 3132 In non-UTF mode the input is interpreted as UTF-8 if the utf8_input modifier 3133 is set, and no limit is imposed. There is special interpretation of the 0xff 3134 byte (which is illegal in UTF-8) in this case: it causes the top bit of the 3135 next character to be set. This provides a way of generating 32-bit characters 3136 greater than 0x7fffffff. 3137 3138 If all the input bytes are ASCII, the space needed for a 32-bit string is 3139 exactly four times the 8-bit size. Otherwise, the size needed for a 32-bit 3140 string is no more than four times, because the number of characters must be 3141 less than the number of bytes. The result is always left in pbuffer32. Impose a 3142 minimum size to save repeated re-sizing. 3143 3144 Note that this function does not object to surrogate values. This is 3145 deliberate; it makes it possible to construct UTF-32 strings that are invalid, 3146 for the purpose of testing that they are correctly faulted. 3147 3148 Arguments: 3149 p points to a byte string 3150 utf true in UTF mode 3151 lenptr points to number of bytes in the string (excluding trailing zero) 3152 3153 Returns: 0 on success, with the length updated to the number of 32-bit 3154 data items used (excluding the trailing zero) 3155 OR -1 if a UTF-8 string is malformed 3156 OR -2 if a value > 0x10ffff is encountered in UTF mode 3157 */ 3158 3159 static PCRE2_SIZE 3160 to32(uint8_t *p, int utf, PCRE2_SIZE *lenptr) 3161 { 3162 uint32_t *pp; 3163 PCRE2_SIZE len = *lenptr; 3164 3165 if (pbuffer32_size < 4*len + 4) 3166 { 3167 if (pbuffer32 != NULL) free(pbuffer32); 3168 pbuffer32_size = 4*len + 4; 3169 if (pbuffer32_size < 8192) pbuffer32_size = 8192; 3170 pbuffer32 = (uint32_t *)malloc(pbuffer32_size); 3171 if (pbuffer32 == NULL) 3172 { 3173 fprintf(stderr, "pcre2test: malloc(%" SIZ_FORM ") failed for pbuffer32\n", 3174 SIZ_CAST pbuffer32_size); 3175 exit(1); 3176 } 3177 } 3178 3179 pp = pbuffer32; 3180 3181 if (!utf && (pat_patctl.control & CTL_UTF8_INPUT) == 0) 3182 { 3183 for (; len > 0; len--) *pp++ = *p++; 3184 } 3185 3186 else while (len > 0) 3187 { 3188 int chlen; 3189 uint32_t c; 3190 uint32_t topbit = 0; 3191 if (!utf && *p == 0xff && len > 1) 3192 { 3193 topbit = 0x80000000u; 3194 p++; 3195 len--; 3196 } 3197 chlen = utf82ord(p, &c); 3198 if (chlen <= 0) return -1; 3199 if (utf && c > 0x10ffff) return -2; 3200 p += chlen; 3201 len -= chlen; 3202 *pp++ = c | topbit; 3203 } 3204 3205 *pp = 0; 3206 *lenptr = pp - pbuffer32; 3207 return 0; 3208 } 3209 #endif /* SUPPORT_PCRE2_32 */ 3210 3211 3212 3213 /************************************************* 3214 * Move back by so many characters * 3215 *************************************************/ 3216 3217 /* Given a code unit offset in a subject string, move backwards by a number of 3218 characters, and return the resulting offset. 3219 3220 Arguments: 3221 subject pointer to the string 3222 offset start offset 3223 count count to move back by 3224 utf TRUE if in UTF mode 3225 3226 Returns: a possibly changed offset 3227 */ 3228 3229 static PCRE2_SIZE 3230 backchars(uint8_t *subject, PCRE2_SIZE offset, uint32_t count, BOOL utf) 3231 { 3232 if (!utf || test_mode == PCRE32_MODE) 3233 return (count >= offset)? 0 : (offset - count); 3234 3235 else if (test_mode == PCRE8_MODE) 3236 { 3237 PCRE2_SPTR8 pp = (PCRE2_SPTR8)subject + offset; 3238 for (; count > 0 && pp > (PCRE2_SPTR8)subject; count--) 3239 { 3240 pp--; 3241 while ((*pp & 0xc0) == 0x80) pp--; 3242 } 3243 return pp - (PCRE2_SPTR8)subject; 3244 } 3245 3246 else /* 16-bit mode */ 3247 { 3248 PCRE2_SPTR16 pp = (PCRE2_SPTR16)subject + offset; 3249 for (; count > 0 && pp > (PCRE2_SPTR16)subject; count--) 3250 { 3251 pp--; 3252 if ((*pp & 0xfc00) == 0xdc00) pp--; 3253 } 3254 return pp - (PCRE2_SPTR16)subject; 3255 } 3256 } 3257 3258 3259 3260 /************************************************* 3261 * Expand input buffers * 3262 *************************************************/ 3263 3264 /* This function doubles the size of the input buffer and the buffer for 3265 keeping an 8-bit copy of patterns (pbuffer8), and copies the current buffers to 3266 the new ones. 3267 3268 Arguments: none 3269 Returns: nothing (aborts if malloc() fails) 3270 */ 3271 3272 static void 3273 expand_input_buffers(void) 3274 { 3275 int new_pbuffer8_size = 2*pbuffer8_size; 3276 uint8_t *new_buffer = (uint8_t *)malloc(new_pbuffer8_size); 3277 uint8_t *new_pbuffer8 = (uint8_t *)malloc(new_pbuffer8_size); 3278 3279 if (new_buffer == NULL || new_pbuffer8 == NULL) 3280 { 3281 fprintf(stderr, "pcre2test: malloc(%d) failed\n", new_pbuffer8_size); 3282 exit(1); 3283 } 3284 3285 memcpy(new_buffer, buffer, pbuffer8_size); 3286 memcpy(new_pbuffer8, pbuffer8, pbuffer8_size); 3287 3288 pbuffer8_size = new_pbuffer8_size; 3289 3290 free(buffer); 3291 free(pbuffer8); 3292 3293 buffer = new_buffer; 3294 pbuffer8 = new_pbuffer8; 3295 } 3296 3297 3298 3299 /************************************************* 3300 * Read or extend an input line * 3301 *************************************************/ 3302 3303 /* Input lines are read into buffer, but both patterns and data lines can be 3304 continued over multiple input lines. In addition, if the buffer fills up, we 3305 want to automatically expand it so as to be able to handle extremely large 3306 lines that are needed for certain stress tests, although this is less likely 3307 now that there are repetition features for both patterns and data. When the 3308 input buffer is expanded, the other two buffers must also be expanded likewise, 3309 and the contents of pbuffer, which are a copy of the input for callouts, must 3310 be preserved (for when expansion happens for a data line). This is not the most 3311 optimal way of handling this, but hey, this is just a test program! 3312 3313 Arguments: 3314 f the file to read 3315 start where in buffer to start (this *must* be within buffer) 3316 prompt for stdin or readline() 3317 3318 Returns: pointer to the start of new data 3319 could be a copy of start, or could be moved 3320 NULL if no data read and EOF reached 3321 */ 3322 3323 static uint8_t * 3324 extend_inputline(FILE *f, uint8_t *start, const char *prompt) 3325 { 3326 uint8_t *here = start; 3327 3328 for (;;) 3329 { 3330 size_t rlen = (size_t)(pbuffer8_size - (here - buffer)); 3331 3332 if (rlen > 1000) 3333 { 3334 size_t dlen; 3335 3336 /* If libreadline or libedit support is required, use readline() to read a 3337 line if the input is a terminal. Note that readline() removes the trailing 3338 newline, so we must put it back again, to be compatible with fgets(). */ 3339 3340 #if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 3341 if (INTERACTIVE(f)) 3342 { 3343 size_t len; 3344 char *s = readline(prompt); 3345 if (s == NULL) return (here == start)? NULL : start; 3346 len = strlen(s); 3347 if (len > 0) add_history(s); 3348 if (len > rlen - 1) len = rlen - 1; 3349 memcpy(here, s, len); 3350 here[len] = '\n'; 3351 here[len+1] = 0; 3352 free(s); 3353 } 3354 else 3355 #endif 3356 3357 /* Read the next line by normal means, prompting if the file is a tty. */ 3358 3359 { 3360 if (INTERACTIVE(f)) printf("%s", prompt); 3361 if (fgets((char *)here, rlen, f) == NULL) 3362 return (here == start)? NULL : start; 3363 } 3364 3365 dlen = strlen((char *)here); 3366 here += dlen; 3367 3368 /* Check for end of line reached. Take care not to read data from before 3369 start (dlen will be zero for a file starting with a binary zero). */ 3370 3371 if (here > start && here[-1] == '\n') return start; 3372 3373 /* If we have not read a newline when reading a file, we have either filled 3374 the buffer or reached the end of the file. We can detect the former by 3375 checking that the string fills the buffer, and the latter by feof(). If 3376 neither of these is true, it means we read a binary zero which has caused 3377 strlen() to give a short length. This is a hard error because pcre2test 3378 expects to work with C strings. */ 3379 3380 if (!INTERACTIVE(f) && dlen < rlen - 1 && !feof(f)) 3381 { 3382 fprintf(outfile, "** Binary zero encountered in input\n"); 3383 fprintf(outfile, "** pcre2test run abandoned\n"); 3384 exit(1); 3385 } 3386 } 3387 3388 else 3389 { 3390 size_t start_offset = start - buffer; 3391 size_t here_offset = here - buffer; 3392 expand_input_buffers(); 3393 start = buffer + start_offset; 3394 here = buffer + here_offset; 3395 } 3396 } 3397 3398 /* Control never gets here */ 3399 } 3400 3401 3402 3403 /************************************************* 3404 * Case-independent strncmp() function * 3405 *************************************************/ 3406 3407 /* 3408 Arguments: 3409 s first string 3410 t second string 3411 n number of characters to compare 3412 3413 Returns: < 0, = 0, or > 0, according to the comparison 3414 */ 3415 3416 static int 3417 strncmpic(const uint8_t *s, const uint8_t *t, int n) 3418 { 3419 while (n--) 3420 { 3421 int c = tolower(*s++) - tolower(*t++); 3422 if (c != 0) return c; 3423 } 3424 return 0; 3425 } 3426 3427 3428 3429 /************************************************* 3430 * Scan the main modifier list * 3431 *************************************************/ 3432 3433 /* This function searches the modifier list for a long modifier name. 3434 3435 Argument: 3436 p start of the name 3437 lenp length of the name 3438 3439 Returns: an index in the modifier list, or -1 on failure 3440 */ 3441 3442 static int 3443 scan_modifiers(const uint8_t *p, unsigned int len) 3444 { 3445 int bot = 0; 3446 int top = MODLISTCOUNT; 3447 3448 while (top > bot) 3449 { 3450 int mid = (bot + top)/2; 3451 unsigned int mlen = strlen(modlist[mid].name); 3452 int c = strncmp((char *)p, modlist[mid].name, (len < mlen)? len : mlen); 3453 if (c == 0) 3454 { 3455 if (len == mlen) return mid; 3456 c = (int)len - (int)mlen; 3457 } 3458 if (c > 0) bot = mid + 1; else top = mid; 3459 } 3460 3461 return -1; 3462 3463 } 3464 3465 3466 3467 /************************************************* 3468 * Check a modifer and find its field * 3469 *************************************************/ 3470 3471 /* This function is called when a modifier has been identified. We check that 3472 it is allowed here and find the field that is to be changed. 3473 3474 Arguments: 3475 m the modifier list entry 3476 ctx CTX_PAT => pattern context 3477 CTX_POPPAT => pattern context for popped pattern 3478 CTX_DEFPAT => default pattern context 3479 CTX_DAT => data context 3480 CTX_DEFDAT => default data context 3481 pctl point to pattern control block 3482 dctl point to data control block 3483 c a single character or 0 3484 3485 Returns: a field pointer or NULL 3486 */ 3487 3488 static void * 3489 check_modifier(modstruct *m, int ctx, patctl *pctl, datctl *dctl, uint32_t c) 3490 { 3491 void *field = NULL; 3492 PCRE2_SIZE offset = m->offset; 3493 3494 if (restrict_for_perl_test) switch(m->which) 3495 { 3496 case MOD_PNDP: 3497 case MOD_PATP: 3498 case MOD_PDP: 3499 break; 3500 3501 default: 3502 fprintf(outfile, "** '%s' is not allowed in a Perl-compatible test\n", 3503 m->name); 3504 return NULL; 3505 } 3506 3507 switch (m->which) 3508 { 3509 case MOD_CTC: /* Compile context modifier */ 3510 if (ctx == CTX_DEFPAT) field = PTR(default_pat_context); 3511 else if (ctx == CTX_PAT) field = PTR(pat_context); 3512 break; 3513 3514 case MOD_CTM: /* Match context modifier */ 3515 if (ctx == CTX_DEFDAT) field = PTR(default_dat_context); 3516 else if (ctx == CTX_DAT) field = PTR(dat_context); 3517 break; 3518 3519 case MOD_DAT: /* Data line modifier */ 3520 if (dctl != NULL) field = dctl; 3521 break; 3522 3523 case MOD_PAT: /* Pattern modifier */ 3524 case MOD_PATP: /* Allowed for Perl test */ 3525 if (pctl != NULL) field = pctl; 3526 break; 3527 3528 case MOD_PD: /* Pattern or data line modifier */ 3529 case MOD_PDP: /* Ditto, allowed for Perl test */ 3530 case MOD_PND: /* Ditto, but not default pattern */ 3531 case MOD_PNDP: /* Ditto, allowed for Perl test */ 3532 if (dctl != NULL) field = dctl; 3533 else if (pctl != NULL && (m->which == MOD_PD || m->which == MOD_PDP || 3534 ctx != CTX_DEFPAT)) 3535 field = pctl; 3536 break; 3537 } 3538 3539 if (field == NULL) 3540 { 3541 if (c == 0) 3542 fprintf(outfile, "** '%s' is not valid here\n", m->name); 3543 else 3544 fprintf(outfile, "** /%c is not valid here\n", c); 3545 return NULL; 3546 } 3547 3548 return (char *)field + offset; 3549 } 3550 3551 3552 3553 /************************************************* 3554 * Decode a modifier list * 3555 *************************************************/ 3556 3557 /* A pointer to a control block is NULL when called in cases when that block is 3558 not relevant. They are never all relevant in one call. At least one of patctl 3559 and datctl is NULL. The second argument specifies which context to use for 3560 modifiers that apply to contexts. 3561 3562 Arguments: 3563 p point to modifier string 3564 ctx CTX_PAT => pattern context 3565 CTX_POPPAT => pattern context for popped pattern 3566 CTX_DEFPAT => default pattern context 3567 CTX_DAT => data context 3568 CTX_DEFDAT => default data context 3569 pctl point to pattern control block 3570 dctl point to data control block 3571 3572 Returns: TRUE if successful decode, FALSE otherwise 3573 */ 3574 3575 static BOOL 3576 decode_modifiers(uint8_t *p, int ctx, patctl *pctl, datctl *dctl) 3577 { 3578 uint8_t *ep, *pp; 3579 long li; 3580 unsigned long uli; 3581 BOOL first = TRUE; 3582 3583 for (;;) 3584 { 3585 void *field; 3586 modstruct *m; 3587 BOOL off = FALSE; 3588 unsigned int i, len; 3589 int index; 3590 char *endptr; 3591 3592 /* Skip white space and commas. */ 3593 3594 while (isspace(*p) || *p == ',') p++; 3595 if (*p == 0) break; 3596 3597 /* Find the end of the item; lose trailing whitespace at end of line. */ 3598 3599 for (ep = p; *ep != 0 && *ep != ','; ep++); 3600 if (*ep == 0) 3601 { 3602 while (ep > p && isspace(ep[-1])) ep--; 3603 *ep = 0; 3604 } 3605 3606 /* Remember if the first character is '-'. */ 3607 3608 if (*p == '-') 3609 { 3610 off = TRUE; 3611 p++; 3612 } 3613 3614 /* Find the length of a full-length modifier name, and scan for it. */ 3615 3616 pp = p; 3617 while (pp < ep && *pp != '=') pp++; 3618 index = scan_modifiers(p, pp - p); 3619 3620 /* If the first modifier is unrecognized, try to interpret it as a sequence 3621 of single-character abbreviated modifiers. None of these modifiers have any 3622 associated data. They just set options or control bits. */ 3623 3624 if (index < 0) 3625 { 3626 uint32_t cc; 3627 uint8_t *mp = p; 3628 3629 if (!first) 3630 { 3631 fprintf(outfile, "** Unrecognized modifier '%.*s'\n", (int)(ep-p), p); 3632 if (ep - p == 1) 3633 fprintf(outfile, "** Single-character modifiers must come first\n"); 3634 return FALSE; 3635 } 3636 3637 for (cc = *p; cc != ',' && cc != '\n' && cc != 0; cc = *(++p)) 3638 { 3639 for (i = 0; i < C1MODLISTCOUNT; i++) 3640 if (cc == c1modlist[i].onechar) break; 3641 3642 if (i >= C1MODLISTCOUNT) 3643 { 3644 fprintf(outfile, "** Unrecognized modifier '%c' in '%.*s'\n", 3645 *p, (int)(ep-mp), mp); 3646 return FALSE; 3647 } 3648 3649 if (c1modlist[i].index >= 0) 3650 { 3651 index = c1modlist[i].index; 3652 } 3653 3654 else 3655 { 3656 index = scan_modifiers((uint8_t *)(c1modlist[i].fullname), 3657 strlen(c1modlist[i].fullname)); 3658 if (index < 0) 3659 { 3660 fprintf(outfile, "** Internal error: single-character equivalent " 3661 "modifier '%s' not found\n", c1modlist[i].fullname); 3662 return FALSE; 3663 } 3664 c1modlist[i].index = index; /* Cache for next time */ 3665 } 3666 3667 field = check_modifier(modlist + index, ctx, pctl, dctl, *p); 3668 if (field == NULL) return FALSE; 3669 3670 /* /x is a special case; a second appearance changes PCRE2_EXTENDED to 3671 PCRE2_EXTENDED_MORE. */ 3672 3673 if (cc == 'x' && (*((uint32_t *)field) & PCRE2_EXTENDED) != 0) 3674 { 3675 *((uint32_t *)field) &= ~PCRE2_EXTENDED; 3676 *((uint32_t *)field) |= PCRE2_EXTENDED_MORE; 3677 } 3678 else 3679 *((uint32_t *)field) |= modlist[index].value; 3680 } 3681 3682 continue; /* With tne next (fullname) modifier */ 3683 } 3684 3685 /* We have a match on a full-name modifier. Check for the existence of data 3686 when needed. */ 3687 3688 m = modlist + index; /* Save typing */ 3689 if (m->type != MOD_CTL && m->type != MOD_OPT && 3690 (m->type != MOD_IND || *pp == '=')) 3691 { 3692 if (*pp++ != '=') 3693 { 3694 fprintf(outfile, "** '=' expected after '%s'\n", m->name); 3695 return FALSE; 3696 } 3697 if (off) 3698 { 3699 fprintf(outfile, "** '-' is not valid for '%s'\n", m->name); 3700 return FALSE; 3701 } 3702 } 3703 3704 /* These on/off types have no data. */ 3705 3706 else if (*pp != ',' && *pp != '\n' && *pp != ' ' && *pp != 0) 3707 { 3708 fprintf(outfile, "** Unrecognized modifier '%.*s'\n", (int)(ep-p), p); 3709 return FALSE; 3710 } 3711 3712 /* Set the data length for those types that have data. Then find the field 3713 that is to be set. If check_modifier() returns NULL, it has already output an 3714 error message. */ 3715 3716 len = ep - pp; 3717 field = check_modifier(m, ctx, pctl, dctl, 0); 3718 if (field == NULL) return FALSE; 3719 3720 /* Process according to data type. */ 3721 3722 switch (m->type) 3723 { 3724 case MOD_CTL: 3725 case MOD_OPT: 3726 if (off) *((uint32_t *)field) &= ~m->value; 3727 else *((uint32_t *)field) |= m->value; 3728 break; 3729 3730 case MOD_BSR: 3731 if (len == 7 && strncmpic(pp, (const uint8_t *)"default", 7) == 0) 3732 { 3733 #ifdef BSR_ANYCRLF 3734 *((uint16_t *)field) = PCRE2_BSR_ANYCRLF; 3735 #else 3736 *((uint16_t *)field) = PCRE2_BSR_UNICODE; 3737 #endif 3738 if (ctx == CTX_PAT || ctx == CTX_DEFPAT) pctl->control2 &= ~CTL2_BSR_SET; 3739 else dctl->control2 &= ~CTL2_BSR_SET; 3740 } 3741 else 3742 { 3743 if (len == 7 && strncmpic(pp, (const uint8_t *)"anycrlf", 7) == 0) 3744 *((uint16_t *)field) = PCRE2_BSR_ANYCRLF; 3745 else if (len == 7 && strncmpic(pp, (const uint8_t *)"unicode", 7) == 0) 3746 *((uint16_t *)field) = PCRE2_BSR_UNICODE; 3747 else goto INVALID_VALUE; 3748 if (ctx == CTX_PAT || ctx == CTX_DEFPAT) pctl->control2 |= CTL2_BSR_SET; 3749 else dctl->control2 |= CTL2_BSR_SET; 3750 } 3751 pp = ep; 3752 break; 3753 3754 case MOD_CHR: /* A single character */ 3755 *((uint32_t *)field) = *pp++; 3756 break; 3757 3758 case MOD_CON: /* A convert type/options list */ 3759 for (;; pp++) 3760 { 3761 uint8_t *colon = (uint8_t *)strchr((const char *)pp, ':'); 3762 len = ((colon != NULL && colon < ep)? colon:ep) - pp; 3763 for (i = 0; i < convertlistcount; i++) 3764 { 3765 if (strncmpic(pp, (const uint8_t *)convertlist[i].name, len) == 0) 3766 { 3767 if (*((uint32_t *)field) == CONVERT_UNSET) 3768 *((uint32_t *)field) = convertlist[i].option; 3769 else 3770 *((uint32_t *)field) |= convertlist[i].option; 3771 break; 3772 } 3773 } 3774 if (i >= convertlistcount) goto INVALID_VALUE; 3775 pp += len; 3776 if (*pp != ':') break; 3777 } 3778 break; 3779 3780 case MOD_IN2: /* One or two unsigned integers */ 3781 if (!isdigit(*pp)) goto INVALID_VALUE; 3782 uli = strtoul((const char *)pp, &endptr, 10); 3783 if (U32OVERFLOW(uli)) goto INVALID_VALUE; 3784 ((uint32_t *)field)[0] = (uint32_t)uli; 3785 if (*endptr == ':') 3786 { 3787 uli = strtoul((const char *)endptr+1, &endptr, 10); 3788 if (U32OVERFLOW(uli)) goto INVALID_VALUE; 3789 ((uint32_t *)field)[1] = (uint32_t)uli; 3790 } 3791 else ((uint32_t *)field)[1] = 0; 3792 pp = (uint8_t *)endptr; 3793 break; 3794 3795 /* PCRE2_SIZE_MAX is usually SIZE_MAX, which may be greater, equal to, or 3796 less than ULONG_MAX. So first test for overflowing the long int, and then 3797 test for overflowing PCRE2_SIZE_MAX if it is smaller than ULONG_MAX. */ 3798 3799 case MOD_SIZ: /* PCRE2_SIZE value */ 3800 if (!isdigit(*pp)) goto INVALID_VALUE; 3801 uli = strtoul((const char *)pp, &endptr, 10); 3802 if (uli == ULONG_MAX) goto INVALID_VALUE; 3803 #if ULONG_MAX > PCRE2_SIZE_MAX 3804 if (uli > PCRE2_SIZE_MAX) goto INVALID_VALUE; 3805 #endif 3806 *((PCRE2_SIZE *)field) = (PCRE2_SIZE)uli; 3807 pp = (uint8_t *)endptr; 3808 break; 3809 3810 case MOD_IND: /* Unsigned integer with default */ 3811 if (len == 0) 3812 { 3813 *((uint32_t *)field) = (uint32_t)(m->value); 3814 break; 3815 } 3816 /* Fall through */ 3817 3818 case MOD_INT: /* Unsigned integer */ 3819 if (!isdigit(*pp)) goto INVALID_VALUE; 3820 uli = strtoul((const char *)pp, &endptr, 10); 3821 if (U32OVERFLOW(uli)) goto INVALID_VALUE; 3822 *((uint32_t *)field) = (uint32_t)uli; 3823 pp = (uint8_t *)endptr; 3824 break; 3825 3826 case MOD_INS: /* Signed integer */ 3827 if (!isdigit(*pp) && *pp != '-') goto INVALID_VALUE; 3828 li = strtol((const char *)pp, &endptr, 10); 3829 if (S32OVERFLOW(li)) goto INVALID_VALUE; 3830 *((int32_t *)field) = (int32_t)li; 3831 pp = (uint8_t *)endptr; 3832 break; 3833 3834 case MOD_NL: 3835 for (i = 0; i < sizeof(newlines)/sizeof(char *); i++) 3836 if (len == strlen(newlines[i]) && 3837 strncmpic(pp, (const uint8_t *)newlines[i], len) == 0) break; 3838 if (i >= sizeof(newlines)/sizeof(char *)) goto INVALID_VALUE; 3839 if (i == 0) 3840 { 3841 *((uint16_t *)field) = NEWLINE_DEFAULT; 3842 if (ctx == CTX_PAT || ctx == CTX_DEFPAT) pctl->control2 &= ~CTL2_NL_SET; 3843 else dctl->control2 &= ~CTL2_NL_SET; 3844 } 3845 else 3846 { 3847 *((uint16_t *)field) = i; 3848 if (ctx == CTX_PAT || ctx == CTX_DEFPAT) pctl->control2 |= CTL2_NL_SET; 3849 else dctl->control2 |= CTL2_NL_SET; 3850 } 3851 pp = ep; 3852 break; 3853 3854 case MOD_NN: /* Name or (signed) number; may be several */ 3855 if (isdigit(*pp) || *pp == '-') 3856 { 3857 int ct = MAXCPYGET - 1; 3858 int32_t value; 3859 li = strtol((const char *)pp, &endptr, 10); 3860 if (S32OVERFLOW(li)) goto INVALID_VALUE; 3861 value = (int32_t)li; 3862 field = (char *)field - m->offset + m->value; /* Adjust field ptr */ 3863 if (value >= 0) /* Add new number */ 3864 { 3865 while (*((int32_t *)field) >= 0 && ct-- > 0) /* Skip previous */ 3866 field = (char *)field + sizeof(int32_t); 3867 if (ct <= 0) 3868 { 3869 fprintf(outfile, "** Too many numeric '%s' modifiers\n", m->name); 3870 return FALSE; 3871 } 3872 } 3873 *((int32_t *)field) = value; 3874 if (ct > 0) ((int32_t *)field)[1] = -1; 3875 pp = (uint8_t *)endptr; 3876 } 3877 3878 /* Multiple strings are put end to end. */ 3879 3880 else 3881 { 3882 char *nn = (char *)field; 3883 if (len > 0) /* Add new name */ 3884 { 3885 if (len > MAX_NAME_SIZE) 3886 { 3887 fprintf(outfile, "** Group name in '%s' is too long\n", m->name); 3888 return FALSE; 3889 } 3890 while (*nn != 0) nn += strlen(nn) + 1; 3891 if (nn + len + 2 - (char *)field > LENCPYGET) 3892 { 3893 fprintf(outfile, "** Too many characters in named '%s' modifiers\n", 3894 m->name); 3895 return FALSE; 3896 } 3897 memcpy(nn, pp, len); 3898 } 3899 nn[len] = 0 ; 3900 nn[len+1] = 0; 3901 pp = ep; 3902 } 3903 break; 3904 3905 case MOD_STR: 3906 if (len + 1 > m->value) 3907 { 3908 fprintf(outfile, "** Overlong value for '%s' (max %d code units)\n", 3909 m->name, m->value - 1); 3910 return FALSE; 3911 } 3912 memcpy(field, pp, len); 3913 ((uint8_t *)field)[len] = 0; 3914 pp = ep; 3915 break; 3916 } 3917 3918 if (*pp != ',' && *pp != '\n' && *pp != ' ' && *pp != 0) 3919 { 3920 fprintf(outfile, "** Comma expected after modifier item '%s'\n", m->name); 3921 return FALSE; 3922 } 3923 3924 p = pp; 3925 first = FALSE; 3926 3927 if (ctx == CTX_POPPAT && 3928 (pctl->options != 0 || 3929 pctl->tables_id != 0 || 3930 pctl->locale[0] != 0 || 3931 (pctl->control & NOTPOP_CONTROLS) != 0)) 3932 { 3933 fprintf(outfile, "** '%s' is not valid here\n", m->name); 3934 return FALSE; 3935 } 3936 } 3937 3938 return TRUE; 3939 3940 INVALID_VALUE: 3941 fprintf(outfile, "** Invalid value in '%.*s'\n", (int)(ep-p), p); 3942 return FALSE; 3943 } 3944 3945 3946 /************************************************* 3947 * Get info from a pattern * 3948 *************************************************/ 3949 3950 /* A wrapped call to pcre2_pattern_info(), applied to the current compiled 3951 pattern. 3952 3953 Arguments: 3954 what code for the required information 3955 where where to put the answer 3956 unsetok PCRE2_ERROR_UNSET is an "expected" result 3957 3958 Returns: the return from pcre2_pattern_info() 3959 */ 3960 3961 static int 3962 pattern_info(int what, void *where, BOOL unsetok) 3963 { 3964 int rc; 3965 PCRE2_PATTERN_INFO(rc, compiled_code, what, NULL); /* Exercise the code */ 3966 PCRE2_PATTERN_INFO(rc, compiled_code, what, where); 3967 if (rc >= 0) return 0; 3968 if (rc != PCRE2_ERROR_UNSET || !unsetok) 3969 { 3970 fprintf(outfile, "Error %d from pcre2_pattern_info_%d(%d)\n", rc, test_mode, 3971 what); 3972 if (rc == PCRE2_ERROR_BADMODE) 3973 fprintf(outfile, "Running in %d-bit mode but pattern was compiled in " 3974 "%d-bit mode\n", test_mode, 3975 8 * (FLD(compiled_code, flags) & PCRE2_MODE_MASK)); 3976 } 3977 return rc; 3978 } 3979 3980 3981 3982 #ifdef SUPPORT_PCRE2_8 3983 /************************************************* 3984 * Show something in a list * 3985 *************************************************/ 3986 3987 /* This function just helps to keep the code that uses it tidier. It's used for 3988 various lists of things where there needs to be introductory text before the 3989 first item. As these calls are all in the POSIX-support code, they happen only 3990 when 8-bit mode is supported. */ 3991 3992 static void 3993 prmsg(const char **msg, const char *s) 3994 { 3995 fprintf(outfile, "%s %s", *msg, s); 3996 *msg = ""; 3997 } 3998 #endif /* SUPPORT_PCRE2_8 */ 3999 4000 4001 4002 /************************************************* 4003 * Show control bits * 4004 *************************************************/ 4005 4006 /* Called for mutually exclusive controls and for unsupported POSIX controls. 4007 Because the bits are unique, this can be used for both pattern and data control 4008 words. 4009 4010 Arguments: 4011 controls control bits 4012 controls2 more control bits 4013 before text to print before 4014 4015 Returns: nothing 4016 */ 4017 4018 static void 4019 show_controls(uint32_t controls, uint32_t controls2, const char *before) 4020 { 4021 fprintf(outfile, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", 4022 before, 4023 ((controls & CTL_AFTERTEXT) != 0)? " aftertext" : "", 4024 ((controls & CTL_ALLAFTERTEXT) != 0)? " allaftertext" : "", 4025 ((controls & CTL_ALLCAPTURES) != 0)? " allcaptures" : "", 4026 ((controls & CTL_ALLUSEDTEXT) != 0)? " allusedtext" : "", 4027 ((controls & CTL_ALTGLOBAL) != 0)? " altglobal" : "", 4028 ((controls & CTL_BINCODE) != 0)? " bincode" : "", 4029 ((controls2 & CTL2_BSR_SET) != 0)? " bsr" : "", 4030 ((controls & CTL_CALLOUT_CAPTURE) != 0)? " callout_capture" : "", 4031 ((controls2 & CTL2_CALLOUT_EXTRA) != 0)? " callout_extra" : "", 4032 ((controls & CTL_CALLOUT_INFO) != 0)? " callout_info" : "", 4033 ((controls & CTL_CALLOUT_NONE) != 0)? " callout_none" : "", 4034 ((controls2 & CTL2_CALLOUT_NO_WHERE) != 0)? " callout_no_where" : "", 4035 ((controls & CTL_DFA) != 0)? " dfa" : "", 4036 ((controls & CTL_EXPAND) != 0)? " expand" : "", 4037 ((controls & CTL_FINDLIMITS) != 0)? " find_limits" : "", 4038 ((controls & CTL_FRAMESIZE) != 0)? " framesize" : "", 4039 ((controls & CTL_FULLBINCODE) != 0)? " fullbincode" : "", 4040 ((controls & CTL_GETALL) != 0)? " getall" : "", 4041 ((controls & CTL_GLOBAL) != 0)? " global" : "", 4042 ((controls & CTL_HEXPAT) != 0)? " hex" : "", 4043 ((controls & CTL_INFO) != 0)? " info" : "", 4044 ((controls & CTL_JITFAST) != 0)? " jitfast" : "", 4045 ((controls & CTL_JITVERIFY) != 0)? " jitverify" : "", 4046 ((controls & CTL_MARK) != 0)? " mark" : "", 4047 ((controls & CTL_MEMORY) != 0)? " memory" : "", 4048 ((controls2 & CTL2_NL_SET) != 0)? " newline" : "", 4049 ((controls & CTL_NULLCONTEXT) != 0)? " null_context" : "", 4050 ((controls & CTL_POSIX) != 0)? " posix" : "", 4051 ((controls & CTL_POSIX_NOSUB) != 0)? " posix_nosub" : "", 4052 ((controls & CTL_PUSH) != 0)? " push" : "", 4053 ((controls & CTL_PUSHCOPY) != 0)? " pushcopy" : "", 4054 ((controls & CTL_PUSHTABLESCOPY) != 0)? " pushtablescopy" : "", 4055 ((controls & CTL_STARTCHAR) != 0)? " startchar" : "", 4056 ((controls2 & CTL2_SUBSTITUTE_EXTENDED) != 0)? " substitute_extended" : "", 4057 ((controls2 & CTL2_SUBSTITUTE_OVERFLOW_LENGTH) != 0)? " substitute_overflow_length" : "", 4058 ((controls2 & CTL2_SUBSTITUTE_UNKNOWN_UNSET) != 0)? " substitute_unknown_unset" : "", 4059 ((controls2 & CTL2_SUBSTITUTE_UNSET_EMPTY) != 0)? " substitute_unset_empty" : "", 4060 ((controls & CTL_USE_LENGTH) != 0)? " use_length" : "", 4061 ((controls & CTL_UTF8_INPUT) != 0)? " utf8_input" : "", 4062 ((controls & CTL_ZERO_TERMINATE) != 0)? " zero_terminate" : ""); 4063 } 4064 4065 4066 4067 /************************************************* 4068 * Show compile options * 4069 *************************************************/ 4070 4071 /* Called from show_pattern_info() and for unsupported POSIX options. 4072 4073 Arguments: 4074 options an options word 4075 before text to print before 4076 after text to print after 4077 4078 Returns: nothing 4079 */ 4080 4081 static void 4082 show_compile_options(uint32_t options, const char *before, const char *after) 4083 { 4084 if (options == 0) fprintf(outfile, "%s <none>%s", before, after); 4085 else fprintf(outfile, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", 4086 before, 4087 ((options & PCRE2_ALT_BSUX) != 0)? " alt_bsux" : "", 4088 ((options & PCRE2_ALT_CIRCUMFLEX) != 0)? " alt_circumflex" : "", 4089 ((options & PCRE2_ALT_VERBNAMES) != 0)? " alt_verbnames" : "", 4090 ((options & PCRE2_ALLOW_EMPTY_CLASS) != 0)? " allow_empty_class" : "", 4091 ((options & PCRE2_ANCHORED) != 0)? " anchored" : "", 4092 ((options & PCRE2_AUTO_CALLOUT) != 0)? " auto_callout" : "", 4093 ((options & PCRE2_CASELESS) != 0)? " caseless" : "", 4094 ((options & PCRE2_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "", 4095 ((options & PCRE2_DOTALL) != 0)? " dotall" : "", 4096 ((options & PCRE2_DUPNAMES) != 0)? " dupnames" : "", 4097 ((options & PCRE2_ENDANCHORED) != 0)? " endanchored" : "", 4098 ((options & PCRE2_EXTENDED) != 0)? " extended" : "", 4099 ((options & PCRE2_EXTENDED_MORE) != 0)? " extended_more" : "", 4100 ((options & PCRE2_FIRSTLINE) != 0)? " firstline" : "", 4101 ((options & PCRE2_LITERAL) != 0)? " literal" : "", 4102 ((options & PCRE2_MATCH_UNSET_BACKREF) != 0)? " match_unset_backref" : "", 4103 ((options & PCRE2_MULTILINE) != 0)? " multiline" : "", 4104 ((options & PCRE2_NEVER_BACKSLASH_C) != 0)? " never_backslash_c" : "", 4105 ((options & PCRE2_NEVER_UCP) != 0)? " never_ucp" : "", 4106 ((options & PCRE2_NEVER_UTF) != 0)? " never_utf" : "", 4107 ((options & PCRE2_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "", 4108 ((options & PCRE2_NO_AUTO_POSSESS) != 0)? " no_auto_possess" : "", 4109 ((options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)? " no_dotstar_anchor" : "", 4110 ((options & PCRE2_NO_UTF_CHECK) != 0)? " no_utf_check" : "", 4111 ((options & PCRE2_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "", 4112 ((options & PCRE2_UCP) != 0)? " ucp" : "", 4113 ((options & PCRE2_UNGREEDY) != 0)? " ungreedy" : "", 4114 ((options & PCRE2_USE_OFFSET_LIMIT) != 0)? " use_offset_limit" : "", 4115 ((options & PCRE2_UTF) != 0)? " utf" : "", 4116 after); 4117 } 4118 4119 4120 /************************************************* 4121 * Show compile extra options * 4122 *************************************************/ 4123 4124 /* Called from show_pattern_info() and for unsupported POSIX options. 4125 4126 Arguments: 4127 options an options word 4128 before text to print before 4129 after text to print after 4130 4131 Returns: nothing 4132 */ 4133 4134 static void 4135 show_compile_extra_options(uint32_t options, const char *before, 4136 const char *after) 4137 { 4138 if (options == 0) fprintf(outfile, "%s <none>%s", before, after); 4139 else fprintf(outfile, "%s%s%s%s%s%s", 4140 before, 4141 ((options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) != 0)? " allow_surrogate_escapes" : "", 4142 ((options & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) != 0)? " bad_escape_is_literal" : "", 4143 ((options & PCRE2_EXTRA_MATCH_WORD) != 0)? " match_word" : "", 4144 ((options & PCRE2_EXTRA_MATCH_LINE) != 0)? " match_line" : "", 4145 after); 4146 } 4147 4148 4149 4150 #ifdef SUPPORT_PCRE2_8 4151 /************************************************* 4152 * Show match options * 4153 *************************************************/ 4154 4155 /* Called for unsupported POSIX options. */ 4156 4157 static void 4158 show_match_options(uint32_t options) 4159 { 4160 fprintf(outfile, "%s%s%s%s%s%s%s%s%s%s%s", 4161 ((options & PCRE2_ANCHORED) != 0)? " anchored" : "", 4162 ((options & PCRE2_DFA_RESTART) != 0)? " dfa_restart" : "", 4163 ((options & PCRE2_DFA_SHORTEST) != 0)? " dfa_shortest" : "", 4164 ((options & PCRE2_ENDANCHORED) != 0)? " endanchored" : "", 4165 ((options & PCRE2_NO_UTF_CHECK) != 0)? " no_utf_check" : "", 4166 ((options & PCRE2_NOTBOL) != 0)? " notbol" : "", 4167 ((options & PCRE2_NOTEMPTY) != 0)? " notempty" : "", 4168 ((options & PCRE2_NOTEMPTY_ATSTART) != 0)? " notempty_atstart" : "", 4169 ((options & PCRE2_NOTEOL) != 0)? " noteol" : "", 4170 ((options & PCRE2_PARTIAL_HARD) != 0)? " partial_hard" : "", 4171 ((options & PCRE2_PARTIAL_SOFT) != 0)? " partial_soft" : ""); 4172 } 4173 #endif /* SUPPORT_PCRE2_8 */ 4174 4175 4176 4177 /************************************************* 4178 * Show memory usage info for a pattern * 4179 *************************************************/ 4180 4181 static void 4182 show_memory_info(void) 4183 { 4184 uint32_t name_count, name_entry_size; 4185 size_t size, cblock_size; 4186 4187 /* One of the test_mode values will always be true, but to stop a compiler 4188 warning we must initialize cblock_size. */ 4189 4190 cblock_size = 0; 4191 #ifdef SUPPORT_PCRE2_8 4192 if (test_mode == PCRE8_MODE) cblock_size = sizeof(pcre2_real_code_8); 4193 #endif 4194 #ifdef SUPPORT_PCRE2_16 4195 if (test_mode == PCRE16_MODE) cblock_size = sizeof(pcre2_real_code_16); 4196 #endif 4197 #ifdef SUPPORT_PCRE2_32 4198 if (test_mode == PCRE32_MODE) cblock_size = sizeof(pcre2_real_code_32); 4199 #endif 4200 4201 (void)pattern_info(PCRE2_INFO_SIZE, &size, FALSE); 4202 (void)pattern_info(PCRE2_INFO_NAMECOUNT, &name_count, FALSE); 4203 (void)pattern_info(PCRE2_INFO_NAMEENTRYSIZE, &name_entry_size, FALSE); 4204 fprintf(outfile, "Memory allocation (code space): %d\n", 4205 (int)(size - name_count*name_entry_size*code_unit_size - cblock_size)); 4206 if (pat_patctl.jit != 0) 4207 { 4208 (void)pattern_info(PCRE2_INFO_JITSIZE, &size, FALSE); 4209 fprintf(outfile, "Memory allocation (JIT code): %d\n", (int)size); 4210 } 4211 } 4212 4213 4214 4215 /************************************************* 4216 * Show frame size info for a pattern * 4217 *************************************************/ 4218 4219 static void 4220 show_framesize(void) 4221 { 4222 size_t frame_size; 4223 (void)pattern_info(PCRE2_INFO_FRAMESIZE, &frame_size, FALSE); 4224 fprintf(outfile, "Frame size for pcre2_match(): %d\n", (int)frame_size); 4225 } 4226 4227 4228 4229 /************************************************* 4230 * Get and output an error message * 4231 *************************************************/ 4232 4233 static BOOL 4234 print_error_message(int errorcode, const char *before, const char *after) 4235 { 4236 int len; 4237 PCRE2_GET_ERROR_MESSAGE(len, errorcode, pbuffer); 4238 if (len < 0) 4239 { 4240 fprintf(outfile, "\n** pcre2test internal error: cannot interpret error " 4241 "number\n** Unexpected return (%d) from pcre2_get_error_message()\n", len); 4242 } 4243 else 4244 { 4245 fprintf(outfile, "%s", before); 4246 PCHARSV(CASTVAR(void *, pbuffer), 0, len, FALSE, outfile); 4247 fprintf(outfile, "%s", after); 4248 } 4249 return len >= 0; 4250 } 4251 4252 4253 /************************************************* 4254 * Callback function for callout enumeration * 4255 *************************************************/ 4256 4257 /* The only differences in the callout emumeration block for different code 4258 unit widths are that the pointers to the subject, the most recent MARK, and a 4259 callout argument string point to strings of the appropriate width. Casts can be 4260 used to deal with this. 4261 4262 Argument: 4263 cb pointer to enumerate block 4264 callout_data user data 4265 4266 Returns: 0 4267 */ 4268 4269 static int callout_callback(pcre2_callout_enumerate_block_8 *cb, 4270 void *callout_data) 4271 { 4272 uint32_t i; 4273 BOOL utf = (FLD(compiled_code, overall_options) & PCRE2_UTF) != 0; 4274 4275 (void)callout_data; /* Not currently displayed */ 4276 4277 fprintf(outfile, "Callout "); 4278 if (cb->callout_string != NULL) 4279 { 4280 uint32_t delimiter = CODE_UNIT(cb->callout_string, -1); 4281 fprintf(outfile, "%c", delimiter); 4282 PCHARSV(cb->callout_string, 0, 4283 cb->callout_string_length, utf, outfile); 4284 for (i = 0; callout_start_delims[i] != 0; i++) 4285 if (delimiter == callout_start_delims[i]) 4286 { 4287 delimiter = callout_end_delims[i]; 4288 break; 4289 } 4290 fprintf(outfile, "%c ", delimiter); 4291 } 4292 else fprintf(outfile, "%d ", cb->callout_number); 4293 4294 fprintf(outfile, "%.*s\n", 4295 (int)((cb->next_item_length == 0)? 1 : cb->next_item_length), 4296 pbuffer8 + cb->pattern_position); 4297 4298 return 0; 4299 } 4300 4301 4302 4303 /************************************************* 4304 * Show information about a pattern * 4305 *************************************************/ 4306 4307 /* This function is called after a pattern has been compiled if any of the 4308 information-requesting controls have been set. 4309 4310 Arguments: none 4311 4312 Returns: PR_OK continue processing next line 4313 PR_SKIP skip to a blank line 4314 PR_ABEND abort the pcre2test run 4315 */ 4316 4317 static int 4318 show_pattern_info(void) 4319 { 4320 uint32_t compile_options, overall_options, extra_options; 4321 4322 if ((pat_patctl.control & (CTL_BINCODE|CTL_FULLBINCODE)) != 0) 4323 { 4324 fprintf(outfile, "------------------------------------------------------------------\n"); 4325 PCRE2_PRINTINT((pat_patctl.control & CTL_FULLBINCODE) != 0); 4326 } 4327 4328 if ((pat_patctl.control & CTL_INFO) != 0) 4329 { 4330 int rc; 4331 void *nametable; 4332 uint8_t *start_bits; 4333 BOOL heap_limit_set, match_limit_set, depth_limit_set; 4334 uint32_t backrefmax, bsr_convention, capture_count, first_ctype, first_cunit, 4335 hasbackslashc, hascrorlf, jchanged, last_ctype, last_cunit, match_empty, 4336 depth_limit, heap_limit, match_limit, minlength, nameentrysize, namecount, 4337 newline_convention; 4338 4339 /* Exercise the error route. */ 4340 4341 PCRE2_PATTERN_INFO(rc, compiled_code, 999, NULL); 4342 (void)rc; 4343 4344 /* These info requests may return PCRE2_ERROR_UNSET. */ 4345 4346 switch(pattern_info(PCRE2_INFO_HEAPLIMIT, &heap_limit, TRUE)) 4347 { 4348 case 0: 4349 heap_limit_set = TRUE; 4350 break; 4351 4352 case PCRE2_ERROR_UNSET: 4353 heap_limit_set = FALSE; 4354 break; 4355 4356 default: 4357 return PR_ABEND; 4358 } 4359 4360 switch(pattern_info(PCRE2_INFO_MATCHLIMIT, &match_limit, TRUE)) 4361 { 4362 case 0: 4363 match_limit_set = TRUE; 4364 break; 4365 4366 case PCRE2_ERROR_UNSET: 4367 match_limit_set = FALSE; 4368 break; 4369 4370 default: 4371 return PR_ABEND; 4372 } 4373 4374 switch(pattern_info(PCRE2_INFO_DEPTHLIMIT, &depth_limit, TRUE)) 4375 { 4376 case 0: 4377 depth_limit_set = TRUE; 4378 break; 4379 4380 case PCRE2_ERROR_UNSET: 4381 depth_limit_set = FALSE; 4382 break; 4383 4384 default: 4385 return PR_ABEND; 4386 } 4387 4388 /* These info requests should always succeed. */ 4389 4390 if (pattern_info(PCRE2_INFO_BACKREFMAX, &backrefmax, FALSE) + 4391 pattern_info(PCRE2_INFO_BSR, &bsr_convention, FALSE) + 4392 pattern_info(PCRE2_INFO_CAPTURECOUNT, &capture_count, FALSE) + 4393 pattern_info(PCRE2_INFO_FIRSTBITMAP, &start_bits, FALSE) + 4394 pattern_info(PCRE2_INFO_FIRSTCODEUNIT, &first_cunit, FALSE) + 4395 pattern_info(PCRE2_INFO_FIRSTCODETYPE, &first_ctype, FALSE) + 4396 pattern_info(PCRE2_INFO_HASBACKSLASHC, &hasbackslashc, FALSE) + 4397 pattern_info(PCRE2_INFO_HASCRORLF, &hascrorlf, FALSE) + 4398 pattern_info(PCRE2_INFO_JCHANGED, &jchanged, FALSE) + 4399 pattern_info(PCRE2_INFO_LASTCODEUNIT, &last_cunit, FALSE) + 4400 pattern_info(PCRE2_INFO_LASTCODETYPE, &last_ctype, FALSE) + 4401 pattern_info(PCRE2_INFO_MATCHEMPTY, &match_empty, FALSE) + 4402 pattern_info(PCRE2_INFO_MINLENGTH, &minlength, FALSE) + 4403 pattern_info(PCRE2_INFO_NAMECOUNT, &namecount, FALSE) + 4404 pattern_info(PCRE2_INFO_NAMEENTRYSIZE, &nameentrysize, FALSE) + 4405 pattern_info(PCRE2_INFO_NAMETABLE, &nametable, FALSE) + 4406 pattern_info(PCRE2_INFO_NEWLINE, &newline_convention, FALSE) 4407 != 0) 4408 return PR_ABEND; 4409 4410 fprintf(outfile, "Capturing subpattern count = %d\n", capture_count); 4411 4412 if (backrefmax > 0) 4413 fprintf(outfile, "Max back reference = %d\n", backrefmax); 4414 4415 if (maxlookbehind > 0) 4416 fprintf(outfile, "Max lookbehind = %d\n", maxlookbehind); 4417 4418 if (heap_limit_set) 4419 fprintf(outfile, "Heap limit = %u\n", heap_limit); 4420 4421 if (match_limit_set) 4422 fprintf(outfile, "Match limit = %u\n", match_limit); 4423 4424 if (depth_limit_set) 4425 fprintf(outfile, "Depth limit = %u\n", depth_limit); 4426 4427 if (namecount > 0) 4428 { 4429 fprintf(outfile, "Named capturing subpatterns:\n"); 4430 for (; namecount > 0; namecount--) 4431 { 4432 int imm2_size = test_mode == PCRE8_MODE ? 2 : 1; 4433 uint32_t length = (uint32_t)STRLEN(nametable + imm2_size); 4434 fprintf(outfile, " "); 4435 PCHARSV(nametable, imm2_size, length, FALSE, outfile); 4436 while (length++ < nameentrysize - imm2_size) putc(' ', outfile); 4437 #ifdef SUPPORT_PCRE2_32 4438 if (test_mode == PCRE32_MODE) 4439 fprintf(outfile, "%3d\n", (int)(((PCRE2_SPTR32)nametable)[0])); 4440 #endif 4441 #ifdef SUPPORT_PCRE2_16 4442 if (test_mode == PCRE16_MODE) 4443 fprintf(outfile, "%3d\n", (int)(((PCRE2_SPTR16)nametable)[0])); 4444 #endif 4445 #ifdef SUPPORT_PCRE2_8 4446 if (test_mode == PCRE8_MODE) 4447 fprintf(outfile, "%3d\n", (int)( 4448 ((((PCRE2_SPTR8)nametable)[0]) << 8) | ((PCRE2_SPTR8)nametable)[1])); 4449 #endif 4450 nametable = (void*)((PCRE2_SPTR8)nametable + nameentrysize * code_unit_size); 4451 } 4452 } 4453 4454 if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n"); 4455 if (hasbackslashc) fprintf(outfile, "Contains \\C\n"); 4456 if (match_empty) fprintf(outfile, "May match empty string\n"); 4457 4458 pattern_info(PCRE2_INFO_ARGOPTIONS, &compile_options, FALSE); 4459 pattern_info(PCRE2_INFO_ALLOPTIONS, &overall_options, FALSE); 4460 pattern_info(PCRE2_INFO_EXTRAOPTIONS, &extra_options, FALSE); 4461 4462 /* Remove UTF/UCP if they were there only because of forbid_utf. This saves 4463 cluttering up the verification output of non-UTF test files. */ 4464 4465 if ((pat_patctl.options & PCRE2_NEVER_UTF) == 0) 4466 { 4467 compile_options &= ~PCRE2_NEVER_UTF; 4468 overall_options &= ~PCRE2_NEVER_UTF; 4469 } 4470 4471 if ((pat_patctl.options & PCRE2_NEVER_UCP) == 0) 4472 { 4473 compile_options &= ~PCRE2_NEVER_UCP; 4474 overall_options &= ~PCRE2_NEVER_UCP; 4475 } 4476 4477 if ((compile_options|overall_options) != 0) 4478 { 4479 if (compile_options == overall_options) 4480 show_compile_options(compile_options, "Options:", "\n"); 4481 else 4482 { 4483 show_compile_options(compile_options, "Compile options:", "\n"); 4484 show_compile_options(overall_options, "Overall options:", "\n"); 4485 } 4486 } 4487 4488 if (extra_options != 0) 4489 show_compile_extra_options(extra_options, "Extra options:", "\n"); 4490 4491 if (jchanged) fprintf(outfile, "Duplicate name status changes\n"); 4492 4493 if ((pat_patctl.control2 & CTL2_BSR_SET) != 0 || 4494 (FLD(compiled_code, flags) & PCRE2_BSR_SET) != 0) 4495 fprintf(outfile, "\\R matches %s\n", (bsr_convention == PCRE2_BSR_UNICODE)? 4496 "any Unicode newline" : "CR, LF, or CRLF"); 4497 4498 if ((FLD(compiled_code, flags) & PCRE2_NL_SET) != 0) 4499 { 4500 switch (newline_convention) 4501 { 4502 case PCRE2_NEWLINE_CR: 4503 fprintf(outfile, "Forced newline is CR\n"); 4504 break; 4505 4506 case PCRE2_NEWLINE_LF: 4507 fprintf(outfile, "Forced newline is LF\n"); 4508 break; 4509 4510 case PCRE2_NEWLINE_CRLF: 4511 fprintf(outfile, "Forced newline is CRLF\n"); 4512 break; 4513 4514 case PCRE2_NEWLINE_ANYCRLF: 4515 fprintf(outfile, "Forced newline is CR, LF, or CRLF\n"); 4516 break; 4517 4518 case PCRE2_NEWLINE_ANY: 4519 fprintf(outfile, "Forced newline is any Unicode newline\n"); 4520 break; 4521 4522 case PCRE2_NEWLINE_NUL: 4523 fprintf(outfile, "Forced newline is NUL\n"); 4524 break; 4525 4526 default: 4527 break; 4528 } 4529 } 4530 4531 if (first_ctype == 2) 4532 { 4533 fprintf(outfile, "First code unit at start or follows newline\n"); 4534 } 4535 else if (first_ctype == 1) 4536 { 4537 const char *caseless = 4538 ((FLD(compiled_code, flags) & PCRE2_FIRSTCASELESS) == 0)? 4539 "" : " (caseless)"; 4540 if (PRINTOK(first_cunit)) 4541 fprintf(outfile, "First code unit = \'%c\'%s\n", first_cunit, caseless); 4542 else 4543 { 4544 fprintf(outfile, "First code unit = "); 4545 pchar(first_cunit, FALSE, outfile); 4546 fprintf(outfile, "%s\n", caseless); 4547 } 4548 } 4549 else if (start_bits != NULL) 4550 { 4551 int i; 4552 int c = 24; 4553 fprintf(outfile, "Starting code units: "); 4554 for (i = 0; i < 256; i++) 4555 { 4556 if ((start_bits[i/8] & (1<<(i&7))) != 0) 4557 { 4558 if (c > 75) 4559 { 4560 fprintf(outfile, "\n "); 4561 c = 2; 4562 } 4563 if (PRINTOK(i) && i != ' ') 4564 { 4565 fprintf(outfile, "%c ", i); 4566 c += 2; 4567 } 4568 else 4569 { 4570 fprintf(outfile, "\\x%02x ", i); 4571 c += 5; 4572 } 4573 } 4574 } 4575 fprintf(outfile, "\n"); 4576 } 4577 4578 if (last_ctype != 0) 4579 { 4580 const char *caseless = 4581 ((FLD(compiled_code, flags) & PCRE2_LASTCASELESS) == 0)? 4582 "" : " (caseless)"; 4583 if (PRINTOK(last_cunit)) 4584 fprintf(outfile, "Last code unit = \'%c\'%s\n", last_cunit, caseless); 4585 else 4586 { 4587 fprintf(outfile, "Last code unit = "); 4588 pchar(last_cunit, FALSE, outfile); 4589 fprintf(outfile, "%s\n", caseless); 4590 } 4591 } 4592 4593 fprintf(outfile, "Subject length lower bound = %d\n", minlength); 4594 4595 if (pat_patctl.jit != 0 && (pat_patctl.control & CTL_JITVERIFY) != 0) 4596 { 4597 if (FLD(compiled_code, executable_jit) != NULL) 4598 fprintf(outfile, "JIT compilation was successful\n"); 4599 else 4600 { 4601 #ifdef SUPPORT_JIT 4602 fprintf(outfile, "JIT compilation was not successful"); 4603 if (jitrc != 0 && !print_error_message(jitrc, " (", ")")) 4604 return PR_ABEND; 4605 fprintf(outfile, "\n"); 4606 #else 4607 fprintf(outfile, "JIT support is not available in this version of PCRE2\n"); 4608 #endif 4609 } 4610 } 4611 } 4612 4613 if ((pat_patctl.control & CTL_CALLOUT_INFO) != 0) 4614 { 4615 int errorcode; 4616 PCRE2_CALLOUT_ENUMERATE(errorcode, callout_callback, 0); 4617 if (errorcode != 0) 4618 { 4619 fprintf(outfile, "Callout enumerate failed: error %d: ", errorcode); 4620 if (errorcode < 0 && !print_error_message(errorcode, "", "\n")) 4621 return PR_ABEND; 4622 return PR_SKIP; 4623 } 4624 } 4625 4626 return PR_OK; 4627 } 4628 4629 4630 4631 /************************************************* 4632 * Handle serialization error * 4633 *************************************************/ 4634 4635 /* Print an error message after a serialization failure. 4636 4637 Arguments: 4638 rc the error code 4639 msg an initial message for what failed 4640 4641 Returns: FALSE if print_error_message() fails 4642 */ 4643 4644 static BOOL 4645 serial_error(int rc, const char *msg) 4646 { 4647 fprintf(outfile, "%s failed: error %d: ", msg, rc); 4648 return print_error_message(rc, "", "\n"); 4649 } 4650 4651 4652 4653 /************************************************* 4654 * Open file for save/load commands * 4655 *************************************************/ 4656 4657 /* This function decodes the file name and opens the file. 4658 4659 Arguments: 4660 buffptr point after the #command 4661 mode open mode 4662 fptr points to the FILE variable 4663 4664 Returns: PR_OK or PR_ABEND 4665 */ 4666 4667 static int 4668 open_file(uint8_t *buffptr, const char *mode, FILE **fptr) 4669 { 4670 char *endf; 4671 char *filename = (char *)buffptr; 4672 while (isspace(*filename)) filename++; 4673 endf = filename + strlen8(filename); 4674 while (endf > filename && isspace(endf[-1])) endf--; 4675 4676 if (endf == filename) 4677 { 4678 fprintf(outfile, "** File name expected after #save\n"); 4679 return PR_ABEND; 4680 } 4681 4682 *endf = 0; 4683 *fptr = fopen((const char *)filename, mode); 4684 if (*fptr == NULL) 4685 { 4686 fprintf(outfile, "** Failed to open '%s': %s\n", filename, strerror(errno)); 4687 return PR_ABEND; 4688 } 4689 4690 return PR_OK; 4691 } 4692 4693 4694 4695 /************************************************* 4696 * Process command line * 4697 *************************************************/ 4698 4699 /* This function is called for lines beginning with # and a character that is 4700 not ! or whitespace, when encountered between tests, which means that there is 4701 no compiled pattern (compiled_code is NULL). The line is in buffer. 4702 4703 Arguments: none 4704 4705 Returns: PR_OK continue processing next line 4706 PR_SKIP skip to a blank line 4707 PR_ABEND abort the pcre2test run 4708 */ 4709 4710 static int 4711 process_command(void) 4712 { 4713 FILE *f; 4714 PCRE2_SIZE serial_size; 4715 size_t i; 4716 int rc, cmd, cmdlen, yield; 4717 uint16_t first_listed_newline; 4718 const char *cmdname; 4719 uint8_t *argptr, *serial; 4720 4721 yield = PR_OK; 4722 cmd = CMD_UNKNOWN; 4723 cmdlen = 0; 4724 4725 for (i = 0; i < cmdlistcount; i++) 4726 { 4727 cmdname = cmdlist[i].name; 4728 cmdlen = strlen(cmdname); 4729 if (strncmp((char *)(buffer+1), cmdname, cmdlen) == 0 && 4730 isspace(buffer[cmdlen+1])) 4731 { 4732 cmd = cmdlist[i].value; 4733 break; 4734 } 4735 } 4736 4737 argptr = buffer + cmdlen + 1; 4738 4739 if (restrict_for_perl_test && cmd != CMD_PATTERN && cmd != CMD_SUBJECT) 4740 { 4741 fprintf(outfile, "** #%s is not allowed after #perltest\n", cmdname); 4742 return PR_ABEND; 4743 } 4744 4745 switch(cmd) 4746 { 4747 case CMD_UNKNOWN: 4748 fprintf(outfile, "** Unknown command: %s", buffer); 4749 break; 4750 4751 case CMD_FORBID_UTF: 4752 forbid_utf = PCRE2_NEVER_UTF|PCRE2_NEVER_UCP; 4753 break; 4754 4755 case CMD_PERLTEST: 4756 restrict_for_perl_test = TRUE; 4757 break; 4758 4759 /* Set default pattern modifiers */ 4760 4761 case CMD_PATTERN: 4762 (void)decode_modifiers(argptr, CTX_DEFPAT, &def_patctl, NULL); 4763 if (def_patctl.jit == 0 && (def_patctl.control & CTL_JITVERIFY) != 0) 4764 def_patctl.jit = 7; 4765 break; 4766 4767 /* Set default subject modifiers */ 4768 4769 case CMD_SUBJECT: 4770 (void)decode_modifiers(argptr, CTX_DEFDAT, NULL, &def_datctl); 4771 break; 4772 4773 /* Check the default newline, and if not one of those listed, set up the 4774 first one to be forced. An empty list unsets. */ 4775 4776 case CMD_NEWLINE_DEFAULT: 4777 local_newline_default = 0; /* Unset */ 4778 first_listed_newline = 0; 4779 for (;;) 4780 { 4781 while (isspace(*argptr)) argptr++; 4782 if (*argptr == 0) break; 4783 for (i = 1; i < sizeof(newlines)/sizeof(char *); i++) 4784 { 4785 size_t nlen = strlen(newlines[i]); 4786 if (strncmpic(argptr, (const uint8_t *)newlines[i], nlen) == 0 && 4787 isspace(argptr[nlen])) 4788 { 4789 if (i == NEWLINE_DEFAULT) return PR_OK; /* Default is valid */ 4790 if (first_listed_newline == 0) first_listed_newline = i; 4791 } 4792 } 4793 while (*argptr != 0 && !isspace(*argptr)) argptr++; 4794 } 4795 local_newline_default = first_listed_newline; 4796 break; 4797 4798 /* Pop or copy a compiled pattern off the stack. Modifiers that do not affect 4799 the compiled pattern (e.g. to give information) are permitted. The default 4800 pattern modifiers are ignored. */ 4801 4802 case CMD_POP: 4803 case CMD_POPCOPY: 4804 if (patstacknext <= 0) 4805 { 4806 fprintf(outfile, "** Can't pop off an empty stack\n"); 4807 return PR_SKIP; 4808 } 4809 memset(&pat_patctl, 0, sizeof(patctl)); /* Completely unset */ 4810 if (!decode_modifiers(argptr, CTX_POPPAT, &pat_patctl, NULL)) 4811 return PR_SKIP; 4812 4813 if (cmd == CMD_POP) 4814 { 4815 SET(compiled_code, patstack[--patstacknext]); 4816 } 4817 else 4818 { 4819 PCRE2_CODE_COPY_FROM_VOID(compiled_code, patstack[patstacknext - 1]); 4820 } 4821 4822 if (pat_patctl.jit != 0) 4823 { 4824 PCRE2_JIT_COMPILE(jitrc, compiled_code, pat_patctl.jit); 4825 } 4826 if ((pat_patctl.control & CTL_MEMORY) != 0) show_memory_info(); 4827 if ((pat_patctl.control & CTL_FRAMESIZE) != 0) show_framesize(); 4828 if ((pat_patctl.control & CTL_ANYINFO) != 0) 4829 { 4830 rc = show_pattern_info(); 4831 if (rc != PR_OK) return rc; 4832 } 4833 break; 4834 4835 /* Save the stack of compiled patterns to a file, then empty the stack. */ 4836 4837 case CMD_SAVE: 4838 if (patstacknext <= 0) 4839 { 4840 fprintf(outfile, "** No stacked patterns to save\n"); 4841 return PR_OK; 4842 } 4843 4844 rc = open_file(argptr+1, BINARY_OUTPUT_MODE, &f); 4845 if (rc != PR_OK) return rc; 4846 4847 PCRE2_SERIALIZE_ENCODE(rc, patstack, patstacknext, &serial, &serial_size, 4848 general_context); 4849 if (rc < 0) 4850 { 4851 fclose(f); 4852 if (!serial_error(rc, "Serialization")) return PR_ABEND; 4853 break; 4854 } 4855 4856 /* Write the length at the start of the file to make it straightforward to 4857 get the right memory when re-loading. This saves having to read the file size 4858 in different operating systems. To allow for different endianness (even 4859 though reloading with the opposite endianness does not work), write the 4860 length byte-by-byte. */ 4861 4862 for (i = 0; i < 4; i++) fputc((serial_size >> (i*8)) & 255, f); 4863 if (fwrite(serial, 1, serial_size, f) != serial_size) 4864 { 4865 fprintf(outfile, "** Wrong return from fwrite()\n"); 4866 fclose(f); 4867 return PR_ABEND; 4868 } 4869 4870 fclose(f); 4871 PCRE2_SERIALIZE_FREE(serial); 4872 while(patstacknext > 0) 4873 { 4874 SET(compiled_code, patstack[--patstacknext]); 4875 SUB1(pcre2_code_free, compiled_code); 4876 } 4877 SET(compiled_code, NULL); 4878 break; 4879 4880 /* Load a set of compiled patterns from a file onto the stack */ 4881 4882 case CMD_LOAD: 4883 rc = open_file(argptr+1, BINARY_INPUT_MODE, &f); 4884 if (rc != PR_OK) return rc; 4885 4886 serial_size = 0; 4887 for (i = 0; i < 4; i++) serial_size |= fgetc(f) << (i*8); 4888 4889 serial = malloc(serial_size); 4890 if (serial == NULL) 4891 { 4892 fprintf(outfile, "** Failed to get memory (size %" SIZ_FORM ") for #load\n", 4893 SIZ_CAST serial_size); 4894 fclose(f); 4895 return PR_ABEND; 4896 } 4897 4898 i = fread(serial, 1, serial_size, f); 4899 fclose(f); 4900 4901 if (i != serial_size) 4902 { 4903 fprintf(outfile, "** Wrong return from fread()\n"); 4904 yield = PR_ABEND; 4905 } 4906 else 4907 { 4908 PCRE2_SERIALIZE_GET_NUMBER_OF_CODES(rc, serial); 4909 if (rc < 0) 4910 { 4911 if (!serial_error(rc, "Get number of codes")) yield = PR_ABEND; 4912 } 4913 else 4914 { 4915 if (rc + patstacknext > PATSTACKSIZE) 4916 { 4917 fprintf(outfile, "** Not enough space on pattern stack for %d pattern%s\n", 4918 rc, (rc == 1)? "" : "s"); 4919 rc = PATSTACKSIZE - patstacknext; 4920 fprintf(outfile, "** Decoding %d pattern%s\n", rc, 4921 (rc == 1)? "" : "s"); 4922 } 4923 PCRE2_SERIALIZE_DECODE(rc, patstack + patstacknext, rc, serial, 4924 general_context); 4925 if (rc < 0) 4926 { 4927 if (!serial_error(rc, "Deserialization")) yield = PR_ABEND; 4928 } 4929 else patstacknext += rc; 4930 } 4931 } 4932 4933 free(serial); 4934 break; 4935 } 4936 4937 return yield; 4938 } 4939 4940 4941 4942 /************************************************* 4943 * Process pattern line * 4944 *************************************************/ 4945 4946 /* This function is called when the input buffer contains the start of a 4947 pattern. The first character is known to be a valid delimiter. The pattern is 4948 read, modifiers are interpreted, and a suitable local context is set up for 4949 this test. The pattern is then compiled. 4950 4951 Arguments: none 4952 4953 Returns: PR_OK continue processing next line 4954 PR_SKIP skip to a blank line 4955 PR_ABEND abort the pcre2test run 4956 */ 4957 4958 static int 4959 process_pattern(void) 4960 { 4961 BOOL utf; 4962 uint32_t k; 4963 uint8_t *p = buffer; 4964 unsigned int delimiter = *p++; 4965 int errorcode; 4966 void *use_pat_context; 4967 uint32_t use_forbid_utf = forbid_utf; 4968 PCRE2_SIZE patlen; 4969 PCRE2_SIZE valgrind_access_length; 4970 PCRE2_SIZE erroroffset; 4971 4972 /* Initialize the context and pattern/data controls for this test from the 4973 defaults. */ 4974 4975 PATCTXCPY(pat_context, default_pat_context); 4976 memcpy(&pat_patctl, &def_patctl, sizeof(patctl)); 4977 4978 /* Find the end of the pattern, reading more lines if necessary. */ 4979 4980 for(;;) 4981 { 4982 while (*p != 0) 4983 { 4984 if (*p == '\\' && p[1] != 0) p++; 4985 else if (*p == delimiter) break; 4986 p++; 4987 } 4988 if (*p != 0) break; 4989 if ((p = extend_inputline(infile, p, " > ")) == NULL) 4990 { 4991 fprintf(outfile, "** Unexpected EOF\n"); 4992 return PR_ABEND; 4993 } 4994 if (!INTERACTIVE(infile)) fprintf(outfile, "%s", (char *)p); 4995 } 4996 4997 /* If the first character after the delimiter is backslash, make the pattern 4998 end with backslash. This is purely to provide a way of testing for the error 4999 message when a pattern ends with backslash. */ 5000 5001 if (p[1] == '\\') *p++ = '\\'; 5002 5003 /* Terminate the pattern at the delimiter, and compute the length. */ 5004 5005 *p++ = 0; 5006 patlen = p - buffer - 2; 5007 5008 /* Look for modifiers and options after the final delimiter. */ 5009 5010 if (!decode_modifiers(p, CTX_PAT, &pat_patctl, NULL)) return PR_SKIP; 5011 utf = (pat_patctl.options & PCRE2_UTF) != 0; 5012 5013 /* The utf8_input modifier is not allowed in 8-bit mode, and is mutually 5014 exclusive with the utf modifier. */ 5015 5016 if ((pat_patctl.control & CTL_UTF8_INPUT) != 0) 5017 { 5018 if (test_mode == PCRE8_MODE) 5019 { 5020 fprintf(outfile, "** The utf8_input modifier is not allowed in 8-bit mode\n"); 5021 return PR_SKIP; 5022 } 5023 if (utf) 5024 { 5025 fprintf(outfile, "** The utf and utf8_input modifiers are mutually exclusive\n"); 5026 return PR_SKIP; 5027 } 5028 } 5029 5030 /* The convert and posix modifiers are mutually exclusive. */ 5031 5032 if (pat_patctl.convert_type != CONVERT_UNSET && 5033 (pat_patctl.control & CTL_POSIX) != 0) 5034 { 5035 fprintf(outfile, "** The convert and posix modifiers are mutually exclusive\n"); 5036 return PR_SKIP; 5037 } 5038 5039 /* Check for mutually exclusive control modifiers. At present, these are all in 5040 the first control word. */ 5041 5042 for (k = 0; k < sizeof(exclusive_pat_controls)/sizeof(uint32_t); k++) 5043 { 5044 uint32_t c = pat_patctl.control & exclusive_pat_controls[k]; 5045 if (c != 0 && c != (c & (~c+1))) 5046 { 5047 show_controls(c, 0, "** Not allowed together:"); 5048 fprintf(outfile, "\n"); 5049 return PR_SKIP; 5050 } 5051 } 5052 5053 /* Assume full JIT compile for jitverify and/or jitfast if nothing else was 5054 specified. */ 5055 5056 if (pat_patctl.jit == 0 && 5057 (pat_patctl.control & (CTL_JITVERIFY|CTL_JITFAST)) != 0) 5058 pat_patctl.jit = 7; 5059 5060 /* Now copy the pattern to pbuffer8 for use in 8-bit testing and for reflecting 5061 in callouts. Convert from hex if requested (literal strings in quotes may be 5062 present within the hexadecimal pairs). The result must necessarily be fewer 5063 characters so will always fit in pbuffer8. */ 5064 5065 if ((pat_patctl.control & CTL_HEXPAT) != 0) 5066 { 5067 uint8_t *pp, *pt; 5068 uint32_t c, d; 5069 5070 pt = pbuffer8; 5071 for (pp = buffer + 1; *pp != 0; pp++) 5072 { 5073 if (isspace(*pp)) continue; 5074 c = *pp++; 5075 5076 /* Handle a literal substring */ 5077 5078 if (c == '\'' || c == '"') 5079 { 5080 uint8_t *pq = pp; 5081 for (;; pp++) 5082 { 5083 d = *pp; 5084 if (d == 0) 5085 { 5086 fprintf(outfile, "** Missing closing quote in hex pattern: " 5087 "opening quote is at offset %" PTR_FORM ".\n", pq - buffer - 2); 5088 return PR_SKIP; 5089 } 5090 if (d == c) break; 5091 *pt++ = d; 5092 } 5093 } 5094 5095 /* Expect a hex pair */ 5096 5097 else 5098 { 5099 if (!isxdigit(c)) 5100 { 5101 fprintf(outfile, "** Unexpected non-hex-digit '%c' at offset %" 5102 PTR_FORM " in hex pattern: quote missing?\n", c, pp - buffer - 2); 5103 return PR_SKIP; 5104 } 5105 if (*pp == 0) 5106 { 5107 fprintf(outfile, "** Odd number of digits in hex pattern\n"); 5108 return PR_SKIP; 5109 } 5110 d = *pp; 5111 if (!isxdigit(d)) 5112 { 5113 fprintf(outfile, "** Unexpected non-hex-digit '%c' at offset %" 5114 PTR_FORM " in hex pattern: quote missing?\n", d, pp - buffer - 1); 5115 return PR_SKIP; 5116 } 5117 c = toupper(c); 5118 d = toupper(d); 5119 *pt++ = ((isdigit(c)? (c - '0') : (c - 'A' + 10)) << 4) + 5120 (isdigit(d)? (d - '0') : (d - 'A' + 10)); 5121 } 5122 } 5123 *pt = 0; 5124 patlen = pt - pbuffer8; 5125 } 5126 5127 /* If not a hex string, process for repetition expansion if requested. */ 5128 5129 else if ((pat_patctl.control & CTL_EXPAND) != 0) 5130 { 5131 uint8_t *pp, *pt; 5132 5133 pt = pbuffer8; 5134 for (pp = buffer + 1; *pp != 0; pp++) 5135 { 5136 uint8_t *pc = pp; 5137 uint32_t count = 1; 5138 size_t length = 1; 5139 5140 /* Check for replication syntax; if not found, the defaults just set will 5141 prevail and one character will be copied. */ 5142 5143 if (pp[0] == '\\' && pp[1] == '[') 5144 { 5145 uint8_t *pe; 5146 for (pe = pp + 2; *pe != 0; pe++) 5147 { 5148 if (pe[0] == ']' && pe[1] == '{') 5149 { 5150 uint32_t clen = pe - pc - 2; 5151 uint32_t i = 0; 5152 unsigned long uli; 5153 char *endptr; 5154 5155 pe += 2; 5156 uli = strtoul((const char *)pe, &endptr, 10); 5157 if (U32OVERFLOW(uli)) 5158 { 5159 fprintf(outfile, "** Pattern repeat count too large\n"); 5160 return PR_SKIP; 5161 } 5162 5163 i = (uint32_t)uli; 5164 pe = (uint8_t *)endptr; 5165 if (*pe == '}') 5166 { 5167 if (i == 0) 5168 { 5169 fprintf(outfile, "** Zero repeat not allowed\n"); 5170 return PR_SKIP; 5171 } 5172 pc += 2; 5173 count = i; 5174 length = clen; 5175 pp = pe; 5176 break; 5177 } 5178 } 5179 } 5180 } 5181 5182 /* Add to output. If the buffer is too small expand it. The function for 5183 expanding buffers always keeps buffer and pbuffer8 in step as far as their 5184 size goes. */ 5185 5186 while (pt + count * length > pbuffer8 + pbuffer8_size) 5187 { 5188 size_t pc_offset = pc - buffer; 5189 size_t pp_offset = pp - buffer; 5190 size_t pt_offset = pt - pbuffer8; 5191 expand_input_buffers(); 5192 pc = buffer + pc_offset; 5193 pp = buffer + pp_offset; 5194 pt = pbuffer8 + pt_offset; 5195 } 5196 5197 for (; count > 0; count--) 5198 { 5199 memcpy(pt, pc, length); 5200 pt += length; 5201 } 5202 } 5203 5204 *pt = 0; 5205 patlen = pt - pbuffer8; 5206 5207 if ((pat_patctl.control & CTL_INFO) != 0) 5208 fprintf(outfile, "Expanded: %s\n", pbuffer8); 5209 } 5210 5211 /* Neither hex nor expanded, just copy the input verbatim. */ 5212 5213 else 5214 { 5215 strncpy((char *)pbuffer8, (char *)(buffer+1), patlen + 1); 5216 } 5217 5218 /* Sort out character tables */ 5219 5220 if (pat_patctl.locale[0] != 0) 5221 { 5222 if (pat_patctl.tables_id != 0) 5223 { 5224 fprintf(outfile, "** 'Locale' and 'tables' must not both be set\n"); 5225 return PR_SKIP; 5226 } 5227 if (setlocale(LC_CTYPE, (const char *)pat_patctl.locale) == NULL) 5228 { 5229 fprintf(outfile, "** Failed to set locale '%s'\n", pat_patctl.locale); 5230 return PR_SKIP; 5231 } 5232 if (strcmp((const char *)pat_patctl.locale, (const char *)locale_name) != 0) 5233 { 5234 strcpy((char *)locale_name, (char *)pat_patctl.locale); 5235 if (locale_tables != NULL) free((void *)locale_tables); 5236 PCRE2_MAKETABLES(locale_tables); 5237 } 5238 use_tables = locale_tables; 5239 } 5240 5241 else switch (pat_patctl.tables_id) 5242 { 5243 case 0: use_tables = NULL; break; 5244 case 1: use_tables = tables1; break; 5245 case 2: use_tables = tables2; break; 5246 default: 5247 fprintf(outfile, "** 'Tables' must specify 0, 1, or 2.\n"); 5248 return PR_SKIP; 5249 } 5250 5251 PCRE2_SET_CHARACTER_TABLES(pat_context, use_tables); 5252 5253 /* Set up for the stackguard test. */ 5254 5255 if (pat_patctl.stackguard_test != 0) 5256 { 5257 PCRE2_SET_COMPILE_RECURSION_GUARD(pat_context, stack_guard, NULL); 5258 } 5259 5260 /* Handle compiling via the POSIX interface, which doesn't support the 5261 timing, showing, or debugging options, nor the ability to pass over 5262 local character tables. Neither does it have 16-bit or 32-bit support. */ 5263 5264 if ((pat_patctl.control & CTL_POSIX) != 0) 5265 { 5266 #ifdef SUPPORT_PCRE2_8 5267 int rc; 5268 int cflags = 0; 5269 const char *msg = "** Ignored with POSIX interface:"; 5270 #endif 5271 5272 if (test_mode != PCRE8_MODE) 5273 { 5274 fprintf(outfile, "** The POSIX interface is available only in 8-bit mode\n"); 5275 return PR_SKIP; 5276 } 5277 5278 #ifdef SUPPORT_PCRE2_8 5279 /* Check for features that the POSIX interface does not support. */ 5280 5281 if (pat_patctl.locale[0] != 0) prmsg(&msg, "locale"); 5282 if (pat_patctl.replacement[0] != 0) prmsg(&msg, "replace"); 5283 if (pat_patctl.tables_id != 0) prmsg(&msg, "tables"); 5284 if (pat_patctl.stackguard_test != 0) prmsg(&msg, "stackguard"); 5285 if (timeit > 0) prmsg(&msg, "timing"); 5286 if (pat_patctl.jit != 0) prmsg(&msg, "JIT"); 5287 5288 if ((pat_patctl.options & ~POSIX_SUPPORTED_COMPILE_OPTIONS) != 0) 5289 { 5290 show_compile_options( 5291 pat_patctl.options & ~POSIX_SUPPORTED_COMPILE_OPTIONS, msg, ""); 5292 msg = ""; 5293 } 5294 5295 if ((FLD(pat_context, extra_options) & 5296 ~POSIX_SUPPORTED_COMPILE_EXTRA_OPTIONS) != 0) 5297 { 5298 show_compile_extra_options( 5299 FLD(pat_context, extra_options) & ~POSIX_SUPPORTED_COMPILE_EXTRA_OPTIONS, 5300 msg, ""); 5301 msg = ""; 5302 } 5303 5304 if ((pat_patctl.control & ~POSIX_SUPPORTED_COMPILE_CONTROLS) != 0 || 5305 (pat_patctl.control2 & ~POSIX_SUPPORTED_COMPILE_CONTROLS2) != 0) 5306 { 5307 show_controls(pat_patctl.control & ~POSIX_SUPPORTED_COMPILE_CONTROLS, 5308 pat_patctl.control2 & ~POSIX_SUPPORTED_COMPILE_CONTROLS2, msg); 5309 msg = ""; 5310 } 5311 5312 if (local_newline_default != 0) prmsg(&msg, "#newline_default"); 5313 if (FLD(pat_context, max_pattern_length) != PCRE2_UNSET) 5314 prmsg(&msg, "max_pattern_length"); 5315 if (FLD(pat_context, parens_nest_limit) != PARENS_NEST_DEFAULT) 5316 prmsg(&msg, "parens_nest_limit"); 5317 5318 if (msg[0] == 0) fprintf(outfile, "\n"); 5319 5320 /* Translate PCRE2 options to POSIX options and then compile. */ 5321 5322 if (utf) cflags |= REG_UTF; 5323 if ((pat_patctl.control & CTL_POSIX_NOSUB) != 0) cflags |= REG_NOSUB; 5324 if ((pat_patctl.options & PCRE2_UCP) != 0) cflags |= REG_UCP; 5325 if ((pat_patctl.options & PCRE2_CASELESS) != 0) cflags |= REG_ICASE; 5326 if ((pat_patctl.options & PCRE2_LITERAL) != 0) cflags |= REG_NOSPEC; 5327 if ((pat_patctl.options & PCRE2_MULTILINE) != 0) cflags |= REG_NEWLINE; 5328 if ((pat_patctl.options & PCRE2_DOTALL) != 0) cflags |= REG_DOTALL; 5329 if ((pat_patctl.options & PCRE2_UNGREEDY) != 0) cflags |= REG_UNGREEDY; 5330 5331 if ((pat_patctl.control & (CTL_HEXPAT|CTL_USE_LENGTH)) != 0) 5332 { 5333 preg.re_endp = (char *)pbuffer8 + patlen; 5334 cflags |= REG_PEND; 5335 } 5336 5337 rc = regcomp(&preg, (char *)pbuffer8, cflags); 5338 5339 /* Compiling failed */ 5340 5341 if (rc != 0) 5342 { 5343 size_t bsize, usize; 5344 int psize; 5345 5346 preg.re_pcre2_code = NULL; /* In case something was left in there */ 5347 preg.re_match_data = NULL; 5348 5349 bsize = (pat_patctl.regerror_buffsize != 0)? 5350 pat_patctl.regerror_buffsize : pbuffer8_size; 5351 if (bsize + 8 < pbuffer8_size) 5352 memcpy(pbuffer8 + bsize, "DEADBEEF", 8); 5353 usize = regerror(rc, &preg, (char *)pbuffer8, bsize); 5354 5355 /* Inside regerror(), snprintf() is used. If the buffer is too small, some 5356 versions of snprintf() put a zero byte at the end, but others do not. 5357 Therefore, we print a maximum of one less than the size of the buffer. */ 5358 5359 psize = (int)bsize - 1; 5360 fprintf(outfile, "Failed: POSIX code %d: %.*s\n", rc, psize, pbuffer8); 5361 if (usize > bsize) 5362 { 5363 fprintf(outfile, "** regerror() message truncated\n"); 5364 if (memcmp(pbuffer8 + bsize, "DEADBEEF", 8) != 0) 5365 fprintf(outfile, "** regerror() buffer overflow\n"); 5366 } 5367 return PR_SKIP; 5368 } 5369 5370 /* Compiling succeeded. Check that the values in the preg block are sensible. 5371 It can happen that pcre2test is accidentally linked with a different POSIX 5372 library which succeeds, but of course puts different things into preg. In 5373 this situation, calling regfree() may cause a segfault (or invalid free() in 5374 valgrind), so ensure that preg.re_pcre2_code is NULL, which suppresses the 5375 calling of regfree() on exit. */ 5376 5377 if (preg.re_pcre2_code == NULL || 5378 ((pcre2_real_code_8 *)preg.re_pcre2_code)->magic_number != MAGIC_NUMBER || 5379 ((pcre2_real_code_8 *)preg.re_pcre2_code)->top_bracket != preg.re_nsub || 5380 preg.re_match_data == NULL || 5381 preg.re_cflags != cflags) 5382 { 5383 fprintf(outfile, 5384 "** The regcomp() function returned zero (success), but the values set\n" 5385 "** in the preg block are not valid for PCRE2. Check that pcre2test is\n" 5386 "** linked with PCRE2's pcre2posix module (-lpcre2-posix) and not with\n" 5387 "** some other POSIX regex library.\n**\n"); 5388 preg.re_pcre2_code = NULL; 5389 return PR_ABEND; 5390 } 5391 5392 return PR_OK; 5393 #endif /* SUPPORT_PCRE2_8 */ 5394 } 5395 5396 /* Handle compiling via the native interface. Controls that act later are 5397 ignored with "push". Replacements are locked out. */ 5398 5399 if ((pat_patctl.control & (CTL_PUSH|CTL_PUSHCOPY|CTL_PUSHTABLESCOPY)) != 0) 5400 { 5401 if (pat_patctl.replacement[0] != 0) 5402 { 5403 fprintf(outfile, "** Replacement text is not supported with 'push'.\n"); 5404 return PR_OK; 5405 } 5406 if ((pat_patctl.control & ~PUSH_SUPPORTED_COMPILE_CONTROLS) != 0 || 5407 (pat_patctl.control2 & ~PUSH_SUPPORTED_COMPILE_CONTROLS2) != 0) 5408 { 5409 show_controls(pat_patctl.control & ~PUSH_SUPPORTED_COMPILE_CONTROLS, 5410 pat_patctl.control2 & ~PUSH_SUPPORTED_COMPILE_CONTROLS2, 5411 "** Ignored when compiled pattern is stacked with 'push':"); 5412 fprintf(outfile, "\n"); 5413 } 5414 if ((pat_patctl.control & PUSH_COMPILE_ONLY_CONTROLS) != 0 || 5415 (pat_patctl.control2 & PUSH_COMPILE_ONLY_CONTROLS2) != 0) 5416 { 5417 show_controls(pat_patctl.control & PUSH_COMPILE_ONLY_CONTROLS, 5418 pat_patctl.control2 & PUSH_COMPILE_ONLY_CONTROLS2, 5419 "** Applies only to compile when pattern is stacked with 'push':"); 5420 fprintf(outfile, "\n"); 5421 } 5422 } 5423 5424 /* Convert the input in non-8-bit modes. */ 5425 5426 errorcode = 0; 5427 5428 #ifdef SUPPORT_PCRE2_16 5429 if (test_mode == PCRE16_MODE) errorcode = to16(pbuffer8, utf, &patlen); 5430 #endif 5431 5432 #ifdef SUPPORT_PCRE2_32 5433 if (test_mode == PCRE32_MODE) errorcode = to32(pbuffer8, utf, &patlen); 5434 #endif 5435 5436 switch(errorcode) 5437 { 5438 case -1: 5439 fprintf(outfile, "** Failed: invalid UTF-8 string cannot be " 5440 "converted to %d-bit string\n", (test_mode == PCRE16_MODE)? 16:32); 5441 return PR_SKIP; 5442 5443 case -2: 5444 fprintf(outfile, "** Failed: character value greater than 0x10ffff " 5445 "cannot be converted to UTF\n"); 5446 return PR_SKIP; 5447 5448 case -3: 5449 fprintf(outfile, "** Failed: character value greater than 0xffff " 5450 "cannot be converted to 16-bit in non-UTF mode\n"); 5451 return PR_SKIP; 5452 5453 default: 5454 break; 5455 } 5456 5457 /* The pattern is now in pbuffer[8|16|32], with the length in code units in 5458 patlen. If it is to be converted, copy the result back afterwards so that it 5459 ends up back in the usual place. */ 5460 5461 if (pat_patctl.convert_type != CONVERT_UNSET) 5462 { 5463 int rc; 5464 int convert_return = PR_OK; 5465 uint32_t convert_options = pat_patctl.convert_type; 5466 void *converted_pattern; 5467 PCRE2_SIZE converted_length; 5468 5469 if (pat_patctl.convert_length != 0) 5470 { 5471 converted_length = pat_patctl.convert_length; 5472 converted_pattern = malloc(converted_length * code_unit_size); 5473 if (converted_pattern == NULL) 5474 { 5475 fprintf(outfile, "** Failed: malloc failed for converted pattern\n"); 5476 return PR_SKIP; 5477 } 5478 } 5479 else converted_pattern = NULL; /* Let the library allocate */ 5480 5481 if (utf) convert_options |= PCRE2_CONVERT_UTF; 5482 if ((pat_patctl.options & PCRE2_NO_UTF_CHECK) != 0) 5483 convert_options |= PCRE2_CONVERT_NO_UTF_CHECK; 5484 5485 CONCTXCPY(con_context, default_con_context); 5486 5487 if (pat_patctl.convert_glob_escape != 0) 5488 { 5489 uint32_t escape = (pat_patctl.convert_glob_escape == '0')? 0 : 5490 pat_patctl.convert_glob_escape; 5491 PCRE2_SET_GLOB_ESCAPE(rc, con_context, escape); 5492 if (rc != 0) 5493 { 5494 fprintf(outfile, "** Invalid glob escape '%c'\n", 5495 pat_patctl.convert_glob_escape); 5496 convert_return = PR_SKIP; 5497 goto CONVERT_FINISH; 5498 } 5499 } 5500 5501 if (pat_patctl.convert_glob_separator != 0) 5502 { 5503 PCRE2_SET_GLOB_SEPARATOR(rc, con_context, pat_patctl.convert_glob_separator); 5504 if (rc != 0) 5505 { 5506 fprintf(outfile, "** Invalid glob separator '%c'\n", 5507 pat_patctl.convert_glob_separator); 5508 convert_return = PR_SKIP; 5509 goto CONVERT_FINISH; 5510 } 5511 } 5512 5513 PCRE2_PATTERN_CONVERT(rc, pbuffer, patlen, convert_options, 5514 &converted_pattern, &converted_length, con_context); 5515 5516 if (rc != 0) 5517 { 5518 fprintf(outfile, "** Pattern conversion error at offset %" SIZ_FORM ": ", 5519 SIZ_CAST converted_length); 5520 convert_return = print_error_message(rc, "", "\n")? PR_SKIP:PR_ABEND; 5521 } 5522 5523 /* Output the converted pattern, then copy it. */ 5524 5525 else 5526 { 5527 PCHARSV(converted_pattern, 0, converted_length, utf, outfile); 5528 fprintf(outfile, "\n"); 5529 patlen = converted_length; 5530 CONVERT_COPY(pbuffer, converted_pattern, converted_length + 1); 5531 } 5532 5533 /* Free the converted pattern. */ 5534 5535 CONVERT_FINISH: 5536 if (pat_patctl.convert_length != 0) 5537 free(converted_pattern); 5538 else 5539 PCRE2_CONVERTED_PATTERN_FREE(converted_pattern); 5540 5541 /* Return if conversion was unsuccessful. */ 5542 5543 if (convert_return != PR_OK) return convert_return; 5544 } 5545 5546 /* By default we pass a zero-terminated pattern, but a length is passed if 5547 "use_length" was specified or this is a hex pattern (which might contain binary 5548 zeros). When valgrind is supported, arrange for the unused part of the buffer 5549 to be marked as no access. */ 5550 5551 valgrind_access_length = patlen; 5552 if ((pat_patctl.control & (CTL_HEXPAT|CTL_USE_LENGTH)) == 0) 5553 { 5554 patlen = PCRE2_ZERO_TERMINATED; 5555 valgrind_access_length += 1; /* For the terminating zero */ 5556 } 5557 5558 #ifdef SUPPORT_VALGRIND 5559 #ifdef SUPPORT_PCRE2_8 5560 if (test_mode == PCRE8_MODE && pbuffer8 != NULL) 5561 { 5562 VALGRIND_MAKE_MEM_NOACCESS(pbuffer8 + valgrind_access_length, 5563 pbuffer8_size - valgrind_access_length); 5564 } 5565 #endif 5566 #ifdef SUPPORT_PCRE2_16 5567 if (test_mode == PCRE16_MODE && pbuffer16 != NULL) 5568 { 5569 VALGRIND_MAKE_MEM_NOACCESS(pbuffer16 + valgrind_access_length, 5570 pbuffer16_size - valgrind_access_length*sizeof(uint16_t)); 5571 } 5572 #endif 5573 #ifdef SUPPORT_PCRE2_32 5574 if (test_mode == PCRE32_MODE && pbuffer32 != NULL) 5575 { 5576 VALGRIND_MAKE_MEM_NOACCESS(pbuffer32 + valgrind_access_length, 5577 pbuffer32_size - valgrind_access_length*sizeof(uint32_t)); 5578 } 5579 #endif 5580 #else /* Valgrind not supported */ 5581 (void)valgrind_access_length; /* Avoid compiler warning */ 5582 #endif 5583 5584 /* If #newline_default has been used and the library was not compiled with an 5585 appropriate default newline setting, local_newline_default will be non-zero. We 5586 use this if there is no explicit newline modifier. */ 5587 5588 if ((pat_patctl.control2 & CTL2_NL_SET) == 0 && local_newline_default != 0) 5589 { 5590 SETFLD(pat_context, newline_convention, local_newline_default); 5591 } 5592 5593 /* The null_context modifier is used to test calling pcre2_compile() with a 5594 NULL context. */ 5595 5596 use_pat_context = ((pat_patctl.control & CTL_NULLCONTEXT) != 0)? 5597 NULL : PTR(pat_context); 5598 5599 /* If PCRE2_LITERAL is set, set use_forbid_utf zero because PCRE2_NEVER_UTF 5600 and PCRE2_NEVER_UCP are invalid with it. */ 5601 5602 if ((pat_patctl.options & PCRE2_LITERAL) != 0) use_forbid_utf = 0; 5603 5604 /* Compile many times when timing. */ 5605 5606 if (timeit > 0) 5607 { 5608 int i; 5609 clock_t time_taken = 0; 5610 for (i = 0; i < timeit; i++) 5611 { 5612 clock_t start_time = clock(); 5613 PCRE2_COMPILE(compiled_code, pbuffer, patlen, 5614 pat_patctl.options|use_forbid_utf, &errorcode, &erroroffset, 5615 use_pat_context); 5616 time_taken += clock() - start_time; 5617 if (TEST(compiled_code, !=, NULL)) 5618 { SUB1(pcre2_code_free, compiled_code); } 5619 } 5620 total_compile_time += time_taken; 5621 fprintf(outfile, "Compile time %.4f milliseconds\n", 5622 (((double)time_taken * 1000.0) / (double)timeit) / 5623 (double)CLOCKS_PER_SEC); 5624 } 5625 5626 /* A final compile that is used "for real". */ 5627 5628 PCRE2_COMPILE(compiled_code, pbuffer, patlen, pat_patctl.options|use_forbid_utf, 5629 &errorcode, &erroroffset, use_pat_context); 5630 5631 /* Call the JIT compiler if requested. When timing, we must free and recompile 5632 the pattern each time because that is the only way to free the JIT compiled 5633 code. We know that compilation will always succeed. */ 5634 5635 if (TEST(compiled_code, !=, NULL) && pat_patctl.jit != 0) 5636 { 5637 if (timeit > 0) 5638 { 5639 int i; 5640 clock_t time_taken = 0; 5641 for (i = 0; i < timeit; i++) 5642 { 5643 clock_t start_time; 5644 SUB1(pcre2_code_free, compiled_code); 5645 PCRE2_COMPILE(compiled_code, pbuffer, patlen, 5646 pat_patctl.options|use_forbid_utf, &errorcode, &erroroffset, 5647 use_pat_context); 5648 start_time = clock(); 5649 PCRE2_JIT_COMPILE(jitrc,compiled_code, pat_patctl.jit); 5650 time_taken += clock() - start_time; 5651 } 5652 total_jit_compile_time += time_taken; 5653 fprintf(outfile, "JIT compile %.4f milliseconds\n", 5654 (((double)time_taken * 1000.0) / (double)timeit) / 5655 (double)CLOCKS_PER_SEC); 5656 } 5657 else 5658 { 5659 PCRE2_JIT_COMPILE(jitrc, compiled_code, pat_patctl.jit); 5660 } 5661 } 5662 5663 /* If valgrind is supported, mark the pbuffer as accessible again. The 16-bit 5664 and 32-bit buffers can be marked completely undefined, but we must leave the 5665 pattern in the 8-bit buffer defined because it may be read from a callout 5666 during matching. */ 5667 5668 #ifdef SUPPORT_VALGRIND 5669 #ifdef SUPPORT_PCRE2_8 5670 if (test_mode == PCRE8_MODE) 5671 { 5672 VALGRIND_MAKE_MEM_UNDEFINED(pbuffer8 + valgrind_access_length, 5673 pbuffer8_size - valgrind_access_length); 5674 } 5675 #endif 5676 #ifdef SUPPORT_PCRE2_16 5677 if (test_mode == PCRE16_MODE) 5678 { 5679 VALGRIND_MAKE_MEM_UNDEFINED(pbuffer16, pbuffer16_size); 5680 } 5681 #endif 5682 #ifdef SUPPORT_PCRE2_32 5683 if (test_mode == PCRE32_MODE) 5684 { 5685 VALGRIND_MAKE_MEM_UNDEFINED(pbuffer32, pbuffer32_size); 5686 } 5687 #endif 5688 #endif 5689 5690 /* Compilation failed; go back for another re, skipping to blank line 5691 if non-interactive. */ 5692 5693 if (TEST(compiled_code, ==, NULL)) 5694 { 5695 fprintf(outfile, "Failed: error %d at offset %d: ", errorcode, 5696 (int)erroroffset); 5697 if (!print_error_message(errorcode, "", "\n")) return PR_ABEND; 5698 return PR_SKIP; 5699 } 5700 5701 /* If forbid_utf is non-zero, we are running a non-UTF test. UTF and UCP are 5702 locked out at compile time, but we must also check for occurrences of \P, \p, 5703 and \X, which are only supported when Unicode is supported. */ 5704 5705 if (forbid_utf != 0) 5706 { 5707 if ((FLD(compiled_code, flags) & PCRE2_HASBKPORX) != 0) 5708 { 5709 fprintf(outfile, "** \\P, \\p, and \\X are not allowed after the " 5710 "#forbid_utf command\n"); 5711 return PR_SKIP; 5712 } 5713 } 5714 5715 /* Remember the maximum lookbehind, for partial matching. */ 5716 5717 if (pattern_info(PCRE2_INFO_MAXLOOKBEHIND, &maxlookbehind, FALSE) != 0) 5718 return PR_ABEND; 5719 5720 /* If an explicit newline modifier was given, set the information flag in the 5721 pattern so that it is preserved over push/pop. */ 5722 5723 if ((pat_patctl.control2 & CTL2_NL_SET) != 0) 5724 { 5725 SETFLD(compiled_code, flags, FLD(compiled_code, flags) | PCRE2_NL_SET); 5726 } 5727 5728 /* Output code size and other information if requested. */ 5729 5730 if ((pat_patctl.control & CTL_MEMORY) != 0) show_memory_info(); 5731 if ((pat_patctl.control & CTL_FRAMESIZE) != 0) show_framesize(); 5732 if ((pat_patctl.control & CTL_ANYINFO) != 0) 5733 { 5734 int rc = show_pattern_info(); 5735 if (rc != PR_OK) return rc; 5736 } 5737 5738 /* The "push" control requests that the compiled pattern be remembered on a 5739 stack. This is mainly for testing the serialization functionality. */ 5740 5741 if ((pat_patctl.control & CTL_PUSH) != 0) 5742 { 5743 if (patstacknext >= PATSTACKSIZE) 5744 { 5745 fprintf(outfile, "** Too many pushed patterns (max %d)\n", PATSTACKSIZE); 5746 return PR_ABEND; 5747 } 5748 patstack[patstacknext++] = PTR(compiled_code); 5749 SET(compiled_code, NULL); 5750 } 5751 5752 /* The "pushcopy" and "pushtablescopy" controls are similar, but push a 5753 copy of the pattern, the latter with a copy of its character tables. This tests 5754 the pcre2_code_copy() and pcre2_code_copy_with_tables() functions. */ 5755 5756 if ((pat_patctl.control & (CTL_PUSHCOPY|CTL_PUSHTABLESCOPY)) != 0) 5757 { 5758 if (patstacknext >= PATSTACKSIZE) 5759 { 5760 fprintf(outfile, "** Too many pushed patterns (max %d)\n", PATSTACKSIZE); 5761 return PR_ABEND; 5762 } 5763 if ((pat_patctl.control & CTL_PUSHCOPY) != 0) 5764 { 5765 PCRE2_CODE_COPY_TO_VOID(patstack[patstacknext++], compiled_code); 5766 } 5767 else 5768 { 5769 PCRE2_CODE_COPY_WITH_TABLES_TO_VOID(patstack[patstacknext++], 5770 compiled_code); } 5771 } 5772 5773 return PR_OK; 5774 } 5775 5776 5777 5778 /************************************************* 5779 * Check heap, match or depth limit * 5780 *************************************************/ 5781 5782 /* This is used for DFA, normal, and JIT fast matching. For DFA matching it 5783 should only be called with the third argument set to PCRE2_ERROR_DEPTHLIMIT. 5784 5785 Arguments: 5786 pp the subject string 5787 ulen length of subject or PCRE2_ZERO_TERMINATED 5788 errnumber defines which limit to test 5789 msg string to include in final message 5790 5791 Returns: the return from the final match function call 5792 */ 5793 5794 static int 5795 check_match_limit(uint8_t *pp, PCRE2_SIZE ulen, int errnumber, const char *msg) 5796 { 5797 int capcount; 5798 uint32_t min = 0; 5799 uint32_t mid = 64; 5800 uint32_t max = UINT32_MAX; 5801 5802 PCRE2_SET_MATCH_LIMIT(dat_context, max); 5803 PCRE2_SET_DEPTH_LIMIT(dat_context, max); 5804 PCRE2_SET_HEAP_LIMIT(dat_context, max); 5805 5806 for (;;) 5807 { 5808 uint32_t stack_start = 0; 5809 5810 if (errnumber == PCRE2_ERROR_HEAPLIMIT) 5811 { 5812 PCRE2_SET_HEAP_LIMIT(dat_context, mid); 5813 } 5814 else if (errnumber == PCRE2_ERROR_MATCHLIMIT) 5815 { 5816 PCRE2_SET_MATCH_LIMIT(dat_context, mid); 5817 } 5818 else 5819 { 5820 PCRE2_SET_DEPTH_LIMIT(dat_context, mid); 5821 } 5822 5823 if ((dat_datctl.control & CTL_DFA) != 0) 5824 { 5825 stack_start = DFA_START_RWS_SIZE/1024; 5826 if (dfa_workspace == NULL) 5827 dfa_workspace = (int *)malloc(DFA_WS_DIMENSION*sizeof(int)); 5828 if (dfa_matched++ == 0) 5829 dfa_workspace[0] = -1; /* To catch bad restart */ 5830 PCRE2_DFA_MATCH(capcount, compiled_code, pp, ulen, dat_datctl.offset, 5831 dat_datctl.options, match_data, 5832 PTR(dat_context), dfa_workspace, DFA_WS_DIMENSION); 5833 } 5834 5835 else if ((pat_patctl.control & CTL_JITFAST) != 0) 5836 PCRE2_JIT_MATCH(capcount, compiled_code, pp, ulen, dat_datctl.offset, 5837 dat_datctl.options, match_data, PTR(dat_context)); 5838 5839 else 5840 { 5841 stack_start = START_FRAMES_SIZE/1024; 5842 PCRE2_MATCH(capcount, compiled_code, pp, ulen, dat_datctl.offset, 5843 dat_datctl.options, match_data, PTR(dat_context)); 5844 } 5845 5846 if (capcount == errnumber) 5847 { 5848 if ((mid & 0x80000000u) != 0) 5849 { 5850 fprintf(outfile, "Can't find minimum %s limit: check pattern for " 5851 "restriction\n", msg); 5852 break; 5853 } 5854 5855 min = mid; 5856 mid = (mid == max - 1)? max : (max != UINT32_MAX)? (min + max)/2 : mid*2; 5857 } 5858 else if (capcount >= 0 || 5859 capcount == PCRE2_ERROR_NOMATCH || 5860 capcount == PCRE2_ERROR_PARTIAL) 5861 { 5862 /* If we've not hit the error with a heap limit less than the size of the 5863 initial stack frame vector (for pcre2_match()) or the initial stack 5864 workspace vector (for pcre2_dfa_match()), the heap is not being used, so 5865 the minimum limit is zero; there's no need to go on. The other limits are 5866 always greater than zero. */ 5867 5868 if (errnumber == PCRE2_ERROR_HEAPLIMIT && mid < stack_start) 5869 { 5870 fprintf(outfile, "Minimum %s limit = 0\n", msg); 5871 break; 5872 } 5873 if (mid == min + 1) 5874 { 5875 fprintf(outfile, "Minimum %s limit = %d\n", msg, mid); 5876 break; 5877 } 5878 max = mid; 5879 mid = (min + max)/2; 5880 } 5881 else break; /* Some other error */ 5882 } 5883 5884 return capcount; 5885 } 5886 5887 5888 5889 /************************************************* 5890 * Callout function * 5891 *************************************************/ 5892 5893 /* Called from a PCRE2 library as a result of the (?C) item. We print out where 5894 we are in the match (unless suppressed). Yield zero unless more callouts than 5895 the fail count, or the callout data is not zero. The only differences in the 5896 callout block for different code unit widths are that the pointers to the 5897 subject, the most recent MARK, and a callout argument string point to strings 5898 of the appropriate width. Casts can be used to deal with this. 5899 5900 Argument: a pointer to a callout block 5901 Return: 5902 */ 5903 5904 static int 5905 callout_function(pcre2_callout_block_8 *cb, void *callout_data_ptr) 5906 { 5907 FILE *f, *fdefault; 5908 uint32_t i, pre_start, post_start, subject_length; 5909 PCRE2_SIZE current_position; 5910 BOOL utf = (FLD(compiled_code, overall_options) & PCRE2_UTF) != 0; 5911 BOOL callout_capture = (dat_datctl.control & CTL_CALLOUT_CAPTURE) != 0; 5912 BOOL callout_where = (dat_datctl.control2 & CTL2_CALLOUT_NO_WHERE) == 0; 5913 5914 /* The FILE f is used for echoing the subject string if it is non-NULL. This 5915 happens only once in simple cases, but we want to repeat after any additional 5916 output caused by CALLOUT_EXTRA. */ 5917 5918 fdefault = (!first_callout && !callout_capture && cb->callout_string == NULL)? 5919 NULL : outfile; 5920 5921 if ((dat_datctl.control2 & CTL2_CALLOUT_EXTRA) != 0) 5922 { 5923 f = outfile; 5924 switch (cb->callout_flags) 5925 { 5926 case PCRE2_CALLOUT_BACKTRACK: 5927 fprintf(f, "Backtrack\n"); 5928 break; 5929 5930 case PCRE2_CALLOUT_STARTMATCH|PCRE2_CALLOUT_BACKTRACK: 5931 fprintf(f, "Backtrack\nNo other matching paths\n"); 5932 /* Fall through */ 5933 5934 case PCRE2_CALLOUT_STARTMATCH: 5935 fprintf(f, "New match attempt\n"); 5936 break; 5937 5938 default: 5939 f = fdefault; 5940 break; 5941 } 5942 } 5943 else f = fdefault; 5944 5945 /* For a callout with a string argument, show the string first because there 5946 isn't a tidy way to fit it in the rest of the data. */ 5947 5948 if (cb->callout_string != NULL) 5949 { 5950 uint32_t delimiter = CODE_UNIT(cb->callout_string, -1); 5951 fprintf(outfile, "Callout (%" SIZ_FORM "): %c", 5952 SIZ_CAST cb->callout_string_offset, delimiter); 5953 PCHARSV(cb->callout_string, 0, 5954 cb->callout_string_length, utf, outfile); 5955 for (i = 0; callout_start_delims[i] != 0; i++) 5956 if (delimiter == callout_start_delims[i]) 5957 { 5958 delimiter = callout_end_delims[i]; 5959 break; 5960 } 5961 fprintf(outfile, "%c", delimiter); 5962 if (!callout_capture) fprintf(outfile, "\n"); 5963 } 5964 5965 /* Show captured strings if required */ 5966 5967 if (callout_capture) 5968 { 5969 if (cb->callout_string == NULL) 5970 fprintf(outfile, "Callout %d:", cb->callout_number); 5971 fprintf(outfile, " last capture = %d\n", cb->capture_last); 5972 for (i = 2; i < cb->capture_top * 2; i += 2) 5973 { 5974 fprintf(outfile, "%2d: ", i/2); 5975 if (cb->offset_vector[i] == PCRE2_UNSET) 5976 fprintf(outfile, "<unset>"); 5977 else 5978 { 5979 PCHARSV(cb->subject, cb->offset_vector[i], 5980 cb->offset_vector[i+1] - cb->offset_vector[i], utf, f); 5981 } 5982 fprintf(outfile, "\n"); 5983 } 5984 } 5985 5986 /* Unless suppressed, re-print the subject in canonical form (with escapes for 5987 non-printing characters), the first time, or if giving full details. On 5988 subsequent calls in the same match, we use PCHARS() just to find the printed 5989 lengths of the substrings. */ 5990 5991 if (callout_where) 5992 { 5993 if (f != NULL) fprintf(f, "--->"); 5994 5995 /* The subject before the match start. */ 5996 5997 PCHARS(pre_start, cb->subject, 0, cb->start_match, utf, f); 5998 5999 /* If a lookbehind is involved, the current position may be earlier than the 6000 match start. If so, use the match start instead. */ 6001 6002 current_position = (cb->current_position >= cb->start_match)? 6003 cb->current_position : cb->start_match; 6004 6005 /* The subject between the match start and the current position. */ 6006 6007 PCHARS(post_start, cb->subject, cb->start_match, 6008 current_position - cb->start_match, utf, f); 6009 6010 /* Print from the current position to the end. */ 6011 6012 PCHARSV(cb->subject, current_position, cb->subject_length - current_position, 6013 utf, f); 6014 6015 /* Calculate the total subject printed length (no print). */ 6016 6017 PCHARS(subject_length, cb->subject, 0, cb->subject_length, utf, NULL); 6018 6019 if (f != NULL) fprintf(f, "\n"); 6020 6021 /* For automatic callouts, show the pattern offset. Otherwise, for a 6022 numerical callout whose number has not already been shown with captured 6023 strings, show the number here. A callout with a string argument has been 6024 displayed above. */ 6025 6026 if (cb->callout_number == 255) 6027 { 6028 fprintf(outfile, "%+3d ", (int)cb->pattern_position); 6029 if (cb->pattern_position > 99) fprintf(outfile, "\n "); 6030 } 6031 else 6032 { 6033 if (callout_capture || cb->callout_string != NULL) fprintf(outfile, " "); 6034 else fprintf(outfile, "%3d ", cb->callout_number); 6035 } 6036 6037 /* Now show position indicators */ 6038 6039 for (i = 0; i < pre_start; i++) fprintf(outfile, " "); 6040 fprintf(outfile, "^"); 6041 6042 if (post_start > 0) 6043 { 6044 for (i = 0; i < post_start - 1; i++) fprintf(outfile, " "); 6045 fprintf(outfile, "^"); 6046 } 6047 6048 for (i = 0; i < subject_length - pre_start - post_start + 4; i++) 6049 fprintf(outfile, " "); 6050 6051 if (cb->next_item_length != 0) 6052 fprintf(outfile, "%.*s", (int)(cb->next_item_length), 6053 pbuffer8 + cb->pattern_position); 6054 else 6055 fprintf(outfile, "End of pattern"); 6056 6057 fprintf(outfile, "\n"); 6058 } 6059 6060 first_callout = FALSE; 6061 6062 /* Show any mark info */ 6063 6064 if (cb->mark != last_callout_mark) 6065 { 6066 if (cb->mark == NULL) 6067 fprintf(outfile, "Latest Mark: <unset>\n"); 6068 else 6069 { 6070 fprintf(outfile, "Latest Mark: "); 6071 PCHARSV(cb->mark, 0, -1, utf, outfile); 6072 putc('\n', outfile); 6073 } 6074 last_callout_mark = cb->mark; 6075 } 6076 6077 /* Show callout data */ 6078 6079 if (callout_data_ptr != NULL) 6080 { 6081 int callout_data = *((int32_t *)callout_data_ptr); 6082 if (callout_data != 0) 6083 { 6084 fprintf(outfile, "Callout data = %d\n", callout_data); 6085 return callout_data; 6086 } 6087 } 6088 6089 /* Keep count and give the appropriate return code */ 6090 6091 callout_count++; 6092 6093 if (cb->callout_number == dat_datctl.cerror[0] && 6094 callout_count >= dat_datctl.cerror[1]) 6095 return PCRE2_ERROR_CALLOUT; 6096 6097 if (cb->callout_number == dat_datctl.cfail[0] && 6098 callout_count >= dat_datctl.cfail[1]) 6099 return 1; 6100 6101 return 0; 6102 } 6103 6104 6105 6106 /************************************************* 6107 * Handle *MARK and copy/get tests * 6108 *************************************************/ 6109 6110 /* This function is called after complete and partial matches. It runs the 6111 tests for substring extraction. 6112 6113 Arguments: 6114 utf TRUE for utf 6115 capcount return from pcre2_match() 6116 6117 Returns: FALSE if print_error_message() fails 6118 */ 6119 6120 static BOOL 6121 copy_and_get(BOOL utf, int capcount) 6122 { 6123 int i; 6124 uint8_t *nptr; 6125 6126 /* Test copy strings by number */ 6127 6128 for (i = 0; i < MAXCPYGET && dat_datctl.copy_numbers[i] >= 0; i++) 6129 { 6130 int rc; 6131 PCRE2_SIZE length, length2; 6132 uint32_t copybuffer[256]; 6133 uint32_t n = (uint32_t)(dat_datctl.copy_numbers[i]); 6134 length = sizeof(copybuffer)/code_unit_size; 6135 PCRE2_SUBSTRING_COPY_BYNUMBER(rc, match_data, n, copybuffer, &length); 6136 if (rc < 0) 6137 { 6138 fprintf(outfile, "Copy substring %d failed (%d): ", n, rc); 6139 if (!print_error_message(rc, "", "\n")) return FALSE; 6140 } 6141 else 6142 { 6143 PCRE2_SUBSTRING_LENGTH_BYNUMBER(rc, match_data, n, &length2); 6144 if (rc < 0) 6145 { 6146 fprintf(outfile, "Get substring %d length failed (%d): ", n, rc); 6147 if (!print_error_message(rc, "", "\n")) return FALSE; 6148 } 6149 else if (length2 != length) 6150 { 6151 fprintf(outfile, "Mismatched substring lengths: %" 6152 SIZ_FORM " %" SIZ_FORM "\n", SIZ_CAST length, SIZ_CAST length2); 6153 } 6154 fprintf(outfile, "%2dC ", n); 6155 PCHARSV(copybuffer, 0, length, utf, outfile); 6156 fprintf(outfile, " (%" SIZ_FORM ")\n", SIZ_CAST length); 6157 } 6158 } 6159 6160 /* Test copy strings by name */ 6161 6162 nptr = dat_datctl.copy_names; 6163 for (;;) 6164 { 6165 int rc; 6166 int groupnumber; 6167 PCRE2_SIZE length, length2; 6168 uint32_t copybuffer[256]; 6169 int namelen = strlen((const char *)nptr); 6170 #if defined SUPPORT_PCRE2_16 || defined SUPPORT_PCRE2_32 6171 PCRE2_SIZE cnl = namelen; 6172 #endif 6173 if (namelen == 0) break; 6174 6175 #ifdef SUPPORT_PCRE2_8 6176 if (test_mode == PCRE8_MODE) strcpy((char *)pbuffer8, (char *)nptr); 6177 #endif 6178 #ifdef SUPPORT_PCRE2_16 6179 if (test_mode == PCRE16_MODE)(void)to16(nptr, utf, &cnl); 6180 #endif 6181 #ifdef SUPPORT_PCRE2_32 6182 if (test_mode == PCRE32_MODE)(void)to32(nptr, utf, &cnl); 6183 #endif 6184 6185 PCRE2_SUBSTRING_NUMBER_FROM_NAME(groupnumber, compiled_code, pbuffer); 6186 if (groupnumber < 0 && groupnumber != PCRE2_ERROR_NOUNIQUESUBSTRING) 6187 fprintf(outfile, "Number not found for group '%s'\n", nptr); 6188 6189 length = sizeof(copybuffer)/code_unit_size; 6190 PCRE2_SUBSTRING_COPY_BYNAME(rc, match_data, pbuffer, copybuffer, &length); 6191 if (rc < 0) 6192 { 6193 fprintf(outfile, "Copy substring '%s' failed (%d): ", nptr, rc); 6194 if (!print_error_message(rc, "", "\n")) return FALSE; 6195 } 6196 else 6197 { 6198 PCRE2_SUBSTRING_LENGTH_BYNAME(rc, match_data, pbuffer, &length2); 6199 if (rc <