regex-posix 0.72 → 0.72.0.1
raw patch · 23 files changed
+9082/−26 lines, 23 filesdep +arraydep +bytestringdep ~basesetup-changed
Dependencies added: array, bytestring
Dependency ranges changed: base
Files
- Setup.hs +0/−6
- Setup.lhs +11/−0
- Text/Regex/Posix/ByteString.hs +5/−1
- Text/Regex/Posix/Wrap.hsc +4/−8
- aclocal.m4 +2/−0
- cbits/COPYRIGHT +56/−0
- cbits/cclass.h +62/−0
- cbits/cname.h +141/−0
- cbits/engine.c +1139/−0
- cbits/reallocf.c +39/−0
- cbits/regcomp.c +2099/−0
- cbits/regerror.c +177/−0
- cbits/regex2.h +178/−0
- cbits/regexec.c +181/−0
- cbits/regfree.c +87/−0
- cbits/utils.h +62/−0
- config.mk.in +5/−0
- configure +4609/−0
- configure.ac +28/−0
- include/HsRegexPosixConfig.h.in +55/−0
- include/regex/regex.h +112/−0
- regex-posix.buildinfo.in +3/−0
- regex-posix.cabal +27/−11
− Setup.hs
@@ -1,6 +0,0 @@-#!/usr/bin/env runhaskell---- I usually compile this with "ghc --make -o setup Setup.hs"--import Distribution.Simple(defaultMainWithHooks, defaultUserHooks)-main = defaultMainWithHooks defaultUserHooks
+ Setup.lhs view
@@ -0,0 +1,11 @@+#!/usr/bin/env runhaskell++> -- I usually compile this with "ghc --make -o setup Setup.hs"++> module Main (main) where+>+> import Distribution.Simple+>+> main :: IO ()+> main = defaultMainWithHooks defaultUserHooks+
Text/Regex/Posix/ByteString.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts #-}+{-# OPTIONS_GHC -fglasgow-exts -cpp #-} ----------------------------------------------------------------------------- -- | -- Module : Text.Regex.Posix.ByteString@@ -54,7 +54,11 @@ import Data.Array(Array,listArray) import Data.ByteString(ByteString) import qualified Data.ByteString as B(empty,useAsCString,last,null,take,drop)+#if __GLASGOW_HASKELL__ == 606 import qualified Data.ByteString.Base as B(unsafeUseAsCString)+#else+import qualified Data.ByteString.Unsafe as B(unsafeUseAsCString)+#endif import System.IO.Unsafe(unsafePerformIO) import Text.Regex.Base.RegexLike(RegexMaker(..),RegexContext(..),RegexLike(..),MatchOffset,MatchLength) import Text.Regex.Posix.Wrap -- all
Text/Regex/Posix/Wrap.hsc view
@@ -76,16 +76,12 @@ retEspace ) where +#ifndef __NHC__+#include "HsRegexPosixConfig.h"+#else #define HAVE_REGEX_H 1 #define HAVE_REGCOMP 1---- Different from darcs repository version--- #ifndef __NHC__--- #include "HsRegexPosixConfig.h"--- #else--- #define HAVE_REGEX_H 1--- #define HAVE_REGCOMP 1--- #endif+#endif #include <sys/types.h>
+ aclocal.m4 view
@@ -0,0 +1,2 @@+# Empty file to avoid a dependency on automake: autoreconf calls aclocal to+# generate a temporary aclocal.m4t when no aclocal.m4 is present.
+ cbits/COPYRIGHT view
@@ -0,0 +1,56 @@+Copyright 1992, 1993, 1994 Henry Spencer. All rights reserved.+This software is not subject to any license of the American Telephone+and Telegraph Company or of the Regents of the University of California.++Permission is granted to anyone to use this software for any purpose on+any computer system, and to alter it and redistribute it, subject+to the following restrictions:++1. The author is not responsible for the consequences of use of this+ software, no matter how awful, even if they arise from flaws in it.++2. The origin of this software must not be misrepresented, either by+ explicit claim or by omission. Since few users ever read sources,+ credits must appear in the documentation.++3. Altered versions must be plainly marked as such, and must not be+ misrepresented as being the original software. Since few users+ ever read sources, credits must appear in the documentation.++4. This notice may not be removed or altered.++=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=+/*-+ * Copyright (c) 1994+ * The Regents of the University of California. All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)COPYRIGHT 8.1 (Berkeley) 3/16/94+ */
+ cbits/cclass.h view
@@ -0,0 +1,62 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)cclass.h 8.3 (Berkeley) 3/20/94+ */+++typedef enum {CALNUM, CALPHA, CBLANK, CCNTRL, CDIGIT, CGRAPH,+ CLOWER, CPRINT, CPUNCT, CSPACE, CUPPER, CXDIGIT} citype;++/* character-class table */+static struct cclass {+ char *name;+ citype fidx;+} cclasses[] = {+ {"alnum", CALNUM},+ {"alpha", CALPHA},+ {"blank", CBLANK},+ {"cntrl", CCNTRL},+ {"digit", CDIGIT},+ {"graph", CGRAPH},+ {"lower", CLOWER},+ {"print", CPRINT},+ {"punct", CPUNCT},+ {"space", CSPACE},+ {"upper", CUPPER},+ {"xdigit", CXDIGIT},+ {NULL, }+};
+ cbits/cname.h view
@@ -0,0 +1,141 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)cname.h 8.3 (Berkeley) 3/20/94+ */++/* character-name table */+static struct cname {+ char *name;+ char code;+} cnames[] = {+ {"NUL", '\0'},+ {"SOH", '\001'},+ {"STX", '\002'},+ {"ETX", '\003'},+ {"EOT", '\004'},+ {"ENQ", '\005'},+ {"ACK", '\006'},+ {"BEL", '\007'},+ {"alert", '\007'},+ {"BS", '\010'},+ {"backspace", '\b'},+ {"HT", '\011'},+ {"tab", '\t'},+ {"LF", '\012'},+ {"newline", '\n'},+ {"VT", '\013'},+ {"vertical-tab", '\v'},+ {"FF", '\014'},+ {"form-feed", '\f'},+ {"CR", '\015'},+ {"carriage-return", '\r'},+ {"SO", '\016'},+ {"SI", '\017'},+ {"DLE", '\020'},+ {"DC1", '\021'},+ {"DC2", '\022'},+ {"DC3", '\023'},+ {"DC4", '\024'},+ {"NAK", '\025'},+ {"SYN", '\026'},+ {"ETB", '\027'},+ {"CAN", '\030'},+ {"EM", '\031'},+ {"SUB", '\032'},+ {"ESC", '\033'},+ {"IS4", '\034'},+ {"FS", '\034'},+ {"IS3", '\035'},+ {"GS", '\035'},+ {"IS2", '\036'},+ {"RS", '\036'},+ {"IS1", '\037'},+ {"US", '\037'},+ {"space", ' '},+ {"exclamation-mark", '!'},+ {"quotation-mark", '"'},+ {"number-sign", '#'},+ {"dollar-sign", '$'},+ {"percent-sign", '%'},+ {"ampersand", '&'},+ {"apostrophe", '\''},+ {"left-parenthesis", '('},+ {"right-parenthesis", ')'},+ {"asterisk", '*'},+ {"plus-sign", '+'},+ {"comma", ','},+ {"hyphen", '-'},+ {"hyphen-minus", '-'},+ {"period", '.'},+ {"full-stop", '.'},+ {"slash", '/'},+ {"solidus", '/'},+ {"zero", '0'},+ {"one", '1'},+ {"two", '2'},+ {"three", '3'},+ {"four", '4'},+ {"five", '5'},+ {"six", '6'},+ {"seven", '7'},+ {"eight", '8'},+ {"nine", '9'},+ {"colon", ':'},+ {"semicolon", ';'},+ {"less-than-sign", '<'},+ {"equals-sign", '='},+ {"greater-than-sign", '>'},+ {"question-mark", '?'},+ {"commercial-at", '@'},+ {"left-square-bracket", '['},+ {"backslash", '\\'},+ {"reverse-solidus", '\\'},+ {"right-square-bracket",']'},+ {"circumflex", '^'},+ {"circumflex-accent", '^'},+ {"underscore", '_'},+ {"low-line", '_'},+ {"grave-accent", '`'},+ {"left-brace", '{'},+ {"left-curly-bracket", '{'},+ {"vertical-line", '|'},+ {"right-brace", '}'},+ {"right-curly-bracket", '}'},+ {"tilde", '~'},+ {"DEL", '\177'},+ {NULL, 0}+};
+ cbits/engine.c view
@@ -0,0 +1,1139 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)engine.c 8.5 (Berkeley) 3/20/94+ *+ * $FreeBSD: src/lib/libc/regex/engine.c,v 1.5.8.1 2000/07/31 06:30:37 dcs Exp $+ */++/*+ * The matching engine and friends. This file is #included by regexec.c+ * after suitable #defines of a variety of macros used herein, so that+ * different state representations can be used without duplicating masses+ * of code.+ */++#ifdef SNAMES+#define matcher smatcher+#define fast sfast+#define slow sslow+#define dissect sdissect+#define backref sbackref+#define step sstep+#define print sprint+#define at sat+#define match smat+#endif+#ifdef LNAMES+#define matcher lmatcher+#define fast lfast+#define slow lslow+#define dissect ldissect+#define backref lbackref+#define step lstep+#define print lprint+#define at lat+#define match lmat+#endif++/* another structure passed up and down to avoid zillions of parameters */+struct match {+ struct re_guts *g;+ int eflags;+ regmatch_t *pmatch; /* [nsub+1] (0 element unused) */+ char *offp; /* offsets work from here */+ char *beginp; /* start of string -- virtual NUL precedes */+ char *endp; /* end of string -- virtual NUL here */+ char *coldp; /* can be no match starting before here */+ char **lastpos; /* [nplus+1] */+ STATEVARS;+ states st; /* current states */+ states fresh; /* states for a fresh start */+ states tmp; /* temporary */+ states empty; /* empty set of states */+};++/* ========= begin header generated by ./mkh ========= */+#ifdef __cplusplus+extern "C" {+#endif++/* === engine.c === */+static int matcher (struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);+static char *dissect (struct match *m, char *start, char *stop, sopno startst, sopno stopst);+static char *backref (struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);+static char *fast (struct match *m, char *start, char *stop, sopno startst, sopno stopst);+static char *slow (struct match *m, char *start, char *stop, sopno startst, sopno stopst);+static states step (struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft);+#define BOL (OUT+1)+#define EOL (BOL+1)+#define BOLEOL (BOL+2)+#define NOTHING (BOL+3)+#define BOW (BOL+4)+#define EOW (BOL+5)+#define CODEMAX (BOL+5) /* highest code used */+#define NONCHAR(c) ((c) > CHAR_MAX)+#define NNONCHAR (CODEMAX-CHAR_MAX)+#ifdef REDEBUG+static void print (struct match *m, char *caption, states st, int ch, FILE *d);+#endif+#ifdef REDEBUG+static void at __P((struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst));+#endif+#ifdef REDEBUG+static char *pchar __P((int ch));+#endif++#ifdef __cplusplus+}+#endif+/* ========= end header generated by ./mkh ========= */++#ifdef REDEBUG+#define SP(t, s, c) print(m, t, s, c, stdout)+#define AT(t, p1, p2, s1, s2) at(m, t, p1, p2, s1, s2)+#define NOTE(str) { if (m->eflags®_TRACE) printf("=%s\n", (str)); }+#else+#define SP(t, s, c) /* nothing */+#define AT(t, p1, p2, s1, s2) /* nothing */+#define NOTE(s) /* nothing */+#endif++/*+ - matcher - the actual matching engine+ == static int matcher(register struct re_guts *g, char *string, \+ == size_t nmatch, regmatch_t pmatch[], int eflags);+ */+static int /* 0 success, REG_NOMATCH failure */+matcher(g, string, nmatch, pmatch, eflags)+register struct re_guts *g;+char *string;+size_t nmatch;+regmatch_t pmatch[];+int eflags;+{+ register char *endp;+ register int i;+ struct match mv;+ register struct match *m = &mv;+ register char *dp;+ register const sopno gf = g->firststate+1; /* +1 for OEND */+ register const sopno gl = g->laststate;+ char *start;+ char *stop;+ /* Boyer-Moore algorithms variables */+ register char *pp;+ int cj, mj;+ register char *mustfirst;+ register char *mustlast;+ register int *matchjump;+ register int *charjump;++ /* simplify the situation where possible */+ if (g->cflags®_NOSUB)+ nmatch = 0;+ if (eflags®_STARTEND) {+ start = string + pmatch[0].rm_so;+ stop = string + pmatch[0].rm_eo;+ } else {+ start = string;+ stop = start + strlen(start);+ }+ if (stop < start)+ return(REG_INVARG);++ /* prescreening; this does wonders for this rather slow code */+ if (g->must != NULL) {+ if (g->charjump != NULL && g->matchjump != NULL) {+ mustfirst = g->must;+ mustlast = g->must + g->mlen - 1;+ charjump = g->charjump;+ matchjump = g->matchjump;+ pp = mustlast;+ for (dp = start+g->mlen-1; dp < stop;) {+ /* Fast skip non-matches */+ while (dp < stop && charjump[*dp])+ dp += charjump[*dp];++ if (dp >= stop)+ break;++ /* Greedy matcher */+ /* We depend on not being used for+ * for strings of length 1+ */+ while (*--dp == *--pp && pp != mustfirst);++ if (*dp == *pp)+ break;++ /* Jump to next possible match */+ mj = matchjump[pp - mustfirst];+ cj = charjump[*dp];+ dp += (cj < mj ? mj : cj);+ pp = mustlast;+ }+ if (pp != mustfirst)+ return(REG_NOMATCH);+ } else {+ for (dp = start; dp < stop; dp++)+ if (*dp == g->must[0] &&+ stop - dp >= g->mlen &&+ memcmp(dp, g->must, (size_t)g->mlen) == 0)+ break;+ if (dp == stop) /* we didn't find g->must */+ return(REG_NOMATCH);+ }+ }++ /* match struct setup */+ m->g = g;+ m->eflags = eflags;+ m->pmatch = NULL;+ m->lastpos = NULL;+ m->offp = string;+ m->beginp = start;+ m->endp = stop;+ STATESETUP(m, 4);+ SETUP(m->st);+ SETUP(m->fresh);+ SETUP(m->tmp);+ SETUP(m->empty);+ CLEAR(m->empty);++ /* Adjust start according to moffset, to speed things up */+ if (g->moffset > -1)+ start = ((dp - g->moffset) < start) ? start : dp - g->moffset;++ /* this loop does only one repetition except for backrefs */+ for (;;) {+ endp = fast(m, start, stop, gf, gl);+ if (endp == NULL) { /* a miss */+ STATETEARDOWN(m);+ return(REG_NOMATCH);+ }+ if (nmatch == 0 && !g->backrefs)+ break; /* no further info needed */++ /* where? */+ assert(m->coldp != NULL);+ for (;;) {+ NOTE("finding start");+ endp = slow(m, m->coldp, stop, gf, gl);+ if (endp != NULL)+ break;+ assert(m->coldp < m->endp);+ m->coldp++;+ }+ if (nmatch == 1 && !g->backrefs)+ break; /* no further info needed */++ /* oh my, he wants the subexpressions... */+ if (m->pmatch == NULL)+ m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *+ sizeof(regmatch_t));+ if (m->pmatch == NULL) {+ STATETEARDOWN(m);+ return(REG_ESPACE);+ }+ for (i = 1; i <= m->g->nsub; i++)+ m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;+ if (!g->backrefs && !(m->eflags®_BACKR)) {+ NOTE("dissecting");+ dp = dissect(m, m->coldp, endp, gf, gl);+ } else {+ if (g->nplus > 0 && m->lastpos == NULL)+ m->lastpos = (char **)malloc((g->nplus+1) *+ sizeof(char *));+ if (g->nplus > 0 && m->lastpos == NULL) {+ free(m->pmatch);+ STATETEARDOWN(m);+ return(REG_ESPACE);+ }+ NOTE("backref dissect");+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);+ }+ if (dp != NULL)+ break;++ /* uh-oh... we couldn't find a subexpression-level match */+ assert(g->backrefs); /* must be back references doing it */+ assert(g->nplus == 0 || m->lastpos != NULL);+ for (;;) {+ if (dp != NULL || endp <= m->coldp)+ break; /* defeat */+ NOTE("backoff");+ endp = slow(m, m->coldp, endp-1, gf, gl);+ if (endp == NULL)+ break; /* defeat */+ /* try it on a shorter possibility */+#ifndef NDEBUG+ for (i = 1; i <= m->g->nsub; i++) {+ assert(m->pmatch[i].rm_so == -1);+ assert(m->pmatch[i].rm_eo == -1);+ }+#endif+ NOTE("backoff dissect");+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);+ }+ assert(dp == NULL || dp == endp);+ if (dp != NULL) /* found a shorter one */+ break;++ /* despite initial appearances, there is no match here */+ NOTE("false alarm");+ start = m->coldp + 1; /* recycle starting later */+ assert(start <= stop);+ }++ /* fill in the details if requested */+ if (nmatch > 0) {+ pmatch[0].rm_so = m->coldp - m->offp;+ pmatch[0].rm_eo = endp - m->offp;+ }+ if (nmatch > 1) {+ assert(m->pmatch != NULL);+ for (i = 1; i < nmatch; i++)+ if (i <= m->g->nsub)+ pmatch[i] = m->pmatch[i];+ else {+ pmatch[i].rm_so = -1;+ pmatch[i].rm_eo = -1;+ }+ }++ if (m->pmatch != NULL)+ free((char *)m->pmatch);+ if (m->lastpos != NULL)+ free((char *)m->lastpos);+ STATETEARDOWN(m);+ return(0);+}++/*+ - dissect - figure out what matched what, no back references+ == static char *dissect(register struct match *m, char *start, \+ == char *stop, sopno startst, sopno stopst);+ */+static char * /* == stop (success) always */+dissect(m, start, stop, startst, stopst)+register struct match *m;+char *start;+char *stop;+sopno startst;+sopno stopst;+{+ register int i;+ register sopno ss; /* start sop of current subRE */+ register sopno es; /* end sop of current subRE */+ register char *sp; /* start of string matched by it */+ register char *stp; /* string matched by it cannot pass here */+ register char *rest; /* start of rest of string */+ register char *tail; /* string unmatched by rest of RE */+ register sopno ssub; /* start sop of subsubRE */+ register sopno esub; /* end sop of subsubRE */+ register char *ssp; /* start of string matched by subsubRE */+ register char *sep; /* end of string matched by subsubRE */+ register char *oldssp; /* previous ssp */+ register char *dp;++ AT("diss", start, stop, startst, stopst);+ sp = start;+ for (ss = startst; ss < stopst; ss = es) {+ /* identify end of subRE */+ es = ss;+ switch (OP(m->g->strip[es])) {+ case OPLUS_:+ case OQUEST_:+ es += OPND(m->g->strip[es]);+ break;+ case OCH_:+ while (OP(m->g->strip[es]) != O_CH)+ es += OPND(m->g->strip[es]);+ break;+ }+ es++;++ /* figure out what it matched */+ switch (OP(m->g->strip[ss])) {+ case OEND:+ assert(nope);+ break;+ case OCHAR:+ sp++;+ break;+ case OBOL:+ case OEOL:+ case OBOW:+ case OEOW:+ break;+ case OANY:+ case OANYOF:+ sp++;+ break;+ case OBACK_:+ case O_BACK:+ assert(nope);+ break;+ /* cases where length of match is hard to find */+ case OQUEST_:+ stp = stop;+ for (;;) {+ /* how long could this one be? */+ rest = slow(m, sp, stp, ss, es);+ assert(rest != NULL); /* it did match */+ /* could the rest match the rest? */+ tail = slow(m, rest, stop, es, stopst);+ if (tail == stop)+ break; /* yes! */+ /* no -- try a shorter match for this one */+ stp = rest - 1;+ assert(stp >= sp); /* it did work */+ }+ ssub = ss + 1;+ esub = es - 1;+ /* did innards match? */+ if (slow(m, sp, rest, ssub, esub) != NULL) {+ dp = dissect(m, sp, rest, ssub, esub);+ assert(dp == rest);+ } else /* no */+ assert(sp == rest);+ sp = rest;+ break;+ case OPLUS_:+ stp = stop;+ for (;;) {+ /* how long could this one be? */+ rest = slow(m, sp, stp, ss, es);+ assert(rest != NULL); /* it did match */+ /* could the rest match the rest? */+ tail = slow(m, rest, stop, es, stopst);+ if (tail == stop)+ break; /* yes! */+ /* no -- try a shorter match for this one */+ stp = rest - 1;+ assert(stp >= sp); /* it did work */+ }+ ssub = ss + 1;+ esub = es - 1;+ ssp = sp;+ oldssp = ssp;+ for (;;) { /* find last match of innards */+ sep = slow(m, ssp, rest, ssub, esub);+ if (sep == NULL || sep == ssp)+ break; /* failed or matched null */+ oldssp = ssp; /* on to next try */+ ssp = sep;+ }+ if (sep == NULL) {+ /* last successful match */+ sep = ssp;+ ssp = oldssp;+ }+ assert(sep == rest); /* must exhaust substring */+ assert(slow(m, ssp, sep, ssub, esub) == rest);+ dp = dissect(m, ssp, sep, ssub, esub);+ assert(dp == sep);+ sp = rest;+ break;+ case OCH_:+ stp = stop;+ for (;;) {+ /* how long could this one be? */+ rest = slow(m, sp, stp, ss, es);+ assert(rest != NULL); /* it did match */+ /* could the rest match the rest? */+ tail = slow(m, rest, stop, es, stopst);+ if (tail == stop)+ break; /* yes! */+ /* no -- try a shorter match for this one */+ stp = rest - 1;+ assert(stp >= sp); /* it did work */+ }+ ssub = ss + 1;+ esub = ss + OPND(m->g->strip[ss]) - 1;+ assert(OP(m->g->strip[esub]) == OOR1);+ for (;;) { /* find first matching branch */+ if (slow(m, sp, rest, ssub, esub) == rest)+ break; /* it matched all of it */+ /* that one missed, try next one */+ assert(OP(m->g->strip[esub]) == OOR1);+ esub++;+ assert(OP(m->g->strip[esub]) == OOR2);+ ssub = esub + 1;+ esub += OPND(m->g->strip[esub]);+ if (OP(m->g->strip[esub]) == OOR2)+ esub--;+ else+ assert(OP(m->g->strip[esub]) == O_CH);+ }+ dp = dissect(m, sp, rest, ssub, esub);+ assert(dp == rest);+ sp = rest;+ break;+ case O_PLUS:+ case O_QUEST:+ case OOR1:+ case OOR2:+ case O_CH:+ assert(nope);+ break;+ case OLPAREN:+ i = OPND(m->g->strip[ss]);+ assert(0 < i && i <= m->g->nsub);+ m->pmatch[i].rm_so = sp - m->offp;+ break;+ case ORPAREN:+ i = OPND(m->g->strip[ss]);+ assert(0 < i && i <= m->g->nsub);+ m->pmatch[i].rm_eo = sp - m->offp;+ break;+ default: /* uh oh */+ assert(nope);+ break;+ }+ }++ assert(sp == stop);+ return(sp);+}++/*+ - backref - figure out what matched what, figuring in back references+ == static char *backref(register struct match *m, char *start, \+ == char *stop, sopno startst, sopno stopst, sopno lev);+ */+static char * /* == stop (success) or NULL (failure) */+backref(m, start, stop, startst, stopst, lev)+register struct match *m;+char *start;+char *stop;+sopno startst;+sopno stopst;+sopno lev; /* PLUS nesting level */+{+ register int i;+ register sopno ss; /* start sop of current subRE */+ register char *sp; /* start of string matched by it */+ register sopno ssub; /* start sop of subsubRE */+ register sopno esub; /* end sop of subsubRE */+ register char *ssp; /* start of string matched by subsubRE */+ register char *dp;+ register size_t len;+ register int hard;+ register sop s;+ register regoff_t offsave;+ register cset *cs;++ AT("back", start, stop, startst, stopst);+ sp = start;++ /* get as far as we can with easy stuff */+ hard = 0;+ for (ss = startst; !hard && ss < stopst; ss++)+ switch (OP(s = m->g->strip[ss])) {+ case OCHAR:+ if (sp == stop || *sp++ != (char)OPND(s))+ return(NULL);+ break;+ case OANY:+ if (sp == stop)+ return(NULL);+ sp++;+ break;+ case OANYOF:+ cs = &m->g->sets[OPND(s)];+ if (sp == stop || !CHIN(cs, *sp++))+ return(NULL);+ break;+ case OBOL:+ if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||+ (sp < m->endp && *(sp-1) == '\n' &&+ (m->g->cflags®_NEWLINE)) )+ { /* yes */ }+ else+ return(NULL);+ break;+ case OEOL:+ if ( (sp == m->endp && !(m->eflags®_NOTEOL)) ||+ (sp < m->endp && *sp == '\n' &&+ (m->g->cflags®_NEWLINE)) )+ { /* yes */ }+ else+ return(NULL);+ break;+ case OBOW:+ if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||+ (sp < m->endp && *(sp-1) == '\n' &&+ (m->g->cflags®_NEWLINE)) ||+ (sp > m->beginp &&+ !ISWORD(*(sp-1))) ) &&+ (sp < m->endp && ISWORD(*sp)) )+ { /* yes */ }+ else+ return(NULL);+ break;+ case OEOW:+ if (( (sp == m->endp && !(m->eflags®_NOTEOL)) ||+ (sp < m->endp && *sp == '\n' &&+ (m->g->cflags®_NEWLINE)) ||+ (sp < m->endp && !ISWORD(*sp)) ) &&+ (sp > m->beginp && ISWORD(*(sp-1))) )+ { /* yes */ }+ else+ return(NULL);+ break;+ case O_QUEST:+ break;+ case OOR1: /* matches null but needs to skip */+ ss++;+ s = m->g->strip[ss];+ do {+ assert(OP(s) == OOR2);+ ss += OPND(s);+ } while (OP(s = m->g->strip[ss]) != O_CH);+ /* note that the ss++ gets us past the O_CH */+ break;+ default: /* have to make a choice */+ hard = 1;+ break;+ }+ if (!hard) { /* that was it! */+ if (sp != stop)+ return(NULL);+ return(sp);+ }+ ss--; /* adjust for the for's final increment */++ /* the hard stuff */+ AT("hard", sp, stop, ss, stopst);+ s = m->g->strip[ss];+ switch (OP(s)) {+ case OBACK_: /* the vilest depths */+ i = OPND(s);+ assert(0 < i && i <= m->g->nsub);+ if (m->pmatch[i].rm_eo == -1)+ return(NULL);+ assert(m->pmatch[i].rm_so != -1);+ len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;+ assert(stop - m->beginp >= len);+ if (sp > stop - len)+ return(NULL); /* not enough left to match */+ ssp = m->offp + m->pmatch[i].rm_so;+ if (memcmp(sp, ssp, len) != 0)+ return(NULL);+ while (m->g->strip[ss] != SOP(O_BACK, i))+ ss++;+ return(backref(m, sp+len, stop, ss+1, stopst, lev));+ break;+ case OQUEST_: /* to null or not */+ dp = backref(m, sp, stop, ss+1, stopst, lev);+ if (dp != NULL)+ return(dp); /* not */+ return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));+ break;+ case OPLUS_:+ assert(m->lastpos != NULL);+ assert(lev+1 <= m->g->nplus);+ m->lastpos[lev+1] = sp;+ return(backref(m, sp, stop, ss+1, stopst, lev+1));+ break;+ case O_PLUS:+ if (sp == m->lastpos[lev]) /* last pass matched null */+ return(backref(m, sp, stop, ss+1, stopst, lev-1));+ /* try another pass */+ m->lastpos[lev] = sp;+ dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);+ if (dp == NULL)+ return(backref(m, sp, stop, ss+1, stopst, lev-1));+ else+ return(dp);+ break;+ case OCH_: /* find the right one, if any */+ ssub = ss + 1;+ esub = ss + OPND(s) - 1;+ assert(OP(m->g->strip[esub]) == OOR1);+ for (;;) { /* find first matching branch */+ dp = backref(m, sp, stop, ssub, esub, lev);+ if (dp != NULL)+ return(dp);+ /* that one missed, try next one */+ if (OP(m->g->strip[esub]) == O_CH)+ return(NULL); /* there is none */+ esub++;+ assert(OP(m->g->strip[esub]) == OOR2);+ ssub = esub + 1;+ esub += OPND(m->g->strip[esub]);+ if (OP(m->g->strip[esub]) == OOR2)+ esub--;+ else+ assert(OP(m->g->strip[esub]) == O_CH);+ }+ break;+ case OLPAREN: /* must undo assignment if rest fails */+ i = OPND(s);+ assert(0 < i && i <= m->g->nsub);+ offsave = m->pmatch[i].rm_so;+ m->pmatch[i].rm_so = sp - m->offp;+ dp = backref(m, sp, stop, ss+1, stopst, lev);+ if (dp != NULL)+ return(dp);+ m->pmatch[i].rm_so = offsave;+ return(NULL);+ break;+ case ORPAREN: /* must undo assignment if rest fails */+ i = OPND(s);+ assert(0 < i && i <= m->g->nsub);+ offsave = m->pmatch[i].rm_eo;+ m->pmatch[i].rm_eo = sp - m->offp;+ dp = backref(m, sp, stop, ss+1, stopst, lev);+ if (dp != NULL)+ return(dp);+ m->pmatch[i].rm_eo = offsave;+ return(NULL);+ break;+ default: /* uh oh */+ assert(nope);+ break;+ }++ /* "can't happen" */+ assert(nope);+ /* NOTREACHED */+ return "shut up gcc";+}++/*+ - fast - step through the string at top speed+ == static char *fast(register struct match *m, char *start, \+ == char *stop, sopno startst, sopno stopst);+ */+static char * /* where tentative match ended, or NULL */+fast(m, start, stop, startst, stopst)+register struct match *m;+char *start;+char *stop;+sopno startst;+sopno stopst;+{+ register states st = m->st;+ register states fresh = m->fresh;+ register states tmp = m->tmp;+ register char *p = start;+ register int c = (start == m->beginp) ? OUT : *(start-1);+ register int lastc; /* previous c */+ register int flagch;+ register int i;+ register char *coldp; /* last p after which no match was underway */++ CLEAR(st);+ SET1(st, startst);+ st = step(m->g, startst, stopst, st, NOTHING, st);+ ASSIGN(fresh, st);+ SP("start", st, *p);+ coldp = NULL;+ for (;;) {+ /* next character */+ lastc = c;+ c = (p == m->endp) ? OUT : *p;+ if (EQ(st, fresh))+ coldp = p;++ /* is there an EOL and/or BOL between lastc and c? */+ flagch = '\0';+ i = 0;+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {+ flagch = BOL;+ i = m->g->nbol;+ }+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||+ (c == OUT && !(m->eflags®_NOTEOL)) ) {+ flagch = (flagch == BOL) ? BOLEOL : EOL;+ i += m->g->neol;+ }+ if (i != 0) {+ for (; i > 0; i--)+ st = step(m->g, startst, stopst, st, flagch, st);+ SP("boleol", st, c);+ }++ /* how about a word boundary? */+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&+ (c != OUT && ISWORD(c)) ) {+ flagch = BOW;+ }+ if ( (lastc != OUT && ISWORD(lastc)) &&+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {+ flagch = EOW;+ }+ if (flagch == BOW || flagch == EOW) {+ st = step(m->g, startst, stopst, st, flagch, st);+ SP("boweow", st, c);+ }++ /* are we done? */+ if (ISSET(st, stopst) || p == stop)+ break; /* NOTE BREAK OUT */++ /* no, we must deal with this character */+ ASSIGN(tmp, st);+ ASSIGN(st, fresh);+ assert(c != OUT);+ st = step(m->g, startst, stopst, tmp, c, st);+ SP("aft", st, c);+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));+ p++;+ }++ assert(coldp != NULL);+ m->coldp = coldp;+ if (ISSET(st, stopst))+ return(p+1);+ else+ return(NULL);+}++/*+ - slow - step through the string more deliberately+ == static char *slow(register struct match *m, char *start, \+ == char *stop, sopno startst, sopno stopst);+ */+static char * /* where it ended */+slow(m, start, stop, startst, stopst)+register struct match *m;+char *start;+char *stop;+sopno startst;+sopno stopst;+{+ register states st = m->st;+ register states empty = m->empty;+ register states tmp = m->tmp;+ register char *p = start;+ register int c = (start == m->beginp) ? OUT : *(start-1);+ register int lastc; /* previous c */+ register int flagch;+ register int i;+ register char *matchp; /* last p at which a match ended */++ AT("slow", start, stop, startst, stopst);+ CLEAR(st);+ SET1(st, startst);+ SP("sstart", st, *p);+ st = step(m->g, startst, stopst, st, NOTHING, st);+ matchp = NULL;+ for (;;) {+ /* next character */+ lastc = c;+ c = (p == m->endp) ? OUT : *p;++ /* is there an EOL and/or BOL between lastc and c? */+ flagch = '\0';+ i = 0;+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {+ flagch = BOL;+ i = m->g->nbol;+ }+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||+ (c == OUT && !(m->eflags®_NOTEOL)) ) {+ flagch = (flagch == BOL) ? BOLEOL : EOL;+ i += m->g->neol;+ }+ if (i != 0) {+ for (; i > 0; i--)+ st = step(m->g, startst, stopst, st, flagch, st);+ SP("sboleol", st, c);+ }++ /* how about a word boundary? */+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&+ (c != OUT && ISWORD(c)) ) {+ flagch = BOW;+ }+ if ( (lastc != OUT && ISWORD(lastc)) &&+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {+ flagch = EOW;+ }+ if (flagch == BOW || flagch == EOW) {+ st = step(m->g, startst, stopst, st, flagch, st);+ SP("sboweow", st, c);+ }++ /* are we done? */+ if (ISSET(st, stopst))+ matchp = p;+ if (EQ(st, empty) || p == stop)+ break; /* NOTE BREAK OUT */++ /* no, we must deal with this character */+ ASSIGN(tmp, st);+ ASSIGN(st, empty);+ assert(c != OUT);+ st = step(m->g, startst, stopst, tmp, c, st);+ SP("saft", st, c);+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));+ p++;+ }++ return(matchp);+}+++/*+ - step - map set of states reachable before char to set reachable after+ == static states step(register struct re_guts *g, sopno start, sopno stop, \+ == register states bef, int ch, register states aft);+ == #define BOL (OUT+1)+ == #define EOL (BOL+1)+ == #define BOLEOL (BOL+2)+ == #define NOTHING (BOL+3)+ == #define BOW (BOL+4)+ == #define EOW (BOL+5)+ == #define CODEMAX (BOL+5) // highest code used+ == #define NONCHAR(c) ((c) > CHAR_MAX)+ == #define NNONCHAR (CODEMAX-CHAR_MAX)+ */+static states+step(g, start, stop, bef, ch, aft)+register struct re_guts *g;+sopno start; /* start state within strip */+sopno stop; /* state after stop state within strip */+register states bef; /* states reachable before */+int ch; /* character or NONCHAR code */+register states aft; /* states already known reachable after */+{+ register cset *cs;+ register sop s;+ register sopno pc;+ register onestate here; /* note, macros know this name */+ register sopno look;+ register int i;++ for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {+ s = g->strip[pc];+ switch (OP(s)) {+ case OEND:+ assert(pc == stop-1);+ break;+ case OCHAR:+ /* only characters can match */+ assert(!NONCHAR(ch) || ch != (char)OPND(s));+ if (ch == (char)OPND(s))+ FWD(aft, bef, 1);+ break;+ case OBOL:+ if (ch == BOL || ch == BOLEOL)+ FWD(aft, bef, 1);+ break;+ case OEOL:+ if (ch == EOL || ch == BOLEOL)+ FWD(aft, bef, 1);+ break;+ case OBOW:+ if (ch == BOW)+ FWD(aft, bef, 1);+ break;+ case OEOW:+ if (ch == EOW)+ FWD(aft, bef, 1);+ break;+ case OANY:+ if (!NONCHAR(ch))+ FWD(aft, bef, 1);+ break;+ case OANYOF:+ cs = &g->sets[OPND(s)];+ if (!NONCHAR(ch) && CHIN(cs, ch))+ FWD(aft, bef, 1);+ break;+ case OBACK_: /* ignored here */+ case O_BACK:+ FWD(aft, aft, 1);+ break;+ case OPLUS_: /* forward, this is just an empty */+ FWD(aft, aft, 1);+ break;+ case O_PLUS: /* both forward and back */+ FWD(aft, aft, 1);+ i = ISSETBACK(aft, OPND(s));+ BACK(aft, aft, OPND(s));+ if (!i && ISSETBACK(aft, OPND(s))) {+ /* oho, must reconsider loop body */+ pc -= OPND(s) + 1;+ INIT(here, pc);+ }+ break;+ case OQUEST_: /* two branches, both forward */+ FWD(aft, aft, 1);+ FWD(aft, aft, OPND(s));+ break;+ case O_QUEST: /* just an empty */+ FWD(aft, aft, 1);+ break;+ case OLPAREN: /* not significant here */+ case ORPAREN:+ FWD(aft, aft, 1);+ break;+ case OCH_: /* mark the first two branches */+ FWD(aft, aft, 1);+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);+ FWD(aft, aft, OPND(s));+ break;+ case OOR1: /* done a branch, find the O_CH */+ if (ISSTATEIN(aft, here)) {+ for (look = 1;+ OP(s = g->strip[pc+look]) != O_CH;+ look += OPND(s))+ assert(OP(s) == OOR2);+ FWD(aft, aft, look);+ }+ break;+ case OOR2: /* propagate OCH_'s marking */+ FWD(aft, aft, 1);+ if (OP(g->strip[pc+OPND(s)]) != O_CH) {+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);+ FWD(aft, aft, OPND(s));+ }+ break;+ case O_CH: /* just empty */+ FWD(aft, aft, 1);+ break;+ default: /* ooooops... */+ assert(nope);+ break;+ }+ }++ return(aft);+}++#ifdef REDEBUG+/*+ - print - print a set of states+ == #ifdef REDEBUG+ == static void print(struct match *m, char *caption, states st, \+ == int ch, FILE *d);+ == #endif+ */+static void+print(m, caption, st, ch, d)+struct match *m;+char *caption;+states st;+int ch;+FILE *d;+{+ register struct re_guts *g = m->g;+ register int i;+ register int first = 1;++ if (!(m->eflags®_TRACE))+ return;++ fprintf(d, "%s", caption);+ if (ch != '\0')+ fprintf(d, " %s", pchar(ch));+ for (i = 0; i < g->nstates; i++)+ if (ISSET(st, i)) {+ fprintf(d, "%s%d", (first) ? "\t" : ", ", i);+ first = 0;+ }+ fprintf(d, "\n");+}++/*+ - at - print current situation+ == #ifdef REDEBUG+ == static void at(struct match *m, char *title, char *start, char *stop, \+ == sopno startst, sopno stopst);+ == #endif+ */+static void+at(m, title, start, stop, startst, stopst)+struct match *m;+char *title;+char *start;+char *stop;+sopno startst;+sopno stopst;+{+ if (!(m->eflags®_TRACE))+ return;++ printf("%s %s-", title, pchar(*start));+ printf("%s ", pchar(*stop));+ printf("%ld-%ld\n", (long)startst, (long)stopst);+}++#ifndef PCHARDONE+#define PCHARDONE /* never again */+/*+ - pchar - make a character printable+ == #ifdef REDEBUG+ == static char *pchar(int ch);+ == #endif+ *+ * Is this identical to regchar() over in debug.c? Well, yes. But a+ * duplicate here avoids having a debugging-capable regexec.o tied to+ * a matching debug.o, and this is convenient. It all disappears in+ * the non-debug compilation anyway, so it doesn't matter much.+ */+static char * /* -> representation */+pchar(ch)+int ch;+{+ static char pbuf[10];++ if (isprint((uch)ch) || ch == ' ')+ sprintf(pbuf, "%c", ch);+ else+ sprintf(pbuf, "\\%o", ch);+ return(pbuf);+}+#endif+#endif++#undef matcher+#undef fast+#undef slow+#undef dissect+#undef backref+#undef step+#undef print+#undef at+#undef match
+ cbits/reallocf.c view
@@ -0,0 +1,39 @@+/*-+ * Copyright (c) 1998, M. Warner Losh <imp@freebsd.org>+ * All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ *+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.+ *+ * $FreeBSD: src/lib/libc/stdlib/reallocf.c,v 1.3 1999/08/28 00:01:37 peter Exp $+ */+#include <stdlib.h>++void *+reallocf(void *ptr, size_t size)+{+ void *nptr;++ nptr = realloc(ptr, size);+ if (!nptr && ptr)+ free(ptr);+ return (nptr);+}
+ cbits/regcomp.c view
@@ -0,0 +1,2099 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regcomp.c 8.5 (Berkeley) 3/20/94+ *+ * $FreeBSD: src/lib/libc/regex/regcomp.c,v 1.13.2.1 2000/07/31 06:30:37 dcs Exp $+ */++#if defined(LIBC_SCCS) && !defined(lint)+static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";+#endif /* LIBC_SCCS and not lint */++#include <sys/types.h>+#include <stdio.h>+#include <string.h>+#include <ctype.h>+#include <limits.h>+#include <stdlib.h>+#include "regex/regex.h"++// removed collate stuff --SDM+// #include "collate.h"++#ifdef _WIN32+#define isblank(c) ((c) == ' ' || (c) == '\t')+#endif++#include "utils.h"+#include "regex2.h"++#include "cclass.h"+#include "cname.h"++/*+ * parse structure, passed up and down to avoid global variables and+ * other clumsinesses+ */+struct parse {+ char *next; /* next character in RE */+ char *end; /* end of string (-> NUL normally) */+ int error; /* has an error been seen? */+ sop *strip; /* malloced strip */+ sopno ssize; /* malloced strip size (allocated) */+ sopno slen; /* malloced strip length (used) */+ int ncsalloc; /* number of csets allocated */+ struct re_guts *g;+# define NPAREN 10 /* we need to remember () 1-9 for back refs */+ sopno pbegin[NPAREN]; /* -> ( ([0] unused) */+ sopno pend[NPAREN]; /* -> ) ([0] unused) */+};++/* ========= begin header generated by ./mkh ========= */+#ifdef __cplusplus+extern "C" {+#endif++/* === regcomp.c === */+static void p_ere (struct parse *p, int stop);+static void p_ere_exp (struct parse *p);+static void p_str (struct parse *p);+static void p_bre (struct parse *p, int end1, int end2);+static int p_simp_re (struct parse *p, int starordinary);+static int p_count (struct parse *p);+static void p_bracket (struct parse *p);+static void p_b_term (struct parse *p, cset *cs);+static void p_b_cclass (struct parse *p, cset *cs);+static void p_b_eclass (struct parse *p, cset *cs);+static char p_b_symbol (struct parse *p);+static char p_b_coll_elem (struct parse *p, int endc);+static char othercase (int ch);+static void bothcases (struct parse *p, int ch);+static void ordinary (struct parse *p, int ch);+static void nonnewline (struct parse *p);+static void repeat (struct parse *p, sopno start, int from, int to);+static int seterr (struct parse *p, int e);+static cset *allocset (struct parse *p);+static void freeset (struct parse *p, cset *cs);+static int freezeset (struct parse *p, cset *cs);+static int firstch (struct parse *p, cset *cs);+static int nch (struct parse *p, cset *cs);+static void mcadd (struct parse *p, cset *cs, char *cp);+#if used+static void mcsub (cset *cs, char *cp);+static int mcin (cset *cs, char *cp);+static char *mcfind (cset *cs, char *cp);+#endif+static void mcinvert (struct parse *p, cset *cs);+static void mccase (struct parse *p, cset *cs);+static int isinsets (struct re_guts *g, int c);+static int samesets (struct re_guts *g, int c1, int c2);+static void categorize (struct parse *p, struct re_guts *g);+static sopno dupl (struct parse *p, sopno start, sopno finish);+static void doemit (struct parse *p, sop op, size_t opnd);+static void doinsert (struct parse *p, sop op, size_t opnd, sopno pos);+static void dofwd (struct parse *p, sopno pos, sop value);+static void enlarge (struct parse *p, sopno size);+static void stripsnug (struct parse *p, struct re_guts *g);+static void findmust (struct parse *p, struct re_guts *g);+static int altoffset (sop *scan, int offset, int mccs);+static void computejumps (struct parse *p, struct re_guts *g);+static void computematchjumps (struct parse *p, struct re_guts *g);+static sopno pluscount (struct parse *p, struct re_guts *g);++#ifdef __cplusplus+}+#endif+/* ========= end header generated by ./mkh ========= */++static char nuls[10]; /* place to point scanner in event of error */++/*+ * macros for use with parse structure+ * BEWARE: these know that the parse structure is named `p' !!!+ */+#define PEEK() (*p->next)+#define PEEK2() (*(p->next+1))+#define MORE() (p->next < p->end)+#define MORE2() (p->next+1 < p->end)+#define SEE(c) (MORE() && PEEK() == (c))+#define SEETWO(a, b) (MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))+#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0)+#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0)+#define NEXT() (p->next++)+#define NEXT2() (p->next += 2)+#define NEXTn(n) (p->next += (n))+#define GETNEXT() (*p->next++)+#define SETERROR(e) seterr(p, (e))+#define REQUIRE(co, e) ((co) || SETERROR(e))+#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e))+#define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e))+#define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e))+#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))+#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos)+#define AHEAD(pos) dofwd(p, pos, HERE()-(pos))+#define ASTERN(sop, pos) EMIT(sop, HERE()-pos)+#define HERE() (p->slen)+#define THERE() (p->slen - 1)+#define THERETHERE() (p->slen - 2)+#define DROP(n) (p->slen -= (n))++#ifndef NDEBUG+static int never = 0; /* for use in asserts; shuts lint up */+#else+#define never 0 /* some <assert.h>s have bugs too */+#endif++/* Macro used by computejump()/computematchjump() */+#define MIN(a,b) ((a)<(b)?(a):(b))++/*+ - regcomp - interface for parser and compilation+ = extern int regcomp(regex_t *, const char *, int);+ = #define REG_BASIC 0000+ = #define REG_EXTENDED 0001+ = #define REG_ICASE 0002+ = #define REG_NOSUB 0004+ = #define REG_NEWLINE 0010+ = #define REG_NOSPEC 0020+ = #define REG_PEND 0040+ = #define REG_DUMP 0200+ */+int /* 0 success, otherwise REG_something */+regcomp(preg, pattern, cflags)+regex_t *preg;+const char *pattern;+int cflags;+{+ struct parse pa;+ register struct re_guts *g;+ register struct parse *p = &pa;+ register int i;+ register size_t len;+#ifdef REDEBUG+# define GOODFLAGS(f) (f)+#else+# define GOODFLAGS(f) ((f)&~REG_DUMP)+#endif++ cflags = GOODFLAGS(cflags);+ if ((cflags®_EXTENDED) && (cflags®_NOSPEC))+ return(REG_INVARG);++ if (cflags®_PEND) {+ if (preg->re_endp < pattern)+ return(REG_INVARG);+ len = preg->re_endp - pattern;+ } else+ len = strlen((char *)pattern);++ /* do the mallocs early so failure handling is easy */+ g = (struct re_guts *)malloc(sizeof(struct re_guts) ++ (NC-1)*sizeof(cat_t));+ if (g == NULL)+ return(REG_ESPACE);+ p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */+ p->strip = (sop *)malloc(p->ssize * sizeof(sop));+ p->slen = 0;+ if (p->strip == NULL) {+ free((char *)g);+ return(REG_ESPACE);+ }++ /* set things up */+ p->g = g;+ p->next = (char *)pattern; /* convenience; we do not modify it */+ p->end = p->next + len;+ p->error = 0;+ p->ncsalloc = 0;+ for (i = 0; i < NPAREN; i++) {+ p->pbegin[i] = 0;+ p->pend[i] = 0;+ }+ g->csetsize = NC;+ g->sets = NULL;+ g->setbits = NULL;+ g->ncsets = 0;+ g->cflags = cflags;+ g->iflags = 0;+ g->nbol = 0;+ g->neol = 0;+ g->must = NULL;+ g->moffset = -1;+ g->charjump = NULL;+ g->matchjump = NULL;+ g->mlen = 0;+ g->nsub = 0;+ g->ncategories = 1; /* category 0 is "everything else" */+ g->categories = &g->catspace[-(CHAR_MIN)];+ (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));+ g->backrefs = 0;++ /* do it */+ EMIT(OEND, 0);+ g->firststate = THERE();+ if (cflags®_EXTENDED)+ p_ere(p, OUT);+ else if (cflags®_NOSPEC)+ p_str(p);+ else+ p_bre(p, OUT, OUT);+ EMIT(OEND, 0);+ g->laststate = THERE();++ /* tidy up loose ends and fill things in */+ categorize(p, g);+ stripsnug(p, g);+ findmust(p, g);+ /* only use Boyer-Moore algorithm if the pattern is bigger+ * than three characters+ */+ if(g->mlen > 3) {+ computejumps(p, g);+ computematchjumps(p, g);+ if(g->matchjump == NULL && g->charjump != NULL) {+ free(g->charjump);+ g->charjump = NULL;+ }+ }+ g->nplus = pluscount(p, g);+ g->magic = MAGIC2;+ preg->re_nsub = g->nsub;+ preg->re_g = g;+ preg->re_magic = MAGIC1;+#ifndef REDEBUG+ /* not debugging, so can't rely on the assert() in regexec() */+ if (g->iflags&BAD)+ SETERROR(REG_ASSERT);+#endif++ /* win or lose, we're done */+ if (p->error != 0) /* lose */+ regfree(preg);+ return(p->error);+}++/*+ - p_ere - ERE parser top level, concatenation and alternation+ == static void p_ere(register struct parse *p, int stop);+ */+static void+p_ere(p, stop)+register struct parse *p;+int stop; /* character this ERE should end at */+{+ register char c;+ register sopno prevback;+ register sopno prevfwd;+ register sopno conc;+ register int first = 1; /* is this the first alternative? */++ for (;;) {+ /* do a bunch of concatenated expressions */+ conc = HERE();+ while (MORE() && (c = PEEK()) != '|' && c != stop)+ p_ere_exp(p);+ (void)REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */++ if (!EAT('|'))+ break; /* NOTE BREAK OUT */++ if (first) {+ INSERT(OCH_, conc); /* offset is wrong */+ prevfwd = conc;+ prevback = conc;+ first = 0;+ }+ ASTERN(OOR1, prevback);+ prevback = THERE();+ AHEAD(prevfwd); /* fix previous offset */+ prevfwd = HERE();+ EMIT(OOR2, 0); /* offset is very wrong */+ }++ if (!first) { /* tail-end fixups */+ AHEAD(prevfwd);+ ASTERN(O_CH, prevback);+ }++ assert(!MORE() || SEE(stop));+}++/*+ - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op+ == static void p_ere_exp(register struct parse *p);+ */+static void+p_ere_exp(p)+register struct parse *p;+{+ register char c;+ register sopno pos;+ register int count;+ register int count2;+ register sopno subno;+ int wascaret = 0;++ assert(MORE()); /* caller should have ensured this */+ c = GETNEXT();++ pos = HERE();+ switch (c) {+ case '(':+ (void)REQUIRE(MORE(), REG_EPAREN);+ p->g->nsub++;+ subno = p->g->nsub;+ if (subno < NPAREN)+ p->pbegin[subno] = HERE();+ EMIT(OLPAREN, subno);+ if (!SEE(')'))+ p_ere(p, ')');+ if (subno < NPAREN) {+ p->pend[subno] = HERE();+ assert(p->pend[subno] != 0);+ }+ EMIT(ORPAREN, subno);+ (void)MUSTEAT(')', REG_EPAREN);+ break;+#ifndef POSIX_MISTAKE+ case ')': /* happens only if no current unmatched ( */+ /*+ * You may ask, why the ifndef? Because I didn't notice+ * this until slightly too late for 1003.2, and none of the+ * other 1003.2 regular-expression reviewers noticed it at+ * all. So an unmatched ) is legal POSIX, at least until+ * we can get it fixed.+ */+ SETERROR(REG_EPAREN);+ break;+#endif+ case '^':+ EMIT(OBOL, 0);+ p->g->iflags |= USEBOL;+ p->g->nbol++;+ wascaret = 1;+ break;+ case '$':+ EMIT(OEOL, 0);+ p->g->iflags |= USEEOL;+ p->g->neol++;+ break;+ case '|':+ SETERROR(REG_EMPTY);+ break;+ case '*':+ case '+':+ case '?':+ SETERROR(REG_BADRPT);+ break;+ case '.':+ if (p->g->cflags®_NEWLINE)+ nonnewline(p);+ else+ EMIT(OANY, 0);+ break;+ case '[':+ p_bracket(p);+ break;+ case '\\':+ (void)REQUIRE(MORE(), REG_EESCAPE);+ c = GETNEXT();+ ordinary(p, c);+ break;+ case '{': /* okay as ordinary except if digit follows */+ (void)REQUIRE(!MORE() || !isdigit((uch)PEEK()), REG_BADRPT);+ /* FALLTHROUGH */+ default:+ ordinary(p, c);+ break;+ }++ if (!MORE())+ return;+ c = PEEK();+ /* we call { a repetition if followed by a digit */+ if (!( c == '*' || c == '+' || c == '?' ||+ (c == '{' && MORE2() && isdigit((uch)PEEK2())) ))+ return; /* no repetition, we're done */+ NEXT();++ (void)REQUIRE(!wascaret, REG_BADRPT);+ switch (c) {+ case '*': /* implemented as +? */+ /* this case does not require the (y|) trick, noKLUDGE */+ INSERT(OPLUS_, pos);+ ASTERN(O_PLUS, pos);+ INSERT(OQUEST_, pos);+ ASTERN(O_QUEST, pos);+ break;+ case '+':+ INSERT(OPLUS_, pos);+ ASTERN(O_PLUS, pos);+ break;+ case '?':+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */+ INSERT(OCH_, pos); /* offset slightly wrong */+ ASTERN(OOR1, pos); /* this one's right */+ AHEAD(pos); /* fix the OCH_ */+ EMIT(OOR2, 0); /* offset very wrong... */+ AHEAD(THERE()); /* ...so fix it */+ ASTERN(O_CH, THERETHERE());+ break;+ case '{':+ count = p_count(p);+ if (EAT(',')) {+ if (isdigit((uch)PEEK())) {+ count2 = p_count(p);+ (void)REQUIRE(count <= count2, REG_BADBR);+ } else /* single number with comma */+ count2 = INFINITY;+ } else /* just a single number */+ count2 = count;+ repeat(p, pos, count, count2);+ if (!EAT('}')) { /* error heuristics */+ while (MORE() && PEEK() != '}')+ NEXT();+ (void)REQUIRE(MORE(), REG_EBRACE);+ SETERROR(REG_BADBR);+ }+ break;+ }++ if (!MORE())+ return;+ c = PEEK();+ if (!( c == '*' || c == '+' || c == '?' ||+ (c == '{' && MORE2() && isdigit((uch)PEEK2())) ) )+ return;+ SETERROR(REG_BADRPT);+}++/*+ - p_str - string (no metacharacters) "parser"+ == static void p_str(register struct parse *p);+ */+static void+p_str(p)+register struct parse *p;+{+ (void)REQUIRE(MORE(), REG_EMPTY);+ while (MORE())+ ordinary(p, GETNEXT());+}++/*+ - p_bre - BRE parser top level, anchoring and concatenation+ == static void p_bre(register struct parse *p, register int end1, \+ == register int end2);+ * Giving end1 as OUT essentially eliminates the end1/end2 check.+ *+ * This implementation is a bit of a kludge, in that a trailing $ is first+ * taken as an ordinary character and then revised to be an anchor. The+ * only undesirable side effect is that '$' gets included as a character+ * category in such cases. This is fairly harmless; not worth fixing.+ * The amount of lookahead needed to avoid this kludge is excessive.+ */+static void+p_bre(p, end1, end2)+register struct parse *p;+register int end1; /* first terminating character */+register int end2; /* second terminating character */+{+ register sopno start = HERE();+ register int first = 1; /* first subexpression? */+ register int wasdollar = 0;++ if (EAT('^')) {+ EMIT(OBOL, 0);+ p->g->iflags |= USEBOL;+ p->g->nbol++;+ }+ while (MORE() && !SEETWO(end1, end2)) {+ wasdollar = p_simp_re(p, first);+ first = 0;+ }+ if (wasdollar) { /* oops, that was a trailing anchor */+ DROP(1);+ EMIT(OEOL, 0);+ p->g->iflags |= USEEOL;+ p->g->neol++;+ }++ (void)REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */+}++/*+ - p_simp_re - parse a simple RE, an atom possibly followed by a repetition+ == static int p_simp_re(register struct parse *p, int starordinary);+ */+static int /* was the simple RE an unbackslashed $? */+p_simp_re(p, starordinary)+register struct parse *p;+int starordinary; /* is a leading * an ordinary character? */+{+ register int c;+ register int count;+ register int count2;+ register sopno pos;+ register int i;+ register sopno subno;+# define BACKSL (1<<CHAR_BIT)++ pos = HERE(); /* repetion op, if any, covers from here */++ assert(MORE()); /* caller should have ensured this */+ c = GETNEXT();+ if (c == '\\') {+ (void)REQUIRE(MORE(), REG_EESCAPE);+ c = BACKSL | GETNEXT();+ }+ switch (c) {+ case '.':+ if (p->g->cflags®_NEWLINE)+ nonnewline(p);+ else+ EMIT(OANY, 0);+ break;+ case '[':+ p_bracket(p);+ break;+ case BACKSL|'{':+ SETERROR(REG_BADRPT);+ break;+ case BACKSL|'(':+ p->g->nsub++;+ subno = p->g->nsub;+ if (subno < NPAREN)+ p->pbegin[subno] = HERE();+ EMIT(OLPAREN, subno);+ /* the MORE here is an error heuristic */+ if (MORE() && !SEETWO('\\', ')'))+ p_bre(p, '\\', ')');+ if (subno < NPAREN) {+ p->pend[subno] = HERE();+ assert(p->pend[subno] != 0);+ }+ EMIT(ORPAREN, subno);+ (void)REQUIRE(EATTWO('\\', ')'), REG_EPAREN);+ break;+ case BACKSL|')': /* should not get here -- must be user */+ case BACKSL|'}':+ SETERROR(REG_EPAREN);+ break;+ case BACKSL|'1':+ case BACKSL|'2':+ case BACKSL|'3':+ case BACKSL|'4':+ case BACKSL|'5':+ case BACKSL|'6':+ case BACKSL|'7':+ case BACKSL|'8':+ case BACKSL|'9':+ i = (c&~BACKSL) - '0';+ assert(i < NPAREN);+ if (p->pend[i] != 0) {+ assert(i <= p->g->nsub);+ EMIT(OBACK_, i);+ assert(p->pbegin[i] != 0);+ assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);+ assert(OP(p->strip[p->pend[i]]) == ORPAREN);+ (void) dupl(p, p->pbegin[i]+1, p->pend[i]);+ EMIT(O_BACK, i);+ } else+ SETERROR(REG_ESUBREG);+ p->g->backrefs = 1;+ break;+ case '*':+ (void)REQUIRE(starordinary, REG_BADRPT);+ /* FALLTHROUGH */+ default:+ ordinary(p, (char)c);+ break;+ }++ if (EAT('*')) { /* implemented as +? */+ /* this case does not require the (y|) trick, noKLUDGE */+ INSERT(OPLUS_, pos);+ ASTERN(O_PLUS, pos);+ INSERT(OQUEST_, pos);+ ASTERN(O_QUEST, pos);+ } else if (EATTWO('\\', '{')) {+ count = p_count(p);+ if (EAT(',')) {+ if (MORE() && isdigit((uch)PEEK())) {+ count2 = p_count(p);+ (void)REQUIRE(count <= count2, REG_BADBR);+ } else /* single number with comma */+ count2 = INFINITY;+ } else /* just a single number */+ count2 = count;+ repeat(p, pos, count, count2);+ if (!EATTWO('\\', '}')) { /* error heuristics */+ while (MORE() && !SEETWO('\\', '}'))+ NEXT();+ (void)REQUIRE(MORE(), REG_EBRACE);+ SETERROR(REG_BADBR);+ }+ } else if (c == '$') /* $ (but not \$) ends it */+ return(1);++ return(0);+}++/*+ - p_count - parse a repetition count+ == static int p_count(register struct parse *p);+ */+static int /* the value */+p_count(p)+register struct parse *p;+{+ register int count = 0;+ register int ndigits = 0;++ while (MORE() && isdigit((uch)PEEK()) && count <= DUPMAX) {+ count = count*10 + (GETNEXT() - '0');+ ndigits++;+ }++ (void)REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);+ return(count);+}++/*+ - p_bracket - parse a bracketed character list+ == static void p_bracket(register struct parse *p);+ *+ * Note a significant property of this code: if the allocset() did SETERROR,+ * no set operations are done.+ */+static void+p_bracket(p)+register struct parse *p;+{+ register cset *cs = allocset(p);+ register int invert = 0;++ /* Dept of Truly Sickening Special-Case Kludges */+ if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {+ EMIT(OBOW, 0);+ NEXTn(6);+ return;+ }+ if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {+ EMIT(OEOW, 0);+ NEXTn(6);+ return;+ }++ if (EAT('^'))+ invert++; /* make note to invert set at end */+ if (EAT(']'))+ CHadd(cs, ']');+ else if (EAT('-'))+ CHadd(cs, '-');+ while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))+ p_b_term(p, cs);+ if (EAT('-'))+ CHadd(cs, '-');+ (void)MUSTEAT(']', REG_EBRACK);++ if (p->error != 0) /* don't mess things up further */+ return;++ if (p->g->cflags®_ICASE) {+ register int i;+ register int ci;++ for (i = p->g->csetsize - 1; i >= 0; i--)+ if (CHIN(cs, i) && isalpha(i)) {+ ci = othercase(i);+ if (ci != i)+ CHadd(cs, ci);+ }+ if (cs->multis != NULL)+ mccase(p, cs);+ }+ if (invert) {+ register int i;++ for (i = p->g->csetsize - 1; i >= 0; i--)+ if (CHIN(cs, i))+ CHsub(cs, i);+ else+ CHadd(cs, i);+ if (p->g->cflags®_NEWLINE)+ CHsub(cs, '\n');+ if (cs->multis != NULL)+ mcinvert(p, cs);+ }++ assert(cs->multis == NULL); /* xxx */++ if (nch(p, cs) == 1) { /* optimize singleton sets */+ ordinary(p, firstch(p, cs));+ freeset(p, cs);+ } else+ EMIT(OANYOF, freezeset(p, cs));+}++/*+ - p_b_term - parse one term of a bracketed character list+ == static void p_b_term(register struct parse *p, register cset *cs);+ */+static void+p_b_term(p, cs)+register struct parse *p;+register cset *cs;+{+ register char c;+ register char start, finish;+ register int i;++ /* classify what we've got */+ switch ((MORE()) ? PEEK() : '\0') {+ case '[':+ c = (MORE2()) ? PEEK2() : '\0';+ break;+ case '-':+ SETERROR(REG_ERANGE);+ return; /* NOTE RETURN */+ break;+ default:+ c = '\0';+ break;+ }++ switch (c) {+ case ':': /* character class */+ NEXT2();+ (void)REQUIRE(MORE(), REG_EBRACK);+ c = PEEK();+ (void)REQUIRE(c != '-' && c != ']', REG_ECTYPE);+ p_b_cclass(p, cs);+ (void)REQUIRE(MORE(), REG_EBRACK);+ (void)REQUIRE(EATTWO(':', ']'), REG_ECTYPE);+ break;+ case '=': /* equivalence class */+ NEXT2();+ (void)REQUIRE(MORE(), REG_EBRACK);+ c = PEEK();+ (void)REQUIRE(c != '-' && c != ']', REG_ECOLLATE);+ p_b_eclass(p, cs);+ (void)REQUIRE(MORE(), REG_EBRACK);+ (void)REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);+ break;+ default: /* symbol, ordinary character, or range */+/* xxx revision needed for multichar stuff */+ start = p_b_symbol(p);+ if (SEE('-') && MORE2() && PEEK2() != ']') {+ /* range */+ NEXT();+ if (EAT('-'))+ finish = '-';+ else+ finish = p_b_symbol(p);+ } else+ finish = start;+ if (start == finish)+ CHadd(cs, start);+ else {+// remove collate stuff --SDM+#if 0+ if (__collate_load_error) {+ (void)REQUIRE((uch)start <= (uch)finish, REG_ERANGE);+#endif + for (i = (uch)start; i <= (uch)finish; i++)+ CHadd(cs, i);+#if 0+ } else {+ (void)REQUIRE(__collate_range_cmp(start, finish) <= 0, REG_ERANGE);+ for (i = CHAR_MIN; i <= CHAR_MAX; i++) {+ if ( __collate_range_cmp(start, i) <= 0+ && __collate_range_cmp(i, finish) <= 0+ )+ CHadd(cs, i);+ }+ }+#endif+ }+ break;+ }+}++/*+ - p_b_cclass - parse a character-class name and deal with it+ == static void p_b_cclass(register struct parse *p, register cset *cs);+ */+static void+p_b_cclass(p, cs)+register struct parse *p;+register cset *cs;+{+ register int c;+ register char *sp = p->next;+ register struct cclass *cp;+ register size_t len;++ while (MORE() && isalpha((uch)PEEK()))+ NEXT();+ len = p->next - sp;+ for (cp = cclasses; cp->name != NULL; cp++)+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')+ break;+ if (cp->name == NULL) {+ /* oops, didn't find it */+ SETERROR(REG_ECTYPE);+ return;+ }++ switch (cp->fidx) {+ case CALNUM:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isalnum((uch)c))+ CHadd(cs, c);+ break;+ case CALPHA:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isalpha((uch)c))+ CHadd(cs, c);+ break;+ case CBLANK:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isblank((uch)c))+ CHadd(cs, c);+ break;+ case CCNTRL:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (iscntrl((uch)c))+ CHadd(cs, c);+ break;+ case CDIGIT:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isdigit((uch)c))+ CHadd(cs, c);+ break;+ case CGRAPH:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isgraph((uch)c))+ CHadd(cs, c);+ break;+ case CLOWER:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (islower((uch)c))+ CHadd(cs, c);+ break;+ case CPRINT:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isprint((uch)c))+ CHadd(cs, c);+ break;+ case CPUNCT:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (ispunct((uch)c))+ CHadd(cs, c);+ break;+ case CSPACE:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isspace((uch)c))+ CHadd(cs, c);+ break;+ case CUPPER:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isupper((uch)c))+ CHadd(cs, c);+ break;+ case CXDIGIT:+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (isxdigit((uch)c))+ CHadd(cs, c);+ break;+ }+#if 0+ for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)+ MCadd(p, cs, u);+#endif+}++/*+ - p_b_eclass - parse an equivalence-class name and deal with it+ == static void p_b_eclass(register struct parse *p, register cset *cs);+ *+ * This implementation is incomplete. xxx+ */+static void+p_b_eclass(p, cs)+register struct parse *p;+register cset *cs;+{+ register char c;++ c = p_b_coll_elem(p, '=');+ CHadd(cs, c);+}++/*+ - p_b_symbol - parse a character or [..]ed multicharacter collating symbol+ == static char p_b_symbol(register struct parse *p);+ */+static char /* value of symbol */+p_b_symbol(p)+register struct parse *p;+{+ register char value;++ (void)REQUIRE(MORE(), REG_EBRACK);+ if (!EATTWO('[', '.'))+ return(GETNEXT());++ /* collating symbol */+ value = p_b_coll_elem(p, '.');+ (void)REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);+ return(value);+}++/*+ - p_b_coll_elem - parse a collating-element name and look it up+ == static char p_b_coll_elem(register struct parse *p, int endc);+ */+static char /* value of collating element */+p_b_coll_elem(p, endc)+register struct parse *p;+int endc; /* name ended by endc,']' */+{+ register char *sp = p->next;+ register struct cname *cp;+ register int len;++ while (MORE() && !SEETWO(endc, ']'))+ NEXT();+ if (!MORE()) {+ SETERROR(REG_EBRACK);+ return(0);+ }+ len = p->next - sp;+ for (cp = cnames; cp->name != NULL; cp++)+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')+ return(cp->code); /* known name */+ if (len == 1)+ return(*sp); /* single character */+ SETERROR(REG_ECOLLATE); /* neither */+ return(0);+}++/*+ - othercase - return the case counterpart of an alphabetic+ == static char othercase(int ch);+ */+static char /* if no counterpart, return ch */+othercase(ch)+int ch;+{+ ch = (uch)ch;+ assert(isalpha(ch));+ if (isupper(ch))+ return(tolower(ch));+ else if (islower(ch))+ return(toupper(ch));+ else /* peculiar, but could happen */+ return(ch);+}++/*+ - bothcases - emit a dualcase version of a two-case character+ == static void bothcases(register struct parse *p, int ch);+ *+ * Boy, is this implementation ever a kludge...+ */+static void+bothcases(p, ch)+register struct parse *p;+int ch;+{+ register char *oldnext = p->next;+ register char *oldend = p->end;+ char bracket[3];++ ch = (uch)ch;+ assert(othercase(ch) != ch); /* p_bracket() would recurse */+ p->next = bracket;+ p->end = bracket+2;+ bracket[0] = ch;+ bracket[1] = ']';+ bracket[2] = '\0';+ p_bracket(p);+ assert(p->next == bracket+2);+ p->next = oldnext;+ p->end = oldend;+}++/*+ - ordinary - emit an ordinary character+ == static void ordinary(register struct parse *p, register int ch);+ */+static void+ordinary(p, ch)+register struct parse *p;+register int ch;+{+ register cat_t *cap = p->g->categories;++ if ((p->g->cflags®_ICASE) && isalpha((uch)ch) && othercase(ch) != ch)+ bothcases(p, ch);+ else {+ EMIT(OCHAR, (uch)ch);+ if (cap[ch] == 0)+ cap[ch] = p->g->ncategories++;+ }+}++/*+ - nonnewline - emit REG_NEWLINE version of OANY+ == static void nonnewline(register struct parse *p);+ *+ * Boy, is this implementation ever a kludge...+ */+static void+nonnewline(p)+register struct parse *p;+{+ register char *oldnext = p->next;+ register char *oldend = p->end;+ char bracket[4];++ p->next = bracket;+ p->end = bracket+3;+ bracket[0] = '^';+ bracket[1] = '\n';+ bracket[2] = ']';+ bracket[3] = '\0';+ p_bracket(p);+ assert(p->next == bracket+3);+ p->next = oldnext;+ p->end = oldend;+}++/*+ - repeat - generate code for a bounded repetition, recursively if needed+ == static void repeat(register struct parse *p, sopno start, int from, int to);+ */+static void+repeat(p, start, from, to)+register struct parse *p;+sopno start; /* operand from here to end of strip */+int from; /* repeated from this number */+int to; /* to this number of times (maybe INFINITY) */+{+ register sopno finish = HERE();+# define N 2+# define INF 3+# define REP(f, t) ((f)*8 + (t))+# define MAP(n) (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)+ register sopno copy;++ if (p->error != 0) /* head off possible runaway recursion */+ return;++ assert(from <= to);++ switch (REP(MAP(from), MAP(to))) {+ case REP(0, 0): /* must be user doing this */+ DROP(finish-start); /* drop the operand */+ break;+ case REP(0, 1): /* as x{1,1}? */+ case REP(0, N): /* as x{1,n}? */+ case REP(0, INF): /* as x{1,}? */+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */+ INSERT(OCH_, start); /* offset is wrong... */+ repeat(p, start+1, 1, to);+ ASTERN(OOR1, start);+ AHEAD(start); /* ... fix it */+ EMIT(OOR2, 0);+ AHEAD(THERE());+ ASTERN(O_CH, THERETHERE());+ break;+ case REP(1, 1): /* trivial case */+ /* done */+ break;+ case REP(1, N): /* as x?x{1,n-1} */+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */+ INSERT(OCH_, start);+ ASTERN(OOR1, start);+ AHEAD(start);+ EMIT(OOR2, 0); /* offset very wrong... */+ AHEAD(THERE()); /* ...so fix it */+ ASTERN(O_CH, THERETHERE());+ copy = dupl(p, start+1, finish+1);+ assert(copy == finish+4);+ repeat(p, copy, 1, to-1);+ break;+ case REP(1, INF): /* as x+ */+ INSERT(OPLUS_, start);+ ASTERN(O_PLUS, start);+ break;+ case REP(N, N): /* as xx{m-1,n-1} */+ copy = dupl(p, start, finish);+ repeat(p, copy, from-1, to-1);+ break;+ case REP(N, INF): /* as xx{n-1,INF} */+ copy = dupl(p, start, finish);+ repeat(p, copy, from-1, to);+ break;+ default: /* "can't happen" */+ SETERROR(REG_ASSERT); /* just in case */+ break;+ }+}++/*+ - seterr - set an error condition+ == static int seterr(register struct parse *p, int e);+ */+static int /* useless but makes type checking happy */+seterr(p, e)+register struct parse *p;+int e;+{+ if (p->error == 0) /* keep earliest error condition */+ p->error = e;+ p->next = nuls; /* try to bring things to a halt */+ p->end = nuls;+ return(0); /* make the return value well-defined */+}++/*+ - allocset - allocate a set of characters for []+ == static cset *allocset(register struct parse *p);+ */+static cset *+allocset(p)+register struct parse *p;+{+ register int no = p->g->ncsets++;+ register size_t nc;+ register size_t nbytes;+ register cset *cs;+ register size_t css = (size_t)p->g->csetsize;+ register int i;++ if (no >= p->ncsalloc) { /* need another column of space */+ p->ncsalloc += CHAR_BIT;+ nc = p->ncsalloc;+ assert(nc % CHAR_BIT == 0);+ nbytes = nc / CHAR_BIT * css;+ if (p->g->sets == NULL)+ p->g->sets = (cset *)malloc(nc * sizeof(cset));+ else+ p->g->sets = (cset *)reallocf((char *)p->g->sets,+ nc * sizeof(cset));+ if (p->g->setbits == NULL)+ p->g->setbits = (uch *)malloc(nbytes);+ else {+ p->g->setbits = (uch *)reallocf((char *)p->g->setbits,+ nbytes);+ /* xxx this isn't right if setbits is now NULL */+ for (i = 0; i < no; i++)+ p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);+ }+ if (p->g->sets != NULL && p->g->setbits != NULL)+ (void) memset((char *)p->g->setbits + (nbytes - css),+ 0, css);+ else {+ no = 0;+ SETERROR(REG_ESPACE);+ /* caller's responsibility not to do set ops */+ }+ }++ assert(p->g->sets != NULL); /* xxx */+ cs = &p->g->sets[no];+ cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);+ cs->mask = 1 << ((no) % CHAR_BIT);+ cs->hash = 0;+ cs->smultis = 0;+ cs->multis = NULL;++ return(cs);+}++/*+ - freeset - free a now-unused set+ == static void freeset(register struct parse *p, register cset *cs);+ */+static void+freeset(p, cs)+register struct parse *p;+register cset *cs;+{+ register int i;+ register cset *top = &p->g->sets[p->g->ncsets];+ register size_t css = (size_t)p->g->csetsize;++ for (i = 0; i < css; i++)+ CHsub(cs, i);+ if (cs == top-1) /* recover only the easy case */+ p->g->ncsets--;+}++/*+ - freezeset - final processing on a set of characters+ == static int freezeset(register struct parse *p, register cset *cs);+ *+ * The main task here is merging identical sets. This is usually a waste+ * of time (although the hash code minimizes the overhead), but can win+ * big if REG_ICASE is being used. REG_ICASE, by the way, is why the hash+ * is done using addition rather than xor -- all ASCII [aA] sets xor to+ * the same value!+ */+static int /* set number */+freezeset(p, cs)+register struct parse *p;+register cset *cs;+{+ register short h = cs->hash;+ register int i;+ register cset *top = &p->g->sets[p->g->ncsets];+ register cset *cs2;+ register size_t css = (size_t)p->g->csetsize;++ /* look for an earlier one which is the same */+ for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)+ if (cs2->hash == h && cs2 != cs) {+ /* maybe */+ for (i = 0; i < css; i++)+ if (!!CHIN(cs2, i) != !!CHIN(cs, i))+ break; /* no */+ if (i == css)+ break; /* yes */+ }++ if (cs2 < top) { /* found one */+ freeset(p, cs);+ cs = cs2;+ }++ return((int)(cs - p->g->sets));+}++/*+ - firstch - return first character in a set (which must have at least one)+ == static int firstch(register struct parse *p, register cset *cs);+ */+static int /* character; there is no "none" value */+firstch(p, cs)+register struct parse *p;+register cset *cs;+{+ register int i;+ register size_t css = (size_t)p->g->csetsize;++ for (i = 0; i < css; i++)+ if (CHIN(cs, i))+ return((char)i);+ assert(never);+ return(0); /* arbitrary */+}++/*+ - nch - number of characters in a set+ == static int nch(register struct parse *p, register cset *cs);+ */+static int+nch(p, cs)+register struct parse *p;+register cset *cs;+{+ register int i;+ register size_t css = (size_t)p->g->csetsize;+ register int n = 0;++ for (i = 0; i < css; i++)+ if (CHIN(cs, i))+ n++;+ return(n);+}++/*+ - mcadd - add a collating element to a cset+ == static void mcadd(register struct parse *p, register cset *cs, \+ == register char *cp);+ */+static void+mcadd(p, cs, cp)+register struct parse *p;+register cset *cs;+register char *cp;+{+ register size_t oldend = cs->smultis;++ cs->smultis += strlen(cp) + 1;+ if (cs->multis == NULL)+ cs->multis = malloc(cs->smultis);+ else+ cs->multis = reallocf(cs->multis, cs->smultis);+ if (cs->multis == NULL) {+ SETERROR(REG_ESPACE);+ return;+ }++ (void) strcpy(cs->multis + oldend - 1, cp);+ cs->multis[cs->smultis - 1] = '\0';+}++#if used+/*+ - mcsub - subtract a collating element from a cset+ == static void mcsub(register cset *cs, register char *cp);+ */+static void+mcsub(cs, cp)+register cset *cs;+register char *cp;+{+ register char *fp = mcfind(cs, cp);+ register size_t len = strlen(fp);++ assert(fp != NULL);+ (void) memmove(fp, fp + len + 1,+ cs->smultis - (fp + len + 1 - cs->multis));+ cs->smultis -= len;++ if (cs->smultis == 0) {+ free(cs->multis);+ cs->multis = NULL;+ return;+ }++ cs->multis = reallocf(cs->multis, cs->smultis);+ assert(cs->multis != NULL);+}++/*+ - mcin - is a collating element in a cset?+ == static int mcin(register cset *cs, register char *cp);+ */+static int+mcin(cs, cp)+register cset *cs;+register char *cp;+{+ return(mcfind(cs, cp) != NULL);+}++/*+ - mcfind - find a collating element in a cset+ == static char *mcfind(register cset *cs, register char *cp);+ */+static char *+mcfind(cs, cp)+register cset *cs;+register char *cp;+{+ register char *p;++ if (cs->multis == NULL)+ return(NULL);+ for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)+ if (strcmp(cp, p) == 0)+ return(p);+ return(NULL);+}+#endif++/*+ - mcinvert - invert the list of collating elements in a cset+ == static void mcinvert(register struct parse *p, register cset *cs);+ *+ * This would have to know the set of possibilities. Implementation+ * is deferred.+ */+static void+mcinvert(p, cs)+register struct parse *p;+register cset *cs;+{+ assert(cs->multis == NULL); /* xxx */+}++/*+ - mccase - add case counterparts of the list of collating elements in a cset+ == static void mccase(register struct parse *p, register cset *cs);+ *+ * This would have to know the set of possibilities. Implementation+ * is deferred.+ */+static void+mccase(p, cs)+register struct parse *p;+register cset *cs;+{+ assert(cs->multis == NULL); /* xxx */+}++/*+ - isinsets - is this character in any sets?+ == static int isinsets(register struct re_guts *g, int c);+ */+static int /* predicate */+isinsets(g, c)+register struct re_guts *g;+int c;+{+ register uch *col;+ register int i;+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;+ register unsigned uc = (uch)c;++ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)+ if (col[uc] != 0)+ return(1);+ return(0);+}++/*+ - samesets - are these two characters in exactly the same sets?+ == static int samesets(register struct re_guts *g, int c1, int c2);+ */+static int /* predicate */+samesets(g, c1, c2)+register struct re_guts *g;+int c1;+int c2;+{+ register uch *col;+ register int i;+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;+ register unsigned uc1 = (uch)c1;+ register unsigned uc2 = (uch)c2;++ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)+ if (col[uc1] != col[uc2])+ return(0);+ return(1);+}++/*+ - categorize - sort out character categories+ == static void categorize(struct parse *p, register struct re_guts *g);+ */+static void+categorize(p, g)+struct parse *p;+register struct re_guts *g;+{+ register cat_t *cats = g->categories;+ register int c;+ register int c2;+ register cat_t cat;++ /* avoid making error situations worse */+ if (p->error != 0)+ return;++ for (c = CHAR_MIN; c <= CHAR_MAX; c++)+ if (cats[c] == 0 && isinsets(g, c)) {+ cat = g->ncategories++;+ cats[c] = cat;+ for (c2 = c+1; c2 <= CHAR_MAX; c2++)+ if (cats[c2] == 0 && samesets(g, c, c2))+ cats[c2] = cat;+ }+}++/*+ - dupl - emit a duplicate of a bunch of sops+ == static sopno dupl(register struct parse *p, sopno start, sopno finish);+ */+static sopno /* start of duplicate */+dupl(p, start, finish)+register struct parse *p;+sopno start; /* from here */+sopno finish; /* to this less one */+{+ register sopno ret = HERE();+ register sopno len = finish - start;++ assert(finish >= start);+ if (len == 0)+ return(ret);+ enlarge(p, p->ssize + len); /* this many unexpected additions */+ assert(p->ssize >= p->slen + len);+ (void) memcpy((char *)(p->strip + p->slen),+ (char *)(p->strip + start), (size_t)len*sizeof(sop));+ p->slen += len;+ return(ret);+}++/*+ - doemit - emit a strip operator+ == static void doemit(register struct parse *p, sop op, size_t opnd);+ *+ * It might seem better to implement this as a macro with a function as+ * hard-case backup, but it's just too big and messy unless there are+ * some changes to the data structures. Maybe later.+ */+static void+doemit(p, op, opnd)+register struct parse *p;+sop op;+size_t opnd;+{+ /* avoid making error situations worse */+ if (p->error != 0)+ return;++ /* deal with oversize operands ("can't happen", more or less) */+ assert(opnd < 1<<OPSHIFT);++ /* deal with undersized strip */+ if (p->slen >= p->ssize)+ enlarge(p, (p->ssize+1) / 2 * 3); /* +50% */+ assert(p->slen < p->ssize);++ /* finally, it's all reduced to the easy case */+ p->strip[p->slen++] = SOP(op, opnd);+}++/*+ - doinsert - insert a sop into the strip+ == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);+ */+static void+doinsert(p, op, opnd, pos)+register struct parse *p;+sop op;+size_t opnd;+sopno pos;+{+ register sopno sn;+ register sop s;+ register int i;++ /* avoid making error situations worse */+ if (p->error != 0)+ return;++ sn = HERE();+ EMIT(op, opnd); /* do checks, ensure space */+ assert(HERE() == sn+1);+ s = p->strip[sn];++ /* adjust paren pointers */+ assert(pos > 0);+ for (i = 1; i < NPAREN; i++) {+ if (p->pbegin[i] >= pos) {+ p->pbegin[i]++;+ }+ if (p->pend[i] >= pos) {+ p->pend[i]++;+ }+ }++ memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],+ (HERE()-pos-1)*sizeof(sop));+ p->strip[pos] = s;+}++/*+ - dofwd - complete a forward reference+ == static void dofwd(register struct parse *p, sopno pos, sop value);+ */+static void+dofwd(p, pos, value)+register struct parse *p;+register sopno pos;+sop value;+{+ /* avoid making error situations worse */+ if (p->error != 0)+ return;++ assert(value < 1<<OPSHIFT);+ p->strip[pos] = OP(p->strip[pos]) | value;+}++/*+ - enlarge - enlarge the strip+ == static void enlarge(register struct parse *p, sopno size);+ */+static void+enlarge(p, size)+register struct parse *p;+register sopno size;+{+ register sop *sp;++ if (p->ssize >= size)+ return;++ sp = (sop *)realloc(p->strip, size*sizeof(sop));+ if (sp == NULL) {+ SETERROR(REG_ESPACE);+ return;+ }+ p->strip = sp;+ p->ssize = size;+}++/*+ - stripsnug - compact the strip+ == static void stripsnug(register struct parse *p, register struct re_guts *g);+ */+static void+stripsnug(p, g)+register struct parse *p;+register struct re_guts *g;+{+ g->nstates = p->slen;+ g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));+ if (g->strip == NULL) {+ SETERROR(REG_ESPACE);+ g->strip = p->strip;+ }+}++/*+ - findmust - fill in must and mlen with longest mandatory literal string+ == static void findmust(register struct parse *p, register struct re_guts *g);+ *+ * This algorithm could do fancy things like analyzing the operands of |+ * for common subsequences. Someday. This code is simple and finds most+ * of the interesting cases.+ *+ * Note that must and mlen got initialized during setup.+ */+static void+findmust(p, g)+struct parse *p;+register struct re_guts *g;+{+ register sop *scan;+ sop *start;+ register sop *newstart;+ register sopno newlen;+ register sop s;+ register char *cp;+ register sopno i;+ int offset;+ int cs, mccs;++ /* avoid making error situations worse */+ if (p->error != 0)+ return;++ /* Find out if we can handle OANYOF or not */+ mccs = 0;+ for (cs = 0; cs < g->ncsets; cs++)+ if (g->sets[cs].multis != NULL)+ mccs = 1;++ /* find the longest OCHAR sequence in strip */+ newlen = 0;+ offset = 0;+ g->moffset = 0;+ scan = g->strip + 1;+ do {+ s = *scan++;+ switch (OP(s)) {+ case OCHAR: /* sequence member */+ if (newlen == 0) /* new sequence */+ newstart = scan - 1;+ newlen++;+ break;+ case OPLUS_: /* things that don't break one */+ case OLPAREN:+ case ORPAREN:+ break;+ case OQUEST_: /* things that must be skipped */+ case OCH_:+ offset = altoffset(scan, offset, mccs);+ scan--;+ do {+ scan += OPND(s);+ s = *scan;+ /* assert() interferes w debug printouts */+ if (OP(s) != O_QUEST && OP(s) != O_CH &&+ OP(s) != OOR2) {+ g->iflags |= BAD;+ return;+ }+ } while (OP(s) != O_QUEST && OP(s) != O_CH);+ /* fallthrough */+ case OBOW: /* things that break a sequence */+ case OEOW:+ case OBOL:+ case OEOL:+ case O_QUEST:+ case O_CH:+ case OEND:+ if (newlen > g->mlen) { /* ends one */+ start = newstart;+ g->mlen = newlen;+ if (offset > -1) {+ g->moffset += offset;+ offset = newlen;+ } else+ g->moffset = offset;+ } else {+ if (offset > -1)+ offset += newlen;+ }+ newlen = 0;+ break;+ case OANY:+ if (newlen > g->mlen) { /* ends one */+ start = newstart;+ g->mlen = newlen;+ if (offset > -1) {+ g->moffset += offset;+ offset = newlen;+ } else+ g->moffset = offset;+ } else {+ if (offset > -1)+ offset += newlen;+ }+ if (offset > -1)+ offset++;+ newlen = 0;+ break;+ case OANYOF: /* may or may not invalidate offset */+ /* First, everything as OANY */+ if (newlen > g->mlen) { /* ends one */+ start = newstart;+ g->mlen = newlen;+ if (offset > -1) {+ g->moffset += offset;+ offset = newlen;+ } else+ g->moffset = offset;+ } else {+ if (offset > -1)+ offset += newlen;+ }+ if (offset > -1)+ offset++;+ newlen = 0;+ /* And, now, if we found out we can't deal with+ * it, make offset = -1.+ */+ if (mccs)+ offset = -1;+ break;+ default:+ /* Anything here makes it impossible or too hard+ * to calculate the offset -- so we give up;+ * save the last known good offset, in case the+ * must sequence doesn't occur later.+ */+ if (newlen > g->mlen) { /* ends one */+ start = newstart;+ g->mlen = newlen;+ if (offset > -1)+ g->moffset += offset;+ else+ g->moffset = offset;+ }+ offset = -1;+ newlen = 0;+ break;+ }+ } while (OP(s) != OEND);++ if (g->mlen == 0) { /* there isn't one */+ g->moffset = -1;+ return;+ }++ /* turn it into a character string */+ g->must = malloc((size_t)g->mlen + 1);+ if (g->must == NULL) { /* argh; just forget it */+ g->mlen = 0;+ g->moffset = -1;+ return;+ }+ cp = g->must;+ scan = start;+ for (i = g->mlen; i > 0; i--) {+ while (OP(s = *scan++) != OCHAR)+ continue;+ assert(cp < g->must + g->mlen);+ *cp++ = (char)OPND(s);+ }+ assert(cp == g->must + g->mlen);+ *cp++ = '\0'; /* just on general principles */+}++/*+ - altoffset - choose biggest offset among multiple choices+ == static int altoffset(sop *scan, int offset, int mccs);+ *+ * Compute, recursively if necessary, the largest offset among multiple+ * re paths.+ */+static int+altoffset(scan, offset, mccs)+sop *scan;+int offset;+int mccs;+{+ int largest;+ int try;+ sop s;++ /* If we gave up already on offsets, return */+ if (offset == -1)+ return -1;++ largest = 0;+ try = 0;+ s = *scan++;+ while (OP(s) != O_QUEST && OP(s) != O_CH) {+ switch (OP(s)) {+ case OOR1:+ if (try > largest)+ largest = try;+ try = 0;+ break;+ case OQUEST_:+ case OCH_:+ try = altoffset(scan, try, mccs);+ if (try == -1)+ return -1;+ scan--;+ do {+ scan += OPND(s);+ s = *scan;+ if (OP(s) != O_QUEST && OP(s) != O_CH &&+ OP(s) != OOR2)+ return -1;+ } while (OP(s) != O_QUEST && OP(s) != O_CH);+ /* We must skip to the next position, or we'll+ * leave altoffset() too early.+ */+ scan++;+ break;+ case OANYOF:+ if (mccs)+ return -1;+ case OCHAR:+ case OANY:+ try++;+ case OBOW:+ case OEOW:+ case OLPAREN:+ case ORPAREN:+ case OOR2:+ break;+ default:+ try = -1;+ break;+ }+ if (try == -1)+ return -1;+ s = *scan++;+ }++ if (try > largest)+ largest = try;++ return largest+offset;+}++/*+ - computejumps - compute char jumps for BM scan+ == static void computejumps(register struct parse *p, register struct re_guts *g);+ *+ * This algorithm assumes g->must exists and is has size greater than+ * zero. It's based on the algorithm found on Computer Algorithms by+ * Sara Baase.+ *+ * A char jump is the number of characters one needs to jump based on+ * the value of the character from the text that was mismatched.+ */+static void+computejumps(p, g)+struct parse *p;+struct re_guts *g;+{+ int ch;+ int mindex;++ /* Avoid making errors worse */+ if (p->error != 0)+ return;++ g->charjump = (int*) malloc((NC + 1) * sizeof(int));+ if (g->charjump == NULL) /* Not a fatal error */+ return;+ /* Adjust for signed chars, if necessary */+ g->charjump = &g->charjump[-(CHAR_MIN)];++ /* If the character does not exist in the pattern, the jump+ * is equal to the number of characters in the pattern.+ */+ for (ch = CHAR_MIN; ch < (CHAR_MAX + 1); ch++)+ g->charjump[ch] = g->mlen;++ /* If the character does exist, compute the jump that would+ * take us to the last character in the pattern equal to it+ * (notice that we match right to left, so that last character+ * is the first one that would be matched).+ */+ for (mindex = 0; mindex < g->mlen; mindex++)+ g->charjump[g->must[mindex]] = g->mlen - mindex - 1;+}++/*+ - computematchjumps - compute match jumps for BM scan+ == static void computematchjumps(register struct parse *p, register struct re_guts *g);+ *+ * This algorithm assumes g->must exists and is has size greater than+ * zero. It's based on the algorithm found on Computer Algorithms by+ * Sara Baase.+ *+ * A match jump is the number of characters one needs to advance based+ * on the already-matched suffix.+ * Notice that all values here are minus (g->mlen-1), because of the way+ * the search algorithm works.+ */+static void+computematchjumps(p, g)+struct parse *p;+struct re_guts *g;+{+ int mindex; /* General "must" iterator */+ int suffix; /* Keeps track of matching suffix */+ int ssuffix; /* Keeps track of suffixes' suffix */+ int* pmatches; /* pmatches[k] points to the next i+ * such that i+1...mlen is a substring+ * of k+1...k+mlen-i-1+ */++ /* Avoid making errors worse */+ if (p->error != 0)+ return;++ pmatches = (int*) malloc(g->mlen * sizeof(unsigned int));+ if (pmatches == NULL) {+ g->matchjump = NULL;+ return;+ }++ g->matchjump = (int*) malloc(g->mlen * sizeof(unsigned int));+ if (g->matchjump == NULL) /* Not a fatal error */+ return;++ /* Set maximum possible jump for each character in the pattern */+ for (mindex = 0; mindex < g->mlen; mindex++)+ g->matchjump[mindex] = 2*g->mlen - mindex - 1;++ /* Compute pmatches[] */+ for (mindex = g->mlen - 1, suffix = g->mlen; mindex >= 0;+ mindex--, suffix--) {+ pmatches[mindex] = suffix;++ /* If a mismatch is found, interrupting the substring,+ * compute the matchjump for that position. If no+ * mismatch is found, then a text substring mismatched+ * against the suffix will also mismatch against the+ * substring.+ */+ while (suffix < g->mlen+ && g->must[mindex] != g->must[suffix]) {+ g->matchjump[suffix] = MIN(g->matchjump[suffix],+ g->mlen - mindex - 1);+ suffix = pmatches[suffix];+ }+ }++ /* Compute the matchjump up to the last substring found to jump+ * to the beginning of the largest must pattern prefix matching+ * it's own suffix.+ */+ for (mindex = 0; mindex <= suffix; mindex++)+ g->matchjump[mindex] = MIN(g->matchjump[mindex],+ g->mlen + suffix - mindex);++ ssuffix = pmatches[suffix];+ while (suffix < g->mlen) {+ while (suffix <= ssuffix && suffix < g->mlen) {+ g->matchjump[suffix] = MIN(g->matchjump[suffix],+ g->mlen + ssuffix - suffix);+ suffix++;+ }+ if (suffix < g->mlen)+ ssuffix = pmatches[ssuffix];+ }++ free(pmatches);+}++/*+ - pluscount - count + nesting+ == static sopno pluscount(register struct parse *p, register struct re_guts *g);+ */+static sopno /* nesting depth */+pluscount(p, g)+struct parse *p;+register struct re_guts *g;+{+ register sop *scan;+ register sop s;+ register sopno plusnest = 0;+ register sopno maxnest = 0;++ if (p->error != 0)+ return(0); /* there may not be an OEND */++ scan = g->strip + 1;+ do {+ s = *scan++;+ switch (OP(s)) {+ case OPLUS_:+ plusnest++;+ break;+ case O_PLUS:+ if (plusnest > maxnest)+ maxnest = plusnest;+ plusnest--;+ break;+ }+ } while (OP(s) != OEND);+ if (plusnest != 0)+ g->iflags |= BAD;+ return(maxnest);+}
+ cbits/regerror.c view
@@ -0,0 +1,177 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regerror.c 8.4 (Berkeley) 3/20/94+ */++#if defined(LIBC_SCCS) && !defined(lint)+static char sccsid[] = "@(#)regerror.c 8.4 (Berkeley) 3/20/94";+#endif /* LIBC_SCCS and not lint */++#include <sys/types.h>+#include <stdio.h>+#include <string.h>+#include <limits.h>+#include <stdlib.h>+#include "regex/regex.h"++#include "utils.h"++/* ========= begin header generated by ./mkh ========= */+#ifdef __cplusplus+extern "C" {+#endif++/* === regerror.c === */+static char *regatoi (const regex_t *preg, char *localbuf);++#ifdef __cplusplus+}+#endif+/* ========= end header generated by ./mkh ========= */+/*+ = #define REG_NOMATCH 1+ = #define REG_BADPAT 2+ = #define REG_ECOLLATE 3+ = #define REG_ECTYPE 4+ = #define REG_EESCAPE 5+ = #define REG_ESUBREG 6+ = #define REG_EBRACK 7+ = #define REG_EPAREN 8+ = #define REG_EBRACE 9+ = #define REG_BADBR 10+ = #define REG_ERANGE 11+ = #define REG_ESPACE 12+ = #define REG_BADRPT 13+ = #define REG_EMPTY 14+ = #define REG_ASSERT 15+ = #define REG_INVARG 16+ = #define REG_ATOI 255 // convert name to number (!)+ = #define REG_ITOA 0400 // convert number to name (!)+ */+static struct rerr {+ int code;+ char *name;+ char *explain;+} rerrs[] = {+ {REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match"},+ {REG_BADPAT, "REG_BADPAT", "invalid regular expression"},+ {REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"},+ {REG_ECTYPE, "REG_ECTYPE", "invalid character class"},+ {REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)"},+ {REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"},+ {REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced"},+ {REG_EPAREN, "REG_EPAREN", "parentheses not balanced"},+ {REG_EBRACE, "REG_EBRACE", "braces not balanced"},+ {REG_BADBR, "REG_BADBR", "invalid repetition count(s)"},+ {REG_ERANGE, "REG_ERANGE", "invalid character range"},+ {REG_ESPACE, "REG_ESPACE", "out of memory"},+ {REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid"},+ {REG_EMPTY, "REG_EMPTY", "empty (sub)expression"},+ {REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"},+ {REG_INVARG, "REG_INVARG", "invalid argument to regex routine"},+ {0, "", "*** unknown regexp error code ***"}+};++/*+ - regerror - the interface to error numbers+ = extern size_t regerror(int, const regex_t *, char *, size_t);+ */+/* ARGSUSED */+size_t+regerror(errcode, preg, errbuf, errbuf_size)+int errcode;+const regex_t *preg;+char *errbuf;+size_t errbuf_size;+{+ register struct rerr *r;+ register size_t len;+ register int target = errcode &~ REG_ITOA;+ register char *s;+ char convbuf[50];++ if (errcode == REG_ATOI)+ s = regatoi(preg, convbuf);+ else {+ for (r = rerrs; r->code != 0; r++)+ if (r->code == target)+ break;++ if (errcode®_ITOA) {+ if (r->code != 0)+ (void) strcpy(convbuf, r->name);+ else+ sprintf(convbuf, "REG_0x%x", target);+ assert(strlen(convbuf) < sizeof(convbuf));+ s = convbuf;+ } else+ s = r->explain;+ }++ len = strlen(s) + 1;+ if (errbuf_size > 0) {+ if (errbuf_size > len)+ (void) strcpy(errbuf, s);+ else {+ (void) strncpy(errbuf, s, errbuf_size-1);+ errbuf[errbuf_size-1] = '\0';+ }+ }++ return(len);+}++/*+ - regatoi - internal routine to implement REG_ATOI+ == static char *regatoi(const regex_t *preg, char *localbuf);+ */+static char *+regatoi(preg, localbuf)+const regex_t *preg;+char *localbuf;+{+ register struct rerr *r;++ for (r = rerrs; r->code != 0; r++)+ if (strcmp(r->name, preg->re_endp) == 0)+ break;+ if (r->code == 0)+ return("0");++ sprintf(localbuf, "%d", r->code);+ return(localbuf);+}
+ cbits/regex2.h view
@@ -0,0 +1,178 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regex2.h 8.4 (Berkeley) 3/20/94+ *+ * $FreeBSD: src/lib/libc/regex/regex2.h,v 1.3.6.1 2000/07/31 06:30:37 dcs Exp $+ */++/*+ * First, the stuff that ends up in the outside-world include file+ = typedef off_t regoff_t;+ = typedef struct {+ = int re_magic;+ = size_t re_nsub; // number of parenthesized subexpressions+ = const char *re_endp; // end pointer for REG_PEND+ = struct re_guts *re_g; // none of your business :-)+ = } regex_t;+ = typedef struct {+ = regoff_t rm_so; // start of match+ = regoff_t rm_eo; // end of match+ = } regmatch_t;+ */+/*+ * internals of regex_t+ */+#define MAGIC1 ((('r'^0200)<<8) | 'e')++/*+ * The internal representation is a *strip*, a sequence of+ * operators ending with an endmarker. (Some terminology etc. is a+ * historical relic of earlier versions which used multiple strips.)+ * Certain oddities in the representation are there to permit running+ * the machinery backwards; in particular, any deviation from sequential+ * flow must be marked at both its source and its destination. Some+ * fine points:+ *+ * - OPLUS_ and O_PLUS are *inside* the loop they create.+ * - OQUEST_ and O_QUEST are *outside* the bypass they create.+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while+ * OOR1 and OOR2 are respectively the end and the beginning of one of+ * the branches. Note that there is an implicit OOR2 following OCH_+ * and an implicit OOR1 preceding O_CH.+ *+ * In state representations, an operator's bit is on to signify a state+ * immediately *preceding* "execution" of that operator.+ */+typedef unsigned long sop; /* strip operator */+typedef long sopno;+#define OPRMASK 0xf8000000L+#define OPDMASK 0x07ffffffL+#define OPSHIFT ((unsigned)27)+#define OP(n) ((n)&OPRMASK)+#define OPND(n) ((n)&OPDMASK)+#define SOP(op, opnd) ((op)|(opnd))+/* operators meaning operand */+/* (back, fwd are offsets) */+#define OEND (1L<<OPSHIFT) /* endmarker - */+#define OCHAR (2L<<OPSHIFT) /* character unsigned char */+#define OBOL (3L<<OPSHIFT) /* left anchor - */+#define OEOL (4L<<OPSHIFT) /* right anchor - */+#define OANY (5L<<OPSHIFT) /* . - */+#define OANYOF (6L<<OPSHIFT) /* [...] set number */+#define OBACK_ (7L<<OPSHIFT) /* begin \d paren number */+#define O_BACK (8L<<OPSHIFT) /* end \d paren number */+#define OPLUS_ (9L<<OPSHIFT) /* + prefix fwd to suffix */+#define O_PLUS (10L<<OPSHIFT) /* + suffix back to prefix */+#define OQUEST_ (11L<<OPSHIFT) /* ? prefix fwd to suffix */+#define O_QUEST (12L<<OPSHIFT) /* ? suffix back to prefix */+#define OLPAREN (13L<<OPSHIFT) /* ( fwd to ) */+#define ORPAREN (14L<<OPSHIFT) /* ) back to ( */+#define OCH_ (15L<<OPSHIFT) /* begin choice fwd to OOR2 */+#define OOR1 (16L<<OPSHIFT) /* | pt. 1 back to OOR1 or OCH_ */+#define OOR2 (17L<<OPSHIFT) /* | pt. 2 fwd to OOR2 or O_CH */+#define O_CH (18L<<OPSHIFT) /* end choice back to OOR1 */+#define OBOW (19L<<OPSHIFT) /* begin word - */+#define OEOW (20L<<OPSHIFT) /* end word - */++/*+ * Structure for [] character-set representation. Character sets are+ * done as bit vectors, grouped 8 to a byte vector for compactness.+ * The individual set therefore has both a pointer to the byte vector+ * and a mask to pick out the relevant bit of each byte. A hash code+ * simplifies testing whether two sets could be identical.+ *+ * This will get trickier for multicharacter collating elements. As+ * preliminary hooks for dealing with such things, we also carry along+ * a string of multi-character elements, and decide the size of the+ * vectors at run time.+ */+typedef struct {+ uch *ptr; /* -> uch [csetsize] */+ uch mask; /* bit within array */+ short hash; /* hash code */+ size_t smultis;+ char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */+} cset;+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */+#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (uch)(c))+#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (uch)(c))+#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)+#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */+#define MCsub(p, cs, cp) mcsub(p, cs, cp)+#define MCin(p, cs, cp) mcin(p, cs, cp)++/* stuff for character categories */+typedef unsigned char cat_t;++/*+ * main compiled-expression structure+ */+struct re_guts {+ int magic;+# define MAGIC2 ((('R'^0200)<<8)|'E')+ sop *strip; /* malloced area for strip */+ int csetsize; /* number of bits in a cset vector */+ int ncsets; /* number of csets in use */+ cset *sets; /* -> cset [ncsets] */+ uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */+ int cflags; /* copy of regcomp() cflags argument */+ sopno nstates; /* = number of sops */+ sopno firststate; /* the initial OEND (normally 0) */+ sopno laststate; /* the final OEND */+ int iflags; /* internal flags */+# define USEBOL 01 /* used ^ */+# define USEEOL 02 /* used $ */+# define BAD 04 /* something wrong */+ int nbol; /* number of ^ used */+ int neol; /* number of $ used */+ int ncategories; /* how many character categories */+ cat_t *categories; /* ->catspace[-CHAR_MIN] */+ char *must; /* match must contain this string */+ int moffset; /* latest point at which must may be located */+ int *charjump; /* Boyer-Moore char jump table */+ int *matchjump; /* Boyer-Moore match jump table */+ int mlen; /* length of must */+ size_t nsub; /* copy of re_nsub */+ int backrefs; /* does it use back references? */+ sopno nplus; /* how deep does it nest +s? */+ /* catspace must be last */+ cat_t catspace[1]; /* actually [NC] */+};++/* misc utilities */+#define OUT (CHAR_MAX+1) /* a non-character value */+#define ISWORD(c) (isalnum((uch)(c)) || (c) == '_')
+ cbits/regexec.c view
@@ -0,0 +1,181 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regexec.c 8.3 (Berkeley) 3/20/94+ */++#if defined(LIBC_SCCS) && !defined(lint)+static char sccsid[] = "@(#)regexec.c 8.3 (Berkeley) 3/20/94";+#endif /* LIBC_SCCS and not lint */++/*+ * the outer shell of regexec()+ *+ * This file includes engine.c *twice*, after muchos fiddling with the+ * macros that code uses. This lets the same code operate on two different+ * representations for state sets.+ */+#include <sys/types.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <limits.h>+#include <ctype.h>+#include "regex/regex.h"++#include "utils.h"+#include "regex2.h"++static int nope = 0; /* for use in asserts; shuts lint up */++/* macros for manipulating states, small version */+#define states long+#define states1 states /* for later use in regexec() decision */+#define CLEAR(v) ((v) = 0)+#define SET0(v, n) ((v) &= ~((unsigned long)1 << (n)))+#define SET1(v, n) ((v) |= (unsigned long)1 << (n))+#define ISSET(v, n) (((v) & ((unsigned long)1 << (n))) != 0)+#define ASSIGN(d, s) ((d) = (s))+#define EQ(a, b) ((a) == (b))+#define STATEVARS long dummy /* dummy version */+#define STATESETUP(m, n) /* nothing */+#define STATETEARDOWN(m) /* nothing */+#define SETUP(v) ((v) = 0)+#define onestate long+#define INIT(o, n) ((o) = (unsigned long)1 << (n))+#define INC(o) ((o) <<= 1)+#define ISSTATEIN(v, o) (((v) & (o)) != 0)+/* some abbreviations; note that some of these know variable names! */+/* do "if I'm here, I can also be there" etc without branches */+#define FWD(dst, src, n) ((dst) |= ((unsigned long)(src)&(here)) << (n))+#define BACK(dst, src, n) ((dst) |= ((unsigned long)(src)&(here)) >> (n))+#define ISSETBACK(v, n) (((v) & ((unsigned long)here >> (n))) != 0)+/* function names */+#define SNAMES /* engine.c looks after details */++#include "engine.c"++/* now undo things */+#undef states+#undef CLEAR+#undef SET0+#undef SET1+#undef ISSET+#undef ASSIGN+#undef EQ+#undef STATEVARS+#undef STATESETUP+#undef STATETEARDOWN+#undef SETUP+#undef onestate+#undef INIT+#undef INC+#undef ISSTATEIN+#undef FWD+#undef BACK+#undef ISSETBACK+#undef SNAMES++/* macros for manipulating states, large version */+#define states char *+#define CLEAR(v) memset(v, 0, m->g->nstates)+#define SET0(v, n) ((v)[n] = 0)+#define SET1(v, n) ((v)[n] = 1)+#define ISSET(v, n) ((v)[n])+#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)+#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)+#define STATEVARS long vn; char *space+#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \+ if ((m)->space == NULL) return(REG_ESPACE); \+ (m)->vn = 0; }+#define STATETEARDOWN(m) { free((m)->space); }+#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])+#define onestate long+#define INIT(o, n) ((o) = (n))+#define INC(o) ((o)++)+#define ISSTATEIN(v, o) ((v)[o])+/* some abbreviations; note that some of these know variable names! */+/* do "if I'm here, I can also be there" etc without branches */+#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here])+#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here])+#define ISSETBACK(v, n) ((v)[here - (n)])+/* function names */+#define LNAMES /* flag */++#include "engine.c"++/*+ - regexec - interface for matching+ = extern int regexec(const regex_t *, const char *, size_t, \+ = regmatch_t [], int);+ = #define REG_NOTBOL 00001+ = #define REG_NOTEOL 00002+ = #define REG_STARTEND 00004+ = #define REG_TRACE 00400 // tracing of execution+ = #define REG_LARGE 01000 // force large representation+ = #define REG_BACKR 02000 // force use of backref code+ *+ * We put this here so we can exploit knowledge of the state representation+ * when choosing which matcher to call. Also, by this point the matchers+ * have been prototyped.+ */+int /* 0 success, REG_NOMATCH failure */+regexec(preg, string, nmatch, pmatch, eflags)+const regex_t *preg;+const char *string;+size_t nmatch;+regmatch_t pmatch[];+int eflags;+{+ register struct re_guts *g = preg->re_g;+#ifdef REDEBUG+# define GOODFLAGS(f) (f)+#else+# define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))+#endif++ if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)+ return(REG_BADPAT);+ assert(!(g->iflags&BAD));+ if (g->iflags&BAD) /* backstop for no-debug case */+ return(REG_BADPAT);+ eflags = GOODFLAGS(eflags);++ if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))+ return(smatcher(g, (char *)string, nmatch, pmatch, eflags));+ else+ return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));+}
+ cbits/regfree.c view
@@ -0,0 +1,87 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regfree.c 8.3 (Berkeley) 3/20/94+ *+ * $FreeBSD: src/lib/libc/regex/regfree.c,v 1.1.1.1.14.1 2000/07/31 06:30:37 dcs Exp $+ */++#if defined(LIBC_SCCS) && !defined(lint)+static char sccsid[] = "@(#)regfree.c 8.3 (Berkeley) 3/20/94";+#endif /* LIBC_SCCS and not lint */++#include <sys/types.h>+#include <stdio.h>+#include <stdlib.h>+#include <limits.h>+#include "regex/regex.h"++#include "utils.h"+#include "regex2.h"++/*+ - regfree - free everything+ = extern void regfree(regex_t *);+ */+void+regfree(preg)+regex_t *preg;+{+ register struct re_guts *g;++ if (preg->re_magic != MAGIC1) /* oops */+ return; /* nice to complain, but hard */++ g = preg->re_g;+ if (g == NULL || g->magic != MAGIC2) /* oops again */+ return;+ preg->re_magic = 0; /* mark it invalid */+ g->magic = 0; /* mark it invalid */++ if (g->strip != NULL)+ free((char *)g->strip);+ if (g->sets != NULL)+ free((char *)g->sets);+ if (g->setbits != NULL)+ free((char *)g->setbits);+ if (g->must != NULL)+ free(g->must);+ if (g->charjump != NULL)+ free(&g->charjump[CHAR_MIN]);+ if (g->matchjump != NULL)+ free(g->matchjump);+ free((char *)g);+}
+ cbits/utils.h view
@@ -0,0 +1,62 @@+/*-+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.+ * Copyright (c) 1992, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)utils.h 8.3 (Berkeley) 3/20/94+ */++/* Added by SDM 15/2/2002: apparently mingw doesn't define this constant */+#ifndef _POSIX2_RE_DUP_MAX+#define _POSIX2_RE_DUP_MAX 255+#endif++/* utility definitions */+#define DUPMAX _POSIX2_RE_DUP_MAX /* xxx is this right? */+#define INFINITY (DUPMAX + 1)+#define NC (CHAR_MAX - CHAR_MIN + 1)+typedef unsigned char uch;++/* switch off assertions (if not already off) if no REDEBUG */+#ifndef REDEBUG+#ifndef NDEBUG+#define NDEBUG /* no assertions please */+#endif+#endif+#include <assert.h>++/* for old systems with bcopy() but no memmove() */+#ifdef USEBCOPY+#define memmove(d, s, c) bcopy(s, d, c)+#endif
+ config.mk.in view
@@ -0,0 +1,5 @@+HavePosixRegex = @HavePosixRegex@++PACKAGE=@PACKAGE_TARNAME@+VERSION=@PACKAGE_VERSION@+MAINTAINER=@PACKAGE_BUGREPORT@
+ configure view
@@ -0,0 +1,4609 @@+#! /bin/sh+# Guess values for system-dependent variables and create Makefiles.+# Generated by GNU Autoconf 2.61 for Haskell regex-posix package 0.71.+#+# Report bugs to <TextRegexLazy@personal.mightyreason.com>.+#+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+# This configure script is free software; the Free Software Foundation+# gives unlimited permission to copy, distribute and modify it.+## --------------------- ##+## M4sh Initialization. ##+## --------------------- ##++# Be more Bourne compatible+DUALCASE=1; export DUALCASE # for MKS sh+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in+ *posix*) set -o posix ;;+esac++fi+++++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+ echo "#! /bin/sh" >conf$$.sh+ echo "exit 0" >>conf$$.sh+ chmod +x conf$$.sh+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+ PATH_SEPARATOR=';'+ else+ PATH_SEPARATOR=:+ fi+ rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+ as_unset=unset+else+ as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order. Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" "" $as_nl"++# Find who we are. Look in the path if we contain no directory separator.+case $0 in+ *[\\/]* ) as_myself=$0 ;;+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++ ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+ as_myself=$0+fi+if test ! -f "$as_myself"; then+ echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+ { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+ LC_TELEPHONE LC_TIME+do+ if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+ eval $as_var=C; export $as_var+ else+ ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+ as_basename=basename+else+ as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+ sed '/^.*\/\([^/][^/]*\)\/*$/{+ s//\1/+ q+ }+ /^X\/\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\/\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`++# CDPATH.+$as_unset CDPATH+++if test "x$CONFIG_SHELL" = x; then+ if (eval ":") 2>/dev/null; then+ as_have_required=yes+else+ as_have_required=no+fi++ if test $as_have_required = yes && (eval ":+(as_func_return () {+ (exit \$1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test \$exitcode = 0) || { (exit 1); exit 1; }++(+ as_lineno_1=\$LINENO+ as_lineno_2=\$LINENO+ test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&+ test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }+") 2> /dev/null; then+ :+else+ as_candidate_shells=+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ case $as_dir in+ /*)+ for as_base in sh bash ksh sh5; do+ as_candidate_shells="$as_candidate_shells $as_dir/$as_base"+ done;;+ esac+done+IFS=$as_save_IFS+++ for as_shell in $as_candidate_shells $SHELL; do+ # Try only shells that exist, to save several forks.+ if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&+ { ("$as_shell") 2> /dev/null <<\_ASEOF+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in+ *posix*) set -o posix ;;+esac++fi+++:+_ASEOF+}; then+ CONFIG_SHELL=$as_shell+ as_have_required=yes+ if { "$as_shell" 2> /dev/null <<\_ASEOF+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in+ *posix*) set -o posix ;;+esac++fi+++:+(as_func_return () {+ (exit $1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = "$1" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test $exitcode = 0) || { (exit 1); exit 1; }++(+ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }++_ASEOF+}; then+ break+fi++fi++ done++ if test "x$CONFIG_SHELL" != x; then+ for as_var in BASH_ENV ENV+ do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ done+ export CONFIG_SHELL+ exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}+fi+++ if test $as_have_required = no; then+ echo This script requires a shell more modern than all the+ echo shells that I found on your system. Please install a+ echo modern shell, or manually run the script under such a+ echo shell if you do have one.+ { (exit 1); exit 1; }+fi+++fi++fi++++(eval "as_func_return () {+ (exit \$1)+}+as_func_success () {+ as_func_return 0+}+as_func_failure () {+ as_func_return 1+}+as_func_ret_success () {+ return 0+}+as_func_ret_failure () {+ return 1+}++exitcode=0+if as_func_success; then+ :+else+ exitcode=1+ echo as_func_success failed.+fi++if as_func_failure; then+ exitcode=1+ echo as_func_failure succeeded.+fi++if as_func_ret_success; then+ :+else+ exitcode=1+ echo as_func_ret_success failed.+fi++if as_func_ret_failure; then+ exitcode=1+ echo as_func_ret_failure succeeded.+fi++if ( set x; as_func_ret_success y && test x = \"\$1\" ); then+ :+else+ exitcode=1+ echo positional parameters were not saved.+fi++test \$exitcode = 0") || {+ echo No shell found that supports shell functions.+ echo Please tell autoconf@gnu.org about your system,+ echo including any error possibly output before this+ echo message+}++++ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+ # uniformly replaced by the line number. The first 'sed' inserts a+ # line-number line after each line using $LINENO; the second 'sed'+ # does the real work. The second script uses 'N' to pair each+ # line-number line with the line containing $LINENO, and appends+ # trailing '-' during substitution so that $LINENO is not a special+ # case at line end.+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+ # scripts with optimization help from Paolo Bonzini. Blame Lee+ # E. McMahon (1931-1989) for sed's syntax. :-)+ sed -n '+ p+ /[$]LINENO/=+ ' <$as_myself |+ sed '+ s/[$]LINENO.*/&-/+ t lineno+ b+ :lineno+ N+ :loop+ s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+ t loop+ s/-\n.*//+ ' >$as_me.lineno &&+ chmod +x "$as_me.lineno" ||+ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+ { (exit 1); exit 1; }; }++ # Don't try to exec as it changes $[0], causing all sort of problems+ # (the dirname of $[0] is not the place where we might find the+ # original and so on. Autoconf is especially sensitive to this).+ . "./$as_me.lineno"+ # Exit status is that of the last command.+ exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+ as_dirname=dirname+else+ as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+ case `echo 'x\c'` in+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.+ *) ECHO_C='\c';;+ esac;;+*)+ ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+ rm -f conf$$.dir/conf$$.file+else+ rm -f conf$$.dir+ mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+ as_ln_s='ln -s'+ # ... but there are two gotchas:+ # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+ # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+ # In both cases, we have to default to `cp -p'.+ ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+ as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+ as_ln_s=ln+else+ as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+ as_mkdir_p=:+else+ test -d ./-p && rmdir ./-p+ as_mkdir_p=false+fi++if test -x / >/dev/null 2>&1; then+ as_test_x='test -x'+else+ if ls -dL / >/dev/null 2>&1; then+ as_ls_L_option=L+ else+ as_ls_L_option=+ fi+ as_test_x='+ eval sh -c '\''+ if test -d "$1"; then+ test -d "$1/.";+ else+ case $1 in+ -*)set "./$1";;+ esac;+ case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in+ ???[sx]*):;;*)false;;esac;fi+ '\'' sh+ '+fi+as_executable_p=$as_test_x++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"++++exec 7<&0 </dev/null 6>&1++# Name of the host.+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,+# so uname gets run too.+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`++#+# Initializations.+#+ac_default_prefix=/usr/local+ac_clean_files=+ac_config_libobj_dir=.+LIBOBJS=+cross_compiling=no+subdirs=+MFLAGS=+MAKEFLAGS=+SHELL=${CONFIG_SHELL-/bin/sh}++# Identity of this package.+PACKAGE_NAME='Haskell regex-posix package'+PACKAGE_TARNAME='regex-posix'+PACKAGE_VERSION='0.71'+PACKAGE_STRING='Haskell regex-posix package 0.71'+PACKAGE_BUGREPORT='TextRegexLazy@personal.mightyreason.com'++ac_unique_file="regex-posix.cabal"+# Factoring default headers for most tests.+ac_includes_default="\+#include <stdio.h>+#ifdef HAVE_SYS_TYPES_H+# include <sys/types.h>+#endif+#ifdef HAVE_SYS_STAT_H+# include <sys/stat.h>+#endif+#ifdef STDC_HEADERS+# include <stdlib.h>+# include <stddef.h>+#else+# ifdef HAVE_STDLIB_H+# include <stdlib.h>+# endif+#endif+#ifdef HAVE_STRING_H+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H+# include <memory.h>+# endif+# include <string.h>+#endif+#ifdef HAVE_STRINGS_H+# include <strings.h>+#endif+#ifdef HAVE_INTTYPES_H+# include <inttypes.h>+#endif+#ifdef HAVE_STDINT_H+# include <stdint.h>+#endif+#ifdef HAVE_UNISTD_H+# include <unistd.h>+#endif"++ac_subst_vars='SHELL+PATH_SEPARATOR+PACKAGE_NAME+PACKAGE_TARNAME+PACKAGE_VERSION+PACKAGE_STRING+PACKAGE_BUGREPORT+exec_prefix+prefix+program_transform_name+bindir+sbindir+libexecdir+datarootdir+datadir+sysconfdir+sharedstatedir+localstatedir+includedir+oldincludedir+docdir+infodir+htmldir+dvidir+pdfdir+psdir+libdir+localedir+mandir+DEFS+ECHO_C+ECHO_N+ECHO_T+LIBS+build_alias+host_alias+target_alias+CC+CFLAGS+LDFLAGS+CPPFLAGS+ac_ct_CC+EXEEXT+OBJEXT+CPP+GREP+EGREP+HavePosixRegex+C_SOURCES+LIBOBJS+LTLIBOBJS'+ac_subst_files=''+ ac_precious_vars='build_alias+host_alias+target_alias+CC+CFLAGS+LDFLAGS+LIBS+CPPFLAGS+CPP'+++# Initialize some variables set by options.+ac_init_help=+ac_init_version=false+# The variables have the same names as the options, with+# dashes changed to underlines.+cache_file=/dev/null+exec_prefix=NONE+no_create=+no_recursion=+prefix=NONE+program_prefix=NONE+program_suffix=NONE+program_transform_name=s,x,x,+silent=+site=+srcdir=+verbose=+x_includes=NONE+x_libraries=NONE++# Installation directory options.+# These are left unexpanded so users can "make install exec_prefix=/foo"+# and all the variables that are supposed to be based on exec_prefix+# by default will actually change.+# Use braces instead of parens because sh, perl, etc. also accept them.+# (The list follows the same order as the GNU Coding Standards.)+bindir='${exec_prefix}/bin'+sbindir='${exec_prefix}/sbin'+libexecdir='${exec_prefix}/libexec'+datarootdir='${prefix}/share'+datadir='${datarootdir}'+sysconfdir='${prefix}/etc'+sharedstatedir='${prefix}/com'+localstatedir='${prefix}/var'+includedir='${prefix}/include'+oldincludedir='/usr/include'+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'+infodir='${datarootdir}/info'+htmldir='${docdir}'+dvidir='${docdir}'+pdfdir='${docdir}'+psdir='${docdir}'+libdir='${exec_prefix}/lib'+localedir='${datarootdir}/locale'+mandir='${datarootdir}/man'++ac_prev=+ac_dashdash=+for ac_option+do+ # If the previous option needs an argument, assign it.+ if test -n "$ac_prev"; then+ eval $ac_prev=\$ac_option+ ac_prev=+ continue+ fi++ case $ac_option in+ *=*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;+ *) ac_optarg=yes ;;+ esac++ # Accept the important Cygnus configure options, so we can diagnose typos.++ case $ac_dashdash$ac_option in+ --)+ ac_dashdash=yes ;;++ -bindir | --bindir | --bindi | --bind | --bin | --bi)+ ac_prev=bindir ;;+ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)+ bindir=$ac_optarg ;;++ -build | --build | --buil | --bui | --bu)+ ac_prev=build_alias ;;+ -build=* | --build=* | --buil=* | --bui=* | --bu=*)+ build_alias=$ac_optarg ;;++ -cache-file | --cache-file | --cache-fil | --cache-fi \+ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)+ ac_prev=cache_file ;;+ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \+ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)+ cache_file=$ac_optarg ;;++ --config-cache | -C)+ cache_file=config.cache ;;++ -datadir | --datadir | --datadi | --datad)+ ac_prev=datadir ;;+ -datadir=* | --datadir=* | --datadi=* | --datad=*)+ datadir=$ac_optarg ;;++ -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \+ | --dataroo | --dataro | --datar)+ ac_prev=datarootdir ;;+ -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \+ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)+ datarootdir=$ac_optarg ;;++ -disable-* | --disable-*)+ ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2+ { (exit 1); exit 1; }; }+ ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`+ eval enable_$ac_feature=no ;;++ -docdir | --docdir | --docdi | --doc | --do)+ ac_prev=docdir ;;+ -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)+ docdir=$ac_optarg ;;++ -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)+ ac_prev=dvidir ;;+ -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)+ dvidir=$ac_optarg ;;++ -enable-* | --enable-*)+ ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2+ { (exit 1); exit 1; }; }+ ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`+ eval enable_$ac_feature=\$ac_optarg ;;++ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \+ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \+ | --exec | --exe | --ex)+ ac_prev=exec_prefix ;;+ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \+ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \+ | --exec=* | --exe=* | --ex=*)+ exec_prefix=$ac_optarg ;;++ -gas | --gas | --ga | --g)+ # Obsolete; use --with-gas.+ with_gas=yes ;;++ -help | --help | --hel | --he | -h)+ ac_init_help=long ;;+ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)+ ac_init_help=recursive ;;+ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)+ ac_init_help=short ;;++ -host | --host | --hos | --ho)+ ac_prev=host_alias ;;+ -host=* | --host=* | --hos=* | --ho=*)+ host_alias=$ac_optarg ;;++ -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)+ ac_prev=htmldir ;;+ -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \+ | --ht=*)+ htmldir=$ac_optarg ;;++ -includedir | --includedir | --includedi | --included | --include \+ | --includ | --inclu | --incl | --inc)+ ac_prev=includedir ;;+ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \+ | --includ=* | --inclu=* | --incl=* | --inc=*)+ includedir=$ac_optarg ;;++ -infodir | --infodir | --infodi | --infod | --info | --inf)+ ac_prev=infodir ;;+ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)+ infodir=$ac_optarg ;;++ -libdir | --libdir | --libdi | --libd)+ ac_prev=libdir ;;+ -libdir=* | --libdir=* | --libdi=* | --libd=*)+ libdir=$ac_optarg ;;++ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \+ | --libexe | --libex | --libe)+ ac_prev=libexecdir ;;+ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \+ | --libexe=* | --libex=* | --libe=*)+ libexecdir=$ac_optarg ;;++ -localedir | --localedir | --localedi | --localed | --locale)+ ac_prev=localedir ;;+ -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)+ localedir=$ac_optarg ;;++ -localstatedir | --localstatedir | --localstatedi | --localstated \+ | --localstate | --localstat | --localsta | --localst | --locals)+ ac_prev=localstatedir ;;+ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \+ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)+ localstatedir=$ac_optarg ;;++ -mandir | --mandir | --mandi | --mand | --man | --ma | --m)+ ac_prev=mandir ;;+ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)+ mandir=$ac_optarg ;;++ -nfp | --nfp | --nf)+ # Obsolete; use --without-fp.+ with_fp=no ;;++ -no-create | --no-create | --no-creat | --no-crea | --no-cre \+ | --no-cr | --no-c | -n)+ no_create=yes ;;++ -no-recursion | --no-recursion | --no-recursio | --no-recursi \+ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)+ no_recursion=yes ;;++ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \+ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \+ | --oldin | --oldi | --old | --ol | --o)+ ac_prev=oldincludedir ;;+ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \+ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \+ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)+ oldincludedir=$ac_optarg ;;++ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)+ ac_prev=prefix ;;+ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)+ prefix=$ac_optarg ;;++ -program-prefix | --program-prefix | --program-prefi | --program-pref \+ | --program-pre | --program-pr | --program-p)+ ac_prev=program_prefix ;;+ -program-prefix=* | --program-prefix=* | --program-prefi=* \+ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)+ program_prefix=$ac_optarg ;;++ -program-suffix | --program-suffix | --program-suffi | --program-suff \+ | --program-suf | --program-su | --program-s)+ ac_prev=program_suffix ;;+ -program-suffix=* | --program-suffix=* | --program-suffi=* \+ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)+ program_suffix=$ac_optarg ;;++ -program-transform-name | --program-transform-name \+ | --program-transform-nam | --program-transform-na \+ | --program-transform-n | --program-transform- \+ | --program-transform | --program-transfor \+ | --program-transfo | --program-transf \+ | --program-trans | --program-tran \+ | --progr-tra | --program-tr | --program-t)+ ac_prev=program_transform_name ;;+ -program-transform-name=* | --program-transform-name=* \+ | --program-transform-nam=* | --program-transform-na=* \+ | --program-transform-n=* | --program-transform-=* \+ | --program-transform=* | --program-transfor=* \+ | --program-transfo=* | --program-transf=* \+ | --program-trans=* | --program-tran=* \+ | --progr-tra=* | --program-tr=* | --program-t=*)+ program_transform_name=$ac_optarg ;;++ -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)+ ac_prev=pdfdir ;;+ -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)+ pdfdir=$ac_optarg ;;++ -psdir | --psdir | --psdi | --psd | --ps)+ ac_prev=psdir ;;+ -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)+ psdir=$ac_optarg ;;++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil)+ silent=yes ;;++ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)+ ac_prev=sbindir ;;+ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \+ | --sbi=* | --sb=*)+ sbindir=$ac_optarg ;;++ -sharedstatedir | --sharedstatedir | --sharedstatedi \+ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \+ | --sharedst | --shareds | --shared | --share | --shar \+ | --sha | --sh)+ ac_prev=sharedstatedir ;;+ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \+ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \+ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \+ | --sha=* | --sh=*)+ sharedstatedir=$ac_optarg ;;++ -site | --site | --sit)+ ac_prev=site ;;+ -site=* | --site=* | --sit=*)+ site=$ac_optarg ;;++ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)+ ac_prev=srcdir ;;+ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)+ srcdir=$ac_optarg ;;++ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \+ | --syscon | --sysco | --sysc | --sys | --sy)+ ac_prev=sysconfdir ;;+ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \+ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)+ sysconfdir=$ac_optarg ;;++ -target | --target | --targe | --targ | --tar | --ta | --t)+ ac_prev=target_alias ;;+ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)+ target_alias=$ac_optarg ;;++ -v | -verbose | --verbose | --verbos | --verbo | --verb)+ verbose=yes ;;++ -version | --version | --versio | --versi | --vers | -V)+ ac_init_version=: ;;++ -with-* | --with-*)+ ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid package name: $ac_package" >&2+ { (exit 1); exit 1; }; }+ ac_package=`echo $ac_package | sed 's/[-.]/_/g'`+ eval with_$ac_package=\$ac_optarg ;;++ -without-* | --without-*)+ ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`+ # Reject names that are not valid shell variable names.+ expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid package name: $ac_package" >&2+ { (exit 1); exit 1; }; }+ ac_package=`echo $ac_package | sed 's/[-.]/_/g'`+ eval with_$ac_package=no ;;++ --x)+ # Obsolete; use --with-x.+ with_x=yes ;;++ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \+ | --x-incl | --x-inc | --x-in | --x-i)+ ac_prev=x_includes ;;+ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \+ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)+ x_includes=$ac_optarg ;;++ -x-libraries | --x-libraries | --x-librarie | --x-librari \+ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)+ ac_prev=x_libraries ;;+ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \+ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)+ x_libraries=$ac_optarg ;;++ -*) { echo "$as_me: error: unrecognized option: $ac_option+Try \`$0 --help' for more information." >&2+ { (exit 1); exit 1; }; }+ ;;++ *=*)+ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`+ # Reject names that are not valid shell variable names.+ expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&+ { echo "$as_me: error: invalid variable name: $ac_envvar" >&2+ { (exit 1); exit 1; }; }+ eval $ac_envvar=\$ac_optarg+ export $ac_envvar ;;++ *)+ # FIXME: should be removed in autoconf 3.0.+ echo "$as_me: WARNING: you should use --build, --host, --target" >&2+ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&+ echo "$as_me: WARNING: invalid host type: $ac_option" >&2+ : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}+ ;;++ esac+done++if test -n "$ac_prev"; then+ ac_option=--`echo $ac_prev | sed 's/_/-/g'`+ { echo "$as_me: error: missing argument to $ac_option" >&2+ { (exit 1); exit 1; }; }+fi++# Be sure to have absolute directory names.+for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \+ datadir sysconfdir sharedstatedir localstatedir includedir \+ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \+ libdir localedir mandir+do+ eval ac_val=\$$ac_var+ case $ac_val in+ [\\/$]* | ?:[\\/]* ) continue;;+ NONE | '' ) case $ac_var in *prefix ) continue;; esac;;+ esac+ { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2+ { (exit 1); exit 1; }; }+done++# There might be people who depend on the old broken behavior: `$host'+# used to hold the argument of --host etc.+# FIXME: To remove some day.+build=$build_alias+host=$host_alias+target=$target_alias++# FIXME: To remove some day.+if test "x$host_alias" != x; then+ if test "x$build_alias" = x; then+ cross_compiling=maybe+ echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.+ If a cross compiler is detected then cross compile mode will be used." >&2+ elif test "x$build_alias" != "x$host_alias"; then+ cross_compiling=yes+ fi+fi++ac_tool_prefix=+test -n "$host_alias" && ac_tool_prefix=$host_alias-++test "$silent" = yes && exec 6>/dev/null+++ac_pwd=`pwd` && test -n "$ac_pwd" &&+ac_ls_di=`ls -di .` &&+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||+ { echo "$as_me: error: Working directory cannot be determined" >&2+ { (exit 1); exit 1; }; }+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||+ { echo "$as_me: error: pwd does not report name of working directory" >&2+ { (exit 1); exit 1; }; }+++# Find the source files, if location was not specified.+if test -z "$srcdir"; then+ ac_srcdir_defaulted=yes+ # Try the directory containing this script, then the parent directory.+ ac_confdir=`$as_dirname -- "$0" ||+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$0" : 'X\(//\)[^/]' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$0" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ srcdir=$ac_confdir+ if test ! -r "$srcdir/$ac_unique_file"; then+ srcdir=..+ fi+else+ ac_srcdir_defaulted=no+fi+if test ! -r "$srcdir/$ac_unique_file"; then+ test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."+ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2+ { (exit 1); exit 1; }; }+fi+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"+ac_abs_confdir=`(+ cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2+ { (exit 1); exit 1; }; }+ pwd)`+# When building in place, set srcdir=.+if test "$ac_abs_confdir" = "$ac_pwd"; then+ srcdir=.+fi+# Remove unnecessary trailing slashes from srcdir.+# Double slashes in file names in object file debugging info+# mess up M-x gdb in Emacs.+case $srcdir in+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;+esac+for ac_var in $ac_precious_vars; do+ eval ac_env_${ac_var}_set=\${${ac_var}+set}+ eval ac_env_${ac_var}_value=\$${ac_var}+ eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}+ eval ac_cv_env_${ac_var}_value=\$${ac_var}+done++#+# Report the --help message.+#+if test "$ac_init_help" = "long"; then+ # Omit some internal or obsolete options to make the list less imposing.+ # This message is too long to be a string in the A/UX 3.1 sh.+ cat <<_ACEOF+\`configure' configures Haskell regex-posix package 0.71 to adapt to many kinds of systems.++Usage: $0 [OPTION]... [VAR=VALUE]...++To assign environment variables (e.g., CC, CFLAGS...), specify them as+VAR=VALUE. See below for descriptions of some of the useful variables.++Defaults for the options are specified in brackets.++Configuration:+ -h, --help display this help and exit+ --help=short display options specific to this package+ --help=recursive display the short help of all the included packages+ -V, --version display version information and exit+ -q, --quiet, --silent do not print \`checking...' messages+ --cache-file=FILE cache test results in FILE [disabled]+ -C, --config-cache alias for \`--cache-file=config.cache'+ -n, --no-create do not create output files+ --srcdir=DIR find the sources in DIR [configure dir or \`..']++Installation directories:+ --prefix=PREFIX install architecture-independent files in PREFIX+ [$ac_default_prefix]+ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX+ [PREFIX]++By default, \`make install' will install all the files in+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify+an installation prefix other than \`$ac_default_prefix' using \`--prefix',+for instance \`--prefix=\$HOME'.++For better control, use the options below.++Fine tuning of the installation directories:+ --bindir=DIR user executables [EPREFIX/bin]+ --sbindir=DIR system admin executables [EPREFIX/sbin]+ --libexecdir=DIR program executables [EPREFIX/libexec]+ --sysconfdir=DIR read-only single-machine data [PREFIX/etc]+ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]+ --localstatedir=DIR modifiable single-machine data [PREFIX/var]+ --libdir=DIR object code libraries [EPREFIX/lib]+ --includedir=DIR C header files [PREFIX/include]+ --oldincludedir=DIR C header files for non-gcc [/usr/include]+ --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]+ --datadir=DIR read-only architecture-independent data [DATAROOTDIR]+ --infodir=DIR info documentation [DATAROOTDIR/info]+ --localedir=DIR locale-dependent data [DATAROOTDIR/locale]+ --mandir=DIR man documentation [DATAROOTDIR/man]+ --docdir=DIR documentation root [DATAROOTDIR/doc/regex-posix]+ --htmldir=DIR html documentation [DOCDIR]+ --dvidir=DIR dvi documentation [DOCDIR]+ --pdfdir=DIR pdf documentation [DOCDIR]+ --psdir=DIR ps documentation [DOCDIR]+_ACEOF++ cat <<\_ACEOF+_ACEOF+fi++if test -n "$ac_init_help"; then+ case $ac_init_help in+ short | recursive ) echo "Configuration of Haskell regex-posix package 0.71:";;+ esac+ cat <<\_ACEOF++Optional Packages:+ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]+ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)+C compiler++Some influential environment variables:+ CC C compiler command+ CFLAGS C compiler flags+ LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a+ nonstandard directory <lib dir>+ LIBS libraries to pass to the linker, e.g. -l<library>+ CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I<include dir> if+ you have headers in a nonstandard directory <include dir>+ CPP C preprocessor++Use these variables to override the choices made by `configure' or to help+it to find libraries and programs with nonstandard names/locations.++Report bugs to <TextRegexLazy@personal.mightyreason.com>.+_ACEOF+ac_status=$?+fi++if test "$ac_init_help" = "recursive"; then+ # If there are subdirs, report their specific --help.+ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue+ test -d "$ac_dir" || continue+ ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+ # A ".." for each directory in $ac_dir_suffix.+ ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+ case $ac_top_builddir_sub in+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;+ esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+ .) # We are building in place.+ ac_srcdir=.+ ac_top_srcdir=$ac_top_builddir_sub+ ac_abs_top_srcdir=$ac_pwd ;;+ [\\/]* | ?:[\\/]* ) # Absolute name.+ ac_srcdir=$srcdir$ac_dir_suffix;+ ac_top_srcdir=$srcdir+ ac_abs_top_srcdir=$srcdir ;;+ *) # Relative name.+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+ ac_top_srcdir=$ac_top_build_prefix$srcdir+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix++ cd "$ac_dir" || { ac_status=$?; continue; }+ # Check for guested configure.+ if test -f "$ac_srcdir/configure.gnu"; then+ echo &&+ $SHELL "$ac_srcdir/configure.gnu" --help=recursive+ elif test -f "$ac_srcdir/configure"; then+ echo &&+ $SHELL "$ac_srcdir/configure" --help=recursive+ else+ echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2+ fi || ac_status=$?+ cd "$ac_pwd" || { ac_status=$?; break; }+ done+fi++test -n "$ac_init_help" && exit $ac_status+if $ac_init_version; then+ cat <<\_ACEOF+Haskell regex-posix package configure 0.71+generated by GNU Autoconf 2.61++Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,+2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.+This configure script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it.+_ACEOF+ exit+fi+cat >config.log <<_ACEOF+This file contains any messages produced by compilers while+running configure, to aid debugging if configure makes a mistake.++It was created by Haskell regex-posix package $as_me 0.71, which was+generated by GNU Autoconf 2.61. Invocation command line was++ $ $0 $@++_ACEOF+exec 5>>config.log+{+cat <<_ASUNAME+## --------- ##+## Platform. ##+## --------- ##++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`+uname -m = `(uname -m) 2>/dev/null || echo unknown`+uname -r = `(uname -r) 2>/dev/null || echo unknown`+uname -s = `(uname -s) 2>/dev/null || echo unknown`+uname -v = `(uname -v) 2>/dev/null || echo unknown`++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`+/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`++/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`+/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`+/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`+/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`++_ASUNAME++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ echo "PATH: $as_dir"+done+IFS=$as_save_IFS++} >&5++cat >&5 <<_ACEOF+++## ----------- ##+## Core tests. ##+## ----------- ##++_ACEOF+++# Keep a trace of the command line.+# Strip out --no-create and --no-recursion so they do not pile up.+# Strip out --silent because we don't want to record it for future runs.+# Also quote any args containing shell meta-characters.+# Make two passes to allow for proper duplicate-argument suppression.+ac_configure_args=+ac_configure_args0=+ac_configure_args1=+ac_must_keep_next=false+for ac_pass in 1 2+do+ for ac_arg+ do+ case $ac_arg in+ -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil)+ continue ;;+ *\'*)+ ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;+ esac+ case $ac_pass in+ 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;+ 2)+ ac_configure_args1="$ac_configure_args1 '$ac_arg'"+ if test $ac_must_keep_next = true; then+ ac_must_keep_next=false # Got value, back to normal.+ else+ case $ac_arg in+ *=* | --config-cache | -C | -disable-* | --disable-* \+ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \+ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \+ | -with-* | --with-* | -without-* | --without-* | --x)+ case "$ac_configure_args0 " in+ "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;+ esac+ ;;+ -* ) ac_must_keep_next=true ;;+ esac+ fi+ ac_configure_args="$ac_configure_args '$ac_arg'"+ ;;+ esac+ done+done+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }++# When interrupted or exit'd, cleanup temporary files, and complete+# config.log. We remove comments because anyway the quotes in there+# would cause problems or look ugly.+# WARNING: Use '\'' to represent an apostrophe within the trap.+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.+trap 'exit_status=$?+ # Save into config.log some information that might help in debugging.+ {+ echo++ cat <<\_ASBOX+## ---------------- ##+## Cache variables. ##+## ---------------- ##+_ASBOX+ echo+ # The following way of writing the cache mishandles newlines in values,+(+ for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do+ eval ac_val=\$$ac_var+ case $ac_val in #(+ *${as_nl}*)+ case $ac_var in #(+ *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+ esac+ case $ac_var in #(+ _ | IFS | as_nl) ;; #(+ *) $as_unset $ac_var ;;+ esac ;;+ esac+ done+ (set) 2>&1 |+ case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(+ *${as_nl}ac_space=\ *)+ sed -n \+ "s/'\''/'\''\\\\'\'''\''/g;+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"+ ;; #(+ *)+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+ ;;+ esac |+ sort+)+ echo++ cat <<\_ASBOX+## ----------------- ##+## Output variables. ##+## ----------------- ##+_ASBOX+ echo+ for ac_var in $ac_subst_vars+ do+ eval ac_val=\$$ac_var+ case $ac_val in+ *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+ esac+ echo "$ac_var='\''$ac_val'\''"+ done | sort+ echo++ if test -n "$ac_subst_files"; then+ cat <<\_ASBOX+## ------------------- ##+## File substitutions. ##+## ------------------- ##+_ASBOX+ echo+ for ac_var in $ac_subst_files+ do+ eval ac_val=\$$ac_var+ case $ac_val in+ *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;+ esac+ echo "$ac_var='\''$ac_val'\''"+ done | sort+ echo+ fi++ if test -s confdefs.h; then+ cat <<\_ASBOX+## ----------- ##+## confdefs.h. ##+## ----------- ##+_ASBOX+ echo+ cat confdefs.h+ echo+ fi+ test "$ac_signal" != 0 &&+ echo "$as_me: caught signal $ac_signal"+ echo "$as_me: exit $exit_status"+ } >&5+ rm -f core *.core core.conftest.* &&+ rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&+ exit $exit_status+' 0+for ac_signal in 1 2 13 15; do+ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal+done+ac_signal=0++# confdefs.h avoids OS command line length limits that DEFS can exceed.+rm -f -r conftest* confdefs.h++# Predefined preprocessor variables.++cat >>confdefs.h <<_ACEOF+#define PACKAGE_NAME "$PACKAGE_NAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_VERSION "$PACKAGE_VERSION"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_STRING "$PACKAGE_STRING"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"+_ACEOF+++# Let the site file select an alternate cache file if it wants to.+# Prefer explicitly selected file to automatically selected ones.+if test -n "$CONFIG_SITE"; then+ set x "$CONFIG_SITE"+elif test "x$prefix" != xNONE; then+ set x "$prefix/share/config.site" "$prefix/etc/config.site"+else+ set x "$ac_default_prefix/share/config.site" \+ "$ac_default_prefix/etc/config.site"+fi+shift+for ac_site_file+do+ if test -r "$ac_site_file"; then+ { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5+echo "$as_me: loading site script $ac_site_file" >&6;}+ sed 's/^/| /' "$ac_site_file" >&5+ . "$ac_site_file"+ fi+done++if test -r "$cache_file"; then+ # Some versions of bash will fail to source /dev/null (special+ # files actually), so we avoid doing that.+ if test -f "$cache_file"; then+ { echo "$as_me:$LINENO: loading cache $cache_file" >&5+echo "$as_me: loading cache $cache_file" >&6;}+ case $cache_file in+ [\\/]* | ?:[\\/]* ) . "$cache_file";;+ *) . "./$cache_file";;+ esac+ fi+else+ { echo "$as_me:$LINENO: creating cache $cache_file" >&5+echo "$as_me: creating cache $cache_file" >&6;}+ >$cache_file+fi++# Check that the precious variables saved in the cache have kept the same+# value.+ac_cache_corrupted=false+for ac_var in $ac_precious_vars; do+ eval ac_old_set=\$ac_cv_env_${ac_var}_set+ eval ac_new_set=\$ac_env_${ac_var}_set+ eval ac_old_val=\$ac_cv_env_${ac_var}_value+ eval ac_new_val=\$ac_env_${ac_var}_value+ case $ac_old_set,$ac_new_set in+ set,)+ { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}+ ac_cache_corrupted=: ;;+ ,set)+ { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}+ ac_cache_corrupted=: ;;+ ,);;+ *)+ if test "x$ac_old_val" != "x$ac_new_val"; then+ { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}+ { echo "$as_me:$LINENO: former value: $ac_old_val" >&5+echo "$as_me: former value: $ac_old_val" >&2;}+ { echo "$as_me:$LINENO: current value: $ac_new_val" >&5+echo "$as_me: current value: $ac_new_val" >&2;}+ ac_cache_corrupted=:+ fi;;+ esac+ # Pass precious variables to config.status.+ if test "$ac_new_set" = set; then+ case $ac_new_val in+ *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;+ *) ac_arg=$ac_var=$ac_new_val ;;+ esac+ case " $ac_configure_args " in+ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.+ *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;+ esac+ fi+done+if $ac_cache_corrupted; then+ { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5+echo "$as_me: error: changes in the environment can compromise the build" >&2;}+ { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}+ { (exit 1); exit 1; }; }+fi++++++++++++++++++++++++++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++++ac_config_headers="$ac_config_headers include/HsRegexPosixConfig.h"++++# Check whether --with-cc was given.+if test "${with_cc+set}" = set; then+ withval=$with_cc; CC=$withval+fi++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+if test -n "$ac_tool_prefix"; then+ # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.+set dummy ${ac_tool_prefix}gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="${ac_tool_prefix}gcc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$ac_cv_prog_CC"; then+ ac_ct_CC=$CC+ # Extract the first word of "gcc", so it can be a program name with args.+set dummy gcc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$ac_ct_CC"; then+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_ac_ct_CC="gcc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+ { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi++ if test "x$ac_ct_CC" = x; then+ CC=""+ else+ case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+ CC=$ac_ct_CC+ fi+else+ CC="$ac_cv_prog_CC"+fi++if test -z "$CC"; then+ if test -n "$ac_tool_prefix"; then+ # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.+set dummy ${ac_tool_prefix}cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="${ac_tool_prefix}cc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ fi+fi+if test -z "$CC"; then+ # Extract the first word of "cc", so it can be a program name with args.+set dummy cc; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+ ac_prog_rejected=no+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then+ ac_prog_rejected=yes+ continue+ fi+ ac_cv_prog_CC="cc"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++if test $ac_prog_rejected = yes; then+ # We found a bogon in the path, so make sure we never use it.+ set dummy $ac_cv_prog_CC+ shift+ if test $# != 0; then+ # We chose a different compiler from the bogus one.+ # However, it has the same basename, so the bogon will be chosen+ # first if we set CC to just the basename; use the full file name.+ shift+ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"+ fi+fi+fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++fi+if test -z "$CC"; then+ if test -n "$ac_tool_prefix"; then+ for ac_prog in cl.exe+ do+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.+set dummy $ac_tool_prefix$ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$CC"; then+ ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_CC="$ac_tool_prefix$ac_prog"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+ { echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ test -n "$CC" && break+ done+fi+if test -z "$CC"; then+ ac_ct_CC=$CC+ for ac_prog in cl.exe+do+ # Extract the first word of "$ac_prog", so it can be a program name with args.+set dummy $ac_prog; ac_word=$2+{ echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if test -n "$ac_ct_CC"; then+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_exec_ext in '' $ac_executable_extensions; do+ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then+ ac_cv_prog_ac_ct_CC="$ac_prog"+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+ break 2+ fi+done+done+IFS=$as_save_IFS++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+ { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6; }+else+ { echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6; }+fi+++ test -n "$ac_ct_CC" && break+done++ if test "x$ac_ct_CC" = x; then+ CC=""+ else+ case $cross_compiling:$ac_tool_warned in+yes:)+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&5+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools+whose name does not start with the host triplet. If you think this+configuration is useful to you, please write to autoconf@gnu.org." >&2;}+ac_tool_warned=yes ;;+esac+ CC=$ac_ct_CC+ fi+fi++fi+++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&5+echo "$as_me: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }++# Provide some information about the compiler.+echo "$as_me:$LINENO: checking for C compiler version" >&5+ac_compiler=`set X $ac_compile; echo $2`+{ (ac_try="$ac_compiler --version >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler --version >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }+{ (ac_try="$ac_compiler -v >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler -v >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }+{ (ac_try="$ac_compiler -V >&5"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compiler -V >&5") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }++cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files a.out a.exe b.out"+# Try to create an executable without -o first, disregard a.out.+# It will help us diagnose broken compilers, and finding out an intuition+# of exeext.+{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`+#+# List of possible output files, starting from the most likely.+# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)+# only as a last resort. b.out is created by i960 compilers.+ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'+#+# The IRIX 6 linker writes into existing files which may not be+# executable, retaining their permissions. Remove them first so a+# subsequent execution test works.+ac_rmfiles=+for ac_file in $ac_files+do+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+ * ) ac_rmfiles="$ac_rmfiles $ac_file";;+ esac+done+rm -f $ac_rmfiles++if { (ac_try="$ac_link_default"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link_default") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'+# in a Makefile. We should not override ac_cv_exeext if it was cached,+# so that the user can short-circuit this test for compilers unknown to+# Autoconf.+for ac_file in $ac_files ''+do+ test -f "$ac_file" || continue+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )+ ;;+ [ab].out )+ # We found the default executable, but exeext='' is most+ # certainly right.+ break;;+ *.* )+ if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;+ then :; else+ ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+ fi+ # We set ac_cv_exeext here because the later test for it is not+ # safe: cross compilers may not add the suffix if given an `-o'+ # argument, so we may need to know it at that point already.+ # Even if this section looks crufty: it has the advantage of+ # actually working.+ break;;+ * )+ break;;+ esac+done+test "$ac_cv_exeext" = no && ac_cv_exeext=++else+ ac_file=''+fi++{ echo "$as_me:$LINENO: result: $ac_file" >&5+echo "${ECHO_T}$ac_file" >&6; }+if test -z "$ac_file"; then+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: C compiler cannot create executables+See \`config.log' for more details." >&5+echo "$as_me: error: C compiler cannot create executables+See \`config.log' for more details." >&2;}+ { (exit 77); exit 77; }; }+fi++ac_exeext=$ac_cv_exeext++# Check that the compiler produces executables we can run. If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0+# If not cross compiling, check that we can run a simple program.+if test "$cross_compiling" != yes; then+ if { ac_try='./$ac_file'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ cross_compiling=no+ else+ if test "$cross_compiling" = maybe; then+ cross_compiling=yes+ else+ { { echo "$as_me:$LINENO: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&5+echo "$as_me: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+ fi+ fi+fi+{ echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6; }++rm -f a.out a.exe conftest$ac_cv_exeext b.out+ac_clean_files=$ac_clean_files_save+# Check that the compiler produces executables we can run. If not, either+# the compiler is broken, or we cross compile.+{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }+{ echo "$as_me:$LINENO: result: $cross_compiling" >&5+echo "${ECHO_T}$cross_compiling" >&6; }++{ echo "$as_me:$LINENO: checking for suffix of executables" >&5+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ # If both `conftest.exe' and `conftest' are `present' (well, observable)+# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will+# work properly (i.e., refer to `conftest.exe'), while it won't with+# `rm'.+for ac_file in conftest.exe conftest conftest.*; do+ test -f "$ac_file" || continue+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;+ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+ break;;+ * ) break;;+ esac+done+else+ { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++rm -f conftest$ac_cv_exeext+{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5+echo "${ECHO_T}$ac_cv_exeext" >&6; }++rm -f conftest.$ac_ext+EXEEXT=$ac_cv_exeext+ac_exeext=$EXEEXT+{ echo "$as_me:$LINENO: checking for suffix of object files" >&5+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }+if test "${ac_cv_objext+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.o conftest.obj+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; then+ for ac_file in conftest.o conftest.obj conftest.*; do+ test -f "$ac_file" || continue;+ case $ac_file in+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;+ *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`+ break;;+ esac+done+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++rm -f conftest.$ac_cv_objext conftest.$ac_ext+fi+{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5+echo "${ECHO_T}$ac_cv_objext" >&6; }+OBJEXT=$ac_cv_objext+ac_objext=$OBJEXT+{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }+if test "${ac_cv_c_compiler_gnu+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{+#ifndef __GNUC__+ choke me+#endif++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_compiler_gnu=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_compiler_gnu=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+ac_cv_c_compiler_gnu=$ac_compiler_gnu++fi+{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }+GCC=`test $ac_compiler_gnu = yes && echo yes`+ac_test_CFLAGS=${CFLAGS+set}+ac_save_CFLAGS=$CFLAGS+{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_g+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_save_c_werror_flag=$ac_c_werror_flag+ ac_c_werror_flag=yes+ ac_cv_prog_cc_g=no+ CFLAGS="-g"+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_cv_prog_cc_g=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ CFLAGS=""+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_c_werror_flag=$ac_save_c_werror_flag+ CFLAGS="-g"+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_cv_prog_cc_g=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+ ac_c_werror_flag=$ac_save_c_werror_flag+fi+{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }+if test "$ac_test_CFLAGS" = set; then+ CFLAGS=$ac_save_CFLAGS+elif test $ac_cv_prog_cc_g = yes; then+ if test "$GCC" = yes; then+ CFLAGS="-g -O2"+ else+ CFLAGS="-g"+ fi+else+ if test "$GCC" = yes; then+ CFLAGS="-O2"+ else+ CFLAGS=+ fi+fi+{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5+echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }+if test "${ac_cv_prog_cc_c89+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_cv_prog_cc_c89=no+ac_save_CC=$CC+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdarg.h>+#include <stdio.h>+#include <sys/types.h>+#include <sys/stat.h>+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */+struct buf { int x; };+FILE * (*rcsopen) (struct buf *, struct stat *, int);+static char *e (p, i)+ char **p;+ int i;+{+ return p[i];+}+static char *f (char * (*g) (char **, int), char **p, ...)+{+ char *s;+ va_list v;+ va_start (v,p);+ s = g (p, va_arg (v,int));+ va_end (v);+ return s;+}++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has+ function prototypes and stuff, but not '\xHH' hex character constants.+ These don't provoke an error unfortunately, instead are silently treated+ as 'x'. The following induces an error, until -std is added to get+ proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an+ array size at least. It's necessary to write '\x00'==0 to get something+ that's true only with -std. */+int osf4_cc_array ['\x00' == 0 ? 1 : -1];++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters+ inside strings and character constants. */+#define FOO(x) 'x'+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];++int test (int i, double x);+struct s1 {int (*f) (int a);};+struct s2 {int (*f) (double a);};+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);+int argc;+char **argv;+int+main ()+{+return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];+ ;+ return 0;+}+_ACEOF+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \+ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"+do+ CC="$ac_save_CC $ac_arg"+ rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_cv_prog_cc_c89=$ac_arg+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5+++fi++rm -f core conftest.err conftest.$ac_objext+ test "x$ac_cv_prog_cc_c89" != "xno" && break+done+rm -f conftest.$ac_ext+CC=$ac_save_CC++fi+# AC_CACHE_VAL+case "x$ac_cv_prog_cc_c89" in+ x)+ { echo "$as_me:$LINENO: result: none needed" >&5+echo "${ECHO_T}none needed" >&6; } ;;+ xno)+ { echo "$as_me:$LINENO: result: unsupported" >&5+echo "${ECHO_T}unsupported" >&6; } ;;+ *)+ CC="$CC $ac_cv_prog_cc_c89"+ { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5+echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;+esac+++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++HavePosixRegex=NO++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }+# On Suns, sometimes $CPP names a directory.+if test -n "$CPP" && test -d "$CPP"; then+ CPP=+fi+if test -z "$CPP"; then+ if test "${ac_cv_prog_CPP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ # Double quotes because CPP needs to be expanded+ for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"+ do+ ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+ # Use a header file that comes with gcc, so configuring glibc+ # with a fresh cross-compiler works.+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+ # <limits.h> exists even on freestanding compilers.+ # On the NeXT, cc -E runs the code through the compiler's parser,+ # not just through cpp. "Syntax error" is here to catch this case.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+ Syntax error+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null && {+ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||+ test ! -s conftest.err+ }; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Broken: fails on valid input.+continue+fi++rm -f conftest.err conftest.$ac_ext++ # OK, works on sane cases. Now check whether nonexistent headers+ # can be detected and how.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ac_nonexistent.h>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null && {+ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||+ test ! -s conftest.err+ }; then+ # Broken: success on invalid input.+continue+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Passes both tests.+ac_preproc_ok=:+break+fi++rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+ break+fi++ done+ ac_cv_prog_CPP=$CPP++fi+ CPP=$ac_cv_prog_CPP+else+ ac_cv_prog_CPP=$CPP+fi+{ echo "$as_me:$LINENO: result: $CPP" >&5+echo "${ECHO_T}$CPP" >&6; }+ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+ # Use a header file that comes with gcc, so configuring glibc+ # with a fresh cross-compiler works.+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+ # <limits.h> exists even on freestanding compilers.+ # On the NeXT, cc -E runs the code through the compiler's parser,+ # not just through cpp. "Syntax error" is here to catch this case.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+ Syntax error+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null && {+ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||+ test ! -s conftest.err+ }; then+ :+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Broken: fails on valid input.+continue+fi++rm -f conftest.err conftest.$ac_ext++ # OK, works on sane cases. Now check whether nonexistent headers+ # can be detected and how.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ac_nonexistent.h>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null && {+ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||+ test ! -s conftest.err+ }; then+ # Broken: success on invalid input.+continue+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ # Passes both tests.+ac_preproc_ok=:+break+fi++rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+ :+else+ { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&5+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&2;}+ { (exit 1); exit 1; }; }+fi++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5+echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }+if test "${ac_cv_path_GREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ # Extract the first word of "grep ggrep" to use in msg output+if test -z "$GREP"; then+set dummy grep ggrep; ac_prog_name=$2+if test "${ac_cv_path_GREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_path_GREP_found=false+# Loop through the user's path and test for each of PROGNAME-LIST+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_prog in grep ggrep; do+ for ac_exec_ext in '' $ac_executable_extensions; do+ ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"+ { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue+ # Check for GNU ac_path_GREP and select it if it is found.+ # Check for GNU $ac_path_GREP+case `"$ac_path_GREP" --version 2>&1` in+*GNU*)+ ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;+*)+ ac_count=0+ echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"+ while :+ do+ cat "conftest.in" "conftest.in" >"conftest.tmp"+ mv "conftest.tmp" "conftest.in"+ cp "conftest.in" "conftest.nl"+ echo 'GREP' >> "conftest.nl"+ "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break+ ac_count=`expr $ac_count + 1`+ if test $ac_count -gt ${ac_path_GREP_max-0}; then+ # Best one so far, save it but keep looking for a better one+ ac_cv_path_GREP="$ac_path_GREP"+ ac_path_GREP_max=$ac_count+ fi+ # 10*(2^10) chars as input seems more than enough+ test $ac_count -gt 10 && break+ done+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;+esac+++ $ac_path_GREP_found && break 3+ done+done++done+IFS=$as_save_IFS+++fi++GREP="$ac_cv_path_GREP"+if test -z "$GREP"; then+ { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}+ { (exit 1); exit 1; }; }+fi++else+ ac_cv_path_GREP=$GREP+fi+++fi+{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5+echo "${ECHO_T}$ac_cv_path_GREP" >&6; }+ GREP="$ac_cv_path_GREP"+++{ echo "$as_me:$LINENO: checking for egrep" >&5+echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }+if test "${ac_cv_path_EGREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ if echo a | $GREP -E '(a|b)' >/dev/null 2>&1+ then ac_cv_path_EGREP="$GREP -E"+ else+ # Extract the first word of "egrep" to use in msg output+if test -z "$EGREP"; then+set dummy egrep; ac_prog_name=$2+if test "${ac_cv_path_EGREP+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ ac_path_EGREP_found=false+# Loop through the user's path and test for each of PROGNAME-LIST+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ for ac_prog in egrep; do+ for ac_exec_ext in '' $ac_executable_extensions; do+ ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"+ { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue+ # Check for GNU ac_path_EGREP and select it if it is found.+ # Check for GNU $ac_path_EGREP+case `"$ac_path_EGREP" --version 2>&1` in+*GNU*)+ ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;+*)+ ac_count=0+ echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"+ while :+ do+ cat "conftest.in" "conftest.in" >"conftest.tmp"+ mv "conftest.tmp" "conftest.in"+ cp "conftest.in" "conftest.nl"+ echo 'EGREP' >> "conftest.nl"+ "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break+ ac_count=`expr $ac_count + 1`+ if test $ac_count -gt ${ac_path_EGREP_max-0}; then+ # Best one so far, save it but keep looking for a better one+ ac_cv_path_EGREP="$ac_path_EGREP"+ ac_path_EGREP_max=$ac_count+ fi+ # 10*(2^10) chars as input seems more than enough+ test $ac_count -gt 10 && break+ done+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;+esac+++ $ac_path_EGREP_found && break 3+ done+done++done+IFS=$as_save_IFS+++fi++EGREP="$ac_cv_path_EGREP"+if test -z "$EGREP"; then+ { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}+ { (exit 1); exit 1; }; }+fi++else+ ac_cv_path_EGREP=$EGREP+fi+++ fi+fi+{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5+echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }+ EGREP="$ac_cv_path_EGREP"+++{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }+if test "${ac_cv_header_stdc+set}" = set; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdlib.h>+#include <stdarg.h>+#include <string.h>+#include <float.h>++int+main ()+{++ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_cv_header_stdc=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_cv_header_stdc=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext++if test $ac_cv_header_stdc = yes; then+ # SunOS 4.x string.h does not declare mem*, contrary to ANSI.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <string.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+ $EGREP "memchr" >/dev/null 2>&1; then+ :+else+ ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+ # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <stdlib.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+ $EGREP "free" >/dev/null 2>&1; then+ :+else+ ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+ # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.+ if test "$cross_compiling" = yes; then+ :+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <ctype.h>+#include <stdlib.h>+#if ((' ' & 0x0FF) == 0x020)+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))+#else+# define ISLOWER(c) \+ (('a' <= (c) && (c) <= 'i') \+ || ('j' <= (c) && (c) <= 'r') \+ || ('s' <= (c) && (c) <= 'z'))+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))+#endif++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))+int+main ()+{+ int i;+ for (i = 0; i < 256; i++)+ if (XOR (islower (i), ISLOWER (i))+ || toupper (i) != TOUPPER (i))+ return 2;+ return 0;+}+_ACEOF+rm -f conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && { ac_try='./conftest$ac_exeext'+ { (case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_try") 2>&5+ ac_status=$?+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); }; }; then+ :+else+ echo "$as_me: program exited with status $ac_status" >&5+echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++( exit $ac_status )+ac_cv_header_stdc=no+fi+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext+fi+++fi+fi+{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5+echo "${ECHO_T}$ac_cv_header_stdc" >&6; }+if test $ac_cv_header_stdc = yes; then++cat >>confdefs.h <<\_ACEOF+#define STDC_HEADERS 1+_ACEOF++fi++# On IRIX 5.3, sys/types and inttypes.h are conflicting.++++++++++for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \+ inttypes.h stdint.h unistd.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+{ echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+$ac_includes_default++#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ eval "$as_ac_Header=yes"+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ eval "$as_ac_Header=no"+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }+if test `eval echo '${'$as_ac_Header'}'` = yes; then+ cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done++++for ac_header in regex.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ { echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }+else+ # Is the header compilable?+{ echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (ac_try="$ac_compile"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_compile") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest.$ac_objext; then+ ac_header_compiler=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_header_compiler=no+fi++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext+{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6; }++# Is the header present?+{ echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }+cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+#include <$ac_header>+_ACEOF+if { (ac_try="$ac_cpp conftest.$ac_ext"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } >/dev/null && {+ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||+ test ! -s conftest.err+ }; then+ ac_header_preproc=yes+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ ac_header_preproc=no+fi++rm -f conftest.err conftest.$ac_ext+{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6; }++# So? What about this header?+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in+ yes:no: )+ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}+ ac_header_preproc=yes+ ;;+ no:yes:* )+ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5+echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+ { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}+ ( cat <<\_ASBOX+## ------------------------------------------------------ ##+## Report this to TextRegexLazy@personal.mightyreason.com ##+## ------------------------------------------------------ ##+_ASBOX+ ) | sed "s/^/$as_me: WARNING: /" >&2+ ;;+esac+{ echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ eval "$as_ac_Header=\$ac_header_preproc"+fi+ac_res=`eval echo '${'$as_ac_Header'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+ cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++for ac_func in regcomp+do+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`+{ echo "$as_me:$LINENO: checking for $ac_func" >&5+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }+if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then+ echo $ECHO_N "(cached) $ECHO_C" >&6+else+ cat >conftest.$ac_ext <<_ACEOF+/* confdefs.h. */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h. */+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.+ For example, HP-UX 11i <limits.h> declares gettimeofday. */+#define $ac_func innocuous_$ac_func++/* System header to define __stub macros and hopefully few prototypes,+ which can conflict with char $ac_func (); below.+ Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+ <limits.h> exists even on freestanding compilers. */++#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif++#undef $ac_func++/* Override any GCC internal prototype to avoid an error.+ Use char because int might match the return type of a GCC+ builtin and then its argument prototype would still apply. */+#ifdef __cplusplus+extern "C"+#endif+char $ac_func ();+/* The GNU C library defines this for functions which it implements+ to always fail with ENOSYS. Some functions are actually named+ something starting with __ and the normal name is an alias. */+#if defined __stub_$ac_func || defined __stub___$ac_func+choke me+#endif++int+main ()+{+return $ac_func ();+ ;+ return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (ac_try="$ac_link"+case "(($ac_try" in+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;+ *) ac_try_echo=$ac_try;;+esac+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5+ (eval "$ac_link") 2>conftest.er1+ ac_status=$?+ grep -v '^ *+' conftest.er1 >conftest.err+ rm -f conftest.er1+ cat conftest.err >&5+ echo "$as_me:$LINENO: \$? = $ac_status" >&5+ (exit $ac_status); } && {+ test -z "$ac_c_werror_flag" ||+ test ! -s conftest.err+ } && test -s conftest$ac_exeext &&+ $as_test_x conftest$ac_exeext; then+ eval "$as_ac_var=yes"+else+ echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ eval "$as_ac_var=no"+fi++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \+ conftest$ac_exeext conftest.$ac_ext+fi+ac_res=`eval echo '${'$as_ac_var'}'`+ { echo "$as_me:$LINENO: result: $ac_res" >&5+echo "${ECHO_T}$ac_res" >&6; }+if test `eval echo '${'$as_ac_var'}'` = yes; then+ cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1+_ACEOF+ HavePosixRegex=YES;++cat >>confdefs.h <<\_ACEOF+#define HAVE_POSIX_REGEX 1+_ACEOF++fi+done++fi++done++++if test "$HavePosixRegex" = YES+then+ C_SOURCES=+else+ C_SOURCES="cbits/reallocf.c cbits/regerror.c cbits/regexec.c cbits/regcomp.c cbits/regfree.c"+fi+++ac_config_files="$ac_config_files config.mk regex-posix.buildinfo"+++cat >confcache <<\_ACEOF+# This file is a shell script that caches the results of configure+# tests run on this system so they can be shared between configure+# scripts and configure runs, see configure's option --config-cache.+# It is not useful on other systems. If it contains results you don't+# want to keep, you may remove or edit it.+#+# config.status only pays attention to the cache file if you give it+# the --recheck option to rerun configure.+#+# `ac_cv_env_foo' variables (set or unset) will be overridden when+# loading this file, other *unset* `ac_cv_foo' will be assigned the+# following values.++_ACEOF++# The following way of writing the cache mishandles newlines in values,+# but we know of no workaround that is simple, portable, and efficient.+# So, we kill variables containing newlines.+# Ultrix sh set writes to stderr and can't be redirected directly,+# and sets the high bit in the cache file unless we assign to the vars.+(+ for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do+ eval ac_val=\$$ac_var+ case $ac_val in #(+ *${as_nl}*)+ case $ac_var in #(+ *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;+ esac+ case $ac_var in #(+ _ | IFS | as_nl) ;; #(+ *) $as_unset $ac_var ;;+ esac ;;+ esac+ done++ (set) 2>&1 |+ case $as_nl`(ac_space=' '; set) 2>&1` in #(+ *${as_nl}ac_space=\ *)+ # `set' does not quote correctly, so add quotes (double-quote+ # substitution turns \\\\ into \\, and sed turns \\ into \).+ sed -n \+ "s/'/'\\\\''/g;+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"+ ;; #(+ *)+ # `set' quotes correctly as required by POSIX, so do not add quotes.+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"+ ;;+ esac |+ sort+) |+ sed '+ /^ac_cv_env_/b end+ t clear+ :clear+ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/+ t end+ s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/+ :end' >>confcache+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else+ if test -w "$cache_file"; then+ test "x$cache_file" != "x/dev/null" &&+ { echo "$as_me:$LINENO: updating cache $cache_file" >&5+echo "$as_me: updating cache $cache_file" >&6;}+ cat confcache >$cache_file+ else+ { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5+echo "$as_me: not updating unwritable cache $cache_file" >&6;}+ fi+fi+rm -f confcache++test "x$prefix" = xNONE && prefix=$ac_default_prefix+# Let make expand exec_prefix.+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'++DEFS=-DHAVE_CONFIG_H++ac_libobjs=+ac_ltlibobjs=+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue+ # 1. Remove the extension, and $U if already installed.+ ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'+ ac_i=`echo "$ac_i" | sed "$ac_script"`+ # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR+ # will be set to the directory where LIBOBJS objects are built.+ ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"+ ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'+done+LIBOBJS=$ac_libobjs++LTLIBOBJS=$ac_ltlibobjs++++: ${CONFIG_STATUS=./config.status}+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files $CONFIG_STATUS"+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5+echo "$as_me: creating $CONFIG_STATUS" >&6;}+cat >$CONFIG_STATUS <<_ACEOF+#! $SHELL+# Generated by $as_me.+# Run this file to recreate the current configuration.+# Compiler output produced by configure, useful for debugging+# configure, is in config.log if it exists.++debug=false+ac_cs_recheck=false+ac_cs_silent=false+SHELL=\${CONFIG_SHELL-$SHELL}+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+## --------------------- ##+## M4sh Initialization. ##+## --------------------- ##++# Be more Bourne compatible+DUALCASE=1; export DUALCASE # for MKS sh+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+ emulate sh+ NULLCMD=:+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+ # is contrary to our usage. Disable this feature.+ alias -g '${1+"$@"}'='"$@"'+ setopt NO_GLOB_SUBST+else+ case `(set -o) 2>/dev/null` in+ *posix*) set -o posix ;;+esac++fi+++++# PATH needs CR+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+ echo "#! /bin/sh" >conf$$.sh+ echo "exit 0" >>conf$$.sh+ chmod +x conf$$.sh+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+ PATH_SEPARATOR=';'+ else+ PATH_SEPARATOR=:+ fi+ rm -f conf$$.sh+fi++# Support unset when possible.+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then+ as_unset=unset+else+ as_unset=false+fi+++# IFS+# We need space, tab and new line, in precisely that order. Quoting is+# there to prevent editors from complaining about space-tab.+# (If _AS_PATH_WALK were called with IFS unset, it would disable word+# splitting by setting IFS to empty value.)+as_nl='+'+IFS=" "" $as_nl"++# Find who we are. Look in the path if we contain no directory separator.+case $0 in+ *[\\/]* ) as_myself=$0 ;;+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+ IFS=$as_save_IFS+ test -z "$as_dir" && as_dir=.+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done+IFS=$as_save_IFS++ ;;+esac+# We did not find ourselves, most probably we were run as `sh COMMAND'+# in which case we are not to be found in the path.+if test "x$as_myself" = x; then+ as_myself=$0+fi+if test ! -f "$as_myself"; then+ echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2+ { (exit 1); exit 1; }+fi++# Work around bugs in pre-3.0 UWIN ksh.+for as_var in ENV MAIL MAILPATH+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+done+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+ LC_TELEPHONE LC_TIME+do+ if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then+ eval $as_var=C; export $as_var+ else+ ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var+ fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then+ as_basename=basename+else+ as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename -- "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+ X"$0" : 'X\(//\)$' \| \+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||+echo X/"$0" |+ sed '/^.*\/\([^/][^/]*\)\/*$/{+ s//\1/+ q+ }+ /^X\/\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\/\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`++# CDPATH.+$as_unset CDPATH++++ as_lineno_1=$LINENO+ as_lineno_2=$LINENO+ test "x$as_lineno_1" != "x$as_lineno_2" &&+ test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+ # uniformly replaced by the line number. The first 'sed' inserts a+ # line-number line after each line using $LINENO; the second 'sed'+ # does the real work. The second script uses 'N' to pair each+ # line-number line with the line containing $LINENO, and appends+ # trailing '-' during substitution so that $LINENO is not a special+ # case at line end.+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+ # scripts with optimization help from Paolo Bonzini. Blame Lee+ # E. McMahon (1931-1989) for sed's syntax. :-)+ sed -n '+ p+ /[$]LINENO/=+ ' <$as_myself |+ sed '+ s/[$]LINENO.*/&-/+ t lineno+ b+ :lineno+ N+ :loop+ s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/+ t loop+ s/-\n.*//+ ' >$as_me.lineno &&+ chmod +x "$as_me.lineno" ||+ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+ { (exit 1); exit 1; }; }++ # Don't try to exec as it changes $[0], causing all sort of problems+ # (the dirname of $[0] is not the place where we might find the+ # original and so on. Autoconf is especially sensitive to this).+ . "./$as_me.lineno"+ # Exit status is that of the last command.+ exit+}+++if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then+ as_dirname=dirname+else+ as_dirname=false+fi++ECHO_C= ECHO_N= ECHO_T=+case `echo -n x` in+-n*)+ case `echo 'x\c'` in+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.+ *) ECHO_C='\c';;+ esac;;+*)+ ECHO_N='-n';;+esac++if expr a : '\(a\)' >/dev/null 2>&1 &&+ test "X`expr 00001 : '.*\(...\)'`" = X001; then+ as_expr=expr+else+ as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+if test -d conf$$.dir; then+ rm -f conf$$.dir/conf$$.file+else+ rm -f conf$$.dir+ mkdir conf$$.dir+fi+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+ as_ln_s='ln -s'+ # ... but there are two gotchas:+ # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.+ # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.+ # In both cases, we have to default to `cp -p'.+ ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||+ as_ln_s='cp -p'+elif ln conf$$.file conf$$ 2>/dev/null; then+ as_ln_s=ln+else+ as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file+rmdir conf$$.dir 2>/dev/null++if mkdir -p . 2>/dev/null; then+ as_mkdir_p=:+else+ test -d ./-p && rmdir ./-p+ as_mkdir_p=false+fi++if test -x / >/dev/null 2>&1; then+ as_test_x='test -x'+else+ if ls -dL / >/dev/null 2>&1; then+ as_ls_L_option=L+ else+ as_ls_L_option=+ fi+ as_test_x='+ eval sh -c '\''+ if test -d "$1"; then+ test -d "$1/.";+ else+ case $1 in+ -*)set "./$1";;+ esac;+ case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in+ ???[sx]*):;;*)false;;esac;fi+ '\'' sh+ '+fi+as_executable_p=$as_test_x++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"+++exec 6>&1++# Save the log message, to keep $[0] and so on meaningful, and to+# report actual input values of CONFIG_FILES etc. instead of their+# values after options handling.+ac_log="+This file was extended by Haskell regex-posix package $as_me 0.71, which was+generated by GNU Autoconf 2.61. Invocation command line was++ CONFIG_FILES = $CONFIG_FILES+ CONFIG_HEADERS = $CONFIG_HEADERS+ CONFIG_LINKS = $CONFIG_LINKS+ CONFIG_COMMANDS = $CONFIG_COMMANDS+ $ $0 $@++on `(hostname || uname -n) 2>/dev/null | sed 1q`+"++_ACEOF++cat >>$CONFIG_STATUS <<_ACEOF+# Files that config.status was made for.+config_files="$ac_config_files"+config_headers="$ac_config_headers"++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+ac_cs_usage="\+\`$as_me' instantiates files from templates according to the+current configuration.++Usage: $0 [OPTIONS] [FILE]...++ -h, --help print this help, then exit+ -V, --version print version number and configuration settings, then exit+ -q, --quiet do not print progress messages+ -d, --debug don't remove temporary files+ --recheck update $as_me by reconfiguring in the same conditions+ --file=FILE[:TEMPLATE]+ instantiate the configuration file FILE+ --header=FILE[:TEMPLATE]+ instantiate the configuration header FILE++Configuration files:+$config_files++Configuration headers:+$config_headers++Report bugs to <bug-autoconf@gnu.org>."++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+ac_cs_version="\\+Haskell regex-posix package config.status 0.71+configured by $0, generated by GNU Autoconf 2.61,+ with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"++Copyright (C) 2006 Free Software Foundation, Inc.+This config.status script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it."++ac_pwd='$ac_pwd'+srcdir='$srcdir'+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If no file are specified by the user, then we need to provide default+# value. By we need to know if files were specified by the user.+ac_need_defaults=:+while test $# != 0+do+ case $1 in+ --*=*)+ ac_option=`expr "X$1" : 'X\([^=]*\)='`+ ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`+ ac_shift=:+ ;;+ *)+ ac_option=$1+ ac_optarg=$2+ ac_shift=shift+ ;;+ esac++ case $ac_option in+ # Handling of the options.+ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)+ ac_cs_recheck=: ;;+ --version | --versio | --versi | --vers | --ver | --ve | --v | -V )+ echo "$ac_cs_version"; exit ;;+ --debug | --debu | --deb | --de | --d | -d )+ debug=: ;;+ --file | --fil | --fi | --f )+ $ac_shift+ CONFIG_FILES="$CONFIG_FILES $ac_optarg"+ ac_need_defaults=false;;+ --header | --heade | --head | --hea )+ $ac_shift+ CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"+ ac_need_defaults=false;;+ --he | --h)+ # Conflict between --help and --header+ { echo "$as_me: error: ambiguous option: $1+Try \`$0 --help' for more information." >&2+ { (exit 1); exit 1; }; };;+ --help | --hel | -h )+ echo "$ac_cs_usage"; exit ;;+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \+ | -silent | --silent | --silen | --sile | --sil | --si | --s)+ ac_cs_silent=: ;;++ # This is an error.+ -*) { echo "$as_me: error: unrecognized option: $1+Try \`$0 --help' for more information." >&2+ { (exit 1); exit 1; }; } ;;++ *) ac_config_targets="$ac_config_targets $1"+ ac_need_defaults=false ;;++ esac+ shift+done++ac_configure_extra_args=++if $ac_cs_silent; then+ exec 6>/dev/null+ ac_configure_extra_args="$ac_configure_extra_args --silent"+fi++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+if \$ac_cs_recheck; then+ echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6+ CONFIG_SHELL=$SHELL+ export CONFIG_SHELL+ exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion+fi++_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+exec 5>>config.log+{+ echo+ sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX+## Running $as_me. ##+_ASBOX+ echo "$ac_log"+} >&5++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF++# Handling of arguments.+for ac_config_target in $ac_config_targets+do+ case $ac_config_target in+ "include/HsRegexPosixConfig.h") CONFIG_HEADERS="$CONFIG_HEADERS include/HsRegexPosixConfig.h" ;;+ "config.mk") CONFIG_FILES="$CONFIG_FILES config.mk" ;;+ "regex-posix.buildinfo") CONFIG_FILES="$CONFIG_FILES regex-posix.buildinfo" ;;++ *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}+ { (exit 1); exit 1; }; };;+ esac+done+++# If the user did not use the arguments to specify the items to instantiate,+# then the envvar interface is used. Set only those that are not.+# We use the long form for the default assignment because of an extremely+# bizarre bug on SunOS 4.1.3.+if $ac_need_defaults; then+ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files+ test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers+fi++# Have a temporary directory for convenience. Make it in the build tree+# simply because there is no reason against having it here, and in addition,+# creating and moving files from /tmp can sometimes cause problems.+# Hook for its removal unless debugging.+# Note that there is a small window in which the directory will not be cleaned:+# after its creation but before its name has been assigned to `$tmp'.+$debug ||+{+ tmp=+ trap 'exit_status=$?+ { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status+' 0+ trap '{ (exit 1); exit 1; }' 1 2 13 15+}+# Create a (secure) tmp directory for tmp files.++{+ tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&+ test -n "$tmp" && test -d "$tmp"+} ||+{+ tmp=./conf$$-$RANDOM+ (umask 077 && mkdir "$tmp")+} ||+{+ echo "$me: cannot create a temporary directory in ." >&2+ { (exit 1); exit 1; }+}++#+# Set up the sed scripts for CONFIG_FILES section.+#++# No need to generate the scripts if there are no CONFIG_FILES.+# This happens for instance when ./config.status config.h+if test -n "$CONFIG_FILES"; then++_ACEOF++++ac_delim='%!_!# '+for ac_last_try in false false false false false :; do+ cat >conf$$subs.sed <<_ACEOF+SHELL!$SHELL$ac_delim+PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim+PACKAGE_NAME!$PACKAGE_NAME$ac_delim+PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim+PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim+PACKAGE_STRING!$PACKAGE_STRING$ac_delim+PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim+exec_prefix!$exec_prefix$ac_delim+prefix!$prefix$ac_delim+program_transform_name!$program_transform_name$ac_delim+bindir!$bindir$ac_delim+sbindir!$sbindir$ac_delim+libexecdir!$libexecdir$ac_delim+datarootdir!$datarootdir$ac_delim+datadir!$datadir$ac_delim+sysconfdir!$sysconfdir$ac_delim+sharedstatedir!$sharedstatedir$ac_delim+localstatedir!$localstatedir$ac_delim+includedir!$includedir$ac_delim+oldincludedir!$oldincludedir$ac_delim+docdir!$docdir$ac_delim+infodir!$infodir$ac_delim+htmldir!$htmldir$ac_delim+dvidir!$dvidir$ac_delim+pdfdir!$pdfdir$ac_delim+psdir!$psdir$ac_delim+libdir!$libdir$ac_delim+localedir!$localedir$ac_delim+mandir!$mandir$ac_delim+DEFS!$DEFS$ac_delim+ECHO_C!$ECHO_C$ac_delim+ECHO_N!$ECHO_N$ac_delim+ECHO_T!$ECHO_T$ac_delim+LIBS!$LIBS$ac_delim+build_alias!$build_alias$ac_delim+host_alias!$host_alias$ac_delim+target_alias!$target_alias$ac_delim+CC!$CC$ac_delim+CFLAGS!$CFLAGS$ac_delim+LDFLAGS!$LDFLAGS$ac_delim+CPPFLAGS!$CPPFLAGS$ac_delim+ac_ct_CC!$ac_ct_CC$ac_delim+EXEEXT!$EXEEXT$ac_delim+OBJEXT!$OBJEXT$ac_delim+CPP!$CPP$ac_delim+GREP!$GREP$ac_delim+EGREP!$EGREP$ac_delim+HavePosixRegex!$HavePosixRegex$ac_delim+C_SOURCES!$C_SOURCES$ac_delim+LIBOBJS!$LIBOBJS$ac_delim+LTLIBOBJS!$LTLIBOBJS$ac_delim+_ACEOF++ if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 51; then+ break+ elif $ac_last_try; then+ { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5+echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}+ { (exit 1); exit 1; }; }+ else+ ac_delim="$ac_delim!$ac_delim _$ac_delim!! "+ fi+done++ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`+if test -n "$ac_eof"; then+ ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`+ ac_eof=`expr $ac_eof + 1`+fi++cat >>$CONFIG_STATUS <<_ACEOF+cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end+_ACEOF+sed '+s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g+s/^/s,@/; s/!/@,|#_!!_#|/+:n+t n+s/'"$ac_delim"'$/,g/; t+s/$/\\/; p+N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n+' >>$CONFIG_STATUS <conf$$subs.sed+rm -f conf$$subs.sed+cat >>$CONFIG_STATUS <<_ACEOF+:end+s/|#_!!_#|//g+CEOF$ac_eof+_ACEOF+++# VPATH may cause trouble with some makes, so we remove $(srcdir),+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and+# trailing colons and then remove the whole line if VPATH becomes empty+# (actually we leave an empty line to preserve line numbers).+if test "x$srcdir" = x.; then+ ac_vpsub='/^[ ]*VPATH[ ]*=/{+s/:*\$(srcdir):*/:/+s/:*\${srcdir}:*/:/+s/:*@srcdir@:*/:/+s/^\([^=]*=[ ]*\):*/\1/+s/:*$//+s/^[^=]*=[ ]*$//+}'+fi++cat >>$CONFIG_STATUS <<\_ACEOF+fi # test -n "$CONFIG_FILES"+++for ac_tag in :F $CONFIG_FILES :H $CONFIG_HEADERS+do+ case $ac_tag in+ :[FHLC]) ac_mode=$ac_tag; continue;;+ esac+ case $ac_mode$ac_tag in+ :[FHL]*:*);;+ :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5+echo "$as_me: error: Invalid tag $ac_tag." >&2;}+ { (exit 1); exit 1; }; };;+ :[FH]-) ac_tag=-:-;;+ :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;+ esac+ ac_save_IFS=$IFS+ IFS=:+ set x $ac_tag+ IFS=$ac_save_IFS+ shift+ ac_file=$1+ shift++ case $ac_mode in+ :L) ac_source=$1;;+ :[FH])+ ac_file_inputs=+ for ac_f+ do+ case $ac_f in+ -) ac_f="$tmp/stdin";;+ *) # Look for the file first in the build tree, then in the source tree+ # (if the path is not absolute). The absolute path cannot be DOS-style,+ # because $ac_f cannot contain `:'.+ test -f "$ac_f" ||+ case $ac_f in+ [\\/$]*) false;;+ *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;+ esac ||+ { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5+echo "$as_me: error: cannot find input file: $ac_f" >&2;}+ { (exit 1); exit 1; }; };;+ esac+ ac_file_inputs="$ac_file_inputs $ac_f"+ done++ # Let's still pretend it is `configure' which instantiates (i.e., don't+ # use $as_me), people would be surprised to read:+ # /* config.h. Generated by config.status. */+ configure_input="Generated from "`IFS=:+ echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."+ if test x"$ac_file" != x-; then+ configure_input="$ac_file. $configure_input"+ { echo "$as_me:$LINENO: creating $ac_file" >&5+echo "$as_me: creating $ac_file" >&6;}+ fi++ case $ac_tag in+ *:-:* | *:-) cat >"$tmp/stdin";;+ esac+ ;;+ esac++ ac_dir=`$as_dirname -- "$ac_file" ||+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$ac_file" : 'X\(//\)[^/]' \| \+ X"$ac_file" : 'X\(//\)$' \| \+ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$ac_file" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ { as_dir="$ac_dir"+ case $as_dir in #(+ -*) as_dir=./$as_dir;;+ esac+ test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {+ as_dirs=+ while :; do+ case $as_dir in #(+ *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(+ *) as_qdir=$as_dir;;+ esac+ as_dirs="'$as_qdir' $as_dirs"+ as_dir=`$as_dirname -- "$as_dir" ||+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+ X"$as_dir" : 'X\(//\)[^/]' \| \+ X"$as_dir" : 'X\(//\)$' \| \+ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||+echo X"$as_dir" |+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{+ s//\1/+ q+ }+ /^X\(\/\/\)[^/].*/{+ s//\1/+ q+ }+ /^X\(\/\/\)$/{+ s//\1/+ q+ }+ /^X\(\/\).*/{+ s//\1/+ q+ }+ s/.*/./; q'`+ test -d "$as_dir" && break+ done+ test -z "$as_dirs" || eval "mkdir $as_dirs"+ } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5+echo "$as_me: error: cannot create directory $as_dir" >&2;}+ { (exit 1); exit 1; }; }; }+ ac_builddir=.++case "$ac_dir" in+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;+*)+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+ # A ".." for each directory in $ac_dir_suffix.+ ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`+ case $ac_top_builddir_sub in+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;+ esac ;;+esac+ac_abs_top_builddir=$ac_pwd+ac_abs_builddir=$ac_pwd$ac_dir_suffix+# for backward compatibility:+ac_top_builddir=$ac_top_build_prefix++case $srcdir in+ .) # We are building in place.+ ac_srcdir=.+ ac_top_srcdir=$ac_top_builddir_sub+ ac_abs_top_srcdir=$ac_pwd ;;+ [\\/]* | ?:[\\/]* ) # Absolute name.+ ac_srcdir=$srcdir$ac_dir_suffix;+ ac_top_srcdir=$srcdir+ ac_abs_top_srcdir=$srcdir ;;+ *) # Relative name.+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix+ ac_top_srcdir=$ac_top_build_prefix$srcdir+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;+esac+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix+++ case $ac_mode in+ :F)+ #+ # CONFIG_FILE+ #++_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If the template does not know about datarootdir, expand it.+# FIXME: This hack should be removed a few years after 2.60.+ac_datarootdir_hack=; ac_datarootdir_seen=++case `sed -n '/datarootdir/ {+ p+ q+}+/@datadir@/p+/@docdir@/p+/@infodir@/p+/@localedir@/p+/@mandir@/p+' $ac_file_inputs` in+*datarootdir*) ac_datarootdir_seen=yes;;+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)+ { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5+echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}+_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+ ac_datarootdir_hack='+ s&@datadir@&$datadir&g+ s&@docdir@&$docdir&g+ s&@infodir@&$infodir&g+ s&@localedir@&$localedir&g+ s&@mandir@&$mandir&g+ s&\\\${datarootdir}&$datarootdir&g' ;;+esac+_ACEOF++# Neutralize VPATH when `$srcdir' = `.'.+# Shell code in configure.ac might set extrasub.+# FIXME: do we really want to maintain this feature?+cat >>$CONFIG_STATUS <<_ACEOF+ sed "$ac_vpsub+$extrasub+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+:t+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b+s&@configure_input@&$configure_input&;t t+s&@top_builddir@&$ac_top_builddir_sub&;t t+s&@srcdir@&$ac_srcdir&;t t+s&@abs_srcdir@&$ac_abs_srcdir&;t t+s&@top_srcdir@&$ac_top_srcdir&;t t+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t+s&@builddir@&$ac_builddir&;t t+s&@abs_builddir@&$ac_abs_builddir&;t t+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t+$ac_datarootdir_hack+" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out++test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&+ { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&+ { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&+ { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined. Please make sure it is defined." >&5+echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'+which seems to be undefined. Please make sure it is defined." >&2;}++ rm -f "$tmp/stdin"+ case $ac_file in+ -) cat "$tmp/out"; rm -f "$tmp/out";;+ *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;+ esac+ ;;+ :H)+ #+ # CONFIG_HEADER+ #+_ACEOF++# Transform confdefs.h into a sed script `conftest.defines', that+# substitutes the proper values into config.h.in to produce config.h.+rm -f conftest.defines conftest.tail+# First, append a space to every undef/define line, to ease matching.+echo 's/$/ /' >conftest.defines+# Then, protect against being on the right side of a sed subst, or in+# an unquoted here document, in config.status. If some macros were+# called several times there might be several #defines for the same+# symbol, which is useless. But do not sort them, since the last+# AC_DEFINE must be honored.+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*+# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where+# NAME is the cpp macro being defined, VALUE is the value it is being given.+# PARAMS is the parameter list in the macro definition--in most cases, it's+# just an empty string.+ac_dA='s,^\\([ #]*\\)[^ ]*\\([ ]*'+ac_dB='\\)[ (].*,\\1define\\2'+ac_dC=' '+ac_dD=' ,'++uniq confdefs.h |+ sed -n '+ t rset+ :rset+ s/^[ ]*#[ ]*define[ ][ ]*//+ t ok+ d+ :ok+ s/[\\&,]/\\&/g+ s/^\('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p+ s/^\('"$ac_word_re"'\)[ ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p+ ' >>conftest.defines++# Remove the space that was appended to ease matching.+# Then replace #undef with comments. This is necessary, for+# example, in the case of _POSIX_SOURCE, which is predefined and required+# on some systems where configure will not decide to define it.+# (The regexp can be short, since the line contains either #define or #undef.)+echo 's/ $//+s,^[ #]*u.*,/* & */,' >>conftest.defines++# Break up conftest.defines:+ac_max_sed_lines=50++# First sed command is: sed -f defines.sed $ac_file_inputs >"$tmp/out1"+# Second one is: sed -f defines.sed "$tmp/out1" >"$tmp/out2"+# Third one will be: sed -f defines.sed "$tmp/out2" >"$tmp/out1"+# et cetera.+ac_in='$ac_file_inputs'+ac_out='"$tmp/out1"'+ac_nxt='"$tmp/out2"'++while :+do+ # Write a here document:+ cat >>$CONFIG_STATUS <<_ACEOF+ # First, check the format of the line:+ cat >"\$tmp/defines.sed" <<\\CEOF+/^[ ]*#[ ]*undef[ ][ ]*$ac_word_re[ ]*\$/b def+/^[ ]*#[ ]*define[ ][ ]*$ac_word_re[( ]/b def+b+:def+_ACEOF+ sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS+ echo 'CEOF+ sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS+ ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in+ sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail+ grep . conftest.tail >/dev/null || break+ rm -f conftest.defines+ mv conftest.tail conftest.defines+done+rm -f conftest.defines conftest.tail++echo "ac_result=$ac_in" >>$CONFIG_STATUS+cat >>$CONFIG_STATUS <<\_ACEOF+ if test x"$ac_file" != x-; then+ echo "/* $configure_input */" >"$tmp/config.h"+ cat "$ac_result" >>"$tmp/config.h"+ if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then+ { echo "$as_me:$LINENO: $ac_file is unchanged" >&5+echo "$as_me: $ac_file is unchanged" >&6;}+ else+ rm -f $ac_file+ mv "$tmp/config.h" $ac_file+ fi+ else+ echo "/* $configure_input */"+ cat "$ac_result"+ fi+ rm -f "$tmp/out12"+ ;;+++ esac++done # for ac_tag+++{ (exit 0); exit 0; }+_ACEOF+chmod +x $CONFIG_STATUS+ac_clean_files=$ac_clean_files_save+++# configure is writing to config.log, and then calls config.status.+# config.status does its own redirection, appending to config.log.+# Unfortunately, on DOS this fails, as config.log is still kept open+# by configure, so config.status won't be able to write to it; its+# output is simply discarded. So we exec the FD to /dev/null,+# effectively closing config.log, so it can be properly (re)opened and+# appended to by config.status. When coming back to configure, we+# need to make the FD available again.+if test "$no_create" != yes; then+ ac_cs_success=:+ ac_config_status_args=+ test "$silent" = yes &&+ ac_config_status_args="$ac_config_status_args --quiet"+ exec 5>/dev/null+ $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false+ exec 5>>config.log+ # Use ||, not &&, to avoid exiting from the if with $? = 1, which+ # would make configure fail if this is the last instruction.+ $ac_cs_success || { (exit 1); exit 1; }+fi+
+ configure.ac view
@@ -0,0 +1,28 @@+AC_INIT([Haskell regex-posix package], [0.71], [TextRegexLazy@personal.mightyreason.com], [regex-posix])++AC_CONFIG_SRCDIR([regex-posix.cabal])+AC_CONFIG_HEADERS([include/HsRegexPosixConfig.h])++AC_ARG_WITH([cc],+ [C compiler],+ [CC=$withval])+AC_PROG_CC()++dnl ** check for POSIX regex+HavePosixRegex=NO+AC_CHECK_HEADERS([regex.h], [AC_CHECK_FUNCS(regcomp, + [HavePosixRegex=YES;+ AC_DEFINE(HAVE_POSIX_REGEX, [1], [Define to 1 if you have a POSIX regex library installed])])])+AC_SUBST(HavePosixRegex)++if test "$HavePosixRegex" = YES+then+ C_SOURCES=+else+ C_SOURCES="cbits/reallocf.c cbits/regerror.c cbits/regexec.c cbits/regcomp.c cbits/regfree.c"+fi+AC_SUBST(C_SOURCES)++AC_CONFIG_FILES([config.mk regex-posix.buildinfo])++AC_OUTPUT
+ include/HsRegexPosixConfig.h.in view
@@ -0,0 +1,55 @@+/* include/HsRegexPosixConfig.h.in. Generated from configure.ac by autoheader. */++/* Define to 1 if you have the <inttypes.h> header file. */+#undef HAVE_INTTYPES_H++/* Define to 1 if you have the <memory.h> header file. */+#undef HAVE_MEMORY_H++/* Define to 1 if you have a POSIX regex library installed */+#undef HAVE_POSIX_REGEX++/* Define to 1 if you have the `regcomp' function. */+#undef HAVE_REGCOMP++/* Define to 1 if you have the <regex.h> header file. */+#undef HAVE_REGEX_H++/* Define to 1 if you have the <stdint.h> header file. */+#undef HAVE_STDINT_H++/* Define to 1 if you have the <stdlib.h> header file. */+#undef HAVE_STDLIB_H++/* Define to 1 if you have the <strings.h> header file. */+#undef HAVE_STRINGS_H++/* Define to 1 if you have the <string.h> header file. */+#undef HAVE_STRING_H++/* Define to 1 if you have the <sys/stat.h> header file. */+#undef HAVE_SYS_STAT_H++/* Define to 1 if you have the <sys/types.h> header file. */+#undef HAVE_SYS_TYPES_H++/* Define to 1 if you have the <unistd.h> header file. */+#undef HAVE_UNISTD_H++/* Define to the address where bug reports for this package should be sent. */+#undef PACKAGE_BUGREPORT++/* Define to the full name of this package. */+#undef PACKAGE_NAME++/* Define to the full name and version of this package. */+#undef PACKAGE_STRING++/* Define to the one symbol short name of this package. */+#undef PACKAGE_TARNAME++/* Define to the version of this package. */+#undef PACKAGE_VERSION++/* Define to 1 if you have the ANSI C header files. */+#undef STDC_HEADERS
+ include/regex/regex.h view
@@ -0,0 +1,112 @@+/*-+ * Copyright (c) 1992 Henry Spencer.+ * Copyright (c) 1992, 1993+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Henry Spencer of the University of Toronto.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. 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.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.+ *+ * @(#)regex.h 8.2 (Berkeley) 1/3/94+ */++#ifndef _REGEX_H_+#define _REGEX_H_++#include <sys/types.h>++/* types */+typedef off_t regoff_t;++typedef struct {+ int re_magic;+ size_t re_nsub; /* number of parenthesized subexpressions */+ __const char *re_endp; /* end pointer for REG_PEND */+ struct re_guts *re_g; /* none of your business :-) */+} regex_t;++typedef struct {+ regoff_t rm_so; /* start of match */+ regoff_t rm_eo; /* end of match */+} regmatch_t;++/* regcomp() flags */+#define REG_BASIC 0000+#define REG_EXTENDED 0001+#define REG_ICASE 0002+#define REG_NOSUB 0004+#define REG_NEWLINE 0010+#define REG_NOSPEC 0020+#define REG_PEND 0040+#define REG_DUMP 0200++/* regerror() flags */+#define REG_NOMATCH 1+#define REG_BADPAT 2+#define REG_ECOLLATE 3+#define REG_ECTYPE 4+#define REG_EESCAPE 5+#define REG_ESUBREG 6+#define REG_EBRACK 7+#define REG_EPAREN 8+#define REG_EBRACE 9+#define REG_BADBR 10+#define REG_ERANGE 11+#define REG_ESPACE 12+#define REG_BADRPT 13+#define REG_EMPTY 14+#define REG_ASSERT 15+#define REG_INVARG 16+#define REG_ATOI 255 /* convert name to number (!) */+#define REG_ITOA 0400 /* convert number to name (!) */++/* regexec() flags */+#define REG_NOTBOL 00001+#define REG_NOTEOL 00002+#define REG_STARTEND 00004+#define REG_TRACE 00400 /* tracing of execution */+#define REG_LARGE 01000 /* force large representation */+#define REG_BACKR 02000 /* force use of backref code */++#ifdef __cplusplus+extern "C" {+#endif++int regcomp (regex_t *, const char *, int);+size_t regerror (int, const regex_t *, char *, size_t);+int regexec (const regex_t *,+ const char *, size_t, regmatch_t [], int);+void regfree (regex_t *);++#ifdef __cplusplus+}+#endif++#endif /* !_REGEX_H_ */
+ regex-posix.buildinfo.in view
@@ -0,0 +1,3 @@++c-sources: @C_SOURCES@+
regex-posix.cabal view
@@ -2,7 +2,7 @@ -- To fix for cabal < 1.1.4 comment out the Extra-Source-Files line -- **************************************************************** Name: regex-posix-Version: 0.72+Version: 0.72.0.1 -- Cabal-Version: >=1.1.4 License: BSD3 License-File: LICENSE@@ -16,34 +16,50 @@ Description: The posix regex backend for regex-base Category: Text Tested-With: GHC-Build-Depends: regex-base, base >= 2.0+Build-Type: Configure+Cabal-Version: >=1.2++Extra-Source-Files: aclocal.m4 config.mk.in configure configure.ac+ regex-posix.buildinfo.in+ include/HsRegexPosixConfig.h.in include/regex/regex.h+ cbits/COPYRIGHT cbits/cclass.h cbits/cname.h+ cbits/regex2.h cbits/utils.h cbits/engine.c+ cbits/reallocf.c cbits/regcomp.c cbits/regerror.c+ cbits/regexec.c cbits/regfree.c++Flag split-base++Library+ Build-Depends: regex-base+ if flag(split-base)+ Build-Depends: base >= 3.0, array, bytestring+ else+ Build-Depends: base >= 2.0 && < 3 -- Data-Files:--- comment out Extra-Source-Files, this is different from repository version--- Extra-Source-Files: aclocal.m4 config.mk.in configure configure.ac--- include/HsRegexPosixConfig.h.in -- Extra-Tmp-Files: -- This is the library-Exposed-Modules: Text.Regex.Posix+ Exposed-Modules: Text.Regex.Posix Text.Regex.Posix.Wrap Text.Regex.Posix.String Text.Regex.Posix.ByteString -- Futher fields-Buildable: True+ Buildable: True -- Other-Modules: -- be backward compatible until 6.4.2 is futher deployed -- HS-Source-Dirs: "."--- Extensions:-GHC-Options: -Wall -Werror -O2+ Extensions: CPP+ GHC-Options: -Wall -O2+-- GHC-Options: -Wall -Werror -O2 -- GHC-Options: -Wall -Werror -- GHC-Options: -Wall -ddump-minimal-imports -- GHC-Prog-Options: -- Hugs-Options: -- NHC-Options: -- Includes:-Include-Dirs: include+ Include-Dirs: include -- C-Sources: -- Extra-Libraries: -- Extra-Lib-Dirs:-CC-Options: -DHAVE_REGEX_H+ CC-Options: -DHAVE_REGEX_H -- LD-Options: -- Frameworks: