165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* PCRE testing program * 365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This program was hacked up as a tester for PCRE. I really should have 665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwritten it more tidily in the first place. Will I ever learn? It has grown and 765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichbeen extended and consequently is now rather, er, *very* untidy in places. The 865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichaddition of 16-bit support has made it even worse. :-( 965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 1065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich----------------------------------------------------------------------------- 1165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichRedistribution and use in source and binary forms, with or without 1265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichmodification, are permitted provided that the following conditions are met: 1365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 1465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich * Redistributions of source code must retain the above copyright notice, 1565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich this list of conditions and the following disclaimer. 1665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 1765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich * Redistributions in binary form must reproduce the above copyright 1865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich notice, this list of conditions and the following disclaimer in the 1965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich documentation and/or other materials provided with the distribution. 2065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 2165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich * Neither the name of the University of Cambridge nor the names of its 2265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich contributors may be used to endorse or promote products derived from 2365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich this software without specific prior written permission. 2465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 2565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 2965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichLIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 3065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichCONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 3165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichSUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 3265de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichINTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 3365de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 3465de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 3565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPOSSIBILITY OF SUCH DAMAGE. 3665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich----------------------------------------------------------------------------- 3765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 3865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 3965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This program now supports the testing of all of the 8-bit, 16-bit, and 4065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich32-bit PCRE libraries in a single program. This is different from the modules 4165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsuch as pcre_compile.c in the library itself, which are compiled separately for 4265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevicheach mode. If two modes are enabled, for example, pcre_compile.c is compiled 4365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichtwice. By contrast, pcretest.c is compiled only once. Therefore, it must not 4465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichmake use of any of the macros from pcre_internal.h that depend on 4565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichCOMPILE_PCRE8, COMPILE_PCRE16, or COMPILE_PCRE32. It does, however, make use of 4665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichSUPPORT_PCRE8, SUPPORT_PCRE16, and SUPPORT_PCRE32 to ensure that it calls only 4765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsupported library functions. */ 4865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 4965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef HAVE_CONFIG_H 5065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "config.h" 5165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 5265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 5365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <ctype.h> 5465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <stdio.h> 5565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <string.h> 5665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <stdlib.h> 5765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <time.h> 5865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <locale.h> 5965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <errno.h> 6065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 6165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Both libreadline and libedit are optionally supported. The user-supplied 6265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoriginal patch uses readline/readline.h for libedit, but in at least one system 6365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichit is installed as editline/readline.h, so the configuration code now looks for 6465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthat first, falling back to readline/readline.h. */ 6565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 6665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 6765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef HAVE_UNISTD_H 6865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <unistd.h> 6965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 7065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_LIBREADLINE) 7165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <readline/readline.h> 7265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <readline/history.h> 7365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 7465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(HAVE_EDITLINE_READLINE_H) 7565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <editline/readline.h> 7665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 7765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <readline/readline.h> 7865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 7965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 8065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 8165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* A number of things vary for Windows builds. Originally, pcretest opened its 8365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichinput and output without "b"; then I was told that "b" was needed in some 8465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichenvironments, so it was added for release 5.0 to both the input and output. (It 8565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichmakes no difference on Unix-like systems.) Later I was told that it is wrong 8665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor the input on Windows. I've now abstracted the modes into two macros that 8765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichare set here, to make it easier to fiddle with them, and removed "b" from the 8865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichinput mode under Windows. */ 8965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 9065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(_WIN32) || defined(WIN32) 9165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <io.h> /* For _setmode() */ 9265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <fcntl.h> /* For _O_BINARY */ 9365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define INPUT_MODE "r" 9465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define OUTPUT_MODE "wb" 9565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 9665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef isatty 9765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define isatty _isatty /* This is what Windows calls them, I'm told, */ 9865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* though in some environments they seem to */ 9965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* be already defined, hence the #ifndefs. */ 10065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef fileno 10165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define fileno _fileno 10265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 10365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 10465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* A user sent this fix for Borland Builder 5 under Windows. */ 10565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 10665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __BORLANDC__ 10765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define _setmode(handle, mode) setmode(handle, mode) 10865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 10965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 11065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Not Windows */ 11165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 11265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 11365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <sys/time.h> /* These two includes are needed */ 11465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <sys/resource.h> /* for setrlimit(). */ 11565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined NATIVE_ZOS /* z/OS uses non-binary I/O */ 11665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define INPUT_MODE "r" 11765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define OUTPUT_MODE "w" 11865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 11965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define INPUT_MODE "rb" 12065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define OUTPUT_MODE "wb" 12165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 12265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 12365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 12465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 12565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include <ssdef.h> 12665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid vms_setsymbol( char *, char *, int ); 12765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 12865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 12965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 13065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PRIV(name) name 13165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 13265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* We have to include pcre_internal.h because we need the internal info for 13365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdisplaying the results of pcre_study() and we also need to know about the 13465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichinternal macros, structures, and other internal data values; pcretest has 13565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich"inside information" compared to a program that strictly follows the PCRE API. 13665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 13765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichAlthough pcre_internal.h does itself include pcre.h, we explicitly include it 13865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichhere before pcre_internal.h so that the PCRE_EXP_xxx macros get set 13965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichappropriately for an application, not for building PCRE. */ 14065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 14165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "pcre.h" 14265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "pcre_internal.h" 14365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 14465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The pcre_printint() function, which prints the internal form of a compiled 14565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregex, is held in a separate file so that (a) it can be compiled in either 14665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich8-, 16- or 32-bit mode, and (b) it can be #included directly in pcre_compile.c 14765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhen that is compiled in debug mode. */ 14865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 14965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 15065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths); 15165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 15265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 15365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths); 15465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 15565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 15665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid pcre32_printint(pcre *external_re, FILE *f, BOOL print_lengths); 15765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 15865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 15965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* We need access to some of the data tables that PCRE uses. So as not to have 16065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichto keep two copies, we include the source files here, changing the names of the 16165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichexternal symbols to prevent clashes. */ 16265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_INCLUDED 16465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "pcre_tables.c" 16665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "pcre_ucd.c" 16765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The definition of the macro PRINTABLE, which determines whether to print an 16965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoutput character as-is or as a hex value when showing compiled patterns, is 17065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthe same as in the printint.src file. We uses it here in cases when the locale 17165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichhas not been explicitly changed, so as to get consistent output from systems 17265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthat differ in their output from isprint() even in the "C" locale. */ 17365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 17465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef EBCDIC 17565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PRINTABLE(c) ((c) >= 64 && (c) < 255) 17665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 17765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PRINTABLE(c) ((c) >= 32 && (c) < 127) 17865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 17965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 18065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PRINTOK(c) (locale_set? isprint(c) : PRINTABLE(c)) 18165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 18265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Posix support is disabled in 16 or 32 bit only mode. */ 18365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined SUPPORT_PCRE8 && !defined NOPOSIX 18465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define NOPOSIX 18565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 18665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 18765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* It is possible to compile this test program without including support for 18865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichtesting the POSIX interface, though this is not available via the standard 18965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichMakefile. */ 19065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 19165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 19265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#include "pcreposix.h" 19365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 19465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 19565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* It is also possible, originally for the benefit of a version that was 19665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichimported into Exim, to build pcretest without support for UTF8 or UTF16 (define 19765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichNOUTF), without the interface to the DFA matcher (NODFA). In fact, we 19865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichautomatically cut out the UTF support if PCRE is built without it. */ 19965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 20065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef SUPPORT_UTF 20165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef NOUTF 20265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define NOUTF 20365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 20465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 20565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 20665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* To make the code a bit tidier for 8/16/32-bit support, we define macros 20765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor all the pcre[16]_xxx functions (except pcre16_fullinfo, which is called 20865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichonly from one place and is handled differently). I couldn't dream up any way of 20965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichusing a single macro to do this in a generic way, because of the many different 21065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichargument requirements. We know that at least one of SUPPORT_PCRE8 and 21165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichSUPPORT_PCRE16 must be set. First define macros for each individual mode; then 21265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichuse these in the definitions of generic macros. 21365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 21465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich**** Special note about the PCHARSxxx macros: the address of the string to be 21565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprinted is always given as two arguments: a base address followed by an offset. 21665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichThe base address is cast to the correct data size for 8 or 16 bit data; the 21765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoffset is in units of this size. If the string were given as base+offset in one 21865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichargument, the casting might be incorrectly applied. */ 21965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 22065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 22165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 22265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS8(lv, p, offset, len, f) \ 22365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich lv = pchars((pcre_uint8 *)(p) + offset, len, f) 22465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 22565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV8(p, offset, len, f) \ 22665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pchars((pcre_uint8 *)(p) + offset, len, f) 22765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 22865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re) \ 22965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = read_capture_name8(p, cn8, re) 23065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 23165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN8(p) ((int)strlen((char *)p)) 23265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 23365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT8(callout) \ 23465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_callout = callout 23565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 23665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD8(stack_guard) \ 23765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_stack_guard = stack_guard 23865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 23965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata) \ 24065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_assign_jit_stack(extra, callback, userdata) 24165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 24265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE8(re, pat, options, error, erroffset, tables) \ 24365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich re = pcre_compile((char *)pat, options, error, erroffset, tables) 24465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 24565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 24665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) \ 24765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_copy_named_substring(re, (char *)bptr, offsets, count, \ 24865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (char *)namesptr, cbuffer, size) 24965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 25065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size) \ 25165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_copy_substring((char *)bptr, offsets, count, i, cbuffer, size) 25265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 25365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 25465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) \ 25565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre_dfa_exec(re, extra, (char *)bptr, len, start_offset, options, \ 25665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) 25765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 25865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 25965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) \ 26065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre_exec(re, extra, (char *)bptr, len, start_offset, options, \ 26165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) 26265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 26365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY8(extra) \ 26465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_free_study(extra) 26565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 26665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING8(substring) \ 26765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_free_substring(substring) 26865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 26965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST8(listptr) \ 27065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_free_substring_list(listptr) 27165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 27265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 27365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) \ 27465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_get_named_substring(re, (char *)bptr, offsets, count, \ 27565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (char *)getnamesptr, subsptr) 27665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 27765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER8(n, rc, ptr) \ 27865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich n = pcre_get_stringnumber(re, (char *)ptr) 27965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 28065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING8(rc, bptr, offsets, count, i, subsptr) \ 28165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_get_substring((char *)bptr, offsets, count, i, subsptr) 28265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 28365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr) \ 28465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_get_substring_list((const char *)bptr, offsets, count, listptr) 28565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 28665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables) \ 28765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_pattern_to_host_byte_order(re, extra, tables) 28865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 28965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT8(re, outfile, debug_lengths) \ 29065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_printint(re, outfile, debug_lengths) 29165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 29265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY8(extra, re, options, error) \ 29365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = pcre_study(re, options, error) 29465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 29565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC8(startsize, maxsize) \ 29665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_jit_stack_alloc(startsize, maxsize) 29765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 29865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE8(stack) \ 29965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_jit_stack_free(stack) 30065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 30165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define pcre8_maketables pcre_maketables 30265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 30365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE8 */ 30465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 30565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* -----------------------------------------------------------*/ 30665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 30765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 30865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 30965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS16(lv, p, offset, len, f) \ 31065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich lv = pchars16((PCRE_SPTR16)(p) + offset, len, f) 31165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 31265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV16(p, offset, len, f) \ 31365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pchars16((PCRE_SPTR16)(p) + offset, len, f) 31465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 31565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re) \ 31665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = read_capture_name16(p, cn16, re) 31765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 31865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN16(p) ((int)strlen16((PCRE_SPTR16)p)) 31965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 32065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT16(callout) \ 32165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_callout = (int (*)(pcre16_callout_block *))callout 32265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 32365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD16(stack_guard) \ 32465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_stack_guard = (int (*)(void))stack_guard 32565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 32665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata) \ 32765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_assign_jit_stack((pcre16_extra *)extra, \ 32865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre16_jit_callback)callback, userdata) 32965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 33065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE16(re, pat, options, error, erroffset, tables) \ 33165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich re = (pcre *)pcre16_compile((PCRE_SPTR16)pat, options, error, erroffset, \ 33265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich tables) 33365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 33465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 33565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) \ 33665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_copy_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \ 33765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count, (PCRE_SPTR16)namesptr, (PCRE_UCHAR16 *)cbuffer, size/2) 33865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 33965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size) \ 34065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_copy_substring((PCRE_SPTR16)bptr, offsets, count, i, \ 34165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_UCHAR16 *)cbuffer, size/2) 34265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 34365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 34465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) \ 34565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre16_dfa_exec((pcre16 *)re, (pcre16_extra *)extra, \ 34665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR16)bptr, len, start_offset, options, offsets, size_offsets, \ 34765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich workspace, size_workspace) 34865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 34965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 35065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) \ 35165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre16_exec((pcre16 *)re, (pcre16_extra *)extra, (PCRE_SPTR16)bptr, \ 35265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len, start_offset, options, offsets, size_offsets) 35365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 35465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY16(extra) \ 35565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_free_study((pcre16_extra *)extra) 35665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 35765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING16(substring) \ 35865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_free_substring((PCRE_SPTR16)substring) 35965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 36065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST16(listptr) \ 36165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_free_substring_list((PCRE_SPTR16 *)listptr) 36265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 36365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 36465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) \ 36565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_get_named_substring((pcre16 *)re, (PCRE_SPTR16)bptr, offsets, \ 36665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count, (PCRE_SPTR16)getnamesptr, (PCRE_SPTR16 *)(void*)subsptr) 36765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 36865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER16(n, rc, ptr) \ 36965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich n = pcre16_get_stringnumber(re, (PCRE_SPTR16)ptr) 37065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 37165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING16(rc, bptr, offsets, count, i, subsptr) \ 37265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_get_substring((PCRE_SPTR16)bptr, offsets, count, i, \ 37365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR16 *)(void*)subsptr) 37465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 37565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr) \ 37665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_get_substring_list((PCRE_SPTR16)bptr, offsets, count, \ 37765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR16 **)(void*)listptr) 37865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 37965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables) \ 38065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_pattern_to_host_byte_order((pcre16 *)re, (pcre16_extra *)extra, \ 38165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich tables) 38265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 38365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT16(re, outfile, debug_lengths) \ 38465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_printint(re, outfile, debug_lengths) 38565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 38665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY16(extra, re, options, error) \ 38765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)pcre16_study((pcre16 *)re, options, error) 38865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 38965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \ 39065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_jit_stack *)pcre16_jit_stack_alloc(startsize, maxsize) 39165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 39265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE16(stack) \ 39365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre16_jit_stack_free((pcre16_jit_stack *)stack) 39465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 39565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 39665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 39765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* -----------------------------------------------------------*/ 39865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 39965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 40065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 40165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS32(lv, p, offset, len, f) \ 40265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich lv = pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f) 40365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 40465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV32(p, offset, len, f) \ 40565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pchars32((PCRE_SPTR32)(p) + offset, len, use_utf, f) 40665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 40765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re) \ 40865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = read_capture_name32(p, cn32, re) 40965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 41065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN32(p) ((int)strlen32((PCRE_SPTR32)p)) 41165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 41265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT32(callout) \ 41365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_callout = (int (*)(pcre32_callout_block *))callout 41465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 41565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD32(stack_guard) \ 41665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_stack_guard = (int (*)(void))stack_guard 41765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 41865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata) \ 41965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_assign_jit_stack((pcre32_extra *)extra, \ 42065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre32_jit_callback)callback, userdata) 42165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 42265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE32(re, pat, options, error, erroffset, tables) \ 42365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich re = (pcre *)pcre32_compile((PCRE_SPTR32)pat, options, error, erroffset, \ 42465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich tables) 42565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 42665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 42765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) \ 42865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_copy_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \ 42965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count, (PCRE_SPTR32)namesptr, (PCRE_UCHAR32 *)cbuffer, size/2) 43065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 43165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size) \ 43265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_copy_substring((PCRE_SPTR32)bptr, offsets, count, i, \ 43365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_UCHAR32 *)cbuffer, size/2) 43465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 43565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 43665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) \ 43765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre32_dfa_exec((pcre32 *)re, (pcre32_extra *)extra, \ 43865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR32)bptr, len, start_offset, options, offsets, size_offsets, \ 43965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich workspace, size_workspace) 44065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 44165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 44265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) \ 44365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = pcre32_exec((pcre32 *)re, (pcre32_extra *)extra, (PCRE_SPTR32)bptr, \ 44465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len, start_offset, options, offsets, size_offsets) 44565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 44665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY32(extra) \ 44765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_free_study((pcre32_extra *)extra) 44865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 44965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING32(substring) \ 45065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_free_substring((PCRE_SPTR32)substring) 45165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 45265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST32(listptr) \ 45365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_free_substring_list((PCRE_SPTR32 *)listptr) 45465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 45565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 45665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) \ 45765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_get_named_substring((pcre32 *)re, (PCRE_SPTR32)bptr, offsets, \ 45865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count, (PCRE_SPTR32)getnamesptr, (PCRE_SPTR32 *)(void*)subsptr) 45965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 46065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER32(n, rc, ptr) \ 46165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich n = pcre32_get_stringnumber(re, (PCRE_SPTR32)ptr) 46265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 46365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING32(rc, bptr, offsets, count, i, subsptr) \ 46465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_get_substring((PCRE_SPTR32)bptr, offsets, count, i, \ 46565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR32 *)(void*)subsptr) 46665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 46765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr) \ 46865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_get_substring_list((PCRE_SPTR32)bptr, offsets, count, \ 46965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (PCRE_SPTR32 **)(void*)listptr) 47065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 47165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables) \ 47265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_pattern_to_host_byte_order((pcre32 *)re, (pcre32_extra *)extra, \ 47365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich tables) 47465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 47565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT32(re, outfile, debug_lengths) \ 47665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_printint(re, outfile, debug_lengths) 47765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 47865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY32(extra, re, options, error) \ 47965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)pcre32_study((pcre32 *)re, options, error) 48065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \ 48265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_jit_stack *)pcre32_jit_stack_alloc(startsize, maxsize) 48365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE32(stack) \ 48565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre32_jit_stack_free((pcre32_jit_stack *)stack) 48665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 48865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 49065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- More than one mode is supported; a runtime test is needed, except for 49165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_config(), and the JIT stack functions, when it doesn't matter which 49265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichavailable version is called. ----- */ 49365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 49465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichenum { 49565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE8_MODE, 49665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE16_MODE, 49765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE32_MODE 49865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich}; 49965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 50065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if (defined (SUPPORT_PCRE8) + defined (SUPPORT_PCRE16) + \ 50165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich defined (SUPPORT_PCRE32)) >= 2 50265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 50365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CHAR_SIZE (1 << pcre_mode) 50465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 50565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* There doesn't seem to be an easy way of writing these macros that can cope 50665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwith the 3 pairs of bit sizes plus all three bit sizes. So just handle all the 50765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcases separately. */ 50865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 50965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- All three modes supported ----- */ 51065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 51165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_PCRE8) && defined(SUPPORT_PCRE16) && defined(SUPPORT_PCRE32) 51265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 51365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS(lv, p, offset, len, f) \ 51465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 51565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARS32(lv, p, offset, len, f); \ 51665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 51765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARS16(lv, p, offset, len, f); \ 51865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 51965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARS8(lv, p, offset, len, f) 52065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 52165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV(p, offset, len, f) \ 52265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 52365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV32(p, offset, len, f); \ 52465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 52565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV16(p, offset, len, f); \ 52665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 52765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV8(p, offset, len, f) 52865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 52965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \ 53065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 53165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich READ_CAPTURE_NAME32(p, cn8, cn16, cn32, re); \ 53265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 53365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich READ_CAPTURE_NAME16(p, cn8, cn16, cn32, re); \ 53465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 53565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich READ_CAPTURE_NAME8(p, cn8, cn16, cn32, re) 53665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 53765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT(callout) \ 53865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 53965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_CALLOUT32(callout); \ 54065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 54165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_CALLOUT16(callout); \ 54265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 54365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_CALLOUT8(callout) 54465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 54565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD(stack_guard) \ 54665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 54765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_STACK_GUARD32(stack_guard); \ 54865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 54965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_STACK_GUARD16(stack_guard); \ 55065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 55165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_STACK_GUARD8(stack_guard) 55265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 55365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN(p) (pcre_mode == PCRE32_MODE ? STRLEN32(p) : pcre_mode == PCRE16_MODE ? STRLEN16(p) : STRLEN8(p)) 55465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 55565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \ 55665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 55765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ASSIGN_JIT_STACK32(extra, callback, userdata); \ 55865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 55965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ASSIGN_JIT_STACK16(extra, callback, userdata); \ 56065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 56165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ASSIGN_JIT_STACK8(extra, callback, userdata) 56265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 56365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \ 56465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 56565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COMPILE32(re, pat, options, error, erroffset, tables); \ 56665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 56765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COMPILE16(re, pat, options, error, erroffset, tables); \ 56865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 56965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COMPILE8(re, pat, options, error, erroffset, tables) 57065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 57165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_CONFIG pcre_config 57265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 57365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 57465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) \ 57565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 57665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 57765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size); \ 57865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 57965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 58065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size); \ 58165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 58265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 58365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) 58465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 58565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \ 58665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 58765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_SUBSTRING32(rc, bptr, offsets, count, i, cbuffer, size); \ 58865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 58965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_SUBSTRING16(rc, bptr, offsets, count, i, cbuffer, size); \ 59065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 59165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_SUBSTRING8(rc, bptr, offsets, count, i, cbuffer, size) 59265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 59365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \ 59465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) \ 59565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 59665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_DFA_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 59765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace); \ 59865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 59965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_DFA_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 60065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace); \ 60165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 60265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_DFA_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 60365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) 60465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 60565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \ 60665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) \ 60765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 60865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC32(count, re, extra, bptr, len, start_offset, options, \ 60965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets); \ 61065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 61165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC16(count, re, extra, bptr, len, start_offset, options, \ 61265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets); \ 61365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 61465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC8(count, re, extra, bptr, len, start_offset, options, \ 61565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) 61665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 61765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY(extra) \ 61865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 61965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY32(extra); \ 62065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 62165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY16(extra); \ 62265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 62365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY8(extra) 62465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 62565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING(substring) \ 62665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 62765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING32(substring); \ 62865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 62965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING16(substring); \ 63065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 63165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING8(substring) 63265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 63365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST(listptr) \ 63465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 63565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING_LIST32(listptr); \ 63665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 63765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING_LIST16(listptr); \ 63865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 63965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING_LIST8(listptr) 64065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 64165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 64265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) \ 64365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 64465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_NAMED_SUBSTRING32(rc, re, bptr, offsets, count, \ 64565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr); \ 64665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 64765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_NAMED_SUBSTRING16(rc, re, bptr, offsets, count, \ 64865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr); \ 64965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 65065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_NAMED_SUBSTRING8(rc, re, bptr, offsets, count, \ 65165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) 65265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 65365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER(n, rc, ptr) \ 65465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 65565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_STRINGNUMBER32(n, rc, ptr); \ 65665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 65765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_STRINGNUMBER16(n, rc, ptr); \ 65865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 65965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_STRINGNUMBER8(n, rc, ptr) 66065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 66165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \ 66265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 66365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING32(rc, bptr, use_offsets, count, i, subsptr); \ 66465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 66565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING16(rc, bptr, use_offsets, count, i, subsptr); \ 66665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 66765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING8(rc, bptr, use_offsets, count, i, subsptr) 66865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 66965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \ 67065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 67165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING_LIST32(rc, bptr, offsets, count, listptr); \ 67265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 67365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING_LIST16(rc, bptr, offsets, count, listptr); \ 67465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 67565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING_LIST8(rc, bptr, offsets, count, listptr) 67665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 67765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \ 67865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == PCRE32_MODE ? \ 67965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_ALLOC32(startsize, maxsize) \ 68065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich : pcre_mode == PCRE16_MODE ? \ 68165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_ALLOC16(startsize, maxsize) \ 68265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich : PCRE_JIT_STACK_ALLOC8(startsize, maxsize)) 68365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 68465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE(stack) \ 68565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 68665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_FREE32(stack); \ 68765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 68865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_FREE16(stack); \ 68965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 69065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_FREE8(stack) 69165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 69265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_MAKETABLES \ 69365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == PCRE32_MODE ? pcre32_maketables() : pcre_mode == PCRE16_MODE ? pcre16_maketables() : pcre_maketables()) 69465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 69565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \ 69665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 69765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PATTERN_TO_HOST_BYTE_ORDER32(rc, re, extra, tables); \ 69865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 69965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PATTERN_TO_HOST_BYTE_ORDER16(rc, re, extra, tables); \ 70065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 70165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PATTERN_TO_HOST_BYTE_ORDER8(rc, re, extra, tables) 70265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 70365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT(re, outfile, debug_lengths) \ 70465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 70565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PRINTINT32(re, outfile, debug_lengths); \ 70665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 70765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PRINTINT16(re, outfile, debug_lengths); \ 70865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 70965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PRINTINT8(re, outfile, debug_lengths) 71065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 71165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY(extra, re, options, error) \ 71265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) \ 71365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY32(extra, re, options, error); \ 71465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (pcre_mode == PCRE16_MODE) \ 71565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY16(extra, re, options, error); \ 71665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 71765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY8(extra, re, options, error) 71865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 71965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- Two out of three modes are supported ----- */ 72165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 72365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* We can use some macro trickery to make a single set of definitions work in 72565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthe three different cases. */ 72665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- 32-bit and 16-bit but not 8-bit supported ----- */ 72865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE16) 73065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITONE 32 73165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITTWO 16 73265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 73365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- 32-bit and 8-bit but not 16-bit supported ----- */ 73465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 73565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined(SUPPORT_PCRE32) && defined(SUPPORT_PCRE8) 73665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITONE 32 73765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITTWO 8 73865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 73965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- 16-bit and 8-bit but not 32-bit supported ----- */ 74065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 74165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 74265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITONE 16 74365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define BITTWO 8 74465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 74565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 74665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define glue(a,b) a##b 74765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define G(a,b) glue(a,b) 74865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 74965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 75065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- Common macros for two-mode cases ----- */ 75165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 75265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS(lv, p, offset, len, f) \ 75365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 75465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCHARS,BITONE)(lv, p, offset, len, f); \ 75565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 75665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCHARS,BITTWO)(lv, p, offset, len, f) 75765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 75865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV(p, offset, len, f) \ 75965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 76065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCHARSV,BITONE)(p, offset, len, f); \ 76165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 76265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCHARSV,BITTWO)(p, offset, len, f) 76365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 76465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME(p, cn8, cn16, cn32, re) \ 76565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 76665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(READ_CAPTURE_NAME,BITONE)(p, cn8, cn16, cn32, re); \ 76765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 76865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(READ_CAPTURE_NAME,BITTWO)(p, cn8, cn16, cn32, re) 76965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 77065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT(callout) \ 77165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 77265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(SET_PCRE_CALLOUT,BITONE)(callout); \ 77365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 77465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(SET_PCRE_CALLOUT,BITTWO)(callout) 77565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 77665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD(stack_guard) \ 77765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 77865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(SET_PCRE_STACK_GUARD,BITONE)(stack_guard); \ 77965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 78065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(SET_PCRE_STACK_GUARD,BITTWO)(stack_guard) 78165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 78265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN(p) ((pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 78365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(STRLEN,BITONE)(p) : G(STRLEN,BITTWO)(p)) 78465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 78565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK(extra, callback, userdata) \ 78665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 78765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_ASSIGN_JIT_STACK,BITONE)(extra, callback, userdata); \ 78865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 78965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_ASSIGN_JIT_STACK,BITTWO)(extra, callback, userdata) 79065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 79165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE(re, pat, options, error, erroffset, tables) \ 79265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 79365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COMPILE,BITONE)(re, pat, options, error, erroffset, tables); \ 79465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 79565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COMPILE,BITTWO)(re, pat, options, error, erroffset, tables) 79665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 79765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_CONFIG G(G(pcre,BITONE),_config) 79865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 79965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 80065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) \ 80165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 80265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COPY_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \ 80365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size); \ 80465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 80565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COPY_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \ 80665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich namesptr, cbuffer, size) 80765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 80865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING(rc, bptr, offsets, count, i, cbuffer, size) \ 80965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 81065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COPY_SUBSTRING,BITONE)(rc, bptr, offsets, count, i, cbuffer, size); \ 81165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 81265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_COPY_SUBSTRING,BITTWO)(rc, bptr, offsets, count, i, cbuffer, size) 81365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 81465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, options, \ 81565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) \ 81665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 81765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_DFA_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \ 81865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace); \ 81965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 82065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_DFA_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \ 82165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets, workspace, size_workspace) 82265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 82365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, \ 82465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) \ 82565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 82665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_EXEC,BITONE)(count, re, extra, bptr, len, start_offset, options, \ 82765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets); \ 82865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 82965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_EXEC,BITTWO)(count, re, extra, bptr, len, start_offset, options, \ 83065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich offsets, size_offsets) 83165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 83265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY(extra) \ 83365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 83465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_STUDY,BITONE)(extra); \ 83565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 83665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_STUDY,BITTWO)(extra) 83765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 83865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING(substring) \ 83965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 84065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_SUBSTRING,BITONE)(substring); \ 84165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 84265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_SUBSTRING,BITTWO)(substring) 84365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 84465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST(listptr) \ 84565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 84665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_SUBSTRING_LIST,BITONE)(listptr); \ 84765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 84865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_FREE_SUBSTRING_LIST,BITTWO)(listptr) 84965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 85065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, offsets, count, \ 85165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) \ 85265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 85365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_NAMED_SUBSTRING,BITONE)(rc, re, bptr, offsets, count, \ 85465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr); \ 85565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 85665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_NAMED_SUBSTRING,BITTWO)(rc, re, bptr, offsets, count, \ 85765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getnamesptr, subsptr) 85865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 85965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER(n, rc, ptr) \ 86065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 86165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_STRINGNUMBER,BITONE)(n, rc, ptr); \ 86265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 86365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_STRINGNUMBER,BITTWO)(n, rc, ptr) 86465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 86565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, subsptr) \ 86665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 86765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_SUBSTRING,BITONE)(rc, bptr, use_offsets, count, i, subsptr); \ 86865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 86965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_SUBSTRING,BITTWO)(rc, bptr, use_offsets, count, i, subsptr) 87065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 87165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST(rc, bptr, offsets, count, listptr) \ 87265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 87365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_SUBSTRING_LIST,BITONE)(rc, bptr, offsets, count, listptr); \ 87465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 87565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_GET_SUBSTRING_LIST,BITTWO)(rc, bptr, offsets, count, listptr) 87665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 87765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC(startsize, maxsize) \ 87865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 87965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_JIT_STACK_ALLOC,BITONE)(startsize, maxsize) \ 88065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich : G(PCRE_JIT_STACK_ALLOC,BITTWO)(startsize, maxsize) 88165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 88265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE(stack) \ 88365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 88465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_JIT_STACK_FREE,BITONE)(stack); \ 88565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 88665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_JIT_STACK_FREE,BITTWO)(stack) 88765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 88865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_MAKETABLES \ 88965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == G(G(PCRE,BITONE),_MODE)) ? \ 89065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(G(pcre,BITONE),_maketables)() : G(G(pcre,BITTWO),_maketables)() 89165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 89265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, tables) \ 89365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 89465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITONE)(rc, re, extra, tables); \ 89565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 89665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_PATTERN_TO_HOST_BYTE_ORDER,BITTWO)(rc, re, extra, tables) 89765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 89865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT(re, outfile, debug_lengths) \ 89965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 90065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_PRINTINT,BITONE)(re, outfile, debug_lengths); \ 90165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 90265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_PRINTINT,BITTWO)(re, outfile, debug_lengths) 90365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 90465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY(extra, re, options, error) \ 90565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == G(G(PCRE,BITONE),_MODE)) \ 90665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_STUDY,BITONE)(extra, re, options, error); \ 90765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else \ 90865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich G(PCRE_STUDY,BITTWO)(extra, re, options, error) 90965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 91065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* Two out of three modes */ 91165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 91265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- End of cases where more than one mode is supported ----- */ 91365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 91465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 91565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- Only 8-bit mode is supported ----- */ 91665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 91765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE8 91865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CHAR_SIZE 1 91965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS PCHARS8 92065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV PCHARSV8 92165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME READ_CAPTURE_NAME8 92265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT8 92365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD8 92465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN STRLEN8 92565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK8 92665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE PCRE_COMPILE8 92765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_CONFIG pcre_config 92865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING8 92965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING8 93065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC PCRE_DFA_EXEC8 93165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC PCRE_EXEC8 93265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY PCRE_FREE_STUDY8 93365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING8 93465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST8 93565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING8 93665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER8 93765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING8 93865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST8 93965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC8 94065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE8 94165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_MAKETABLES pcre_maketables() 94265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER8 94365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT PCRE_PRINTINT8 94465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY PCRE_STUDY8 94565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 94665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- Only 16-bit mode is supported ----- */ 94765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 94865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE16 94965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CHAR_SIZE 2 95065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS PCHARS16 95165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV PCHARSV16 95265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME READ_CAPTURE_NAME16 95365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT16 95465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD16 95565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN STRLEN16 95665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK16 95765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE PCRE_COMPILE16 95865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_CONFIG pcre16_config 95965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING16 96065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING16 96165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC PCRE_DFA_EXEC16 96265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC PCRE_EXEC16 96365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY PCRE_FREE_STUDY16 96465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING16 96565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST16 96665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING16 96765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER16 96865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING16 96965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST16 97065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC16 97165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE16 97265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_MAKETABLES pcre16_maketables() 97365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER16 97465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT PCRE_PRINTINT16 97565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY PCRE_STUDY16 97665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 97765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- Only 32-bit mode is supported ----- */ 97865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 97965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE32 98065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CHAR_SIZE 4 98165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARS PCHARS32 98265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCHARSV PCHARSV32 98365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define READ_CAPTURE_NAME READ_CAPTURE_NAME32 98465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_CALLOUT SET_PCRE_CALLOUT32 98565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define SET_PCRE_STACK_GUARD SET_PCRE_STACK_GUARD32 98665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define STRLEN STRLEN32 98765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_ASSIGN_JIT_STACK PCRE_ASSIGN_JIT_STACK32 98865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COMPILE PCRE_COMPILE32 98965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_CONFIG pcre32_config 99065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_NAMED_SUBSTRING PCRE_COPY_NAMED_SUBSTRING32 99165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_COPY_SUBSTRING PCRE_COPY_SUBSTRING32 99265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_DFA_EXEC PCRE_DFA_EXEC32 99365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_EXEC PCRE_EXEC32 99465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_STUDY PCRE_FREE_STUDY32 99565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING PCRE_FREE_SUBSTRING32 99665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_FREE_SUBSTRING_LIST PCRE_FREE_SUBSTRING_LIST32 99765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_NAMED_SUBSTRING PCRE_GET_NAMED_SUBSTRING32 99865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_STRINGNUMBER PCRE_GET_STRINGNUMBER32 99965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING PCRE_GET_SUBSTRING32 100065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_GET_SUBSTRING_LIST PCRE_GET_SUBSTRING_LIST32 100165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_ALLOC PCRE_JIT_STACK_ALLOC32 100265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_JIT_STACK_FREE PCRE_JIT_STACK_FREE32 100365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_MAKETABLES pcre32_maketables() 100465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PATTERN_TO_HOST_BYTE_ORDER PCRE_PATTERN_TO_HOST_BYTE_ORDER32 100565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_PRINTINT PCRE_PRINTINT32 100665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY PCRE_STUDY32 100765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 100865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 100965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 101065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* ----- End of mode-specific function call macros ----- */ 101165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 101265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 101365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Other parameters */ 101465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 101565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef CLOCKS_PER_SEC 101665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef CLK_TCK 101765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CLOCKS_PER_SEC CLK_TCK 101865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 101965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define CLOCKS_PER_SEC 100 102065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 102165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 102265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 102365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 102465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define DFA_WS_DIMENSION 1000 102565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 102665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 102765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This is the default loop count for timing. */ 102865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 102965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define LOOPREPEAT 500000 103065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 103165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Static variables */ 103265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 103365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic FILE *outfile; 103465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int log_store = 0; 103565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int callout_count; 103665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int callout_extra; 103765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int callout_fail_count; 103865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int callout_fail_id; 103965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int debug_lengths; 104065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int first_callout; 104165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int jit_was_used; 104265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int locale_set = 0; 104365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int show_malloc; 104465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int stack_guard_return; 104565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int use_utf; 104665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const unsigned char *last_callout_mark = NULL; 104765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 104865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The buffers grow automatically if very long input lines are encountered. */ 104965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 105065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int buffer_size = 50000; 105165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 *buffer = NULL; 105265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 *pbuffer = NULL; 105365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 105465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Just as a safety check, make sure that COMPILE_PCRE[16|32] are *not* set. */ 105565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 105665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef COMPILE_PCRE16 105765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#error COMPILE_PCRE16 must not be set when compiling pcretest.c 105865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 105965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 106065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef COMPILE_PCRE32 106165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#error COMPILE_PCRE32 must not be set when compiling pcretest.c 106265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 106365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 106465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* We need buffers for building 16/32-bit strings, and the tables of operator 106565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichlengths that are used for 16/32-bit compiling, in order to swap bytes in a 106665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpattern for saving/reloading testing. Luckily, the data for these tables is 106765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdefined as a macro. However, we must ensure that LINK_SIZE and IMM2_SIZE (which 106865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichare used in the tables) are adjusted appropriately for the 16/32-bit world. 106965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichLINK_SIZE is also used later in this program. */ 107065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 107165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 107265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#undef IMM2_SIZE 107365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define IMM2_SIZE 1 107465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 107565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if LINK_SIZE == 2 107665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#undef LINK_SIZE 107765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define LINK_SIZE 1 107865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif LINK_SIZE == 3 || LINK_SIZE == 4 107965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#undef LINK_SIZE 108065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define LINK_SIZE 2 108165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 108265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#error LINK_SIZE must be either 2, 3, or 4 108365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 108465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 108565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int buffer16_size = 0; 108665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint16 *buffer16 = NULL; 108765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const pcre_uint16 OP_lengths16[] = { OP_LENGTHS }; 108865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 108965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 109065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 109165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#undef IMM2_SIZE 109265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define IMM2_SIZE 1 109365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#undef LINK_SIZE 109465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define LINK_SIZE 1 109565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 109665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int buffer32_size = 0; 109765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint32 *buffer32 = NULL; 109865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const pcre_uint32 OP_lengths32[] = { OP_LENGTHS }; 109965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 110065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 110165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* If we have 8-bit support, default to it; if there is also 16-or 32-bit 110265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsupport, it can be changed by an option. If there is no 8-bit support, there 110365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichmust be 16-or 32-bit support, so default it to 1. */ 110465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 110565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE8 110665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pcre_mode = PCRE8_MODE; 110765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE16 110865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pcre_mode = PCRE16_MODE; 110965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE32 111065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pcre_mode = PCRE32_MODE; 111165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 111265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 111365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* JIT study options for -s+n and /S+n where '1' <= n <= '7'. */ 111465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 111565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int jit_study_bits[] = 111665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 111765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_COMPILE, 111865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE, 111965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE, 112065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 112165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 112265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE, 112365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_COMPILE + PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE + 112465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE 112565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich}; 112665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 112765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#define PCRE_STUDY_ALLJIT (PCRE_STUDY_JIT_COMPILE | \ 112865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE) 112965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 113065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Textual explanations for runtime error codes */ 113165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 113265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const char *errtexts[] = { 113365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* 0 is no error */ 113465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* NOMATCH is handled specially */ 113565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "NULL argument passed", 113665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "bad option value", 113765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "magic number missing", 113865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "unknown opcode - pattern overwritten?", 113965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "no more memory", 114065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* never returned by pcre_exec() or pcre_dfa_exec() */ 114165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "match limit exceeded", 114265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "callout error code", 114365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* BADUTF8/16 is handled specially */ 114465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* BADUTF8/16 offset is handled specially */ 114565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* PARTIAL is handled specially */ 114665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "not used - internal error", 114765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "internal error - pattern overwritten?", 114865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "bad count value", 114965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "item unsupported for DFA matching", 115065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "backreference condition or recursion test not supported for DFA matching", 115165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "match limit not supported for DFA matching", 115265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "workspace size exceeded in DFA matching", 115365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "too much recursion for DFA matching", 115465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "recursion limit exceeded", 115565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "not used - internal error", 115665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "invalid combination of newline options", 115765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "bad offset value", 115865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL, /* SHORTUTF8/16 is handled specially */ 115965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "nested recursion at the same subject position", 116065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "JIT stack limit reached", 116165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "pattern compiled in wrong mode: 8-bit/16-bit error", 116265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "pattern compiled with other endianness", 116365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "invalid data in workspace for DFA restart", 116465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "bad JIT option", 116565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "bad length" 116665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich}; 116765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 116865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 116965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 117065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Alternate character tables * 117165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 117265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 117365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* By default, the "tables" pointer when calling PCRE is set to NULL, thereby 117465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichusing the default tables of the library. However, the T option can be used to 117565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichselect alternate sets of tables, for different kinds of testing. Note also that 117665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthe L (locale) option also adjusts the tables. */ 117765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 117865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This is the set of tables distributed as default with PCRE. It recognizes 117965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichonly ASCII characters. */ 118065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 118165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const pcre_uint8 tables0[] = { 118265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 118365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This table is a lower casing table. */ 118465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 118565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0, 1, 2, 3, 4, 5, 6, 7, 118665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8, 9, 10, 11, 12, 13, 14, 15, 118765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16, 17, 18, 19, 20, 21, 22, 23, 118865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 24, 25, 26, 27, 28, 29, 30, 31, 118965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 32, 33, 34, 35, 36, 37, 38, 39, 119065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 40, 41, 42, 43, 44, 45, 46, 47, 119165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48, 49, 50, 51, 52, 53, 54, 55, 119265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 56, 57, 58, 59, 60, 61, 62, 63, 119365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 64, 97, 98, 99,100,101,102,103, 119465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 104,105,106,107,108,109,110,111, 119565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 112,113,114,115,116,117,118,119, 119665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 120,121,122, 91, 92, 93, 94, 95, 119765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 96, 97, 98, 99,100,101,102,103, 119865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 104,105,106,107,108,109,110,111, 119965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 112,113,114,115,116,117,118,119, 120065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 120,121,122,123,124,125,126,127, 120165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 128,129,130,131,132,133,134,135, 120265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 136,137,138,139,140,141,142,143, 120365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 144,145,146,147,148,149,150,151, 120465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 152,153,154,155,156,157,158,159, 120565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 160,161,162,163,164,165,166,167, 120665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 168,169,170,171,172,173,174,175, 120765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 176,177,178,179,180,181,182,183, 120865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 184,185,186,187,188,189,190,191, 120965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 192,193,194,195,196,197,198,199, 121065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 200,201,202,203,204,205,206,207, 121165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208,209,210,211,212,213,214,215, 121265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 216,217,218,219,220,221,222,223, 121365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 224,225,226,227,228,229,230,231, 121465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 232,233,234,235,236,237,238,239, 121565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 240,241,242,243,244,245,246,247, 121665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 248,249,250,251,252,253,254,255, 121765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 121865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This table is a case flipping table. */ 121965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 122065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0, 1, 2, 3, 4, 5, 6, 7, 122165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8, 9, 10, 11, 12, 13, 14, 15, 122265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16, 17, 18, 19, 20, 21, 22, 23, 122365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 24, 25, 26, 27, 28, 29, 30, 31, 122465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 32, 33, 34, 35, 36, 37, 38, 39, 122565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 40, 41, 42, 43, 44, 45, 46, 47, 122665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 48, 49, 50, 51, 52, 53, 54, 55, 122765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 56, 57, 58, 59, 60, 61, 62, 63, 122865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 64, 97, 98, 99,100,101,102,103, 122965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 104,105,106,107,108,109,110,111, 123065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 112,113,114,115,116,117,118,119, 123165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 120,121,122, 91, 92, 93, 94, 95, 123265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 96, 65, 66, 67, 68, 69, 70, 71, 123365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 72, 73, 74, 75, 76, 77, 78, 79, 123465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 80, 81, 82, 83, 84, 85, 86, 87, 123565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 88, 89, 90,123,124,125,126,127, 123665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 128,129,130,131,132,133,134,135, 123765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 136,137,138,139,140,141,142,143, 123865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 144,145,146,147,148,149,150,151, 123965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 152,153,154,155,156,157,158,159, 124065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 160,161,162,163,164,165,166,167, 124165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 168,169,170,171,172,173,174,175, 124265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 176,177,178,179,180,181,182,183, 124365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 184,185,186,187,188,189,190,191, 124465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 192,193,194,195,196,197,198,199, 124565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 200,201,202,203,204,205,206,207, 124665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208,209,210,211,212,213,214,215, 124765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 216,217,218,219,220,221,222,223, 124865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 224,225,226,227,228,229,230,231, 124965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 232,233,234,235,236,237,238,239, 125065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 240,241,242,243,244,245,246,247, 125165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 248,249,250,251,252,253,254,255, 125265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 125365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This table contains bit maps for various character classes. Each map is 32 125465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichbytes long and the bits run from the least significant end of each byte. The 125565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichclasses that have their own maps are: space, xdigit, digit, upper, lower, word, 125665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichgraph, print, punct, and cntrl. Other classes are built from combinations. */ 125765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 125865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00, 125965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 126065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 126165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 126265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 126365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 126465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00, 126565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 126665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 126765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 126865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 126965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 127365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00, 127565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 127865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 127965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07, 128065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 128165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 128265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 128365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03, 128465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07, 128565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 128665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 128765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 128865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff, 128965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 129065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 129165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 129265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 129365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff, 129465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f, 129565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 129665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 129765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 129865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc, 129965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78, 130065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 130165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 130265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 130365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00, 130465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80, 130565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 130665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 130765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 130865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This table identifies various classes of character by individual bits: 130965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x01 white space character 131065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x02 letter 131165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x04 decimal digit 131265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x08 hexadecimal digit 131365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x10 alphanumeric or '_' 131465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x80 regular expression metacharacter or binary zero 131565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 131665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 131765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */ 131865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */ 131965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */ 132065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */ 132165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */ 132265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /* ( - / */ 132365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */ 132465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /* 8 - ? */ 132565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* @ - G */ 132665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* H - O */ 132765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* P - W */ 132865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /* X - _ */ 132965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* ` - g */ 133065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* h - o */ 133165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* p - w */ 133265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /* x -127 */ 133365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */ 133465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */ 133565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */ 133665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */ 133765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */ 133865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */ 133965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */ 134065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */ 134165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */ 134265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */ 134365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */ 134465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */ 134565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */ 134665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */ 134765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */ 134865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */ 134965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 135065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This is a set of tables that came originally from a Windows user. It seems 135165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichto be at least an approximation of ISO 8859. In particular, there are 135265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcharacters greater than 128 that are marked as spaces, letters, etc. */ 135365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 135465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic const pcre_uint8 tables1[] = { 135565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,1,2,3,4,5,6,7, 135665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich8,9,10,11,12,13,14,15, 135765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich16,17,18,19,20,21,22,23, 135865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich24,25,26,27,28,29,30,31, 135965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich32,33,34,35,36,37,38,39, 136065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich40,41,42,43,44,45,46,47, 136165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich48,49,50,51,52,53,54,55, 136265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich56,57,58,59,60,61,62,63, 136365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich64,97,98,99,100,101,102,103, 136465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich104,105,106,107,108,109,110,111, 136565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich112,113,114,115,116,117,118,119, 136665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich120,121,122,91,92,93,94,95, 136765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich96,97,98,99,100,101,102,103, 136865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich104,105,106,107,108,109,110,111, 136965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich112,113,114,115,116,117,118,119, 137065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich120,121,122,123,124,125,126,127, 137165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich128,129,130,131,132,133,134,135, 137265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich136,137,138,139,140,141,142,143, 137365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich144,145,146,147,148,149,150,151, 137465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich152,153,154,155,156,157,158,159, 137565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich160,161,162,163,164,165,166,167, 137665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich168,169,170,171,172,173,174,175, 137765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich176,177,178,179,180,181,182,183, 137865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich184,185,186,187,188,189,190,191, 137965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich224,225,226,227,228,229,230,231, 138065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich232,233,234,235,236,237,238,239, 138165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich240,241,242,243,244,245,246,215, 138265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich248,249,250,251,252,253,254,223, 138365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich224,225,226,227,228,229,230,231, 138465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich232,233,234,235,236,237,238,239, 138565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich240,241,242,243,244,245,246,247, 138665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich248,249,250,251,252,253,254,255, 138765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,1,2,3,4,5,6,7, 138865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich8,9,10,11,12,13,14,15, 138965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich16,17,18,19,20,21,22,23, 139065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich24,25,26,27,28,29,30,31, 139165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich32,33,34,35,36,37,38,39, 139265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich40,41,42,43,44,45,46,47, 139365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich48,49,50,51,52,53,54,55, 139465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich56,57,58,59,60,61,62,63, 139565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich64,97,98,99,100,101,102,103, 139665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich104,105,106,107,108,109,110,111, 139765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich112,113,114,115,116,117,118,119, 139865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich120,121,122,91,92,93,94,95, 139965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich96,65,66,67,68,69,70,71, 140065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich72,73,74,75,76,77,78,79, 140165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich80,81,82,83,84,85,86,87, 140265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich88,89,90,123,124,125,126,127, 140365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich128,129,130,131,132,133,134,135, 140465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich136,137,138,139,140,141,142,143, 140565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich144,145,146,147,148,149,150,151, 140665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich152,153,154,155,156,157,158,159, 140765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich160,161,162,163,164,165,166,167, 140865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich168,169,170,171,172,173,174,175, 140965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich176,177,178,179,180,181,182,183, 141065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich184,185,186,187,188,189,190,191, 141165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich224,225,226,227,228,229,230,231, 141265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich232,233,234,235,236,237,238,239, 141365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich240,241,242,243,244,245,246,215, 141465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich248,249,250,251,252,253,254,223, 141565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich192,193,194,195,196,197,198,199, 141665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich200,201,202,203,204,205,206,207, 141765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich208,209,210,211,212,213,214,247, 141865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich216,217,218,219,220,221,222,255, 141965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,62,0,0,1,0,0,0, 142065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 142165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich32,0,0,0,1,0,0,0, 142265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 142365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,255,3, 142465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich126,0,0,0,126,0,0,0, 142565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 142665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 142765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,255,3, 142865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 142965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,12,2, 143065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 143165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 143265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich254,255,255,7,0,0,0,0, 143365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 143465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,127,127,0,0,0,0, 143565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 143665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,254,255,255,7, 143765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,4,32,4, 143865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,128,255,255,127,255, 143965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,255,3, 144065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich254,255,255,135,254,255,255,7, 144165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,4,44,6, 144265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,127,255,255,255,127,255, 144365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,254,255,255,255, 144465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,255,255,255,127, 144565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,254,255,255,255, 144665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,255,255,255,255, 144765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,2,0,0,255,255,255,255, 144865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,255,255,255,127, 144965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,255,255,255,255, 145065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,255,255,255,255, 145165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,254,255,0,252, 145265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich1,0,0,248,1,0,0,120, 145365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,254,255,255,255, 145465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,128,0,0,0,128,0, 145565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,0,0,0,0, 145665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,128, 145765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich255,255,255,255,0,0,0,0, 145865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 145965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich128,0,0,0,0,0,0,0, 146065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,1,1,0,1,1,0,0, 146165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 146265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 146365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich1,0,0,0,128,0,0,0, 146465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich128,128,128,128,0,0,128,0, 146565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich28,28,28,28,28,28,28,28, 146665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich28,28,0,0,0,0,0,128, 146765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,26,26,26,26,26,26,18, 146865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 146965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 147065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,128,128,0,128,16, 147165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,26,26,26,26,26,26,18, 147265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 147365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 147465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,128,128,0,0,0, 147565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,1,0,0, 147665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 147765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 147865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,0,0,0,0,0,0, 147965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich1,0,0,0,0,0,0,0, 148065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,18,0,0,0,0,0, 148165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,0,20,20,0,18,0,0, 148265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich0,20,18,0,0,0,0,0, 148365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 148465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 148565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,0, 148665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 148765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 148865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18, 148965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,0, 149065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich18,18,18,18,18,18,18,18 149165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich}; 149265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 149365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 149465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 149565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 149665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef HAVE_STRERROR 149765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 149865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Provide strerror() for non-ANSI libraries * 149965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 150065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 150165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror() 150265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin their libraries, but can provide the same facility by this simple 150365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichalternative function. */ 150465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 150565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichextern int sys_nerr; 150665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichextern char *sys_errlist[]; 150765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 150865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichchar * 150965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstrerror(int n) 151065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 151165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (n < 0 || n >= sys_nerr) return "unknown error number"; 151265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn sys_errlist[n]; 151365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 151465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* HAVE_STRERROR */ 151565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 151665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 151765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 151865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 151965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Print newline configuration * 152065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 152165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 152265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* 152365de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 152465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc the return code from PCRE_CONFIG_NEWLINE 152565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich isc TRUE if called from "-C newline" 152665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: nothing 152765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 152865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 152965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void 153065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprint_newline_config(int rc, BOOL isc) 153165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 153265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichconst char *s = NULL; 153365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (!isc) printf(" Newline sequence is "); 153465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichswitch(rc) 153565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 153665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case CHAR_CR: s = "CR"; break; 153765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case CHAR_LF: s = "LF"; break; 153865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case (CHAR_CR<<8 | CHAR_LF): s = "CRLF"; break; 153965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -1: s = "ANY"; break; 154065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -2: s = "ANYCRLF"; break; 154165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 154265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 154365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("a non-standard value: 0x%04x\n", rc); 154465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return; 154565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 154665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 154765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("%s\n", s); 154865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 154965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 155065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 155165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 155265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 155365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* JIT memory callback * 155465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 155565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 155665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_jit_stack* jit_callback(void *arg) 155765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 155865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichjit_was_used = TRUE; 155965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn (pcre_jit_stack *)arg; 156065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 156165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 156265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 156365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOUTF || defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32 156465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 156565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Convert UTF-8 string to value * 156665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 156765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 156865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This function takes one or more bytes that represents a UTF-8 character, 156965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichand returns the value of the character. 157065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 157165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArgument: 157265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich utf8bytes a pointer to the byte vector 157365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vptr a pointer to an int to receive the value 157465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 157565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: > 0 => the number of bytes consumed 157665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich -6 to 0 => malformed UTF-8 character at offset = (-return) 157765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 157865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 157965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 158065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichutf82ord(pcre_uint8 *utf8bytes, pcre_uint32 *vptr) 158165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 158265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 c = *utf8bytes++; 158365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 d = c; 158465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint i, j, s; 158565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 158665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (i = -1; i < 6; i++) /* i is number of additional bytes */ 158765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 158865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((d & 0x80) == 0) break; 158965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich d <<= 1; 159065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 159165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 159265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (i == -1) { *vptr = c; return 1; } /* ascii character */ 159365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (i == 0 || i == 6) return 0; /* invalid UTF-8 */ 159465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 159565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* i now has a value in the range 1-5 */ 159665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 159765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichs = 6*i; 159865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichd = (c & utf8_table3[i]) << s; 159965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 160065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (j = 0; j < i; j++) 160165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 160265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = *utf8bytes++; 160365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((c & 0xc0) != 0x80) return -(j+1); 160465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich s -= 6; 160565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich d |= (c & 0x3f) << s; 160665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 160765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 160865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Check that encoding was the correct unique one */ 160965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 161065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (j = 0; j < utf8_table1_size; j++) 161165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (d <= (pcre_uint32)utf8_table1[j]) break; 161265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (j != i) return -(i+1); 161365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 161465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Valid value */ 161565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 161665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*vptr = d; 161765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn i+1; 161865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 161965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* NOUTF || SUPPORT_PCRE16 */ 162065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 162165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 162265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 162365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE8 && !defined NOUTF 162465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 162565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Convert character value to UTF-8 * 162665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 162765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 162865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This function takes an integer value in the range 0 - 0x7fffffff 162965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichand encodes it as a UTF-8 character in 0 to 6 bytes. 163065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 163165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 163265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cvalue the character value 163365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich utf8bytes pointer to buffer for result - at least 6 bytes long 163465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 163565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: number of characters placed in the buffer 163665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 163765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 163865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 163965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichord2utf8(pcre_uint32 cvalue, pcre_uint8 *utf8bytes) 164065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 164165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregister int i, j; 164265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (cvalue > 0x7fffffffu) 164365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return -1; 164465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (i = 0; i < utf8_table1_size; i++) 164565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (cvalue <= (pcre_uint32)utf8_table1[i]) break; 164665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichutf8bytes += i; 164765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (j = i; j > 0; j--) 164865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 164965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *utf8bytes-- = 0x80 | (cvalue & 0x3f); 165065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cvalue >>= 6; 165165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 165265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*utf8bytes = utf8_table2[i] | cvalue; 165365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn i + 1; 165465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 165565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 165665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 165765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 165865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 165965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 166065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Convert a string to 16-bit * 166165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 166265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 166365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* In non-UTF mode, the space needed for a 16-bit string is exactly double the 166465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich8-bit size. For a UTF-8 string, the size needed for UTF-16 is no more than 166565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdouble, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4 166665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin UTF-16. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-16. The 166765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichresult is always left in buffer16. 166865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 166965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichNote that this function does not object to surrogate values. This is 167065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdeliberate; it makes it possible to construct UTF-16 strings that are invalid, 167165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor the purpose of testing that they are correctly faulted. 167265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 167365de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPatterns to be converted are either plain ASCII or UTF-8; data lines are always 167465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin UTF-8 so that values greater than 255 can be handled. 167565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 167665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 167765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich data TRUE if converting a data line; FALSE for a regex 167865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p points to a byte string 167965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich utf true if UTF-8 (to be converted to UTF-16) 168065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len number of bytes in the string (excluding trailing zero) 168165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 168265de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: number of 16-bit data items used (excluding trailing zero) 168365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -1 if a UTF-8 string is malformed 168465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -2 if a value > 0x10ffff is encountered 168565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -3 if a value > 0xffff is encountered when not in UTF mode 168665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 168765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 168865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 168965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichto16(int data, pcre_uint8 *p, int utf, int len) 169065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 169165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *pp; 169265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 169365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (buffer16_size < 2*len + 2) 169465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 169565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (buffer16 != NULL) free(buffer16); 169665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer16_size = 2*len + 2; 169765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer16 = (pcre_uint16 *)malloc(buffer16_size); 169865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (buffer16 == NULL) 169965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 170065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(stderr, "pcretest: malloc(%d) failed for buffer16\n", buffer16_size); 170165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 170265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 170365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 170465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 170565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpp = buffer16; 170665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 170765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (!utf && !data) 170865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 170965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len-- > 0) *pp++ = *p++; 171065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 171165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 171265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichelse 171365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 171465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 c = 0; 171565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len > 0) 171665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 171765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int chlen = utf82ord(p, &c); 171865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (chlen <= 0) return -1; 171965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0x10ffff) return -2; 172065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p += chlen; 172165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len -= chlen; 172265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c < 0x10000) *pp++ = c; else 172365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 172465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (!utf) return -3; 172565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c -= 0x10000; 172665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp++ = 0xD800 | (c >> 10); 172765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp++ = 0xDC00 | (c & 0x3ff); 172865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 172965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 173065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 173165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 173265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*pp = 0; 173365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn pp - buffer16; 173465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 173565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 173665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 173765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 173865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 173965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Convert a string to 32-bit * 174065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 174165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 174265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* In non-UTF mode, the space needed for a 32-bit string is exactly four times the 174365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich8-bit size. For a UTF-8 string, the size needed for UTF-32 is no more than four 174465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichtimes, because up to 0xffff uses no more than 3 bytes in UTF-8 but possibly 4 174565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin UTF-32. Higher values use 4 bytes in UTF-8 and up to 4 bytes in UTF-32. The 174665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichresult is always left in buffer32. 174765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 174865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichNote that this function does not object to surrogate values. This is 174965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdeliberate; it makes it possible to construct UTF-32 strings that are invalid, 175065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor the purpose of testing that they are correctly faulted. 175165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 175265de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPatterns to be converted are either plain ASCII or UTF-8; data lines are always 175365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin UTF-8 so that values greater than 255 can be handled. 175465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 175565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 175665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich data TRUE if converting a data line; FALSE for a regex 175765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p points to a byte string 175865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich utf true if UTF-8 (to be converted to UTF-32) 175965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len number of bytes in the string (excluding trailing zero) 176065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 176165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: number of 32-bit data items used (excluding trailing zero) 176265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -1 if a UTF-8 string is malformed 176365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -2 if a value > 0x10ffff is encountered 176465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich OR -3 if an ill-formed value is encountered (i.e. a surrogate) 176565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 176665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 176765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 176865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichto32(int data, pcre_uint8 *p, int utf, int len) 176965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 177065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 *pp; 177165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 177265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (buffer32_size < 4*len + 4) 177365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 177465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (buffer32 != NULL) free(buffer32); 177565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer32_size = 4*len + 4; 177665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer32 = (pcre_uint32 *)malloc(buffer32_size); 177765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (buffer32 == NULL) 177865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 177965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(stderr, "pcretest: malloc(%d) failed for buffer32\n", buffer32_size); 178065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 178165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 178265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 178365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 178465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpp = buffer32; 178565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 178665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (!utf && !data) 178765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 178865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len-- > 0) *pp++ = *p++; 178965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 179065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 179165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichelse 179265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 179365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 c = 0; 179465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len > 0) 179565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 179665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int chlen = utf82ord(p, &c); 179765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (chlen <= 0) return -1; 179865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (utf) 179965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 180065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0x10ffff) return -2; 180165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (!data && (c & 0xfffff800u) == 0xd800u) return -3; 180265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 180365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 180465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p += chlen; 180565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len -= chlen; 180665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp++ = c; 180765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 180865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 180965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 181065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*pp = 0; 181165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn pp - buffer32; 181265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 181365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 181465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Check that a 32-bit character string is valid UTF-32. 181565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 181665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 181765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich string points to the string 181865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length length of string, or -1 if the string is zero-terminated 181965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 182065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: TRUE if the string is a valid UTF-32 string 182165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich FALSE otherwise 182265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 182365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 182465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef NEVER /* Not used */ 182565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_UTF 182665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic BOOL 182765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvalid_utf32(pcre_uint32 *string, int length) 182865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 182965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregister pcre_uint32 *p; 183065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregister pcre_uint32 c; 183165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 183265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (p = string; length-- > 0; p++) 183365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 183465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = *p; 183565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0x10ffffu) return FALSE; /* Too big */ 183665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((c & 0xfffff800u) == 0xd800u) return FALSE; /* Surrogate */ 183765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 183865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 183965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn TRUE; 184065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 184165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_UTF */ 184265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* NEVER */ 184365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 184465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 184565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 184665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 184765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Read or extend an input line * 184865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 184965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 185065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Input lines are read into buffer, but both patterns and data lines can be 185165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcontinued over multiple input lines. In addition, if the buffer fills up, we 185265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwant to automatically expand it so as to be able to handle extremely large 185365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichlines that are needed for certain stress tests. When the input buffer is 185465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichexpanded, the other two buffers must also be expanded likewise, and the 185565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcontents of pbuffer, which are a copy of the input for callouts, must be 185665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpreserved (for when expansion happens for a data line). This is not the most 185765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoptimal way of handling this, but hey, this is just a test program! 185865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 185965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 186065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich f the file to read 186165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start where in buffer to start (this *must* be within buffer) 186265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich prompt for stdin or readline() 186365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 186465de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: pointer to the start of new data 186565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich could be a copy of start, or could be moved 186665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NULL if no data read and EOF reached 186765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 186865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 186965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 * 187065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichextend_inputline(FILE *f, pcre_uint8 *start, const char *prompt) 187165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 187265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *here = start; 187365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 187465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (;;) 187565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 187665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_t rlen = (size_t)(buffer_size - (here - buffer)); 187765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 187865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rlen > 1000) 187965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 188065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int dlen; 188165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 188265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If libreadline or libedit support is required, use readline() to read a 188365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich line if the input is a terminal. Note that readline() removes the trailing 188465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich newline, so we must put it back again, to be compatible with fgets(). */ 188565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 188665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 188765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (isatty(fileno(f))) 188865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 188965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_t len; 189065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich char *s = readline(prompt); 189165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (s == NULL) return (here == start)? NULL : start; 189265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = strlen(s); 189365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (len > 0) add_history(s); 189465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (len > rlen - 1) len = rlen - 1; 189565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich memcpy(here, s, len); 189665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich here[len] = '\n'; 189765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich here[len+1] = 0; 189865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(s); 189965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 190065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 190165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 190265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 190365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Read the next line by normal means, prompting if the file is stdin. */ 190465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 190565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 190665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f == stdin) printf("%s", prompt); 190765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fgets((char *)here, rlen, f) == NULL) 190865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return (here == start)? NULL : start; 190965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 191065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 191165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dlen = (int)strlen((char *)here); 191265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dlen > 0 && here[dlen - 1] == '\n') return start; 191365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich here += dlen; 191465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 191565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 191665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 191765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 191865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int new_buffer_size = 2*buffer_size; 191965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *new_buffer = (pcre_uint8 *)malloc(new_buffer_size); 192065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *new_pbuffer = (pcre_uint8 *)malloc(new_buffer_size); 192165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 192265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_buffer == NULL || new_pbuffer == NULL) 192365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 192465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(stderr, "pcretest: malloc(%d) failed\n", new_buffer_size); 192565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 192665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 192765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 192865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich memcpy(new_buffer, buffer, buffer_size); 192965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich memcpy(new_pbuffer, pbuffer, buffer_size); 193065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 193165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer_size = new_buffer_size; 193265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 193365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start = new_buffer + (start - buffer); 193465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich here = new_buffer + (here - buffer); 193565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 193665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(buffer); 193765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(pbuffer); 193865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 193965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer = new_buffer; 194065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pbuffer = new_pbuffer; 194165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 194265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 194365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 194465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Control never gets here */ 194565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 194665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 194765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 194865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 194965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 195065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Read number from string * 195165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 195265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 195365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess 195465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevicharound with conditional compilation, just do the job by hand. It is only used 195565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor unpicking arguments, so just keep it simple. 195665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 195765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 195865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich str string to be converted 195965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich endptr where to put the end pointer 196065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 196165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: the unsigned long 196265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 196365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 196465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 196565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichget_value(pcre_uint8 *str, pcre_uint8 **endptr) 196665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 196765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint result = 0; 196865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile(*str != 0 && isspace(*str)) str++; 196965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (isdigit(*str)) result = result * 10 + (int)(*str++ - '0'); 197065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*endptr = str; 197165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn(result); 197265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 197365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 197465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 197565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 197665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 197765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Print one character * 197865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 197965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 198065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Print a single character either literally, or as a hex escape. */ 198165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 198265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pchar(pcre_uint32 c, FILE *f) 198365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 198465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint n = 0; 198565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (PRINTOK(c)) 198665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 198765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f != NULL) fprintf(f, "%c", c); 198865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return 1; 198965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 199065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 199165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (c < 0x100) 199265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 199365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf) 199465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 199565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f != NULL) fprintf(f, "\\x{%02x}", c); 199665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return 6; 199765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 199865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 199965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 200065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f != NULL) fprintf(f, "\\x%02x", c); 200165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return 4; 200265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 200365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 200465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 200565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (f != NULL) n = fprintf(f, "\\x{%02x}", c); 200665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn n >= 0 ? n : 0; 200765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 200865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 200965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 201065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 201165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 201265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 201365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Print 8-bit character string * 201465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 201565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 201665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Must handle UTF-8 strings in utf8 mode. Yields number of characters printed. 201765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichIf handed a NULL file, just counts chars without printing. */ 201865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 201965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pchars(pcre_uint8 *p, int length, FILE *f) 202065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 202165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 c = 0; 202265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint yield = 0; 202365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 202465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (length < 0) 202565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = strlen((char *)p); 202665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 202765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (length-- > 0) 202865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 202965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOUTF 203065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf) 203165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 203265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc = utf82ord(p, &c); 203365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc > 0 && rc <= length + 1) /* Mustn't run over the end */ 203465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 203565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length -= rc - 1; 203665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p += rc; 203765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield += pchar(c, f); 203865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 203965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 204065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 204165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 204265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = *p++; 204365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield += pchar(c, f); 204465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 204565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 204665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn yield; 204765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 204865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 204965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 205065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 205165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 205265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 205365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 205465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Find length of 0-terminated 16-bit string * 205565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 205665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 205765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int strlen16(PCRE_SPTR16 p) 205865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 205965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCRE_SPTR16 pp = p; 206065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (*pp != 0) pp++; 206165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn (int)(pp - p); 206265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 206365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 206465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 206565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 206665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 206765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 206865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 206965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Find length of 0-terminated 32-bit string * 207065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 207165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 207265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int strlen32(PCRE_SPTR32 p) 207365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 207465de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCRE_SPTR32 pp = p; 207565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (*pp != 0) pp++; 207665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn (int)(pp - p); 207765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 207865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 207965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 208365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 208465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Print 16-bit character string * 208565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 208665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 208765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Must handle UTF-16 strings in utf mode. Yields number of characters printed. 208865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichIf handed a NULL file, just counts chars without printing. */ 208965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 209065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pchars16(PCRE_SPTR16 p, int length, FILE *f) 209165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 209265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint yield = 0; 209365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 209465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (length < 0) 209565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = strlen16(p); 209665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 209765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (length-- > 0) 209865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 209965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 c = *p++ & 0xffff; 210065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOUTF 210165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf && c >= 0xD800 && c < 0xDC00 && length > 0) 210265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 210365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int d = *p & 0xffff; 210465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (d >= 0xDC00 && d <= 0xDFFF) 210565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 210665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = ((c & 0x3ff) << 10) + (d & 0x3ff) + 0x10000; 210765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length--; 210865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 210965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 211065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 211165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 211265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield += pchar(c, f); 211365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 211465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 211565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn yield; 211665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 211765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 211865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 211965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 212065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 212165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 212265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 212365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Print 32-bit character string * 212465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 212565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 212665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Must handle UTF-32 strings in utf mode. Yields number of characters printed. 212765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichIf handed a NULL file, just counts chars without printing. */ 212865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 212965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int pchars32(PCRE_SPTR32 p, int length, BOOL utf, FILE *f) 213065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 213165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint yield = 0; 213265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 213365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich(void)(utf); /* Avoid compiler warning */ 213465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 213565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (length < 0) 213665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = strlen32(p); 213765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 213865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (length-- > 0) 213965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 214065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 c = *p++; 214165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield += pchar(c, f); 214265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 214365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 214465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn yield; 214565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 214665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 214765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 214865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 214965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 215065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 215165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 215265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Read a capture name (8-bit) and check it * 215365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 215465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 215565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 * 215665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichread_capture_name8(pcre_uint8 *p, pcre_uint8 **pp, pcre *re) 215765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 215865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *npp = *pp; 215965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (isalnum(*p)) *npp++ = *p++; 216065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp++ = 0; 216165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp = 0; 216265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (pcre_get_stringnumber(re, (char *)(*pp)) < 0) 216365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 216465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "no parentheses with name \""); 216565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(*pp, 0, -1, outfile); 216665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\"\n"); 216765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 216865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 216965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*pp = npp; 217065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn p; 217165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 217265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE8 */ 217365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 217465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 217565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 217665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 217765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 217865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Read a capture name (16-bit) and check it * 217965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 218065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 218165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Note that the text being read is 8-bit. */ 218265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 218365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 * 218465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichread_capture_name16(pcre_uint8 *p, pcre_uint16 **pp, pcre *re) 218565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 218665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *npp = *pp; 218765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (isalnum(*p)) *npp++ = *p++; 218865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp++ = 0; 218965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp = 0; 219065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (pcre16_get_stringnumber((pcre16 *)re, (PCRE_SPTR16)(*pp)) < 0) 219165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 219265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "no parentheses with name \""); 219365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(*pp, 0, -1, outfile); 219465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\"\n"); 219565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 219665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*pp = npp; 219765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn p; 219865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 219965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 220065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 220165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 220265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 220365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 220465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 220565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Read a capture name (32-bit) and check it * 220665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 220765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 220865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Note that the text being read is 8-bit. */ 220965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 221065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint8 * 221165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichread_capture_name32(pcre_uint8 *p, pcre_uint32 **pp, pcre *re) 221265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 221365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 *npp = *pp; 221465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (isalnum(*p)) *npp++ = *p++; 221565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp++ = 0; 221665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*npp = 0; 221765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (pcre32_get_stringnumber((pcre32 *)re, (PCRE_SPTR32)(*pp)) < 0) 221865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 221965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "no parentheses with name \""); 222065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(*pp, 0, -1, outfile); 222165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\"\n"); 222265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 222365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*pp = npp; 222465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn p; 222565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 222665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 222765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 222865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 222965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 223065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 223165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Stack guard function * 223265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 223365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 223465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Called from PCRE when set in pcre_stack_guard. We give an error (non-zero) 223565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn when a count overflows. */ 223665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 223765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int stack_guard(void) 223865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 223965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn stack_guard_return; 224065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 224165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 224265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 224365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Callout function * 224465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 224565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 224665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Called from PCRE as a result of the (?C) item. We print out where we are in 224765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthe match. Yield zero unless more callouts than the fail count, or the callout 224865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdata is not zero. */ 224965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 225065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int callout(pcre_callout_block *cb) 225165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 225265de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichFILE *f = (first_callout | callout_extra)? outfile : NULL; 225365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint i, pre_start, post_start, subject_length; 225465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 225565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (callout_extra) 225665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 225765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(f, "Callout %d: last capture = %d\n", 225865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cb->callout_number, cb->capture_last); 225965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 226065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < cb->capture_top * 2; i += 2) 226165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 226265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (cb->offset_vector[i] < 0) 226365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(f, "%2d: <unset>\n", i/2); 226465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 226565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 226665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(f, "%2d: ", i/2); 226765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(cb->subject, cb->offset_vector[i], 226865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cb->offset_vector[i+1] - cb->offset_vector[i], f); 226965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(f, "\n"); 227065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 227165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 227265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 227365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 227465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Re-print the subject in canonical form, the first time or if giving full 227565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdatails. On subsequent calls in the same match, we use pchars just to find the 227665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprinted lengths of the substrings. */ 227765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 227865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (f != NULL) fprintf(f, "--->"); 227965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 228065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCHARS(pre_start, cb->subject, 0, cb->start_match, f); 228165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCHARS(post_start, cb->subject, cb->start_match, 228265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cb->current_position - cb->start_match, f); 228365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 228465de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCHARS(subject_length, cb->subject, 0, cb->subject_length, NULL); 228565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 228665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichPCHARSV(cb->subject, cb->current_position, 228765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cb->subject_length - cb->current_position, f); 228865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 228965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (f != NULL) fprintf(f, "\n"); 229065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 229165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Always print appropriate indicators, with callout number if not already 229265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichshown. For automatic callouts, show the pattern offset. */ 229365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 229465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (cb->callout_number == 255) 229565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 229665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%+3d ", cb->pattern_position); 229765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (cb->pattern_position > 99) fprintf(outfile, "\n "); 229865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 229965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichelse 230065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 230165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (callout_extra) fprintf(outfile, " "); 230265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else fprintf(outfile, "%3d ", cb->callout_number); 230365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 230465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 230565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (i = 0; i < pre_start; i++) fprintf(outfile, " "); 230665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfprintf(outfile, "^"); 230765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 230865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (post_start > 0) 230965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 231065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < post_start - 1; i++) fprintf(outfile, " "); 231165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "^"); 231265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 231365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 231465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (i = 0; i < subject_length - pre_start - post_start + 4; i++) 231565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " "); 231665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 231765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfprintf(outfile, "%.*s", (cb->next_item_length == 0)? 1 : cb->next_item_length, 231865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pbuffer + cb->pattern_position); 231965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 232065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfprintf(outfile, "\n"); 232165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfirst_callout = 0; 232265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 232365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (cb->mark != last_callout_mark) 232465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 232565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (cb->mark == NULL) 232665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Latest Mark: <unset>\n"); 232765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 232865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 232965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Latest Mark: "); 233065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(cb->mark, 0, -1, outfile); 233165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich putc('\n', outfile); 233265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 233365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich last_callout_mark = cb->mark; 233465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 233565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 233665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (cb->callout_data != NULL) 233765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 233865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int callout_data = *((int *)(cb->callout_data)); 233965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (callout_data != 0) 234065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 234165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Callout data = %d\n", callout_data); 234265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return callout_data; 234365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 234465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 234565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 234665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn (cb->callout_number != callout_fail_id)? 0 : 234765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (++callout_count >= callout_fail_count)? 1 : 0; 234865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 234965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 235065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 235165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 235265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Local malloc functions * 235365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 235465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 235565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Alternative malloc function, to test functionality and save the size of a 235665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcompiled re, which is the first store request that pcre_compile() makes. The 235765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichshow_malloc variable is set only during matching. */ 235865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 235965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void *new_malloc(size_t size) 236065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 236165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid *block = malloc(size); 236265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (show_malloc) 236365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "malloc %3d %p\n", (int)size, block); 236465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn block; 236565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 236665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 236765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void new_free(void *block) 236865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 236965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (show_malloc) 237065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "free %p\n", block); 237165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(block); 237265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 237365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 237465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* For recursion malloc/free, to test stacking calls */ 237565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 237665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void *stack_malloc(size_t size) 237765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 237865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvoid *block = malloc(size); 237965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (show_malloc) 238065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block); 238165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn block; 238265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 238365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 238465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void stack_free(void *block) 238565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 238665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (show_malloc) 238765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "stack_free %p\n", block); 238865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(block); 238965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 239065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 239165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 239265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 239365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Call pcre_fullinfo() * 239465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 239565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 239665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Get one piece of information from the pcre_fullinfo() function. When only 239765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichone of 8-, 16- or 32-bit is supported, pcre_mode should always have the correct 239865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvalue, but the code is defensive. 239965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 240065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 240165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich re compiled regex 240265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study study data 240365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich option PCRE_INFO_xxx option 240465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr where to put the data 240565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 240665de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: 0 when OK, < 0 on error 240765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 240865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 240965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 241065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichnew_info(pcre *re, pcre_extra *study, int option, void *ptr) 241165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 241265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint rc; 241365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 241465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (pcre_mode == PCRE32_MODE) 241565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 241665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre32_fullinfo((pcre32 *)re, (pcre32_extra *)study, option, ptr); 241765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 241865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = PCRE_ERROR_BADMODE; 241965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 242065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichelse if (pcre_mode == PCRE16_MODE) 242165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 242265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre16_fullinfo((pcre16 *)re, (pcre16_extra *)study, option, ptr); 242365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 242465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = PCRE_ERROR_BADMODE; 242565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 242665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichelse 242765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 242865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = pcre_fullinfo(re, study, option, ptr); 242965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 243065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = PCRE_ERROR_BADMODE; 243165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 243265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 243365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (rc < 0 && rc != PCRE_ERROR_UNSET) 243465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 243565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc, 243665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", option); 243765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc == PCRE_ERROR_BADMODE) 243865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Running in %d-bit mode but pattern was compiled in " 243965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "%d-bit mode\n", 8 * CHAR_SIZE, 244065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8 * (REAL_PCRE_FLAGS(re) & PCRE_MODE_MASK)); 244165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 244265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 244365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn rc; 244465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 244565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 244665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 244765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 244865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 244965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Swap byte functions * 245065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 245165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 245265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The following functions swap the bytes of a pcre_uint16 and pcre_uint32 245365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichvalue, respectively. 245465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 245565de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 245665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich value any number 245765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 245865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: the byte swapped value 245965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 246065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 246165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint32 246265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichswap_uint32(pcre_uint32 value) 246365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 246465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn ((value & 0x000000ff) << 24) | 246565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((value & 0x0000ff00) << 8) | 246665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((value & 0x00ff0000) >> 8) | 246765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (value >> 24); 246865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 246965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 247065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic pcre_uint16 247165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichswap_uint16(pcre_uint16 value) 247265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 247365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn (value >> 8) | (value << 8); 247465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 247565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 247665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 247765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 247865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 247965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Flip bytes in a compiled pattern * 248065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 248165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 248265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This function is called if the 'F' option was present on a pattern that is 248365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichto be written to a file. We flip the bytes of all the integer fields in the 248465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregex data block and the study block. In 16-bit mode this also flips relevant 248565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichbytes in the pattern itself. This is to make it possible to test PCRE's 248665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichability to reload byte-flipped patterns, e.g. those compiled on a different 248765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevicharchitecture. */ 248865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 248965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16 249065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void 249165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregexflip8_or_16(pcre *ere, pcre_extra *extra) 249265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 249365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreal_pcre8_or_16 *re = (real_pcre8_or_16 *)ere; 249465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 249565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint op; 249665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *ptr = (pcre_uint16 *)re + re->name_table_offset; 249765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint length = re->name_count * re->name_entry_size; 249865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_UTF 249965de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichBOOL utf = (re->options & PCRE_UTF16) != 0; 250065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichBOOL utf16_char = FALSE; 250165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_UTF */ 250265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 250365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 250465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Always flip the bytes in the main data block and study blocks. */ 250565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 250665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->magic_number = REVERSED_MAGIC_NUMBER; 250765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->size = swap_uint32(re->size); 250865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->options = swap_uint32(re->options); 250965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->flags = swap_uint32(re->flags); 251065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->limit_match = swap_uint32(re->limit_match); 251165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->limit_recursion = swap_uint32(re->limit_recursion); 251265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->first_char = swap_uint16(re->first_char); 251365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->req_char = swap_uint16(re->req_char); 251465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->max_lookbehind = swap_uint16(re->max_lookbehind); 251565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->top_bracket = swap_uint16(re->top_bracket); 251665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->top_backref = swap_uint16(re->top_backref); 251765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_table_offset = swap_uint16(re->name_table_offset); 251865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_entry_size = swap_uint16(re->name_entry_size); 251965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_count = swap_uint16(re->name_count); 252065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->ref_count = swap_uint16(re->ref_count); 252165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 252265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (extra != NULL) 252365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 252465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_study_data *rsd = (pcre_study_data *)(extra->study_data); 252565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->size = swap_uint32(rsd->size); 252665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->flags = swap_uint32(rsd->flags); 252765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->minlength = swap_uint32(rsd->minlength); 252865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 252965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 253065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* In 8-bit mode, that is all we need to do. In 16-bit mode we must swap bytes 253165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichin the name table, if present, and then in the pattern itself. */ 253265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 253365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 253465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (pcre_mode != PCRE16_MODE) return; 253565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 253665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile(TRUE) 253765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 253865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Swap previous characters. */ 253965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (length-- > 0) 254065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 254165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint16(*ptr); 254265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 254365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 254465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_UTF 254565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (utf16_char) 254665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 254765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((ptr[-1] & 0xfc00) == 0xd800) 254865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 254965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* We know that there is only one extra character in UTF-16. */ 255065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint16(*ptr); 255165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 255265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 255365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 255465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich utf16_char = FALSE; 255565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_UTF */ 255665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 255765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Get next opcode. */ 255865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 255965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = 0; 256065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op = *ptr; 256165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr++ = swap_uint16(op); 256265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 256365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (op) 256465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 256565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_END: 256665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return; 256765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 256865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_UTF 256965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_CHAR: 257065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_CHARI: 257165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOT: 257265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTI: 257365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_STAR: 257465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINSTAR: 257565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_PLUS: 257665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINPLUS: 257765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_QUERY: 257865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINQUERY: 257965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_UPTO: 258065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINUPTO: 258165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_EXACT: 258265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSSTAR: 258365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSPLUS: 258465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSQUERY: 258565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSUPTO: 258665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_STARI: 258765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINSTARI: 258865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_PLUSI: 258965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINPLUSI: 259065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_QUERYI: 259165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINQUERYI: 259265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_UPTOI: 259365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_MINUPTOI: 259465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_EXACTI: 259565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSSTARI: 259665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSPLUSI: 259765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSQUERYI: 259865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_POSUPTOI: 259965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTSTAR: 260065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINSTAR: 260165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPLUS: 260265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINPLUS: 260365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTQUERY: 260465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINQUERY: 260565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTUPTO: 260665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINUPTO: 260765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTEXACT: 260865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSSTAR: 260965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSPLUS: 261065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSQUERY: 261165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSUPTO: 261265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTSTARI: 261365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINSTARI: 261465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPLUSI: 261565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINPLUSI: 261665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTQUERYI: 261765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINQUERYI: 261865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTUPTOI: 261965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTMINUPTOI: 262065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTEXACTI: 262165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSSTARI: 262265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSPLUSI: 262365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSQUERYI: 262465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NOTPOSUPTOI: 262565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (utf) utf16_char = TRUE; 262665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 262765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Fall through. */ 262865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 262965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 263065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = OP_lengths16[op] - 1; 263165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 263265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 263365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_CLASS: 263465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NCLASS: 263565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Skip the character bit map. */ 263665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr += 32/sizeof(pcre_uint16); 263765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = 0; 263865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 263965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 264065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_XCLASS: 264165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* LINK_SIZE can be 1 or 2 in 16 bit mode. */ 264265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (LINK_SIZE > 1) 264365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = (int)((((unsigned int)(ptr[0]) << 16) | (unsigned int)(ptr[1])) 264465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich - (1 + LINK_SIZE + 1)); 264565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 264665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1)); 264765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 264865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Reverse the size of the XCLASS instance. */ 264965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint16(*ptr); 265065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 265165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (LINK_SIZE > 1) 265265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 265365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint16(*ptr); 265465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 265565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 265665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 265765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op = *ptr; 265865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint16(op); 265965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 266065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((op & XCL_MAP) != 0) 266165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 266265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Skip the character bit map. */ 266365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr += 32/sizeof(pcre_uint16); 266465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length -= 32/sizeof(pcre_uint16); 266565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 266665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 266765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 266865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 266965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Control should never reach here in 16 bit mode. */ 267065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE16 */ 267165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 267265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE[8|16] */ 267365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 267465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 267565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 267665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE32 267765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void 267865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregexflip_32(pcre *ere, pcre_extra *extra) 267965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 268065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreal_pcre32 *re = (real_pcre32 *)ere; 268165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint op; 268265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 *ptr = (pcre_uint32 *)re + re->name_table_offset; 268365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint length = re->name_count * re->name_entry_size; 268465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 268565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Always flip the bytes in the main data block and study blocks. */ 268665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 268765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->magic_number = REVERSED_MAGIC_NUMBER; 268865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->size = swap_uint32(re->size); 268965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->options = swap_uint32(re->options); 269065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->flags = swap_uint32(re->flags); 269165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->limit_match = swap_uint32(re->limit_match); 269265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->limit_recursion = swap_uint32(re->limit_recursion); 269365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->first_char = swap_uint32(re->first_char); 269465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->req_char = swap_uint32(re->req_char); 269565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->max_lookbehind = swap_uint16(re->max_lookbehind); 269665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->top_bracket = swap_uint16(re->top_bracket); 269765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->top_backref = swap_uint16(re->top_backref); 269865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_table_offset = swap_uint16(re->name_table_offset); 269965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_entry_size = swap_uint16(re->name_entry_size); 270065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->name_count = swap_uint16(re->name_count); 270165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichre->ref_count = swap_uint16(re->ref_count); 270265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 270365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (extra != NULL) 270465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 270565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_study_data *rsd = (pcre_study_data *)(extra->study_data); 270665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->size = swap_uint32(rsd->size); 270765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->flags = swap_uint32(rsd->flags); 270865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rsd->minlength = swap_uint32(rsd->minlength); 270965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 271065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 271165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* In 32-bit mode we must swap bytes in the name table, if present, and then in 271265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthe pattern itself. */ 271365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 271465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile(TRUE) 271565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 271665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Swap previous characters. */ 271765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (length-- > 0) 271865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 271965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint32(*ptr); 272065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 272165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 272265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 272365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Get next opcode. */ 272465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 272565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = 0; 272665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op = *ptr; 272765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr++ = swap_uint32(op); 272865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 272965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (op) 273065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 273165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_END: 273265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich return; 273365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 273465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 273565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = OP_lengths32[op] - 1; 273665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 273765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 273865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_CLASS: 273965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_NCLASS: 274065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Skip the character bit map. */ 274165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr += 32/sizeof(pcre_uint32); 274265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = 0; 274365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 274465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 274565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case OP_XCLASS: 274665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* LINK_SIZE can only be 1 in 32-bit mode. */ 274765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length = (int)((unsigned int)(ptr[0]) - (1 + LINK_SIZE + 1)); 274865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 274965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Reverse the size of the XCLASS instance. */ 275065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint32(*ptr); 275165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 275265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 275365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op = *ptr; 275465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ptr = swap_uint32(op); 275565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr++; 275665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((op & XCL_MAP) != 0) 275765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 275865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Skip the character bit map. */ 275965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ptr += 32/sizeof(pcre_uint32); 276065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich length -= 32/sizeof(pcre_uint32); 276165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 276265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 276365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 276465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 276565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Control should never reach here in 32 bit mode. */ 276665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 276765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 276865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* SUPPORT_PCRE32 */ 276965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 277065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 277165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 277265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void 277365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichregexflip(pcre *ere, pcre_extra *extra) 277465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 277565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE32 277665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_FLAGS(ere) & PCRE_MODE32) 277765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich regexflip_32(ere, extra); 277865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 277965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE8 || defined SUPPORT_PCRE16 278065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_FLAGS(ere) & (PCRE_MODE8 | PCRE_MODE16)) 278165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich regexflip8_or_16(ere, extra); 278265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 278365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 278465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 278565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 278665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 278765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 278865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Check match or recursion limit * 278965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 279065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 279165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 279265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcheck_match_limit(pcre *re, pcre_extra *extra, pcre_uint8 *bptr, int len, 279365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int start_offset, int options, int *use_offsets, int use_size_offsets, 279465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int flag, unsigned long int *limit, int errnumber, const char *msg) 279565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 279665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint count; 279765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint min = 0; 279865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint mid = 64; 279965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint max = -1; 280065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 280165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichextra->flags |= flag; 280265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 280365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor (;;) 280465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 280565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *limit = mid; 280665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 280765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC(count, re, extra, bptr, len, start_offset, options, 280865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets, use_size_offsets); 280965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 281065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count == errnumber) 281165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 281265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */ 281365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich min = mid; 281465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich mid = (mid == max - 1)? max : (max > 0)? (min + max)/2 : mid*2; 281565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 281665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 281765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (count >= 0 || count == PCRE_ERROR_NOMATCH || 281865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count == PCRE_ERROR_PARTIAL) 281965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 282065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (mid == min + 1) 282165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 282265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Minimum %s limit = %d\n", msg, mid); 282365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 282465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 282565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* fprintf(outfile, "Testing %s limit = %d\n", msg, mid); */ 282665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich max = mid; 282765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich mid = (min + mid)/2; 282865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 282965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else break; /* Some other error */ 283065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 283165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 283265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichextra->flags &= ~flag; 283365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn count; 283465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 283565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 283665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 283765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 283865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 283965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Case-independent strncmp() function * 284065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 284165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 284265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* 284365de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 284465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich s first string 284565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich t second string 284665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich n number of characters to compare 284765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 284865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: < 0, = 0, or > 0, according to the comparison 284965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 285065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 285165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 285265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstrncmpic(pcre_uint8 *s, pcre_uint8 *t, int n) 285365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 285465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (n--) 285565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 285665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int c = tolower(*s++) - tolower(*t++); 285765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c) return c; 285865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 285965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn 0; 286065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 286165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 286265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 286365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 286465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 286565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Check multicharacter option * 286665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 286765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 286865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* This is used both at compile and run-time to check for <xxx> escapes. Print 286965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevicha message and return 0 if there is no match. 287065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 287165de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichArguments: 287265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p points after the leading '<' 287365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich f file for error message 287465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich nl TRUE to check only for newline settings 287565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich stype "modifier" or "escape sequence" 287665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 287765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichReturns: appropriate PCRE_NEWLINE_xxx flags, or 0 287865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*/ 287965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 288065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic int 288165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichcheck_mc_option(pcre_uint8 *p, FILE *f, BOOL nl, const char *stype) 288265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 288365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"cr>", 3) == 0) return PCRE_NEWLINE_CR; 288465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"lf>", 3) == 0) return PCRE_NEWLINE_LF; 288565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF; 288665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF; 288765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"any>", 4) == 0) return PCRE_NEWLINE_ANY; 288865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF; 288965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (strncmpic(p, (pcre_uint8 *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE; 289065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 289165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (!nl) 289265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 289365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (strncmpic(p, (pcre_uint8 *)"JS>", 3) == 0) return PCRE_JAVASCRIPT_COMPAT; 289465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 289565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 289665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfprintf(f, "Unknown %s at: <%s\n", stype, p); 289765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn 0; 289865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 289965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 290065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 290165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 290265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 290365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Usage function * 290465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 290565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 290665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichstatic void 290765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichusage(void) 290865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 290965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("Usage: pcretest [options] [<input file> [<output file>]]\n\n"); 291065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("Input and output default to stdin and stdout.\n"); 291165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(SUPPORT_LIBREADLINE) || defined(SUPPORT_LIBEDIT) 291265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("If input is a terminal, readline() is used to read from it.\n"); 291365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 291465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("This version of pcretest is not linked with readline().\n"); 291565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 291665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf("\nOptions:\n"); 291765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 291865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -16 use the 16-bit library\n"); 291965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 292065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 292165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -32 use the 32-bit library\n"); 292265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 292365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -b show compiled code\n"); 292465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -C show PCRE compile-time options and exit\n"); 292565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -C arg show a specific compile-time option and exit\n"); 292665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" with its value if numeric (else 0). The arg can be:\n"); 292765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" linksize internal link size [2, 3, 4]\n"); 292865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" pcre8 8 bit library support enabled [0, 1]\n"); 292965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" pcre16 16 bit library support enabled [0, 1]\n"); 293065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" pcre32 32 bit library support enabled [0, 1]\n"); 293165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" utf Unicode Transformation Format supported [0, 1]\n"); 293265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" ucp Unicode Properties supported [0, 1]\n"); 293365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" jit Just-in-time compiler supported [0, 1]\n"); 293465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" newline Newline type [CR, LF, CRLF, ANYCRLF, ANY]\n"); 293565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" bsr \\R type [ANYCRLF, ANY]\n"); 293665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -d debug: show compiled code and information (-b and -i)\n"); 293765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 293865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -dfa force DFA matching for all subjects\n"); 293965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 294065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -help show usage information\n"); 294165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -i show information about compiled patterns\n" 294265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -M find MATCH_LIMIT minimum for each subject\n" 294365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -m output memory used information\n" 294465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -O set PCRE_NO_AUTO_POSSESS on each pattern\n" 294565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -o <n> set size of offsets vector to <n>\n"); 294665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 294765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -p use POSIX interface\n"); 294865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 294965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -q quiet: do not output PCRE version number at start\n"); 295065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -S <n> set stack size to <n> megabytes\n"); 295165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -s force each pattern to be studied at basic level\n" 295265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -s+ force each pattern to be studied, using JIT if available\n" 295365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -s++ ditto, verifying when JIT was actually used\n" 295465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -s+n force each pattern to be studied, using JIT if available,\n" 295565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " where 1 <= n <= 7 selects JIT options\n" 295665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -s++n ditto, verifying when JIT was actually used\n" 295765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich " -t time compilation and execution\n"); 295865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -t <n> time compilation and execution, repeating <n> times\n"); 295965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -tm time execution (matching) only\n"); 296065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -tm <n> time execution (matching) only, repeating <n> times\n"); 296165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -T same as -t, but show total times at the end\n"); 296265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichprintf(" -TM same as -tm, but show total time at the end\n"); 296365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 296465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 296565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 296665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 296765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/************************************************* 296865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich* Main Program * 296965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich*************************************************/ 297065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 297165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Read lines from named file or stdin and write to named file or stdout; lines 297265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichconsist of a regular expression, in delimiters and optionally followed by 297365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoptions, followed by a set of test data, terminated by an empty line. */ 297465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 297565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint main(int argc, char **argv) 297665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich{ 297765de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichFILE *infile = stdin; 297865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichconst char *version; 297965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint options = 0; 298065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint study_options = 0; 298165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint default_find_match_limit = FALSE; 298265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 default_options = 0; 298365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint op = 1; 298465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint timeit = 0; 298565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint timeitm = 0; 298665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint showtotaltimes = 0; 298765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint showinfo = 0; 298865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint showstore = 0; 298965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint force_study = -1; 299065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint force_study_options = 0; 299165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint quiet = 0; 299265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint size_offsets = 45; 299365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint size_offsets_max; 299465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint *offsets = NULL; 299565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint debug = 0; 299665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint done = 0; 299765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint all_use_dfa = 0; 299865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint verify_jit = 0; 299965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint yield = 0; 300065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint stack_size; 300165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *dbuffer = NULL; 300265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 lockout[24] = { 0 }; 300365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsize_t dbuffer_size = 1u << 14; 300465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichclock_t total_compile_time = 0; 300565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichclock_t total_study_time = 0; 300665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichclock_t total_match_time = 0; 300765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 300865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 300965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint posix = 0; 301065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 301165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 301265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichint *dfa_workspace = NULL; 301365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 301465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 301565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_jit_stack *jit_stack = NULL; 301665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 301765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* These vectors store, end-to-end, a list of zero-terminated captured 301865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsubstring names, each list itself being terminated by an empty name. Assume 301965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichthat 1024 is plenty long enough for the few names we'll be testing. It is 302065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevicheasiest to keep separate 8-, 16- and 32-bit versions, using the 32-bit version 302165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfor the actual memory, to ensure alignment. */ 302265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 302365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 copynames[1024]; 302465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 getnames[1024]; 302565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 302665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 302765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 *cn32ptr; 302865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint32 *gn32ptr; 302965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 303065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 303165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 303265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *copynames16 = (pcre_uint16 *)copynames; 303365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *getnames16 = (pcre_uint16 *)getnames; 303465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *cn16ptr; 303565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint16 *gn16ptr; 303665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 303765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 303865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 303965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *copynames8 = (pcre_uint8 *)copynames; 304065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *getnames8 = (pcre_uint8 *)getnames; 304165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *cn8ptr; 304265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_uint8 *gn8ptr; 304365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 304465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 304565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Get buffers from malloc() so that valgrind will check their misuse when 304665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichdebugging. They grow automatically when very long lines are read. The 16- 304765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichand 32-bit buffers (buffer16, buffer32) are obtained only if needed. */ 304865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 304965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichbuffer = (pcre_uint8 *)malloc(buffer_size); 305065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpbuffer = (pcre_uint8 *)malloc(buffer_size); 305165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 305265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The outfile variable is static so that new_malloc can use it. */ 305365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 305465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoutfile = stdout; 305565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 305665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* The following _setmode() stuff is some Windows magic that tells its runtime 305765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichlibrary to translate CRLF into a single LF character. At least, that's what 305865de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichI've been told: never having used Windows I take this all on trust. Originally 305965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichit set 0x8000, but then I was advised that _O_BINARY was better. */ 306065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 306165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(_WIN32) || defined(WIN32) 306265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich_setmode( _fileno( stdout ), _O_BINARY ); 306365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 306465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 306565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Get the version number: both pcre_version() and pcre16_version() give the 306665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsame answer. We just need to ensure that we call one that is available. */ 306765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 306865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined SUPPORT_PCRE8 306965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichversion = pcre_version(); 307065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE16 307165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichversion = pcre16_version(); 307265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#elif defined SUPPORT_PCRE32 307365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichversion = pcre32_version(); 307465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 307565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 307665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Scan options */ 307765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 307865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (argc > 1 && argv[op][0] == '-') 307965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 308065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *endptr; 308165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich char *arg = argv[op]; 308265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 308365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (strcmp(arg, "-m") == 0) showstore = 1; 308465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-s") == 0) force_study = 0; 308565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 308665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strncmp(arg, "-s+", 3) == 0) 308765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 308865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich arg += 3; 308965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*arg == '+') { arg++; verify_jit = TRUE; } 309065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich force_study = 1; 309165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*arg == 0) 309265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich force_study_options = jit_study_bits[6]; 309365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*arg >= '1' && *arg <= '7') 309465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich force_study_options = jit_study_bits[*arg - '1']; 309565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else goto BAD_ARG; 309665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 309765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-8") == 0) 309865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 309965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 310065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_mode = PCRE8_MODE; 310165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 310265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** This version of PCRE was built without 8-bit support\n"); 310365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 310465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 310565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 310665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-16") == 0) 310765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 310865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 310965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_mode = PCRE16_MODE; 311065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 311165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** This version of PCRE was built without 16-bit support\n"); 311265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 311365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 311465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 311565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-32") == 0) 311665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 311765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 311865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_mode = PCRE32_MODE; 311965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 312065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** This version of PCRE was built without 32-bit support\n"); 312165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 312265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 312365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 312465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-q") == 0) quiet = 1; 312565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-b") == 0) debug = 1; 312665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-i") == 0) showinfo = 1; 312765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-d") == 0) showinfo = debug = 1; 312865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-M") == 0) default_find_match_limit = TRUE; 312965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-O") == 0) default_options |= PCRE_NO_AUTO_POSSESS; 313065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 313165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-dfa") == 0) all_use_dfa = 1; 313265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 313365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-o") == 0 && argc > 2 && 313465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((size_offsets = get_value((pcre_uint8 *)argv[op+1], &endptr)), 313565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *endptr == 0)) 313665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 313765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op++; 313865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich argc--; 313965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 314065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-t") == 0 || strcmp(arg, "-tm") == 0 || 314165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich strcmp(arg, "-T") == 0 || strcmp(arg, "-TM") == 0) 314265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 314365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int temp; 314465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int both = arg[2] == 0; 314565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich showtotaltimes = arg[1] == 'T'; 314665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (argc > 2 && (temp = get_value((pcre_uint8 *)argv[op+1], &endptr), 314765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *endptr == 0)) 314865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 314965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich timeitm = temp; 315065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op++; 315165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich argc--; 315265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 315365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else timeitm = LOOPREPEAT; 315465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (both) timeit = timeitm; 315565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 315665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-S") == 0 && argc > 2 && 315765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((stack_size = get_value((pcre_uint8 *)argv[op+1], &endptr)), 315865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *endptr == 0)) 315965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 316065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(_WIN32) || defined(WIN32) || defined(__minix) || defined(NATIVE_ZOS) || defined(__VMS) 316165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("PCRE: -S not supported on this OS\n"); 316265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 316365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 316465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 316565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich struct rlimit rlim; 316665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getrlimit(RLIMIT_STACK, &rlim); 316765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rlim.rlim_cur = stack_size * 1024 * 1024; 316865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = setrlimit(RLIMIT_STACK, &rlim); 316965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc != 0) 317065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 317165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("PCRE: setrlimit() failed with error %d\n", rc); 317265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 317365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 317465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op++; 317565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich argc--; 317665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 317765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 317865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 317965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-p") == 0) posix = 1; 318065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 318165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-C") == 0) 318265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 318365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 318465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unsigned long int lrc; 318565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 318665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (argc > 2) 318765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 318865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (strcmp(argv[op + 1], "linksize") == 0) 318965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 319065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc); 319165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("%d\n", rc); 319265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = rc; 319365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 319465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 319565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vms_setsymbol("LINKSIZE",0,yield ); 319665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 319765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 319865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "pcre8") == 0) 319965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 320065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 320165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("1\n"); 320265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 320365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 320465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0\n"); 320565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 0; 320665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 320765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 320865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vms_setsymbol("PCRE8",0,yield ); 320965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 321065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 321165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "pcre16") == 0) 321265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 321365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 321465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("1\n"); 321565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 321665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 321765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0\n"); 321865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 0; 321965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 322065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 322165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vms_setsymbol("PCRE16",0,yield ); 322265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 322365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 322465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "pcre32") == 0) 322565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 322665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 322765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("1\n"); 322865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 322965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 323065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0\n"); 323165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 0; 323265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 323365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 323465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vms_setsymbol("PCRE32",0,yield ); 323565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 323665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 323765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "utf") == 0) 323865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 323965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 324065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 324165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre_config(PCRE_CONFIG_UTF8, &rc); 324265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 324365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 324465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 324565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre16_config(PCRE_CONFIG_UTF16, &rc); 324665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 324765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 324865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 324965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre32_config(PCRE_CONFIG_UTF32, &rc); 325065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 325165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("%d\n", rc); 325265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = rc; 325365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef __VMS 325465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich vms_setsymbol("UTF",0,yield ); 325565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 325665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 325765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "ucp") == 0) 325865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 325965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc); 326065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("%d\n", rc); 326165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = rc; 326265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 326365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "jit") == 0) 326465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 326565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc); 326665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("%d\n", rc); 326765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = rc; 326865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 326965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "newline") == 0) 327065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 327165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc); 327265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich print_newline_config(rc, TRUE); 327365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 327465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "bsr") == 0) 327565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 327665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc); 327765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("%s\n", rc? "ANYCRLF" : "ANY"); 327865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 327965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "ebcdic") == 0) 328065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 328165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef EBCDIC 328265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("1\n"); 328365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 328465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 328565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0\n"); 328665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 328765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 328865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(argv[op + 1], "ebcdic-nl") == 0) 328965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 329065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef EBCDIC 329165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0x%02x\n", CHAR_LF); 329265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 329365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("0\n"); 329465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 329565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 329665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 329765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 329865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("Unknown -C option: %s\n", argv[op + 1]); 329965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 330065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 330165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 330265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 330365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* No argument for -C: output all configuration information. */ 330465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 330565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("PCRE version %s\n", version); 330665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("Compiled with\n"); 330765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 330865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef EBCDIC 330965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" EBCDIC code support: LF is 0x%02x\n", CHAR_LF); 331065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 331165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 331265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* At least one of SUPPORT_PCRE8 and SUPPORT_PCRE16 will be set. If both 331365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichare set, either both UTFs are supported or both are not supported. */ 331465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 331565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 331665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" 8-bit support\n"); 331765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre_config(PCRE_CONFIG_UTF8, &rc); 331865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf (" %sUTF-8 support\n", rc ? "" : "No "); 331965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 332065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 332165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" 16-bit support\n"); 332265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre16_config(PCRE_CONFIG_UTF16, &rc); 332365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf (" %sUTF-16 support\n", rc ? "" : "No "); 332465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 332565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 332665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" 32-bit support\n"); 332765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)pcre32_config(PCRE_CONFIG_UTF32, &rc); 332865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf (" %sUTF-32 support\n", rc ? "" : "No "); 332965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 333065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 333165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_UNICODE_PROPERTIES, &rc); 333265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" %sUnicode properties support\n", rc? "" : "No "); 333365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_JIT, &rc); 333465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc) 333565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 333665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *arch; 333765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_JITTARGET, (void *)(&arch)); 333865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Just-in-time compiler support: %s\n", arch); 333965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 334065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 334165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" No just-in-time compiler support\n"); 334265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &rc); 334365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich print_newline_config(rc, FALSE); 334465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_BSR, &rc); 334565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" \\R matches %s\n", rc? "CR, LF, or CRLF only" : 334665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "all Unicode newlines"); 334765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_LINK_SIZE, &rc); 334865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Internal link size = %d\n", rc); 334965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc); 335065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" POSIX malloc threshold = %d\n", rc); 335165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_PARENS_LIMIT, &lrc); 335265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Parentheses nest limit = %ld\n", lrc); 335365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT, &lrc); 335465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Default match limit = %ld\n", lrc); 335565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_MATCH_LIMIT_RECURSION, &lrc); 335665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Default recursion depth limit = %ld\n", lrc); 335765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_STACKRECURSE, &rc); 335865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(" Match recursion uses %s", rc? "stack" : "heap"); 335965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (showstore) 336065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 336165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC(stack_size, NULL, NULL, NULL, -999, -999, 0, NULL, 0); 336265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf(": %sframe size = %d bytes", rc? "approximate " : "", -stack_size); 336365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 336465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("\n"); 336565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 336665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 336765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (strcmp(arg, "-help") == 0 || 336865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich strcmp(arg, "--help") == 0) 336965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 337065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich usage(); 337165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 337265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 337365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 337465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 337565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich BAD_ARG: 337665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Unknown or malformed option %s\n", arg); 337765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich usage(); 337865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 337965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 338065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 338165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich op++; 338265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich argc--; 338365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 338465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 338565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Get the store for the offsets vector, and remember what it was */ 338665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 338765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichsize_offsets_max = size_offsets; 338865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichoffsets = (int *)malloc(size_offsets_max * sizeof(int)); 338965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (offsets == NULL) 339065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 339165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Failed to get %d bytes of memory for offsets vector\n", 339265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (int)(size_offsets_max * sizeof(int))); 339365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 339465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 339565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 339665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 339765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Sort out the input and output files */ 339865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 339965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (argc > 1) 340065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 340165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich infile = fopen(argv[op], INPUT_MODE); 340265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (infile == NULL) 340365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 340465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Failed to open %s\n", argv[op]); 340565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 340665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 340765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 340865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 340965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 341065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (argc > 2) 341165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 341265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich outfile = fopen(argv[op+1], OUTPUT_MODE); 341365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (outfile == NULL) 341465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 341565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Failed to open %s\n", argv[op+1]); 341665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 341765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 341865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 341965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 342065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 342165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Set alternative malloc function */ 342265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 342365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 342465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_malloc = new_malloc; 342565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_free = new_free; 342665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_stack_malloc = stack_malloc; 342765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre_stack_free = stack_free; 342865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 342965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 343065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 343165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre16_malloc = new_malloc; 343265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre16_free = new_free; 343365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre16_stack_malloc = stack_malloc; 343465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre16_stack_free = stack_free; 343565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 343665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 343765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 343865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre32_malloc = new_malloc; 343965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre32_free = new_free; 344065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre32_stack_malloc = stack_malloc; 344165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichpcre32_stack_free = stack_free; 344265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 344365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 344465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Heading line unless quiet */ 344565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 344665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (!quiet) fprintf(outfile, "PCRE version %s\n\n", version); 344765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 344865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* Main loop */ 344965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 345065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichwhile (!done) 345165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 345265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre *re = NULL; 345365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_extra *extra = NULL; 345465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 345565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX /* There are still compilers that require no indent */ 345665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich regex_t preg; 345765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_posix = 0; 345865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 345965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 346065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *error; 346165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *markptr; 346265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *p, *pp, *ppp; 346365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *to_file = NULL; 346465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const pcre_uint8 *tables = NULL; 346565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unsigned long int get_options; 346665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unsigned long int true_size, true_study_size = 0; 346765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_t size; 346865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_allcaps = 0; 346965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_mark = 0; 347065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_study = 0; 347165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int no_force_study = 0; 347265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_debug = debug; 347365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_G = 0; 347465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_g = 0; 347565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_showinfo = showinfo; 347665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_showrest = 0; 347765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_showcaprest = 0; 347865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int do_flip = 0; 347965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int erroroffset, len, delimiter, poffset; 348065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 348165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 348265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int dfa_matched = 0; 348365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 348465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 348565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_utf = 0; 348665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich debug_lengths = 1; 348765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_STACK_GUARD(NULL); 348865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 348965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extend_inputline(infile, buffer, " re> ") == NULL) break; 349065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); 349165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fflush(outfile); 349265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 349365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = buffer; 349465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(*p)) p++; 349565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == 0) continue; 349665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 349765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle option lock-out setting */ 349865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 349965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '<' && p[1] == ' ') 350065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 350165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p += 2; 350265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(*p)) p++; 350365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (strncmp((char *)p, "forbid ", 7) == 0) 350465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 350565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p += 7; 350665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(*p)) p++; 350765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp = lockout; 350865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (!isspace(*p) && pp < lockout + sizeof(lockout) - 1) 350965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp++ = *p++; 351065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp = 0; 351165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 351265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 351365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 351465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Unrecognized special command '%s'\n", p); 351565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 351665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 351765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 351865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 351965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 352065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 352165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* See if the pattern is to be loaded pre-compiled from a file. */ 352265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 352365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '<' && strchr((char *)(p+1), '<') == NULL) 352465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 352565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 magic; 352665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 sbuf[8]; 352765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich FILE *f; 352865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 352965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 353065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '!') 353165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 353265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_debug = TRUE; 353365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_showinfo = TRUE; 353465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 353565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 353665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 353765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp = p + (int)strlen((char *)p); 353865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(pp[-1])) pp--; 353965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp = 0; 354065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 354165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich f = fopen((char *)p, "rb"); 354265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f == NULL) 354365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 354465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Failed to open %s: %s\n", p, strerror(errno)); 354565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 354665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 354765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ; 354865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 354965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich true_size = 355065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (sbuf[0] << 24) | (sbuf[1] << 16) | (sbuf[2] << 8) | sbuf[3]; 355165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich true_study_size = 355265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7]; 355365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 355465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich re = (pcre *)new_malloc(true_size); 355565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (re == NULL) 355665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 355765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Failed to get %d bytes of memory for pcre object\n", 355865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (int)true_size); 355965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 356065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 356165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 356265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ; 356365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 356465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich magic = REAL_PCRE_MAGIC(re); 356565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (magic != MAGIC_NUMBER) 356665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 356765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (swap_uint32(magic) == MAGIC_NUMBER) 356865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 356965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_flip = 1; 357065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 357165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 357265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 357365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Data in %s is not a compiled PCRE regex\n", p); 357465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free(re); 357565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 357665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 357765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 357865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 357965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 358065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* We hide the byte-invert info for little and big endian tests. */ 358165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Compiled pattern%s loaded from %s\n", 358265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_flip && (p[-1] == '<') ? " (byte-inverted)" : "", p); 358365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 358465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Now see if there is any following study data. */ 358565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 358665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (true_study_size != 0) 358765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 358865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_study_data *psd; 358965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 359065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)new_malloc(sizeof(pcre_extra) + true_study_size); 359165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = PCRE_EXTRA_STUDY_DATA; 359265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 359365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich psd = (pcre_study_data *)(((char *)extra) + sizeof(pcre_extra)); 359465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->study_data = psd; 359565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 359665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fread(psd, 1, true_study_size, f) != true_study_size) 359765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 359865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich FAIL_READ: 359965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Failed to read data from %s\n", p); 360065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) 360165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 360265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY(extra); 360365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 360465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free(re); 360565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 360665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 360765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 360865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Study data loaded from %s\n", p); 360965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_study = 1; /* To get the data output if requested */ 361065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 361165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else fprintf(outfile, "No study data\n"); 361265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 361365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Flip the necessary bytes. */ 361465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_flip) 361565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 361665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 361765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PATTERN_TO_HOST_BYTE_ORDER(rc, re, extra, NULL); 361865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc == PCRE_ERROR_BADMODE) 361965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 362065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 flags_in_host_byte_order; 362165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_MAGIC(re) == MAGIC_NUMBER) 362265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich flags_in_host_byte_order = REAL_PCRE_FLAGS(re); 362365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 362465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich flags_in_host_byte_order = swap_uint32(REAL_PCRE_FLAGS(re)); 362565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Simulate the result of the function call below. */ 362665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d from pcre%s_fullinfo(%d)\n", rc, 362765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_mode == PCRE32_MODE ? "32" : pcre_mode == PCRE16_MODE ? "16" : "", 362865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_INFO_OPTIONS); 362965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Running in %d-bit mode but pattern was compiled in " 363065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "%d-bit mode\n", 8 * CHAR_SIZE, 8 * (flags_in_host_byte_order & PCRE_MODE_MASK)); 363165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free(re); 363265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 363365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 363465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 363565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 363665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 363765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Need to know if UTF-8 for printing data strings. */ 363865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 363965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0) 364065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 364165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free(re); 364265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 364365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 364465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 364565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_utf = (get_options & PCRE_UTF8) != 0; 364665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 364765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 364865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SHOW_INFO; 364965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 365065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 365165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* In-line pattern (the usual case). Get the delimiter and seek the end of 365265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the pattern; if it isn't complete, read more. */ 365365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 365465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich delimiter = *p++; 365565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 365665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (isalnum(delimiter) || delimiter == '\\') 365765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 365865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n"); 365965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 366065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 366165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 366265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp = p; 366365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich poffset = (int)(p - buffer); 366465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 366565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for(;;) 366665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 366765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*pp != 0) 366865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 366965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pp == '\\' && pp[1] != 0) pp++; 367065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*pp == delimiter) break; 367165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp++; 367265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 367365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pp != 0) break; 367465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((pp = extend_inputline(infile, pp, " > ")) == NULL) 367565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 367665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Unexpected EOF\n"); 367765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich done = 1; 367865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto CONTINUE; 367965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 368065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (infile != stdin) fprintf(outfile, "%s", (char *)pp); 368165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 368265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 368365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The buffer may have moved while being extended; reset the start of data 368465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pointer to the correct relative point in the buffer. */ 368565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 368665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = buffer + poffset; 368765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 368865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If the first character after the delimiter is backslash, make 368965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the pattern end with backslash. This is purely to provide a way 369065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich of testing for the error message when a pattern ends with backslash. */ 369165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 369265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pp[1] == '\\') *pp++ = '\\'; 369365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 369465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Terminate the pattern at the delimiter, and save a copy of the pattern 369565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for callouts. */ 369665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 369765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp++ = 0; 369865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich strcpy((char *)pbuffer, (char *)p); 369965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 370065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Look for modifiers and options after the final delimiter. */ 370165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 370265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options = default_options; 370365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study_options = force_study_options; 370465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich log_store = showstore; /* default from command line */ 370565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 370665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*pp != 0) 370765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 370865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Check to see whether this modifier has been locked out for this file. 370965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich This is complicated for the multi-character options that begin with '<'. 371065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich If there is no '>' in the lockout string, all multi-character modifiers are 371165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich locked out. */ 371265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 371365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (strchr((char *)lockout, *pp) != NULL) 371465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 371565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pp == '<' && strchr((char *)lockout, '>') != NULL) 371665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 371765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int x = check_mc_option(pp+1, outfile, FALSE, "modifier"); 371865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (x == 0) goto SKIP_DATA; 371965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 372065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (ppp = lockout; *ppp != 0; ppp++) 372165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 372265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*ppp == '<') 372365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 372465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int y = check_mc_option(ppp+1, outfile, FALSE, "modifier"); 372565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (y == 0) 372665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 372765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Error in modifier forbid data - giving up.\n"); 372865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 372965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 373065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 373165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (x == y) 373265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 373365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ppp = pp; 373465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*ppp != '>') ppp++; 373565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** The %.*s modifier is locked out - giving up.\n", 373665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (int)(ppp - pp + 1), pp); 373765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 373865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 373965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 374065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 374165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 374265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 374365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 374465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The single-character modifiers are straightforward. */ 374565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 374665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 374765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 374865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** The /%c modifier is locked out - giving up.\n", *pp); 374965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 375065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 375165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 375265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 375365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 375465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The modifier is not locked out; handle it. */ 375565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 375665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (*pp++) 375765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 375865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'f': options |= PCRE_FIRSTLINE; break; 375965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'g': do_g = 1; break; 376065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'i': options |= PCRE_CASELESS; break; 376165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'm': options |= PCRE_MULTILINE; break; 376265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 's': options |= PCRE_DOTALL; break; 376365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'x': options |= PCRE_EXTENDED; break; 376465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 376565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '+': 376665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_showrest) do_showcaprest = 1; else do_showrest = 1; 376765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 376865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 376965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '=': do_allcaps = 1; break; 377065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'A': options |= PCRE_ANCHORED; break; 377165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'B': do_debug = 1; break; 377265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'C': options |= PCRE_AUTO_CALLOUT; break; 377365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'D': do_debug = do_showinfo = 1; break; 377465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'E': options |= PCRE_DOLLAR_ENDONLY; break; 377565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'F': do_flip = 1; break; 377665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'G': do_G = 1; break; 377765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'I': do_showinfo = 1; break; 377865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'J': options |= PCRE_DUPNAMES; break; 377965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'K': do_mark = 1; break; 378065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'M': log_store = 1; break; 378165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'N': options |= PCRE_NO_AUTO_CAPTURE; break; 378265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'O': options |= PCRE_NO_AUTO_POSSESS; break; 378365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 378465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 378565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'P': do_posix = 1; break; 378665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 378765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 378865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Q': 378965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (*pp) 379065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 379165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '0': 379265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '1': 379365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich stack_guard_return = *pp++ - '0'; 379465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 379565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 379665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 379765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Missing 0 or 1 after /Q\n"); 379865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 379965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 380065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_STACK_GUARD(stack_guard); 380165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 380265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 380365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'S': 380465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_study = 1; 380565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 380665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 380765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (*pp++) 380865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 380965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'S': 381065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_study = 0; 381165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich no_force_study = 1; 381265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 381365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 381465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '!': 381565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study_options |= PCRE_STUDY_EXTRA_NEEDED; 381665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 381765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 381865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '+': 381965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pp == '+') 382065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 382165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich verify_jit = TRUE; 382265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp++; 382365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 382465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pp >= '1' && *pp <= '7') 382565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study_options |= jit_study_bits[*pp++ - '1']; 382665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 382765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study_options |= jit_study_bits[6]; 382865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 382965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 383065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '-': 383165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich study_options &= ~PCRE_STUDY_ALLJIT; 383265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 383365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 383465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 383565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp--; 383665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto ENDLOOP; 383765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 383865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 383965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ENDLOOP: 384065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 384165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 384265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'U': options |= PCRE_UNGREEDY; break; 384365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'W': options |= PCRE_UCP; break; 384465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'X': options |= PCRE_EXTRA; break; 384565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Y': options |= PCRE_NO_START_OPTIMISE; break; 384665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Z': debug_lengths = 0; break; 384765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '8': options |= PCRE_UTF8; use_utf = 1; break; 384865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '9': options |= PCRE_NEVER_UTF; break; 384965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '?': options |= PCRE_NO_UTF8_CHECK; break; 385065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 385165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'T': 385265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (*pp++) 385365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 385465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '0': tables = tables0; break; 385565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '1': tables = tables1; break; 385665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 385765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '\r': 385865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '\n': 385965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case ' ': 386065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 0: 386165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Missing table number after /T\n"); 386265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 386365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 386465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 386565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]); 386665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 386765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 386865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 386965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 387065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'L': 387165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ppp = pp; 387265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The '\r' test here is so that it works on Windows. */ 387365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The '0' test is just in case this is an unterminated line. */ 387465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*ppp != 0 && *ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++; 387565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *ppp = 0; 387665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (setlocale(LC_CTYPE, (const char *)pp) == NULL) 387765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 387865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Failed to set locale \"%s\"\n", pp); 387965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 388065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 388165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich locale_set = 1; 388265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich tables = PCRE_MAKETABLES; 388365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pp = ppp; 388465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 388565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 388665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '>': 388765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich to_file = pp; 388865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*pp != 0) pp++; 388965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(pp[-1])) pp--; 389065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *pp = 0; 389165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 389265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 389365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '<': 389465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 389565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int x = check_mc_option(pp, outfile, FALSE, "modifier"); 389665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (x == 0) goto SKIP_DATA; 389765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= x; 389865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*pp++ != '>'); 389965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 390065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 390165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 390265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '\r': /* So that it works in Windows */ 390365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '\n': 390465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case ' ': 390565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 390665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 390765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 390865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Unknown modifier '%c'\n", pp[-1]); 390965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 391065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 391165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 391265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 391365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle compiling via the POSIX interface, which doesn't support the 391465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich timing, showing, or debugging options, nor the ability to pass over 391565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich local character tables. Neither does it have 16-bit support. */ 391665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 391765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 391865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (posix || do_posix) 391965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 392065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 392165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int cflags = 0; 392265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 392365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE; 392465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE; 392565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL; 392665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_NO_AUTO_CAPTURE) != 0) cflags |= REG_NOSUB; 392765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_UTF8) != 0) cflags |= REG_UTF8; 392865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_UCP) != 0) cflags |= REG_UCP; 392965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY; 393065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 393165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = regcomp(&preg, (char *)p, cflags); 393265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 393365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Compilation failed; go back for another re, skipping to blank line 393465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if non-interactive. */ 393565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 393665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc != 0) 393765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 393865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)regerror(rc, &preg, (char *)buffer, buffer_size); 393965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Failed: POSIX code %d: %s\n", rc, buffer); 394065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 394165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 394265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 394365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 394465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle compiling via the native interface */ 394565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 394665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 394765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* !defined NOPOSIX */ 394865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 394965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 395065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* In 16- or 32-bit mode, convert the input. */ 395165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 395265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 395365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 395465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 395565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch(to16(FALSE, p, options & PCRE_UTF8, (int)strlen((char *)p))) 395665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 395765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -1: 395865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: invalid UTF-8 string cannot be " 395965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "converted to UTF-16\n"); 396065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 396165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 396265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -2: 396365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: character value greater than 0x10ffff " 396465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "cannot be converted to UTF-16\n"); 396565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 396665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 396765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -3: /* "Impossible error" when to16 is called arg1 FALSE */ 396865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: character value greater than 0xffff " 396965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "cannot be converted to 16-bit in non-UTF mode\n"); 397065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 397165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 397265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 397365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 397465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 397565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = (pcre_uint8 *)buffer16; 397665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 397765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 397865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 397965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 398065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 398165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 398265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch(to32(FALSE, p, options & PCRE_UTF32, (int)strlen((char *)p))) 398365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 398465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -1: 398565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: invalid UTF-8 string cannot be " 398665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "converted to UTF-32\n"); 398765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 398865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 398965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -2: 399065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: character value greater than 0x10ffff " 399165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "cannot be converted to UTF-32\n"); 399265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 399365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 399465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case -3: 399565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: character value is ill-formed UTF-32\n"); 399665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 399765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 399865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 399965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 400065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 400165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = (pcre_uint8 *)buffer32; 400265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 400365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 400465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 400565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Compile many times when timing */ 400665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 400765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (timeit > 0) 400865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 400965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich register int i; 401065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t time_taken; 401165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t start_time = clock(); 401265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < timeit; i++) 401365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 401465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COMPILE(re, p, options, &error, &erroroffset, tables); 401565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (re != NULL) free(re); 401665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 401765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich total_compile_time += (time_taken = clock() - start_time); 401865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Compile time %.4f milliseconds\n", 401965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)time_taken * 1000.0) / (double)timeit) / 402065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 402165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 402265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 402365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COMPILE(re, p, options, &error, &erroroffset, tables); 402465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 402565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Compilation failed; go back for another re, skipping to blank line 402665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if non-interactive. */ 402765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 402865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (re == NULL) 402965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 403065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Failed: %s at offset %d\n", error, erroroffset); 403165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SKIP_DATA: 403265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (infile != stdin) 403365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 403465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 403565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 403665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extend_inputline(infile, buffer, NULL) == NULL) 403765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 403865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich done = 1; 403965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto CONTINUE; 404065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 404165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = (int)strlen((char *)buffer); 404265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len > 0 && isspace(buffer[len-1])) len--; 404365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (len == 0) break; 404465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 404565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 404665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 404765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto CONTINUE; 404865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 404965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 405065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Compilation succeeded. It is now possible to set the UTF-8 option from 405165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich within the regex; check for this so that we know how to process the data 405265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich lines. */ 405365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 405465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options) < 0) 405565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 405665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((get_options & PCRE_UTF8) != 0) use_utf = 1; 405765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 405865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Extract the size for possible writing before possibly flipping it, 405965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich and remember the store that was got. */ 406065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 406165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich true_size = REAL_PCRE_SIZE(re); 406265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 406365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Output code size information if requested */ 406465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 406565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (log_store) 406665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 406765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int name_count, name_entry_size, real_pcre_size; 406865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 406965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_NAMECOUNT, &name_count); 407065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size); 407165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich real_pcre_size = 0; 407265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 407365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_FLAGS(re) & PCRE_MODE8) 407465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich real_pcre_size = sizeof(real_pcre); 407565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 407665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 407765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_FLAGS(re) & PCRE_MODE16) 407865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich real_pcre_size = sizeof(real_pcre16); 407965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 408065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 408165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (REAL_PCRE_FLAGS(re) & PCRE_MODE32) 408265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich real_pcre_size = sizeof(real_pcre32); 408365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 408465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_SIZE, &size); 408565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Memory allocation (code space): %d\n", 408665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (int)(size - real_pcre_size - name_count * name_entry_size)); 408765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 408865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 408965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If -s or /S was present, study the regex to generate additional info to 409065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich help with the matching, unless the pattern has the SS option, which 409165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich suppresses the effect of /S (used for a few test patterns where studying is 409265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich never sensible). */ 409365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 409465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_study || (force_study >= 0 && !no_force_study)) 409565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 409665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (timeit > 0) 409765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 409865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich register int i; 409965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t time_taken; 410065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t start_time = clock(); 410165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < timeit; i++) 410265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 410365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY(extra, re, study_options, &error); 410465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 410565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich total_study_time = (time_taken = clock() - start_time); 410665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) 410765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 410865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY(extra); 410965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 411065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " Study time %.4f milliseconds\n", 411165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)time_taken * 1000.0) / (double)timeit) / 411265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 411365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 411465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_STUDY(extra, re, study_options, &error); 411565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (error != NULL) 411665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Failed to study: %s\n", error); 411765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (extra != NULL) 411865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 411965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich true_study_size = ((pcre_study_data *)(extra->study_data))->size; 412065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (log_store) 412165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 412265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_t jitsize; 412365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, extra, PCRE_INFO_JITSIZE, &jitsize) == 0 && 412465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich jitsize != 0) 412565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Memory allocation (JIT code): %d\n", (int)jitsize); 412665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 412765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 412865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 412965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 413065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If /K was present, we set up for handling MARK data. */ 413165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 413265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_mark) 413365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 413465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra == NULL) 413565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 413665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 413765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = 0; 413865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 413965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->mark = &markptr; 414065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags |= PCRE_EXTRA_MARK; 414165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 414265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 414365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Extract and display information from the compiled data if required. */ 414465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 414565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SHOW_INFO: 414665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 414765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_debug) 414865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 414965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "------------------------------------------------------------------\n"); 415065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PRINTINT(re, outfile, debug_lengths); 415165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 415265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 415365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* We already have the options in get_options (see above) */ 415465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 415565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_showinfo) 415665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 415765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unsigned long int all_options; 415865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 first_char, need_char; 415965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 match_limit, recursion_limit; 416065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int count, backrefmax, first_char_set, need_char_set, okpartial, jchanged, 416165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich hascrorlf, maxlookbehind, match_empty; 416265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int nameentrysize, namecount; 416365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const pcre_uint8 *nametable; 416465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 416565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count) + 416665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax) + 416765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_FIRSTCHARACTER, &first_char) + 416865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_FIRSTCHARACTERFLAGS, &first_char_set) + 416965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_REQUIREDCHAR, &need_char) + 417065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_REQUIREDCHARFLAGS, &need_char_set) + 417165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize) + 417265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount) + 417365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable) + 417465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_OKPARTIAL, &okpartial) + 417565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_JCHANGED, &jchanged) + 417665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_HASCRORLF, &hascrorlf) + 417765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_MATCH_EMPTY, &match_empty) + 417865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_info(re, NULL, PCRE_INFO_MAXLOOKBEHIND, &maxlookbehind) 417965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich != 0) 418065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 418165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 418265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Capturing subpattern count = %d\n", count); 418365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 418465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (backrefmax > 0) 418565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Max back reference = %d\n", backrefmax); 418665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 418765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (maxlookbehind > 0) 418865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Max lookbehind = %d\n", maxlookbehind); 418965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 419065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_MATCHLIMIT, &match_limit) == 0) 419165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Match limit = %u\n", match_limit); 419265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 419365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_RECURSIONLIMIT, &recursion_limit) == 0) 419465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Recursion limit = %u\n", recursion_limit); 419565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 419665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (namecount > 0) 419765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 419865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Named capturing subpatterns:\n"); 419965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (namecount-- > 0) 420065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 420165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int imm2_size = pcre_mode == PCRE8_MODE ? 2 : 1; 420265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int length = (int)STRLEN(nametable + imm2_size); 420365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " "); 420465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(nametable, imm2_size, length, outfile); 420565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (length++ < nameentrysize - imm2_size) putc(' ', outfile); 420665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 420765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 420865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR32)nametable)[0])); 420965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 421065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 421165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 421265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%3d\n", (int)(((PCRE_SPTR16)nametable)[0])); 421365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 421465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 421565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 421665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%3d\n", ((int)nametable[0] << 8) | (int)nametable[1]); 421765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 421865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich nametable += nameentrysize * CHAR_SIZE; 421965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 422065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 422165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 422265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (!okpartial) fprintf(outfile, "Partial matching not supported\n"); 422365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (hascrorlf) fprintf(outfile, "Contains explicit CR or LF match\n"); 422465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (match_empty) fprintf(outfile, "May match empty string\n"); 422565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 422665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich all_options = REAL_PCRE_OPTIONS(re); 422765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_flip) all_options = swap_uint32(all_options); 422865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 422965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (get_options == 0) fprintf(outfile, "No options\n"); 423065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 423165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "", 423265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_CASELESS) != 0)? " caseless" : "", 423365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_EXTENDED) != 0)? " extended" : "", 423465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "", 423565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "", 423665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_DOTALL) != 0)? " dotall" : "", 423765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_BSR_ANYCRLF) != 0)? " bsr_anycrlf" : "", 423865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_BSR_UNICODE) != 0)? " bsr_unicode" : "", 423965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "", 424065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_EXTRA) != 0)? " extra" : "", 424165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "", 424265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_NO_AUTO_CAPTURE) != 0)? " no_auto_capture" : "", 424365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_NO_AUTO_POSSESS) != 0)? " no_auto_possessify" : "", 424465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_UTF8) != 0)? " utf" : "", 424565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_UCP) != 0)? " ucp" : "", 424665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf_check" : "", 424765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "", 424865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "", 424965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((get_options & PCRE_NEVER_UTF) != 0)? " never_utf" : ""); 425065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 425165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (jchanged) fprintf(outfile, "Duplicate name status changes\n"); 425265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 425365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch (get_options & PCRE_NEWLINE_BITS) 425465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 425565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_NEWLINE_CR: 425665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Forced newline sequence: CR\n"); 425765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 425865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 425965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_NEWLINE_LF: 426065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Forced newline sequence: LF\n"); 426165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 426265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 426365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_NEWLINE_CRLF: 426465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Forced newline sequence: CRLF\n"); 426565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 426665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 426765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_NEWLINE_ANYCRLF: 426865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Forced newline sequence: ANYCRLF\n"); 426965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 427065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 427165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_NEWLINE_ANY: 427265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Forced newline sequence: ANY\n"); 427365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 427465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 427565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 427665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 427765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 427865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 427965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (first_char_set == 2) 428065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 428165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "First char at start or follows newline\n"); 428265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 428365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (first_char_set == 1) 428465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 428565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *caseless = 428665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((REAL_PCRE_FLAGS(re) & PCRE_FCH_CASELESS) == 0)? 428765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "" : " (caseless)"; 428865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 428965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (PRINTOK(first_char)) 429065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "First char = \'%c\'%s\n", first_char, caseless); 429165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 429265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 429365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "First char = "); 429465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pchar(first_char, outfile); 429565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%s\n", caseless); 429665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 429765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 429865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 429965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 430065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No first char\n"); 430165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 430265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 430365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (need_char_set == 0) 430465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 430565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No need char\n"); 430665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 430765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 430865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 430965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *caseless = 431065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((REAL_PCRE_FLAGS(re) & PCRE_RCH_CASELESS) == 0)? 431165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "" : " (caseless)"; 431265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 431365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (PRINTOK(need_char)) 431465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Need char = \'%c\'%s\n", need_char, caseless); 431565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 431665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 431765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Need char = "); 431865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pchar(need_char, outfile); 431965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%s\n", caseless); 432065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 432165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 432265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 432365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Don't output study size; at present it is in any case a fixed 432465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich value, but it varies, depending on the computer architecture, and 432565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich so messes up the test suite. (And with the /F option, it might be 432665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich flipped.) If study was forced by an external -s, don't show this 432765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich information unless -i or -d was also present. This means that, except 432865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich when auto-callouts are involved, the output from runs with and without 432965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich -s should be identical. */ 433065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 433165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_study || (force_study >= 0 && showinfo && !no_force_study)) 433265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 433365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra == NULL) 433465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Study returned NULL\n"); 433565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 433665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 433765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *start_bits = NULL; 433865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int minlength; 433965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 434065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, extra, PCRE_INFO_MINLENGTH, &minlength) == 0) 434165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Subject length lower bound = %d\n", minlength); 434265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 434365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits) == 0) 434465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 434565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (start_bits == NULL) 434665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No starting char list\n"); 434765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 434865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 434965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int i; 435065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int c = 24; 435165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Starting chars: "); 435265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < 256; i++) 435365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 435465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((start_bits[i/8] & (1<<(i&7))) != 0) 435565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 435665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 75) 435765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 435865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n "); 435965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = 2; 436065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 436165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (PRINTOK(i) && i != ' ') 436265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 436365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%c ", i); 436465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c += 2; 436565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 436665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 436765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 436865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\\x%02x ", i); 436965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c += 5; 437065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 437465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 437765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 437865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Show this only if the JIT was set by /S, not by -s. */ 437965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 438065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((study_options & PCRE_STUDY_ALLJIT) != 0 && 438165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (force_study_options & PCRE_STUDY_ALLJIT) == 0) 438265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 438365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int jit; 438465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, extra, PCRE_INFO_JIT, &jit) == 0) 438565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 438665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (jit) 438765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "JIT study was successful\n"); 438865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 438965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_JIT 439065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "JIT study was not successful\n"); 439165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 439265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "JIT support is not available in this version of PCRE\n"); 439365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 439465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 439565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 439665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 439765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 439865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 439965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If the '>' option was present, we write out the regex to a file, and 440065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich that is all. The first 8 bytes of the file are the regex length and then 440165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the study length, in big-endian order. */ 440265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 440365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (to_file != NULL) 440465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 440565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich FILE *f = fopen((char *)to_file, "wb"); 440665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (f == NULL) 440765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 440865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Unable to open %s: %s\n", to_file, strerror(errno)); 440965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 441065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 441165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 441265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 sbuf[8]; 441365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 441465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_flip) regexflip(re, extra); 441565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[0] = (pcre_uint8)((true_size >> 24) & 255); 441665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[1] = (pcre_uint8)((true_size >> 16) & 255); 441765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[2] = (pcre_uint8)((true_size >> 8) & 255); 441865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[3] = (pcre_uint8)((true_size) & 255); 441965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[4] = (pcre_uint8)((true_study_size >> 24) & 255); 442065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[5] = (pcre_uint8)((true_study_size >> 16) & 255); 442165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[6] = (pcre_uint8)((true_study_size >> 8) & 255); 442265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich sbuf[7] = (pcre_uint8)((true_study_size) & 255); 442365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 442465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fwrite(sbuf, 1, 8, f) < 8 || 442565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fwrite(re, 1, true_size, f) < true_size) 442665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 442765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Write error on %s: %s\n", to_file, strerror(errno)); 442865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 442965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 443065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 443165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Compiled pattern written to %s\n", to_file); 443265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 443365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If there is study data, write it. */ 443465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 443565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) 443665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 443765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (fwrite(extra->study_data, 1, true_study_size, f) < 443865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich true_study_size) 443965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 444065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Write error on %s: %s\n", to_file, 444165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich strerror(errno)); 444265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 444365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else fprintf(outfile, "Study data written to %s\n", to_file); 444465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 444565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 444665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fclose(f); 444765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 444865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 444965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free(re); 445065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) 445165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 445265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY(extra); 445365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 445465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (locale_set) 445565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 445665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free((void *)tables); 445765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich setlocale(LC_CTYPE, "C"); 445865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich locale_set = 0; 445965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 446065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; /* With next regex */ 446165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 446265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } /* End of non-POSIX compile */ 446365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 446465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Read data lines and test them */ 446565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 446665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 446765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 446865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 446965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *q8; 447065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 447165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 447265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint16 *q16; 447365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 447465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 447565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 *q32; 447665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 447765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *bptr; 447865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int *use_offsets = offsets; 447965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int use_size_offsets = size_offsets; 448065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int callout_data = 0; 448165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int callout_data_set = 0; 448265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int count; 448365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 c; 448465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int copystrings = 0; 448565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int find_match_limit = default_find_match_limit; 448665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int getstrings = 0; 448765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int getlist = 0; 448865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int gmatched = 0; 448965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int start_offset = 0; 449065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int start_offset_sign = 1; 449165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int g_notempty = 0; 449265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int use_dfa = 0; 449365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 449465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *copynames = 0; 449565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *getnames = 0; 449665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 449765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 449865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cn32ptr = copynames; 449965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gn32ptr = getnames; 450065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 450165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 450265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cn16ptr = copynames16; 450365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gn16ptr = getnames16; 450465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 450565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 450665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cn8ptr = copynames8; 450765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gn8ptr = getnames8; 450865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 450965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 451065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_CALLOUT(callout); 451165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich first_callout = 1; 451265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich last_callout_mark = NULL; 451365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_extra = 0; 451465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_count = 0; 451565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_count = 999999; 451665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_id = -1; 451765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich show_malloc = 0; 451865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options = 0; 451965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 452065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) extra->flags &= 452165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ~(PCRE_EXTRA_MATCH_LIMIT|PCRE_EXTRA_MATCH_LIMIT_RECURSION); 452265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 452365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = 0; 452465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 452565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 452665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extend_inputline(infile, buffer + len, "data> ") == NULL) 452765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 452865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (len > 0) /* Reached EOF without hitting a newline */ 452965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 453065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 453165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 453265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 453365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich done = 1; 453465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto CONTINUE; 453565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 453665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); 453765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = (int)strlen((char *)buffer); 453865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (buffer[len-1] == '\n') break; 453965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 454065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 454165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (len > 0 && isspace(buffer[len-1])) len--; 454265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich buffer[len] = 0; 454365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (len == 0) break; 454465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 454565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = buffer; 454665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (isspace(*p)) p++; 454765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 454865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef NOUTF 454965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Check that the data is well-formed UTF-8 if we're in UTF mode. To create 455065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich invalid input to pcre_exec, you must use \x?? or \x{} sequences. */ 455165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 455265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf) 455365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 455465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *q; 455565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint32 cc; 455665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int n = 1; 455765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 455865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (q = p; n > 0 && *q; q += n) n = utf82ord(q, &cc); 455965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (n <= 0) 456065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 456165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "**Failed: invalid UTF-8 string cannot be used as input in UTF mode\n"); 456265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto NEXT_DATA; 456365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 456465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 456565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 456665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 456765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_VALGRIND 456865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Mark the dbuffer as addressable but undefined again. */ 456965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 457065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dbuffer != NULL) 457165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 457265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich VALGRIND_MAKE_MEM_UNDEFINED(dbuffer, dbuffer_size * CHAR_SIZE); 457365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 457465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 457565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 457665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Allocate a buffer to hold the data line; len+1 is an upper bound on 457765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the number of pcre_uchar units that will be needed. */ 457865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 457965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (dbuffer == NULL || (size_t)len >= dbuffer_size) 458065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 458165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dbuffer_size *= 2; 458265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dbuffer = (pcre_uint8 *)realloc(dbuffer, dbuffer_size * CHAR_SIZE); 458365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dbuffer == NULL) 458465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 458565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(stderr, "pcretest: realloc(%d) failed\n", (int)dbuffer_size); 458665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich exit(1); 458765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 458865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 458965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 459065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 459165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich q8 = (pcre_uint8 *) dbuffer; 459265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 459365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 459465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich q16 = (pcre_uint16 *) dbuffer; 459565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 459665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 459765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich q32 = (pcre_uint32 *) dbuffer; 459865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 459965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 460065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while ((c = *p++) != 0) 460165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 460265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int i = 0; 460365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int n = 0; 460465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 460565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* In UTF mode, input can be UTF-8, so just copy all non-backslash bytes. 460665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich In non-UTF mode, allow the value of the byte to fall through to later, 460765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich where values greater than 127 are turned into UTF-8 when running in 460865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 16-bit or 32-bit mode. */ 460965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 461065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c != '\\') 461165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 461265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef NOUTF 461365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf && HASUTF8EXTRALEN(c)) { GETUTF8INC(c, p); } 461465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 461565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 461665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 461765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle backslash escapes */ 461865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 461965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else switch ((c = *p++)) 462065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 462165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'a': c = 7; break; 462265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'b': c = '\b'; break; 462365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'e': c = 27; break; 462465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'f': c = '\f'; break; 462565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'n': c = '\n'; break; 462665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'r': c = '\r'; break; 462765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 't': c = '\t'; break; 462865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'v': c = '\v'; break; 462965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 463065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '0': case '1': case '2': case '3': 463165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '4': case '5': case '6': case '7': 463265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c -= '0'; 463365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9') 463465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = c * 8 + *p++ - '0'; 463565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 463665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 463765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'o': 463865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '{') 463965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 464065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *pt = p; 464165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = 0; 464265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (pt++; isdigit(*pt) && *pt != '8' && *pt != '9'; pt++) 464365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 464465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (++i == 12) 464565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Too many octal digits in \\o{...} item; " 464665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "using only the first twelve.\n"); 464765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else c = c * 8 + *pt - '0'; 464865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 464965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pt == '}') p = pt + 1; 465065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else fprintf(outfile, "** Missing } after \\o{ (assumed)\n"); 465165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 465265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 465365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 465465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'x': 465565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '{') 465665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 465765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_uint8 *pt = p; 465865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = 0; 465965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 466065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* We used to have "while (isxdigit(*(++pt)))" here, but it fails 466165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich when isxdigit() is a macro that refers to its argument more than 466265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich once. This is banned by the C Standard, but apparently happens in at 466365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich least one MacOS environment. */ 466465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 466565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (pt++; isxdigit(*pt); pt++) 466665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 466765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (++i == 9) 466865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Too many hex digits in \\x{...} item; " 466965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "using only the first eight.\n"); 467065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'a' - 10); 467165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 467265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*pt == '}') 467365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 467465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p = pt + 1; 467565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 467665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 467765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Not correct form for \x{...}; fall through */ 467865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 467965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 468065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* \x without {} always defines just one byte in 8-bit mode. This 468165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich allows UTF-8 characters to be constructed byte by byte, and also allows 468265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich invalid UTF-8 sequences to be made. Just copy the byte in UTF mode. 468365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich Otherwise, pass it down to later code so that it can be turned into 468465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich UTF-8 when running in 16/32-bit mode. */ 468565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 468665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = 0; 468765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (i++ < 2 && isxdigit(*p)) 468865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 468965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'a' - 10); 469065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 469165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 469265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOUTF && defined SUPPORT_PCRE8 469365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf && (pcre_mode == PCRE8_MODE)) 469465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 469565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q8++ = c; 469665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 469765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 469865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 469965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 470065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 470165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 0: /* \ followed by EOF allows for an empty line */ 470265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p--; 470365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 470465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 470565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '>': 470665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '-') 470765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 470865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start_offset_sign = -1; 470965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 471065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 471165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0'; 471265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start_offset *= start_offset_sign; 471365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 471465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 471565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'A': /* Option setting */ 471665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_ANCHORED; 471765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 471865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 471965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'B': 472065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_NOTBOL; 472165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 472265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 472365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'C': 472465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (isdigit(*p)) /* Set copy string */ 472565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 472665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 472765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich copystrings |= 1 << n; 472865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 472965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (isalnum(*p)) 473065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 473165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich READ_CAPTURE_NAME(p, &cn8ptr, &cn16ptr, &cn32ptr, re); 473265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 473365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*p == '+') 473465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 473565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_extra = 1; 473665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 473765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 473865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*p == '-') 473965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 474065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich SET_PCRE_CALLOUT(NULL); 474165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 474265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 474365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*p == '!') 474465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 474565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_id = 0; 474665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 474765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) 474865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_id = callout_fail_id * 10 + *p++ - '0'; 474965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_count = 0; 475065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*p == '!') 475165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 475265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich p++; 475365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) 475465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_fail_count = callout_fail_count * 10 + *p++ - '0'; 475565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 475665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 475765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (*p == '*') 475865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 475965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int sign = 1; 476065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_data = 0; 476165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(++p) == '-') { sign = -1; p++; } 476265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) 476365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_data = callout_data * 10 + *p++ - '0'; 476465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_data *= sign; 476565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich callout_data_set = 1; 476665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 476765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 476865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 476965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 477065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'D': 477165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 477265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (posix || do_posix) 477365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Can't use dfa matching in POSIX mode: \\D ignored\n"); 477465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 477565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 477665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_dfa = 1; 477765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 477865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 477965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 478065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 478165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'F': 478265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_DFA_SHORTEST; 478365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 478465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 478565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 478665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'G': 478765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (isdigit(*p)) 478865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 478965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 479065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getstrings |= 1 << n; 479165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 479265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (isalnum(*p)) 479365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 479465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich READ_CAPTURE_NAME(p, &gn8ptr, &gn16ptr, &gn32ptr, re); 479565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 479665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 479765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 479865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'J': 479965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 480065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL 480165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 480265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich && extra->executable_jit != NULL) 480365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 480465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (jit_stack != NULL) { PCRE_JIT_STACK_FREE(jit_stack); } 480565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich jit_stack = PCRE_JIT_STACK_ALLOC(1, n * 1024); 480665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ASSIGN_JIT_STACK(extra, jit_callback, jit_stack); 480765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 480865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 480965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 481065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'L': 481165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich getlist = 1; 481265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 481365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 481465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'M': 481565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich find_match_limit = 1; 481665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 481765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 481865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'N': 481965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_NOTEMPTY) != 0) 482065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options = (options & ~PCRE_NOTEMPTY) | PCRE_NOTEMPTY_ATSTART; 482165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 482265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_NOTEMPTY; 482365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 482465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 482565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'O': 482665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 482765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (n > size_offsets_max) 482865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 482965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_offsets_max = n; 483065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(offsets); 483165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets = offsets = (int *)malloc(size_offsets_max * sizeof(int)); 483265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (offsets == NULL) 483365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 483465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("** Failed to get %d bytes of memory for offsets vector\n", 483565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (int)(size_offsets_max * sizeof(int))); 483665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = 1; 483765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto EXIT; 483865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 483965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 484065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_size_offsets = n; 484165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (n == 0) use_offsets = NULL; /* Ensures it can't write to it */ 484265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else use_offsets = offsets + size_offsets_max - n; /* To catch overruns */ 484365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 484465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 484565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'P': 484665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= ((options & PCRE_PARTIAL_SOFT) == 0)? 484765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_PARTIAL_SOFT : PCRE_PARTIAL_HARD; 484865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 484965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 485065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Q': 485165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 485265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra == NULL) 485365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 485465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 485565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = 0; 485665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 485765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION; 485865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->match_limit_recursion = n; 485965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 486065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 486165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'q': 486265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while(isdigit(*p)) n = n * 10 + *p++ - '0'; 486365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra == NULL) 486465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 486565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 486665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = 0; 486765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 486865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags |= PCRE_EXTRA_MATCH_LIMIT; 486965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->match_limit = n; 487065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 487165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 487265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 487365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'R': 487465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_DFA_RESTART; 487565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 487665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 487765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 487865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'S': 487965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich show_malloc = 1; 488065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 488165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 488265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Y': 488365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_NO_START_OPTIMIZE; 488465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 488565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 488665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case 'Z': 488765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_NOTEOL; 488865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 488965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 489065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '?': 489165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= PCRE_NO_UTF8_CHECK; 489265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 489365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 489465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case '<': 489565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 489665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int x = check_mc_option(p, outfile, TRUE, "escape sequence"); 489765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (x == 0) goto NEXT_DATA; 489865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options |= x; 489965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (*p++ != '>'); 490065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 490165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich continue; 490265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 490365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 490465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* We now have a character value in c that may be greater than 255. 490565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich In 8-bit mode we convert to UTF-8 if we are in UTF mode. Values greater 490665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich than 127 in UTF mode must have come from \x{...} or octal constructs 490765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich because values from \x.. get this far only in non-UTF mode. */ 490865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 490965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 491065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 491165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 491265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef NOUTF 491365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf) 491465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 491565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0x7fffffff) 491665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 491765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Character \\x{%x} is greater than 0x7fffffff " 491865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "and so cannot be converted to UTF-8\n", c); 491965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto NEXT_DATA; 492065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 492165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich q8 += ord2utf8(c, q8); 492265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 492365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 492465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 492565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 492665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0xffu) 492765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 492865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Character \\x{%x} is greater than 255 " 492965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "and UTF-8 mode is not enabled.\n", c); 493065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Truncation will probably give the wrong " 493165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "result.\n"); 493265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 493365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q8++ = c; 493465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 493565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 493665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 493765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 493865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 493965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 494065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifndef NOUTF 494165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_utf) 494265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 494365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0x10ffffu) 494465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 494565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Failed: character \\x{%x} is greater than " 494665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "0x10ffff and so cannot be converted to UTF-16\n", c); 494765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto NEXT_DATA; 494865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 494965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (c >= 0x10000u) 495065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 495165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich c-= 0x10000u; 495265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q16++ = 0xD800 | (c >> 10); 495365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q16++ = 0xDC00 | (c & 0x3ff); 495465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 495565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 495665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q16++ = c; 495765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 495865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 495965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 496065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 496165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (c > 0xffffu) 496265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 496365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Character \\x{%x} is greater than 0xffff " 496465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "and UTF-16 mode is not enabled.\n", c); 496565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** Truncation will probably give the wrong " 496665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "result.\n"); 496765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 496865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 496965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q16++ = c; 497065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 497165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 497265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 497365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 497465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 497565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 497665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q32++ = c; 497765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 497865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 497965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 498065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 498165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 498265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Reached end of subject string */ 498365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 498465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 498565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 498665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 498765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q8 = 0; 498865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = (int)(q8 - (pcre_uint8 *)dbuffer); 498965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 499065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 499165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 499265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 499365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 499465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q16 = 0; 499565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = (int)(q16 - (pcre_uint16 *)dbuffer); 499665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 499765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 499865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 499965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 500065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 500165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich *q32 = 0; 500265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len = (int)(q32 - (pcre_uint32 *)dbuffer); 500365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 500465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 500565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 500665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If we're compiling with explicit valgrind support, Mark the data from after 500765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich its end to the end of the buffer as unaddressable, so that a read over the end 500865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich of the buffer will be seen by valgrind, even if it doesn't cause a crash. 500965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich If we're not building with valgrind support, at least move the data to the end 501065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich of the buffer so that it might at least cause a crash. 501165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich If we are using the POSIX interface, we must include the terminating zero. */ 501265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 501365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr = dbuffer; 501465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 501565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 501665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (posix || do_posix) 501765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 501865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_VALGRIND 501965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich VALGRIND_MAKE_MEM_NOACCESS(dbuffer + len + 1, dbuffer_size - (len + 1)); 502065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 502165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich memmove(bptr + dbuffer_size - len - 1, bptr, len + 1); 502265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr += dbuffer_size - len - 1; 502365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 502465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 502565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 502665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 502765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 502865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_VALGRIND 502965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich VALGRIND_MAKE_MEM_NOACCESS(dbuffer + len * CHAR_SIZE, (dbuffer_size - len) * CHAR_SIZE); 503065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#else 503165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr = memmove(bptr + (dbuffer_size - len) * CHAR_SIZE, bptr, len * CHAR_SIZE); 503265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 503365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 503465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 503565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((all_use_dfa || use_dfa) && find_match_limit) 503665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 503765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich printf("**Match limit not relevant for DFA matching: ignored\n"); 503865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich find_match_limit = 0; 503965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 504065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 504165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle matching via the POSIX interface, which does not 504265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich support timing or playing with the match limit or callout data. */ 504365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 504465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 504565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (posix || do_posix) 504665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 504765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 504865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int eflags = 0; 504965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich regmatch_t *pmatch = NULL; 505065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_size_offsets > 0) 505165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pmatch = (regmatch_t *)malloc(sizeof(regmatch_t) * use_size_offsets); 505265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL; 505365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL; 505465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_NOTEMPTY) != 0) eflags |= REG_NOTEMPTY; 505565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 505665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags); 505765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 505865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc != 0) 505965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 506065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)regerror(rc, &preg, (char *)buffer, buffer_size); 506165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No match: POSIX code %d: %s\n", rc, buffer); 506265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 506365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if ((REAL_PCRE_OPTIONS(preg.re_pcre) & PCRE_NO_AUTO_CAPTURE) != 0) 506465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 506565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Matched with REG_NOSUB\n"); 506665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 506765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 506865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 506965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich size_t i; 507065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < (size_t)use_size_offsets; i++) 507165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 507265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pmatch[i].rm_so >= 0) 507365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 507465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2d: ", (int)i); 507565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(dbuffer, pmatch[i].rm_so, 507665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pmatch[i].rm_eo - pmatch[i].rm_so, outfile); 507765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 507865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_showcaprest || (i == 0 && do_showrest)) 507965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 508065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2d+ ", (int)i); 508165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(dbuffer, pmatch[i].rm_eo, len - pmatch[i].rm_eo, 508265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich outfile); 508365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 508465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 508565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 508665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 508765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 508865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(pmatch); 508965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto NEXT_DATA; 509065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 509165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 509265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif /* !defined NOPOSIX */ 509365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 509465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Handle matching via the native interface - repeats for /g and /G */ 509565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 509665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Ensure that there is a JIT callback if we want to verify that JIT was 509765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich actually used. If jit_stack == NULL, no stack has yet been assigned. */ 509865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 509965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (verify_jit && jit_stack == NULL && extra != NULL) 510065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { PCRE_ASSIGN_JIT_STACK(extra, jit_callback, jit_stack); } 510165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 510265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;; gmatched++) /* Loop for /g or /G */ 510365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 510465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich markptr = NULL; 510565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich jit_was_used = FALSE; 510665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 510765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (timeitm > 0) 510865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 510965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich register int i; 511065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t time_taken; 511165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich clock_t start_time = clock(); 511265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 511365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 511465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (all_use_dfa || use_dfa) 511565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 511665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((options & PCRE_DFA_RESTART) != 0) 511765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 511865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Timing DFA restarts is not supported\n"); 511965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 512065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 512165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dfa_workspace == NULL) 512265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dfa_workspace = (int *)malloc(DFA_WS_DIMENSION*sizeof(int)); 512365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < timeitm; i++) 512465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 512565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, 512665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (options | g_notempty), use_offsets, use_size_offsets, 512765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dfa_workspace, DFA_WS_DIMENSION); 512865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 512965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 513065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 513165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 513265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 513365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < timeitm; i++) 513465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 513565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC(count, re, extra, bptr, len, start_offset, 513665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (options | g_notempty), use_offsets, use_size_offsets); 513765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 513865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich total_match_time += (time_taken = clock() - start_time); 513965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Execute time %.4f milliseconds\n", 514065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)time_taken * 1000.0) / (double)timeitm) / 514165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 514265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 514365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 514465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If find_match_limit is set, we want to do repeated matches with 514565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich varying limits in order to find the minimum value for the match limit and 514665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for the recursion limit. The match limits are relevant only to the normal 514765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich running of pcre_exec(), so disable the JIT optimization. This makes it 514865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich possible to run the same set of tests with and without JIT externally 514965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich requested. */ 515065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 515165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (find_match_limit) 515265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 515365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) { PCRE_FREE_STUDY(extra); } 515465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 515565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = 0; 515665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 515765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)check_match_limit(re, extra, bptr, len, start_offset, 515865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options|g_notempty, use_offsets, use_size_offsets, 515965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit), 516065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ERROR_MATCHLIMIT, "match()"); 516165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 516265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = check_match_limit(re, extra, bptr, len, start_offset, 516365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options|g_notempty, use_offsets, use_size_offsets, 516465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXTRA_MATCH_LIMIT_RECURSION, &(extra->match_limit_recursion), 516565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_ERROR_RECURSIONLIMIT, "match() recursion"); 516665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 516765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 516865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If callout_data is set, use the interface with additional data */ 516965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 517065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (callout_data_set) 517165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 517265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra == NULL) 517365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 517465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra = (pcre_extra *)malloc(sizeof(pcre_extra)); 517565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags = 0; 517665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 517765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags |= PCRE_EXTRA_CALLOUT_DATA; 517865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->callout_data = &callout_data; 517965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC(count, re, extra, bptr, len, start_offset, 518065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options | g_notempty, use_offsets, use_size_offsets); 518165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich extra->flags &= ~PCRE_EXTRA_CALLOUT_DATA; 518265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 518365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 518465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* The normal case is just to do the match once, with the default 518565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich value of match_limit. */ 518665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 518765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 518865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (all_use_dfa || use_dfa) 518965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 519065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dfa_workspace == NULL) 519165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dfa_workspace = (int *)malloc(DFA_WS_DIMENSION*sizeof(int)); 519265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (dfa_matched++ == 0) 519365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich dfa_workspace[0] = -1; /* To catch bad restart */ 519465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_DFA_EXEC(count, re, extra, bptr, len, start_offset, 519565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (options | g_notempty), use_offsets, use_size_offsets, dfa_workspace, 519665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich DFA_WS_DIMENSION); 519765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count == 0) 519865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 519965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Matched, but offsets vector is too small to show all matches\n"); 520065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = use_size_offsets/2; 520165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 520265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 520365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 520465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 520565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 520665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 520765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_EXEC(count, re, extra, bptr, len, start_offset, 520865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich options | g_notempty, use_offsets, use_size_offsets); 520965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count == 0) 521065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 521165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Matched, but too many substrings\n"); 521265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* 2 is a special case; match can be returned */ 521365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = (use_size_offsets == 2)? 1 : use_size_offsets/3; 521465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 521565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 521665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 521765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Matched */ 521865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 521965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count >= 0) 522065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 522165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int i, maxcount; 522265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich void *cnptr, *gnptr; 522365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 522465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 522565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (all_use_dfa || use_dfa) maxcount = use_size_offsets/2; else 522665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 522765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* 2 is a special case; match can be returned */ 522865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich maxcount = (use_size_offsets == 2)? 1 : use_size_offsets/3; 522965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 523065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* This is a check against a lunatic return value. */ 523165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 523265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count > maxcount) 523365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 523465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, 523565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "** PCRE error: returned count %d is too big for offset size %d\n", 523665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count, use_size_offsets); 523765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count = use_size_offsets/3; 523865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_g || do_G) 523965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 524065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "** /%c loop abandoned\n", do_g? 'g' : 'G'); 524165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich do_g = do_G = FALSE; /* Break g/G loop */ 524265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 524365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 524465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 524565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* do_allcaps requests showing of all captures in the pattern, to check 524665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unset ones at the end. */ 524765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 524865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_allcaps) 524965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 525065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count) < 0) 525165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich goto SKIP_DATA; 525265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich count++; /* Allow for full match */ 525365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count * 2 > use_size_offsets) count = use_size_offsets/2; 525465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 525565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 525665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Output the captured substrings. Note that, for the matched string, 525765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the use of \K in an assertion can make the start later than the end. */ 525865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 525965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < count * 2; i += 2) 526065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 526165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_offsets[i] < 0) 526265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 526365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_offsets[i] != -1) 526465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "ERROR: bad negative value %d for offset %d\n", 526565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets[i], i); 526665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_offsets[i+1] != -1) 526765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "ERROR: bad negative value %d for offset %d\n", 526865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets[i+1], i+1); 526965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2d: <unset>\n", i/2); 527065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 527165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 527265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 527365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int start = use_offsets[i]; 527465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int end = use_offsets[i+1]; 527565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 527665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (start > end) 527765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 527865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start = use_offsets[i+1]; 527965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich end = use_offsets[i]; 528065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Start of matched string is beyond its end - " 528165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "displaying from end to start.\n"); 528265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 528365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 528465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2d: ", i/2); 528565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(bptr, start, end - start, outfile); 528665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 528765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 528865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 528965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Note: don't use the start/end variables here because we want to 529065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich show the text from what is reported as the end. */ 529165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 529265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_showcaprest || (i == 0 && do_showrest)) 529365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 529465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2d+ ", i/2); 529565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(bptr, use_offsets[i+1], len - use_offsets[i+1], 529665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich outfile); 529765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 529865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 529965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 530065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 530165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 530265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (markptr != NULL) 530365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 530465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "MK: "); 530565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(markptr, 0, -1, outfile); 530665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 530765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 530865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 530965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < 32; i++) 531065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 531165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((copystrings & (1 << i)) != 0) 531265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 531365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 531465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich char copybuffer[256]; 531565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_SUBSTRING(rc, bptr, use_offsets, count, i, 531665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich copybuffer, sizeof(copybuffer)); 531765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc < 0) 531865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "copy substring %d failed %d\n", i, rc); 531965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 532065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 532165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2dC ", i); 532265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(copybuffer, 0, rc, outfile); 532365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " (%d)\n", rc); 532465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 532565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 532665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 532765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 532865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cnptr = copynames; 532965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 533065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 533165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 533265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich char copybuffer[256]; 533365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 533465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 533565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 533665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 533765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint32 *)cnptr == 0) break; 533865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 533965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 534065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 534165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 534265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 534365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint16 *)cnptr == 0) break; 534465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 534565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 534665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 534765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 534865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 534965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint8 *)cnptr == 0) break; 535065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 535165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 535265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 535365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_COPY_NAMED_SUBSTRING(rc, re, bptr, use_offsets, count, 535465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cnptr, copybuffer, sizeof(copybuffer)); 535565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 535665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc < 0) 535765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 535865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "copy substring "); 535965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(cnptr, 0, -1, outfile); 536065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " failed %d\n", rc); 536165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 536265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 536365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 536465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " C "); 536565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(copybuffer, 0, rc, outfile); 536665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " (%d) ", rc); 536765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(cnptr, 0, -1, outfile); 536865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich putc('\n', outfile); 536965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 537065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 537165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich cnptr = (char *)cnptr + (STRLEN(cnptr) + 1) * CHAR_SIZE; 537265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 537365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 537465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < 32; i++) 537565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 537665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((getstrings & (1 << i)) != 0) 537765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 537865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 537965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *substring; 538065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING(rc, bptr, use_offsets, count, i, &substring); 538165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc < 0) 538265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "get substring %d failed %d\n", i, rc); 538365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 538465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 538565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2dG ", i); 538665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(substring, 0, rc, outfile); 538765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " (%d)\n", rc); 538865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING(substring); 538965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 539065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 539165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 539265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 539365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gnptr = getnames; 539465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (;;) 539565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 539665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 539765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char *substring; 539865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 539965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 540065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE32_MODE) 540165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 540265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint32 *)gnptr == 0) break; 540365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 540465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 540565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 540665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE16_MODE) 540765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 540865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint16 *)gnptr == 0) break; 540965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 541065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 541165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 541265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (pcre_mode == PCRE8_MODE) 541365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 541465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (*(pcre_uint8 *)gnptr == 0) break; 541565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 541665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 541765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 541865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_NAMED_SUBSTRING(rc, re, bptr, use_offsets, count, 541965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gnptr, &substring); 542065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc < 0) 542165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 542265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "get substring "); 542365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(gnptr, 0, -1, outfile); 542465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " failed %d\n", rc); 542565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 542665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 542765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 542865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " G "); 542965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(substring, 0, rc, outfile); 543065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " (%d) ", rc); 543165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(gnptr, 0, -1, outfile); 543265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING(substring); 543365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich putc('\n', outfile); 543465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 543565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 543665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich gnptr = (char *)gnptr + (STRLEN(gnptr) + 1) * CHAR_SIZE; 543765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 543865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 543965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (getlist) 544065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 544165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int rc; 544265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich const char **stringlist; 544365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_GET_SUBSTRING_LIST(rc, bptr, use_offsets, count, &stringlist); 544465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (rc < 0) 544565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "get substring list failed %d\n", rc); 544665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 544765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 544865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich for (i = 0; i < count; i++) 544965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 545065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "%2dL ", i); 545165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(stringlist[i], 0, -1, outfile); 545265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich putc('\n', outfile); 545365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 545465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (stringlist[i] != NULL) 545565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "string list not terminated by NULL\n"); 545665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_SUBSTRING_LIST(stringlist); 545765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 545865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 545965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 546065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 546165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* There was a partial match. If the bumpalong point is not the same as 546265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the first inspected character, show the offset explicitly. */ 546365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 546465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (count == PCRE_ERROR_PARTIAL) 546565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 546665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Partial match"); 546765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_size_offsets > 2 && use_offsets[0] != use_offsets[2]) 546865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " at offset %d", use_offsets[2]); 546965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (markptr != NULL) 547065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 547165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, ", mark="); 547265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(markptr, 0, -1, outfile); 547365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 547465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_size_offsets > 1) 547565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 547665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, ": "); 547765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(bptr, use_offsets[0], use_offsets[1] - use_offsets[0], 547865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich outfile); 547965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 548065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 548165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 548265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; /* Out of the /g loop */ 548365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 548465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 548565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Failed to match. If this is a /g or /G loop and we previously set 548665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich g_notempty after a null match, this is not necessarily the end. We want 548765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich to advance the start offset, and continue. We won't be at the end of the 548865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich string - that was checked before setting g_notempty. 548965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 549065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich Complication arises in the case when the newline convention is "any", 549165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich "crlf", or "anycrlf". If the previous match was at the end of a line 549265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich terminated by CRLF, an advance of one character just passes the \r, 549365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich whereas we should prefer the longer newline sequence, as does the code in 549465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich pcre_exec(). Fudge the offset value to achieve this. We check for a 549565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich newline setting in the pattern; if none was set, use PCRE_CONFIG() to 549665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich find the default. 549765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 549865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich Otherwise, in the case of UTF-8 matching, the advance must be one 549965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich character, not one byte. */ 550065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 550165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 550265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 550365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (g_notempty != 0) 550465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 550565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int onechar = 1; 550665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich unsigned int obits = REAL_PCRE_OPTIONS(re); 550765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets[0] = start_offset; 550865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((obits & PCRE_NEWLINE_BITS) == 0) 550965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 551065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich int d; 551165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (void)PCRE_CONFIG(PCRE_CONFIG_NEWLINE, &d); 551265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* Note that these values are always the ASCII ones, even in 551365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich EBCDIC environments. CR = 13, NL = 10. */ 551465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich obits = (d == 13)? PCRE_NEWLINE_CR : 551565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (d == 10)? PCRE_NEWLINE_LF : 551665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (d == (13<<8 | 10))? PCRE_NEWLINE_CRLF : 551765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (d == -2)? PCRE_NEWLINE_ANYCRLF : 551865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (d == -1)? PCRE_NEWLINE_ANY : 0; 551965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 552065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY || 552165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF || 552265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF) 552365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich && 552465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich start_offset < len - 1 && ( 552565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE8 552665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == PCRE8_MODE && 552765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr[start_offset] == '\r' && 552865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr[start_offset + 1] == '\n') || 552965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 553065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 553165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == PCRE16_MODE && 553265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((PCRE_SPTR16)bptr)[start_offset] == '\r' && 553365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((PCRE_SPTR16)bptr)[start_offset + 1] == '\n') || 553465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 553565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 553665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (pcre_mode == PCRE32_MODE && 553765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((PCRE_SPTR32)bptr)[start_offset] == '\r' && 553865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich ((PCRE_SPTR32)bptr)[start_offset + 1] == '\n') || 553965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 554065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 0)) 554165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich onechar++; 554265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else if (use_utf) 554365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 554465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich while (start_offset + onechar < len) 554565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 554665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break; 554765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich onechar++; 554865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 554965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 555065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets[1] = start_offset + onechar; 555165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 555265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 555365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 555465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich switch(count) 555565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 555665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_ERROR_NOMATCH: 555765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (gmatched == 0) 555865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 555965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (markptr == NULL) 556065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 556165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No match"); 556265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 556365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 556465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 556565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "No match, mark = "); 556665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCHARSV(markptr, 0, -1, outfile); 556765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 556865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (verify_jit && jit_was_used) fprintf(outfile, " (JIT)"); 556965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich putc('\n', outfile); 557065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 557165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 557265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 557365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_ERROR_BADUTF8: 557465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_ERROR_SHORTUTF8: 557565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d (%s UTF-%d string)", count, 557665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (count == PCRE_ERROR_BADUTF8)? "bad" : "short", 557765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8 * CHAR_SIZE); 557865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_size_offsets >= 2) 557965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, " offset=%d reason=%d", use_offsets[0], 558065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich use_offsets[1]); 558165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "\n"); 558265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 558365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 558465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich case PCRE_ERROR_BADUTF8_OFFSET: 558565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d (bad UTF-%d offset)\n", count, 558665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 8 * CHAR_SIZE); 558765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 558865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 558965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich default: 559065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (count < 0 && 559165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (-count) < (int)(sizeof(errtexts)/sizeof(const char *))) 559265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]); 559365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 559465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Error %d (Unexpected value)\n", count); 559565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; 559665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 559765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 559865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich break; /* Out of the /g loop */ 559965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 560065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 560165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 560265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If not /g or /G we are done */ 560365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 560465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (!do_g && !do_G) break; 560565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 560665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* If we have matched an empty string, first check to see if we are at 560765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich the end of the subject. If so, the /g loop is over. Otherwise, mimic what 560865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich Perl's /g options does. This turns out to be rather cunning. First we set 560965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED and try the match again at the 561065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich same point. If this fails (picked up above) we advance to the next 561165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich character. */ 561265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 561365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich g_notempty = 0; 561465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 561565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_offsets[0] == use_offsets[1]) 561665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 561765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (use_offsets[0] == len) break; 561865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich g_notempty = PCRE_NOTEMPTY_ATSTART | PCRE_ANCHORED; 561965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 562065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 562165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* For /g, update the start offset, leaving the rest alone */ 562265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 562365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (do_g) start_offset = use_offsets[1]; 562465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 562565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich /* For /G, update the pointer and length */ 562665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 562765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich else 562865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 562965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich bptr += use_offsets[1] * CHAR_SIZE; 563065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich len -= use_offsets[1]; 563165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 563265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } /* End of loop for /g and /G */ 563365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 563465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich NEXT_DATA: continue; 563565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } /* End of loop for data lines */ 563665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 563765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich CONTINUE: 563865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 563965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NOPOSIX 564065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (posix || do_posix) regfree(&preg); 564165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 564265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 564365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (re != NULL) new_free(re); 564465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (extra != NULL) 564565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 564665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_FREE_STUDY(extra); 564765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 564865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (locale_set) 564965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 565065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich new_free((void *)tables); 565165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich setlocale(LC_CTYPE, "C"); 565265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich locale_set = 0; 565365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 565465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (jit_stack != NULL) 565565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 565665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich PCRE_JIT_STACK_FREE(jit_stack); 565765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich jit_stack = NULL; 565865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 565965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 566065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 566165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (infile == stdin) fprintf(outfile, "\n"); 566265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 566365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (showtotaltimes) 566465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 566565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "--------------------------------------\n"); 566665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich if (timeit > 0) 566765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich { 566865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Total compile time %.4f milliseconds\n", 566965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)total_compile_time * 1000.0) / (double)timeit) / 567065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 567165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Total study time %.4f milliseconds\n", 567265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)total_study_time * 1000.0) / (double)timeit) / 567365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 567465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 567565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich fprintf(outfile, "Total execute time %.4f milliseconds\n", 567665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (((double)total_match_time * 1000.0) / (double)timeitm) / 567765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich (double)CLOCKS_PER_SEC); 567865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich } 567965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 568065de34233da93a3d65c00b8aad3ff9aad44c57deNick KralevichEXIT: 568165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 568265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (infile != NULL && infile != stdin) fclose(infile); 568365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (outfile != NULL && outfile != stdout) fclose(outfile); 568465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 568565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(buffer); 568665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(dbuffer); 568765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(pbuffer); 568865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichfree(offsets); 568965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 569065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE16 569165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (buffer16 != NULL) free(buffer16); 569265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 569365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#ifdef SUPPORT_PCRE32 569465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (buffer32 != NULL) free(buffer32); 569565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 569665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 569765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if !defined NODFA 569865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichif (dfa_workspace != NULL) 569965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich free(dfa_workspace); 570065de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 570165de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 570265de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#if defined(__VMS) 570365de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich yield = SS$_NORMAL; /* Return values via DCL symbols */ 570465de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich#endif 570565de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 570665de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevichreturn yield; 570765de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich} 570865de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich 570965de34233da93a3d65c00b8aad3ff9aad44c57deNick Kralevich/* End of pcretest.c */ 5710