No objections to going ahead with this?
On Thu, Jan 27, 2005 at 03:01:56PM +0000, Joe Orton wrote:
> There are two problems with the use of PCRE in httpd: firstly that there
> is no support for use of an external pcre library (PR27750), and
> secondly that use of the pcreposix.h interface can cause namespace
> collisions with the real POSIX regex API (PR26088, but this is triggered
> when trying to solve 27750).
>
> Attached is a patch which addresses the latter issue and prepares for
> the use of an external PCRE, based on the patches by Andres Solomon in
> 27750: implementing the pcreposix.c wrapper inside the ap_ namespace, by
> doing:
>
> 1. rename pcreposix.h to ap_regex.h (to avoid collisions with any
> external pcre), and copy srclib/pcre/pcreposix.c to server/util_pcre.c
> 2. rename REG_* constants to AP_REG_*, regex_t->ap_regex_t,
> regmatch_t->ap_regmatch_t, and ap_* prefix the reg* functions
>
> Because the error handling in the PCRE-based regcomp() relies on a
> non-public PCRE interface for mapping error strings to codes, this is
> dropped; if ap_regcomp() fails, no specific error code is provided, just
> REG_INVARG aka "invalid argument". (the regcomp error code is not used
> anywhere in httpd so no real difference; this could be improved later)
>
> Two diffs attached: firstly to implement all the above; secondly to
> update the rest of the tree to use the new API, you'll need to do
>
> $ cp srclib/pcre/pcreposix.c server/util_pcre.c
> $ cp include/pcreposix.h include/ap_regex.h
>
> to apply the svn diff to a trunk checkout.
>
> joe
> Index: configure.in
> ===================================================================
> --- configure.in (revision 126611)
> +++ configure.in (working copy)
> @@ -512,6 +512,7 @@
>
> dnl AP_LIBS specifies the actual libraries. note we have some required libs.
> AP_LIBS="$abs_builddir/srclib/pcre/libpcre.la $AP_LIBS"
> +APR_ADDTO(CPPFLAGS, [-I$abs_builddir/srclib/pcre])
>
> dnl APR should go after the other libs, so the right symbols can be picked up
> AP_LIBS="$AP_LIBS `$apu_config --link-libtool --libs` `$apr_config
> --link-libtool --libs`"
> Index: include/ap_mmn.h
> ===================================================================
> --- include/ap_mmn.h (revision 126611)
> +++ include/ap_mmn.h (working copy)
> @@ -85,6 +85,8 @@
> * ap_setup_prelinked_modules,
> ap_process_resource_config
> * 20040425.1 (2.1.0-dev) Added ap_module_symbol_t and
> ap_prelinked_module_symbols
> * 20050101.0 (2.1.2-dev) Axed misnamed http_method for http_scheme (which
> it was!)
> + * 20050127.0 (2.1.3-dev) renamed regex_t->ap_regex_t,
> regmatch_t->ap_regmatch_t,
> + * REG_*->AP_REG_*, removed reg* in place of ap_reg*
> */
>
> #define MODULE_MAGIC_COOKIE 0x41503230UL /* "AP20" */
> Index: include/ap_regex.h
> ===================================================================
> --- include/ap_regex.h (revision 126601)
> +++ include/ap_regex.h (working copy)
> @@ -52,37 +52,24 @@
>
> /* Options defined by POSIX. */
>
> -#define REG_ICASE 0x01
> -#define REG_NEWLINE 0x02
> -#define REG_NOTBOL 0x04
> -#define REG_NOTEOL 0x08
> +#define AP_REG_ICASE 0x01
> +#define AP_REG_NEWLINE 0x02
> +#define AP_REG_NOTBOL 0x04
> +#define AP_REG_NOTEOL 0x08
>
> /* These are not used by PCRE, but by defining them we make it easier
> to slot PCRE into existing programs that make POSIX calls. */
>
> -#define REG_EXTENDED 0
> -#define REG_NOSUB 0
> +#define AP_REG_EXTENDED 0
> +#define AP_REG_NOSUB 0
>
> /* Error values. Not all these are relevant or used by the wrapper. */
>
> enum {
> - REG_ASSERT = 1, /* internal error ? */
> - REG_BADBR, /* invalid repeat counts in {} */
> - REG_BADPAT, /* pattern error */
> - REG_BADRPT, /* ? * + invalid */
> - REG_EBRACE, /* unbalanced {} */
> - REG_EBRACK, /* unbalanced [] */
> - REG_ECOLLATE, /* collation error - not relevant */
> - REG_ECTYPE, /* bad class */
> - REG_EESCAPE, /* bad escape sequence */
> - REG_EMPTY, /* empty expression */
> - REG_EPAREN, /* unbalanced () */
> - REG_ERANGE, /* bad range inside [] */
> - REG_ESIZE, /* expression too big */
> - REG_ESPACE, /* failed to get memory */
> - REG_ESUBREG, /* bad back reference */
> - REG_INVARG, /* bad argument */
> - REG_NOMATCH /* match failed */
> + AP_REG_ASSERT = 1, /* internal error ? */
> + AP_REG_ESPACE, /* failed to get memory */
> + AP_REG_INVARG, /* bad argument */
> + AP_REG_NOMATCH /* match failed */
> };
>
>
> @@ -92,7 +79,7 @@
> void *re_pcre;
> size_t re_nsub;
> size_t re_erroffset;
> -} regex_t;
> +} ap_regex_t;
>
> /* The structure in which a captured offset is returned. */
>
> @@ -101,15 +88,46 @@
> typedef struct {
> regoff_t rm_so;
> regoff_t rm_eo;
> -} regmatch_t;
> +} ap_regmatch_t;
>
> +#ifndef AP_DECLARE
> +#define AP_DECLARE(x) x
> +#endif /* AP_DECLARE */
> +
> /* The functions */
>
> -extern int regcomp(regex_t *, const char *, int);
> -extern int regexec(const regex_t *, const char *, size_t, regmatch_t *, int);
> -extern size_t regerror(int, const regex_t *, char *, size_t);
> -extern void regfree(regex_t *);
> +AP_DECLARE(int) ap_regcomp(ap_regex_t *, const char *, int);
>
> +/**
> + * Match a null-terminated string against a pre-compiled regex.
> + * @param preg The pre-compiled regex
> + * @param string The string to match
> + * @param nmatch Provide information regarding the location of any matches
> + * @param pmatch Provide information regarding the location of any matches
> + * @param eflags Bitwise or of any of:
> + * @li #REG_NOTBOL - match-beginning-of-line operator always
> + * fails to match
> + * @li #REG_NOTEOL - match-end-of-line operator always fails to match
> + * @return 0 for successful match, #REG_NOMATCH otherwise
> + */
> +AP_DECLARE(int) ap_regexec(const ap_regex_t *preg, const char *string,
> + size_t nmatch, ap_regmatch_t *pmatch, int eflags);
> +
> +/**
> + * Return the error code returned by regcomp or regexec into error messages
> + * @param errcode the error code returned by regexec or regcomp
> + * @param preg The precompiled regex
> + * @param errbuf A buffer to store the error in
> + * @param errbuf_size The size of the buffer
> + */
> +AP_DECLARE(size_t) ap_regerror(int errcode, const ap_regex_t *preg,
> + char *errbuf, size_t errbuf_size);
> +
> +/** Destroy a pre-compiled regex.
> + * @param preg The pre-compiled regex to free.
> + */
> +AP_DECLARE(void) ap_regfree(ap_regex_t *preg);
> +
> #ifdef __cplusplus
> } /* extern "C" */
> #endif
> Index: include/http_core.h
> ===================================================================
> --- include/http_core.h (revision 126611)
> +++ include/http_core.h (working copy)
> @@ -488,7 +488,7 @@
>
> /* Access control */
> apr_array_header_t *sec_file;
> - regex_t *r;
> + ap_regex_t *r;
>
> const char *mime_type; /* forced with ForceType */
> const char *handler; /* forced with SetHandler */
> Index: include/httpd.h
> ===================================================================
> --- include/httpd.h (revision 126611)
> +++ include/httpd.h (working copy)
> @@ -41,7 +41,7 @@
>
> #include "os.h"
>
> -#include "pcreposix.h"
> +#include "ap_regex.h"
>
> /* Note: util_uri.h is also included, see below */
>
> @@ -1540,42 +1540,17 @@
> * @li #REG_NEWLINE - Match-any-character operators don't match new-line
> * @return The compiled regular expression
> */
> -AP_DECLARE(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
> - int cflags);
> -
> +AP_DECLARE(ap_regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
> + int cflags);
> +
> /**
> * Free the memory associated with a compiled regular expression
> * @param p The pool the regex was allocated from
> * @param reg The regular expression to free
> */
> -AP_DECLARE(void) ap_pregfree(apr_pool_t *p, regex_t *reg);
> +AP_DECLARE(void) ap_pregfree(apr_pool_t *p, ap_regex_t *reg);
>
> /**
> - * Match a null-terminated string against a pre-compiled regex.
> - * @param preg The pre-compiled regex
> - * @param string The string to match
> - * @param nmatch Provide information regarding the location of any matches
> - * @param pmatch Provide information regarding the location of any matches
> - * @param eflags Bitwise or of any of:
> - * @li #REG_NOTBOL - match-beginning-of-line operator always
> - * fails to match
> - * @li #REG_NOTEOL - match-end-of-line operator always fails to match
> - * @return 0 for successful match, #REG_NOMATCH otherwise
> - */
> -AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string,
> - size_t nmatch, regmatch_t pmatch[], int
> eflags);
> -
> -/**
> - * Return the error code returned by regcomp or regexec into error messages
> - * @param errcode the error code returned by regexec or regcomp
> - * @param preg The precompiled regex
> - * @param errbuf A buffer to store the error in
> - * @param errbuf_size The size of the buffer
> - */
> -AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg,
> - char *errbuf, size_t errbuf_size);
> -
> -/**
> * After performing a successful regex match, you may use this function to
> * perform a series of string substitutions based on subexpressions that were
> * matched during the call to ap_regexec
> @@ -1587,7 +1562,7 @@
> * @param pmatch the pmatch array returned from ap_pregex
> */
> AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input, const char
> *source,
> - size_t nmatch, regmatch_t pmatch[]);
> + size_t nmatch, ap_regmatch_t pmatch[]);
>
> /**
> * We want to downcase the type/subtype for comparison purposes
> Index: include/pcreposix.h
> ===================================================================
> --- include/pcreposix.h (revision 126611)
> +++ include/pcreposix.h (working copy)
> @@ -1,117 +0,0 @@
> -/*************************************************
> -* Perl-Compatible Regular Expressions *
> -*************************************************/
> -
> -#ifndef _PCREPOSIX_H
> -#define _PCREPOSIX_H
> -
> -/* This is the header for the POSIX wrapper interface to the PCRE Perl-
> -Compatible Regular Expression library. It defines the things POSIX says
> should
> -be there. I hope.
> -
> - Copyright (c) 1997-2004 University of Cambridge
> -
> ------------------------------------------------------------------------------
> -Redistribution and use in source and binary forms, with or without
> -modification, are permitted provided that the following conditions are met:
> -
> - * Redistributions of source code must retain the above copyright notice,
> - this list of conditions and the following disclaimer.
> -
> - * Redistributions in binary form must reproduce the above copyright
> - notice, this list of conditions and the following disclaimer in the
> - documentation and/or other materials provided with the distribution.
> -
> - * Neither the name of the University of Cambridge nor the names of its
> - contributors may be used to endorse or promote products derived from
> - this software without specific prior written permission.
> -
> -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> -ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
> -LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> -SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
> -POSSIBILITY OF SUCH DAMAGE.
> ------------------------------------------------------------------------------
> -*/
> -
> -/* Have to include stdlib.h in order to ensure that size_t is defined. */
> -
> -#include <stdlib.h>
> -
> -/* Allow for C++ users */
> -
> -#ifdef __cplusplus
> -extern "C" {
> -#endif
> -
> -/* Options defined by POSIX. */
> -
> -#define REG_ICASE 0x01
> -#define REG_NEWLINE 0x02
> -#define REG_NOTBOL 0x04
> -#define REG_NOTEOL 0x08
> -
> -/* These are not used by PCRE, but by defining them we make it easier
> -to slot PCRE into existing programs that make POSIX calls. */
> -
> -#define REG_EXTENDED 0
> -#define REG_NOSUB 0
> -
> -/* Error values. Not all these are relevant or used by the wrapper. */
> -
> -enum {
> - REG_ASSERT = 1, /* internal error ? */
> - REG_BADBR, /* invalid repeat counts in {} */
> - REG_BADPAT, /* pattern error */
> - REG_BADRPT, /* ? * + invalid */
> - REG_EBRACE, /* unbalanced {} */
> - REG_EBRACK, /* unbalanced [] */
> - REG_ECOLLATE, /* collation error - not relevant */
> - REG_ECTYPE, /* bad class */
> - REG_EESCAPE, /* bad escape sequence */
> - REG_EMPTY, /* empty expression */
> - REG_EPAREN, /* unbalanced () */
> - REG_ERANGE, /* bad range inside [] */
> - REG_ESIZE, /* expression too big */
> - REG_ESPACE, /* failed to get memory */
> - REG_ESUBREG, /* bad back reference */
> - REG_INVARG, /* bad argument */
> - REG_NOMATCH /* match failed */
> -};
> -
> -
> -/* The structure representing a compiled regular expression. */
> -
> -typedef struct {
> - void *re_pcre;
> - size_t re_nsub;
> - size_t re_erroffset;
> -} regex_t;
> -
> -/* The structure in which a captured offset is returned. */
> -
> -typedef int regoff_t;
> -
> -typedef struct {
> - regoff_t rm_so;
> - regoff_t rm_eo;
> -} regmatch_t;
> -
> -/* The functions */
> -
> -extern int regcomp(regex_t *, const char *, int);
> -extern int regexec(const regex_t *, const char *, size_t, regmatch_t *, int);
> -extern size_t regerror(int, const regex_t *, char *, size_t);
> -extern void regfree(regex_t *);
> -
> -#ifdef __cplusplus
> -} /* extern "C" */
> -#endif
> -
> -#endif /* End of pcreposix.h */
> Index: server/Makefile.in
> ===================================================================
> --- server/Makefile.in (revision 126611)
> +++ server/Makefile.in (working copy)
> @@ -12,7 +12,7 @@
> util_script.c util_md5.c util_cfgtree.c util_ebcdic.c util_time.c \
> connection.c listen.c \
> mpm_common.c util_charset.c util_debug.c util_xml.c \
> - util_filter.c exports.c buildmark.c \
> + util_filter.c util_pcre.c exports.c buildmark.c \
> scoreboard.c error_bucket.c protocol.c core.c request.c provider.c \
> eoc_bucket.c core_filters.c
>
> Index: server/util.c
> ===================================================================
> --- server/util.c (revision 126611)
> +++ server/util.c (working copy)
> @@ -246,25 +246,25 @@
> }
>
> /*
> - * Here's a pool-based interface to POSIX regex's regcomp().
> - * Note that we return regex_t instead of being passed one.
> - * The reason is that if you use an already-used regex_t structure,
> + * Here's a pool-based interface to the POSIX-esque ap_regcomp().
> + * Note that we return ap_regex_t instead of being passed one.
> + * The reason is that if you use an already-used ap_regex_t structure,
> * the memory that you've already allocated gets forgotten, and
> * regfree() doesn't clear it. So we don't allow it.
> */
>
> static apr_status_t regex_cleanup(void *preg)
> {
> - regfree((regex_t *) preg);
> + ap_regfree((ap_regex_t *) preg);
> return APR_SUCCESS;
> }
>
> -AP_DECLARE(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
> - int cflags)
> +AP_DECLARE(ap_regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
> + int cflags)
> {
> - regex_t *preg = apr_palloc(p, sizeof(regex_t));
> + ap_regex_t *preg = apr_palloc(p, sizeof *preg);
>
> - if (regcomp(preg, pattern, cflags)) {
> + if (ap_regcomp(preg, pattern, cflags)) {
> return NULL;
> }
>
> @@ -274,9 +274,9 @@
> return preg;
> }
>
> -AP_DECLARE(void) ap_pregfree(apr_pool_t *p, regex_t * reg)
> +AP_DECLARE(void) ap_pregfree(apr_pool_t *p, ap_regex_t *reg)
> {
> - regfree(reg);
> + ap_regfree(reg);
> apr_pool_cleanup_kill(p, (void *) reg, regex_cleanup);
> }
>
> @@ -343,29 +343,10 @@
> return bigstring;
> }
>
> -/*
> - * Apache stub function for the regex libraries regexec() to make sure the
> - * whole regex(3) API is available through the Apache (exported) namespace.
> - * This is especially important for the DSO situations of modules.
> - * DO NOT MAKE A MACRO OUT OF THIS FUNCTION!
> - */
> -AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string,
> - size_t nmatch, regmatch_t pmatch[], int eflags)
> -{
> - return regexec(preg, string, nmatch, pmatch, eflags);
> -}
> -
> -AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg, char
> *errbuf,
> - size_t errbuf_size)
> -{
> - return regerror(errcode, preg, errbuf, errbuf_size);
> -}
> -
> -
> /* This function substitutes for $0-$9, filling in regular expression
> * submatches. Pass it the same nmatch and pmatch arguments that you
> * passed ap_regexec(). pmatch should not be greater than the maximum number
> - * of subexpressions - i.e. one more than the re_nsub member of regex_t.
> + * of subexpressions - i.e. one more than the re_nsub member of ap_regex_t.
> *
> * input should be the string with the $-expressions, source should be the
> * string that was matched against.
> @@ -378,7 +359,7 @@
>
> AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input,
> const char *source, size_t nmatch,
> - regmatch_t pmatch[])
> + ap_regmatch_t pmatch[])
> {
> const char *src = input;
> char *dest, *dst;
> Index: server/util_pcre.c
> ===================================================================
> --- server/util_pcre.c (revision 126601)
> +++ server/util_pcre.c (working copy)
> @@ -43,122 +43,29 @@
> -----------------------------------------------------------------------------
> */
>
> -#include "internal.h"
> -#include "pcreposix.h"
> -#include "stdlib.h"
> +#include <stdlib.h>
>
> +#include "ap_regex.h"
> +#include "pcre.h"
>
> +#ifndef POSIX_MALLOC_THRESHOLD
> +#define POSIX_MALLOC_THRESHOLD (10)
> +#endif
>
> -/* Corresponding tables of PCRE error messages and POSIX error codes. */
> +/* Table of error strings corresponding to POSIX error codes; must be
> + * kept in synch with include/ap_regex.h's AP_REG_E* definitions. */
>
> -static const char *const estring[] = {
> - ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7, ERR8, ERR9, ERR10,
> - ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,
> - ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR29, ERR29, ERR30,
> - ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39, ERR40,
> - ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47 };
> -
> -static const int eint[] = {
> - REG_EESCAPE, /* "\\ at end of pattern" */
> - REG_EESCAPE, /* "\\c at end of pattern" */
> - REG_EESCAPE, /* "unrecognized character follows \\" */
> - REG_BADBR, /* "numbers out of order in {} quantifier" */
> - REG_BADBR, /* "number too big in {} quantifier" */
> - REG_EBRACK, /* "missing terminating ] for character class" */
> - REG_ECTYPE, /* "invalid escape sequence in character class" */
> - REG_ERANGE, /* "range out of order in character class" */
> - REG_BADRPT, /* "nothing to repeat" */
> - REG_BADRPT, /* "operand of unlimited repeat could match the empty string"
> */
> - REG_ASSERT, /* "internal error: unexpected repeat" */
> - REG_BADPAT, /* "unrecognized character after (?" */
> - REG_BADPAT, /* "POSIX named classes are supported only within a class" */
> - REG_EPAREN, /* "missing )" */
> - REG_ESUBREG, /* "reference to non-existent subpattern" */
> - REG_INVARG, /* "erroffset passed as NULL" */
> - REG_INVARG, /* "unknown option bit(s) set" */
> - REG_EPAREN, /* "missing ) after comment" */
> - REG_ESIZE, /* "parentheses nested too deeply" */
> - REG_ESIZE, /* "regular expression too large" */
> - REG_ESPACE, /* "failed to get memory" */
> - REG_EPAREN, /* "unmatched brackets" */
> - REG_ASSERT, /* "internal error: code overflow" */
> - REG_BADPAT, /* "unrecognized character after (?<" */
> - REG_BADPAT, /* "lookbehind assertion is not fixed length" */
> - REG_BADPAT, /* "malformed number after (?(" */
> - REG_BADPAT, /* "conditional group containe more than two branches" */
> - REG_BADPAT, /* "assertion expected after (?(" */
> - REG_BADPAT, /* "(?R or (?digits must be followed by )" */
> - REG_ECTYPE, /* "unknown POSIX class name" */
> - REG_BADPAT, /* "POSIX collating elements are not supported" */
> - REG_INVARG, /* "this version of PCRE is not compiled with PCRE_UTF8
> support" */
> - REG_BADPAT, /* "spare error" */
> - REG_BADPAT, /* "character value in \x{...} sequence is too large" */
> - REG_BADPAT, /* "invalid condition (?(0)" */
> - REG_BADPAT, /* "\\C not allowed in lookbehind assertion" */
> - REG_EESCAPE, /* "PCRE does not support \\L, \\l, \\N, \\U, or \\u" */
> - REG_BADPAT, /* "number after (?C is > 255" */
> - REG_BADPAT, /* "closing ) for (?C expected" */
> - REG_BADPAT, /* "recursive call could loop indefinitely" */
> - REG_BADPAT, /* "unrecognized character after (?P" */
> - REG_BADPAT, /* "syntax error after (?P" */
> - REG_BADPAT, /* "two named groups have the same name" */
> - REG_BADPAT, /* "invalid UTF-8 string" */
> - REG_BADPAT, /* "support for \\P, \\p, and \\X has not been compiled" */
> - REG_BADPAT, /* "malformed \\P or \\p sequence" */
> - REG_BADPAT /* "unknown property name after \\P or \\p" */
> -};
> -
> -/* Table of texts corresponding to POSIX error codes */
> -
> static const char *const pstring[] = {
> "", /* Dummy for value 0 */
> - "internal error", /* REG_ASSERT */
> - "invalid repeat counts in {}", /* BADBR */
> - "pattern error", /* BADPAT */
> - "? * + invalid", /* BADRPT */
> - "unbalanced {}", /* EBRACE */
> - "unbalanced []", /* EBRACK */
> - "collation error - not relevant", /* ECOLLATE */
> - "bad class", /* ECTYPE */
> - "bad escape sequence", /* EESCAPE */
> - "empty expression", /* EMPTY */
> - "unbalanced ()", /* EPAREN */
> - "bad range inside []", /* ERANGE */
> - "expression too big", /* ESIZE */
> - "failed to get memory", /* ESPACE */
> - "bad back reference", /* ESUBREG */
> - "bad argument", /* INVARG */
> - "match failed" /* NOMATCH */
> + "internal error", /* AP_REG_ASSERT */
> + "failed to get memory", /* AP_REG_ESPACE */
> + "bad argument", /* AP_REG_INVARG */
> + "match failed" /* AP_REG_NOMATCH */
> };
>
> -
> -
> -
> -/*************************************************
> -* Translate PCRE text code to int *
> -*************************************************/
> -
> -/* PCRE compile-time errors are given as strings defined as macros. We can
> just
> -look them up in a table to turn them into POSIX-style error codes. */
> -
> -static int
> -pcre_posix_error_code(const char *s)
> +AP_DECLARE(size_t) ap_regerror(int errcode, const ap_regex_t *preg,
> + char *errbuf, size_t errbuf_size)
> {
> -size_t i;
> -for (i = 0; i < sizeof(estring)/sizeof(char *); i++)
> - if (strcmp(s, estring[i]) == 0) return eint[i];
> -return REG_ASSERT;
> -}
> -
> -
> -
> -/*************************************************
> -* Translate error code to string *
> -*************************************************/
> -
> -EXPORT size_t
> -regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
> -{
> const char *message, *addmessage;
> size_t length, addlength;
>
> @@ -191,8 +98,7 @@
> * Free store held by a regex *
> *************************************************/
>
> -EXPORT void
> -regfree(regex_t *preg)
> +AP_DECLARE(void) ap_regfree(ap_regex_t *preg)
> {
> (pcre_free)(preg->re_pcre);
> }
> @@ -214,20 +120,19 @@
> various non-zero codes on failure
> */
>
> -EXPORT int
> -regcomp(regex_t *preg, const char *pattern, int cflags)
> +AP_DECLARE(int) ap_regcomp(ap_regex_t *preg, const char *pattern, int cflags)
> {
> const char *errorptr;
> int erroffset;
> int options = 0;
>
> -if ((cflags & REG_ICASE) != 0) options |= PCRE_CASELESS;
> -if ((cflags & REG_NEWLINE) != 0) options |= PCRE_MULTILINE;
> +if ((cflags & AP_REG_ICASE) != 0) options |= PCRE_CASELESS;
> +if ((cflags & AP_REG_NEWLINE) != 0) options |= PCRE_MULTILINE;
>
> preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset, NULL);
> preg->re_erroffset = erroffset;
>
> -if (preg->re_pcre == NULL) return pcre_posix_error_code(errorptr);
> +if (preg->re_pcre == NULL) return AP_REG_INVARG;
>
> preg->re_nsub = pcre_info((const pcre *)preg->re_pcre, NULL, NULL);
> return 0;
> @@ -247,20 +152,19 @@
> block of store on the stack, to reduce the use of malloc/free. The threshold
> is
> in a macro that can be changed at configure time. */
>
> -EXPORT int
> -regexec(const regex_t *preg, const char *string, size_t nmatch,
> - regmatch_t pmatch[], int eflags)
> +AP_DECLARE(int) ap_regexec(const ap_regex_t *preg, const char *string,
> size_t nmatch,
> + ap_regmatch_t pmatch[], int eflags)
> {
> int rc;
> int options = 0;
> int *ovector = NULL;
> int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
> -BOOL allocated_ovector = FALSE;
> +int allocated_ovector = 0;
>
> -if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
> -if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
> +if ((eflags & AP_REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
> +if ((eflags & AP_REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
>
> -((regex_t *)preg)->re_erroffset = (size_t)(-1); /* Only has meaning after
> compile */
> +((ap_regex_t *)preg)->re_erroffset = (size_t)(-1); /* Only has meaning
> after compile */
>
> if (nmatch > 0)
> {
> @@ -271,8 +175,8 @@
> else
> {
> ovector = (int *)malloc(sizeof(int) * nmatch * 3);
> - if (ovector == NULL) return REG_ESPACE;
> - allocated_ovector = TRUE;
> + if (ovector == NULL) return AP_REG_ESPACE;
> + allocated_ovector = 1;
> }
> }
>
> @@ -299,16 +203,16 @@
> if (allocated_ovector) free(ovector);
> switch(rc)
> {
> - case PCRE_ERROR_NOMATCH: return REG_NOMATCH;
> - case PCRE_ERROR_NULL: return REG_INVARG;
> - case PCRE_ERROR_BADOPTION: return REG_INVARG;
> - case PCRE_ERROR_BADMAGIC: return REG_INVARG;
> - case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;
> - case PCRE_ERROR_NOMEMORY: return REG_ESPACE;
> - case PCRE_ERROR_MATCHLIMIT: return REG_ESPACE;
> - case PCRE_ERROR_BADUTF8: return REG_INVARG;
> - case PCRE_ERROR_BADUTF8_OFFSET: return REG_INVARG;
> - default: return REG_ASSERT;
> + case PCRE_ERROR_NOMATCH: return AP_REG_NOMATCH;
> + case PCRE_ERROR_NULL: return AP_REG_INVARG;
> + case PCRE_ERROR_BADOPTION: return AP_REG_INVARG;
> + case PCRE_ERROR_BADMAGIC: return AP_REG_INVARG;
> + case PCRE_ERROR_UNKNOWN_NODE: return AP_REG_ASSERT;
> + case PCRE_ERROR_NOMEMORY: return AP_REG_ESPACE;
> + case PCRE_ERROR_MATCHLIMIT: return AP_REG_ESPACE;
> + case PCRE_ERROR_BADUTF8: return AP_REG_INVARG;
> + case PCRE_ERROR_BADUTF8_OFFSET: return AP_REG_INVARG;
> + default: return AP_REG_ASSERT;
> }
> }
> }
> Index: srclib/pcre/Makefile.in
> ===================================================================
> --- srclib/pcre/Makefile.in (revision 126611)
> +++ srclib/pcre/Makefile.in (working copy)
> @@ -1,5 +1,5 @@
> LTLIBRARY_NAME = libpcre.la
> -LTLIBRARY_SOURCES = maketables.c get.c study.c pcre.c pcreposix.c
> +LTLIBRARY_SOURCES = maketables.c get.c study.c pcre.c
>
> CLEAN_TARGETS = dftables chartables.c
> DISTCLEAN_TARGETS = pcre.h pcre-config config.h config.log config.status
> $(CLEAN_TARGETS)
> Index: modules/experimental/mod_filter.c
> ===================================================================
> --- modules/experimental/mod_filter.c (revision 126611)
> +++ modules/experimental/mod_filter.c (working copy)
> @@ -66,7 +66,7 @@
> /** The dispatch match itself - union member depends on match_type */
> union {
> const char *string;
> - regex_t *regex;
> + ap_regex_t *regex;
> int number;
> } match;
>
> @@ -232,7 +232,7 @@
> break;
> case REGEX_MATCH:
> if (ap_regexec(provider->match.regex, str, 0, NULL, 0)
> - == REG_NOMATCH) {
> + == AP_REG_NOMATCH) {
> match = 0;
> }
> break;
> @@ -590,10 +590,10 @@
> if (!rxend) {
> return "Bad regexp syntax";
> }
> - flags = REG_NOSUB; /* we're not mod_rewrite:-) */
> + flags = AP_REG_NOSUB; /* we're not mod_rewrite:-) */
> for (c = rxend+1; *c; ++c) {
> switch (*c) {
> - case 'i': flags |= REG_ICASE; break;
> + case 'i': flags |= AP_REG_ICASE; break;
> }
> }
> provider->match.regex = ap_pregcomp(cmd->pool,
> Index: modules/filters/mod_include.c
> ===================================================================
> --- modules/filters/mod_include.c (revision 126611)
> +++ modules/filters/mod_include.c (working copy)
> @@ -154,7 +154,7 @@
> const char *source;
> const char *rexp;
> apr_size_t nsub;
> - regmatch_t match[AP_MAX_REG_MATCH];
> + ap_regmatch_t match[AP_MAX_REG_MATCH];
> } backref_t;
>
> typedef struct {
> @@ -916,11 +916,11 @@
> static APR_INLINE int re_check(include_ctx_t *ctx, const char *string,
> const char *rexp)
> {
> - regex_t *compiled;
> + ap_regex_t *compiled;
> backref_t *re = ctx->intern->re;
> int rc;
>
> - compiled = ap_pregcomp(ctx->dpool, rexp, REG_EXTENDED);
> + compiled = ap_pregcomp(ctx->dpool, rexp, AP_REG_EXTENDED);
> if (!compiled) {
> ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->intern->r, "unable to "
> "compile pattern \"%s\"", rexp);
> Index: modules/mappers/mod_alias.c
> ===================================================================
> --- modules/mappers/mod_alias.c (revision 126611)
> +++ modules/mappers/mod_alias.c (working copy)
> @@ -39,7 +39,7 @@
> const char *real;
> const char *fake;
> char *handler;
> - regex_t *regexp;
> + ap_regex_t *regexp;
> int redir_status; /* 301, 302, 303, 410, etc */
> } alias_entry;
>
> @@ -111,7 +111,7 @@
> /* XX r can NOT be relative to DocumentRoot here... compat bug. */
>
> if (use_regex) {
> - new->regexp = ap_pregcomp(cmd->pool, f, REG_EXTENDED);
> + new->regexp = ap_pregcomp(cmd->pool, f, AP_REG_EXTENDED);
> if (new->regexp == NULL)
> return "Regular expression could not be compiled.";
> new->real = r;
> @@ -175,7 +175,7 @@
> alias_server_conf *serverconf = ap_get_module_config(s->module_config,
> &alias_module);
> int status = (int) (long) cmd->info;
> - regex_t *r = NULL;
> + ap_regex_t *r = NULL;
> const char *f = arg2;
> const char *url = arg3;
>
> @@ -195,7 +195,7 @@
> }
>
> if (use_regex) {
> - r = ap_pregcomp(cmd->pool, f, REG_EXTENDED);
> + r = ap_pregcomp(cmd->pool, f, AP_REG_EXTENDED);
> if (r == NULL)
> return "Regular expression could not be compiled.";
> }
> @@ -313,7 +313,7 @@
> int doesc, int *status)
> {
> alias_entry *entries = (alias_entry *) aliases->elts;
> - regmatch_t regm[AP_MAX_REG_MATCH];
> + ap_regmatch_t regm[AP_MAX_REG_MATCH];
> char *found = NULL;
> int i;
>
> Index: modules/mappers/mod_rewrite.c
> ===================================================================
> --- modules/mappers/mod_rewrite.c (revision 126611)
> +++ modules/mappers/mod_rewrite.c (working copy)
> @@ -244,7 +244,7 @@
> typedef struct {
> char *input; /* Input string of RewriteCond */
> char *pattern; /* the RegExp pattern string */
> - regex_t *regexp; /* the precompiled regexp */
> + ap_regex_t *regexp; /* the precompiled regexp */
> int flags; /* Flags which control the match */
> pattern_type ptype; /* pattern type */
> } rewritecond_entry;
> @@ -258,7 +258,7 @@
> typedef struct {
> apr_array_header_t *rewriteconds;/* the corresponding RewriteCond
> entries */
> char *pattern; /* the RegExp pattern string
> */
> - regex_t *regexp; /* the RegExp pattern compilation
> */
> + ap_regex_t *regexp; /* the RegExp pattern compilation
> */
> char *output; /* the Substitution string
> */
> int flags; /* Flags which control the substitution
> */
> char *forced_mimetype; /* forced MIME type of substitution
> */
> @@ -317,7 +317,7 @@
> typedef struct backrefinfo {
> char *source;
> int nsub;
> - regmatch_t regmatch[AP_MAX_REG_MATCH];
> + ap_regmatch_t regmatch[AP_MAX_REG_MATCH];
> } backrefinfo;
>
> /* single linked list used for
> @@ -3045,7 +3045,7 @@
> char *str = apr_pstrdup(cmd->pool, in_str);
> rewrite_server_conf *sconf;
> rewritecond_entry *newcond;
> - regex_t *regexp;
> + ap_regex_t *regexp;
> char *a1;
> char *a2;
> char *a3;
> @@ -3132,8 +3132,8 @@
>
> if (!newcond->ptype) {
> regexp = ap_pregcomp(cmd->pool, a2,
> - REG_EXTENDED | ((newcond->flags &
> CONDFLAG_NOCASE)
> - ? REG_ICASE : 0));
> + AP_REG_EXTENDED | ((newcond->flags &
> CONDFLAG_NOCASE)
> + ? AP_REG_ICASE : 0));
> if (!regexp) {
> return apr_pstrcat(cmd->pool, "RewriteCond: cannot compile
> regular "
> "expression '", a2, "'", NULL);
> @@ -3373,7 +3373,7 @@
> char *str = apr_pstrdup(cmd->pool, in_str);
> rewrite_server_conf *sconf;
> rewriterule_entry *newrule;
> - regex_t *regexp;
> + ap_regex_t *regexp;
> char *a1;
> char *a2;
> char *a3;
> @@ -3418,9 +3418,9 @@
> ++a1;
> }
>
> - regexp = ap_pregcomp(cmd->pool, a1, REG_EXTENDED |
> + regexp = ap_pregcomp(cmd->pool, a1, AP_REG_EXTENDED |
> ((newrule->flags & RULEFLAG_NOCASE)
> - ? REG_ICASE : 0));
> + ? AP_REG_ICASE : 0));
> if (!regexp) {
> return apr_pstrcat(cmd->pool,
> "RewriteRule: cannot compile regular expression
> '",
> @@ -3492,7 +3492,7 @@
> char *input = do_expand(p->input, ctx);
> apr_finfo_t sb;
> request_rec *rsub, *r = ctx->r;
> - regmatch_t regmatch[AP_MAX_REG_MATCH];
> + ap_regmatch_t regmatch[AP_MAX_REG_MATCH];
> int rc = 0;
>
> switch (p->ptype) {
> @@ -3645,7 +3645,7 @@
> */
> static int apply_rewrite_rule(rewriterule_entry *p, rewrite_ctx *ctx)
> {
> - regmatch_t regmatch[AP_MAX_REG_MATCH];
> + ap_regmatch_t regmatch[AP_MAX_REG_MATCH];
> apr_array_header_t *rewriteconds;
> rewritecond_entry *conds;
> int i, rc;
> Index: modules/metadata/mod_headers.c
> ===================================================================
> --- modules/metadata/mod_headers.c (revision 126611)
> +++ modules/metadata/mod_headers.c (working copy)
> @@ -116,7 +116,7 @@
> hdr_actions action;
> const char *header;
> apr_array_header_t *ta; /* Array of format_tag structs */
> - regex_t *regex;
> + ap_regex_t *regex;
> const char *condition_var;
> } header_entry;
>
> @@ -405,7 +405,7 @@
> }
> }
> else if (new->action == hdr_echo) {
> - regex_t *regex;
> + ap_regex_t *regex;
>
> if (value) {
> if (envclause) {
> @@ -418,7 +418,7 @@
> return "Header echo only valid on Header "
> "directives";
> else {
> - regex = ap_pregcomp(cmd->pool, hdr, REG_EXTENDED | REG_NOSUB);
> + regex = ap_pregcomp(cmd->pool, hdr, AP_REG_EXTENDED |
> AP_REG_NOSUB);
> if (regex == NULL) {
> return "Header echo regex could not be compiled";
> }
> Index: modules/metadata/mod_setenvif.c
> ===================================================================
> --- modules/metadata/mod_setenvif.c (revision 126611)
> +++ modules/metadata/mod_setenvif.c (working copy)
> @@ -105,9 +105,9 @@
> };
> typedef struct {
> char *name; /* header name */
> - regex_t *pnamereg; /* compiled header name regex */
> + ap_regex_t *pnamereg; /* compiled header name regex */
> char *regex; /* regex to match against */
> - regex_t *preg; /* compiled regex */
> + ap_regex_t *preg; /* compiled regex */
> const apr_strmatch_pattern *pattern; /* non-regex pattern to match */
> apr_table_t *features; /* env vars to set (or unset) */
> enum special special_type; /* is it a "special" header ? */
> @@ -158,7 +158,7 @@
> }
>
> /*
> - * any non-NULL magic constant will do... used to indicate if REG_ICASE
> should
> + * any non-NULL magic constant will do... used to indicate if AP_REG_ICASE
> should
> * be used
> */
> #define ICASE_MAGIC ((void *)(&setenvif_module))
> @@ -170,8 +170,8 @@
> * -,_,[A-Z\, [a-z] and [0-9].
> * assume the header name is a regular expression.
> */
> - regex_t *preg = ap_pregcomp(p, "^[-A-Za-z0-9_]*$",
> - (REG_EXTENDED | REG_NOSUB ));
> + ap_regex_t *preg = ap_pregcomp(p, "^[-A-Za-z0-9_]*$",
> + (AP_REG_EXTENDED | AP_REG_NOSUB ));
> ap_assert(preg != NULL);
>
> if (ap_regexec(preg, name, 0, NULL, 0)) {
> @@ -317,7 +317,7 @@
> }
> else {
> new->preg = ap_pregcomp(cmd->pool, regex,
> - (REG_EXTENDED | (icase ? REG_ICASE :
> 0)));
> + (AP_REG_EXTENDED | (icase ? AP_REG_ICASE
> : 0)));
> if (new->preg == NULL) {
> return apr_pstrcat(cmd->pool, cmd->cmd->name,
> " regex could not be compiled.", NULL);
> @@ -353,8 +353,8 @@
> */
> if (is_header_regex(cmd->pool, fname)) {
> new->pnamereg = ap_pregcomp(cmd->pool, fname,
> - (REG_EXTENDED | REG_NOSUB
> - | (icase ? REG_ICASE : 0)));
> + (AP_REG_EXTENDED | AP_REG_NOSUB
> + | (icase ? AP_REG_ICASE : 0)));
> if (new->pnamereg == NULL)
> return apr_pstrcat(cmd->pool, cmd->cmd->name,
> "Header name regex could not be "
> @@ -452,7 +452,7 @@
> apr_size_t val_len = 0;
> int i, j;
> char *last_name;
> - regmatch_t regm[AP_MAX_REG_MATCH];
> + ap_regmatch_t regm[AP_MAX_REG_MATCH];
>
> if (!ap_get_module_config(r->request_config, &setenvif_module)) {
> ap_set_module_config(r->request_config, &setenvif_module,
> Index: modules/metadata/mod_usertrack.c
> ===================================================================
> --- modules/metadata/mod_usertrack.c (revision 126611)
> +++ modules/metadata/mod_usertrack.c (working copy)
> @@ -83,7 +83,7 @@
> char *cookie_name;
> char *cookie_domain;
> char *regexp_string; /* used to compile regexp; save for debugging */
> - regex_t *regexp; /* used to find usertrack cookie in cookie header */
> + ap_regex_t *regexp; /* used to find usertrack cookie in cookie header */
> } cookie_dir_rec;
>
> /* Make Cookie: Now we have to generate something that is going to be
> @@ -199,7 +199,7 @@
> cookie_name,
> "=([^;,]+)", NULL);
>
> - dcfg->regexp = ap_pregcomp(p, dcfg->regexp_string, REG_EXTENDED);
> + dcfg->regexp = ap_pregcomp(p, dcfg->regexp_string, AP_REG_EXTENDED);
> ap_assert(dcfg->regexp != NULL);
> }
>
> @@ -208,7 +208,7 @@
> cookie_dir_rec *dcfg = ap_get_module_config(r->per_dir_config,
> &usertrack_module);
> const char *cookie_header;
> - regmatch_t regm[NUM_SUBS];
> + ap_regmatch_t regm[NUM_SUBS];
>
> /* Do not run in subrequests */
> if (!dcfg->enabled || r->main) {
> Index: modules/metadata/mod_version.c
> ===================================================================
> --- modules/metadata/mod_version.c (revision 126611)
> +++ modules/metadata/mod_version.c (working copy)
> @@ -141,11 +141,11 @@
> static int match_version(apr_pool_t *pool, char *version_string,
> const char **error)
> {
> - regex_t *compiled;
> + ap_regex_t *compiled;
> const char *to_match;
> int rc;
>
> - compiled = ap_pregcomp(pool, version_string, REG_EXTENDED);
> + compiled = ap_pregcomp(pool, version_string, AP_REG_EXTENDED);
> if (!compiled) {
> *error = "Unable to compile regular expression";
> return 0;
> Index: modules/proxy/mod_proxy.c
> ===================================================================
> --- modules/proxy/mod_proxy.c (revision 126611)
> +++ modules/proxy/mod_proxy.c (working copy)
> @@ -872,7 +872,7 @@
> struct proxy_remote *new;
> char *p, *q;
> char *r, *f, *scheme;
> - regex_t *reg = NULL;
> + ap_regex_t *reg = NULL;
> int port;
>
> r = apr_pstrdup(cmd->pool, r1);
> @@ -902,7 +902,7 @@
> port = -1;
> *p = '\0';
> if (regex) {
> - reg = ap_pregcomp(cmd->pool, f, REG_EXTENDED);
> + reg = ap_pregcomp(cmd->pool, f, AP_REG_EXTENDED);
> if (!reg)
> return "Regular expression for ProxyRemoteMatch could not be
> compiled.";
> }
> @@ -1516,7 +1516,7 @@
> char *old_path = cmd->path;
> proxy_dir_conf *conf;
> ap_conf_vector_t *new_dir_conf = ap_create_per_dir_config(cmd->pool);
> - regex_t *r = NULL;
> + ap_regex_t *r = NULL;
> const command_rec *thiscmd = cmd->cmd;
>
> const char *err = ap_check_cmd_context(cmd,
> @@ -1550,7 +1550,7 @@
> * scheme? See proxy_fixup()
> */
> if (thiscmd->cmd_data) { /* <ProxyMatch> */
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
> if (!r) {
> return "Regex could not be compiled";
> }
> @@ -1561,7 +1561,7 @@
> return "<Proxy ~ > block must specify a path";
> if (strncasecmp(cmd->path, "proxy:", 6))
> cmd->path += 6;
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
> if (!r) {
> return "Regex could not be compiled";
> }
> Index: modules/proxy/mod_proxy.h
> ===================================================================
> --- modules/proxy/mod_proxy.h (revision 126611)
> +++ modules/proxy/mod_proxy.h (working copy)
> @@ -95,7 +95,7 @@
> const char *protocol; /* the scheme used to talk to this proxy */
> const char *hostname; /* the hostname of this proxy */
> apr_port_t port; /* the port for this proxy */
> - regex_t *regexp; /* compiled regex (if any) for the remote */
> + ap_regex_t *regexp; /* compiled regex (if any) for the remote */
> int use_regex; /* simple boolean. True if we have a regex
> pattern */
> };
>
> @@ -189,7 +189,7 @@
> typedef struct {
> const char *p; /* The path */
> int p_is_fnmatch; /* Is this path an fnmatch candidate? */
> - regex_t *r; /* Is this a regex? */
> + ap_regex_t *r; /* Is this a regex? */
> } proxy_dir_conf;
>
> typedef struct {
> Index: modules/proxy/proxy_ftp.c
> ===================================================================
> --- modules/proxy/proxy_ftp.c (revision 126611)
> +++ modules/proxy/proxy_ftp.c (working copy)
> @@ -423,12 +423,11 @@
> char *filename;
> int found = 0;
> int eos = 0;
> + ap_regex_t *re = NULL;
> + ap_regmatch_t re_result[LS_REG_MATCH];
>
> - regex_t *re = NULL;
> - regmatch_t re_result[LS_REG_MATCH];
> -
> /* Compile the output format of "ls -s1" as a fallback for non-unix
> ftp listings */
> - re = ap_pregcomp(p, LS_REG_PATTERN, REG_EXTENDED);
> + re = ap_pregcomp(p, LS_REG_PATTERN, AP_REG_EXTENDED);
> ap_assert(re != NULL);
>
> /* get a complete line */
> Index: modules/ssl/ssl_expr_eval.c
> ===================================================================
> --- modules/ssl/ssl_expr_eval.c (revision 126611)
> +++ modules/ssl/ssl_expr_eval.c (working copy)
> @@ -125,24 +125,24 @@
> ssl_expr *e1;
> ssl_expr *e2;
> char *word;
> - regex_t *regex;
> + ap_regex_t *regex;
>
> e1 = (ssl_expr *)node->node_arg1;
> e2 = (ssl_expr *)node->node_arg2;
> word = ssl_expr_eval_word(r, e1);
> - regex = (regex_t *)(e2->node_arg1);
> + regex = (ap_regex_t *)(e2->node_arg1);
> return (ap_regexec(regex, word, 0, NULL, 0) == 0);
> }
> case op_NRE: {
> ssl_expr *e1;
> ssl_expr *e2;
> char *word;
> - regex_t *regex;
> + ap_regex_t *regex;
>
> e1 = (ssl_expr *)node->node_arg1;
> e2 = (ssl_expr *)node->node_arg2;
> word = ssl_expr_eval_word(r, e1);
> - regex = (regex_t *)(e2->node_arg1);
> + regex = (ap_regex_t *)(e2->node_arg1);
> return !(ap_regexec(regex, word, 0, NULL, 0) == 0);
> }
> default: {
> Index: modules/ssl/ssl_expr_parse.c
> ===================================================================
> --- modules/ssl/ssl_expr_parse.c (revision 126611)
> +++ modules/ssl/ssl_expr_parse.c (working copy)
> @@ -818,9 +818,9 @@
> case 24:
> #line 148 "ssl_expr_parse.y"
> {
> - regex_t *regex;
> + ap_regex_t *regex;
> if ((regex = ap_pregcomp(ssl_expr_info.pool,
> ssl_expr_yyvsp[0].cpVal,
> - REG_EXTENDED|REG_NOSUB)) == NULL) {
> + AP_REG_EXTENDED|AP_REG_NOSUB)) ==
> NULL) {
> ssl_expr_error = "Failed to compile regular expression";
> YYERROR;
> regex = NULL;
> @@ -831,9 +831,9 @@
> case 25:
> #line 158 "ssl_expr_parse.y"
> {
> - regex_t *regex;
> + ap_regex_t *regex;
> if ((regex = ap_pregcomp(ssl_expr_info.pool,
> ssl_expr_yyvsp[0].cpVal,
> - REG_EXTENDED|REG_NOSUB|REG_ICASE))
> == NULL) {
> +
> AP_REG_EXTENDED|AP_REG_NOSUB|AP_REG_ICASE)) == NULL) {
> ssl_expr_error = "Failed to compile regular expression";
> YYERROR;
> regex = NULL;
> Index: modules/ssl/ssl_expr_parse.y
> ===================================================================
> --- modules/ssl/ssl_expr_parse.y (revision 126611)
> +++ modules/ssl/ssl_expr_parse.y (working copy)
> @@ -112,18 +112,18 @@
> ;
>
> regex : T_REGEX {
> - regex_t *regex;
> + ap_regex_t *regex;
> if ((regex = ap_pregcomp(ssl_expr_info.pool, $1,
> - REG_EXTENDED|REG_NOSUB)) == NULL) {
> + AP_REG_EXTENDED|AP_REG_NOSUB)) ==
> NULL) {
> ssl_expr_error = "Failed to compile regular expression";
> YYERROR;
> }
> $$ = ssl_expr_make(op_Regex, regex, NULL);
> }
> | T_REGEX_I {
> - regex_t *regex;
> + ap_regex_t *regex;
> if ((regex = ap_pregcomp(ssl_expr_info.pool, $1,
> - REG_EXTENDED|REG_NOSUB|REG_ICASE))
> == NULL) {
> +
> AP_REG_EXTENDED|AP_REG_NOSUB|AP_REG_ICASE)) == NULL) {
> ssl_expr_error = "Failed to compile regular expression";
> YYERROR;
> }
> Index: server/core.c
> ===================================================================
> --- server/core.c (revision 126611)
> +++ server/core.c (working copy)
> @@ -1729,7 +1729,7 @@
> */
>
> #ifdef WIN32
> -#define USE_ICASE REG_ICASE
> +#define USE_ICASE AP_REG_ICASE
> #else
> #define USE_ICASE 0
> #endif
> @@ -1742,7 +1742,7 @@
> char *old_path = cmd->path;
> core_dir_config *conf;
> ap_conf_vector_t *new_dir_conf = ap_create_per_dir_config(cmd->pool);
> - regex_t *r = NULL;
> + ap_regex_t *r = NULL;
> const command_rec *thiscmd = cmd->cmd;
>
> const char *err = ap_check_cmd_context(cmd,
> @@ -1775,13 +1775,13 @@
> cmd->path = ap_getword_conf(cmd->pool, &arg);
> if (!cmd->path)
> return "<Directory ~ > block must specify a path";
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED|USE_ICASE);
> if (!r) {
> return "Regex could not be compiled";
> }
> }
> else if (thiscmd->cmd_data) { /* <DirectoryMatch> */
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED|USE_ICASE);
> if (!r) {
> return "Regex could not be compiled";
> }
> @@ -1846,7 +1846,7 @@
> int old_overrides = cmd->override;
> char *old_path = cmd->path;
> core_dir_config *conf;
> - regex_t *r = NULL;
> + ap_regex_t *r = NULL;
> const command_rec *thiscmd = cmd->cmd;
> ap_conf_vector_t *new_url_conf = ap_create_per_dir_config(cmd->pool);
> const char *err = ap_check_cmd_context(cmd,
> @@ -1869,14 +1869,14 @@
> cmd->override = OR_ALL|ACCESS_CONF;
>
> if (thiscmd->cmd_data) { /* <LocationMatch> */
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
> if (!r) {
> return "Regex could not be compiled";
> }
> }
> else if (!strcmp(cmd->path, "~")) {
> cmd->path = ap_getword_conf(cmd->pool, &arg);
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
> if (!r) {
> return "Regex could not be compiled";
> }
> @@ -1914,7 +1914,7 @@
> int old_overrides = cmd->override;
> char *old_path = cmd->path;
> core_dir_config *conf;
> - regex_t *r = NULL;
> + ap_regex_t *r = NULL;
> const command_rec *thiscmd = cmd->cmd;
> core_dir_config *c = mconfig;
> ap_conf_vector_t *new_file_conf = ap_create_per_dir_config(cmd->pool);
> @@ -1941,14 +1941,14 @@
> }
>
> if (thiscmd->cmd_data) { /* <FilesMatch> */
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED|USE_ICASE);
> if (!r) {
> return "Regex could not be compiled";
> }
> }
> else if (!strcmp(cmd->path, "~")) {
> cmd->path = ap_getword_conf(cmd->pool, &arg);
> - r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
> + r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED|USE_ICASE);
> if (!r) {
> return "Regex could not be compiled";
> }
> Index: server/request.c
> ===================================================================
> --- server/request.c (revision 126611)
> +++ server/request.c (working copy)
> @@ -1047,7 +1047,7 @@
> continue;
> }
>
> - if (ap_regexec(entry_core->r, r->filename, 0, NULL, REG_NOTEOL))
> {
> + if (ap_regexec(entry_core->r, r->filename, 0, NULL,
> AP_REG_NOTEOL)) {
> continue;
> }
>
