*** empty log message ***
authoroes <oes@users.sourceforge.net>
Tue, 15 May 2001 13:59:48 +0000 (13:59 +0000)
committeroes <oes@users.sourceforge.net>
Tue, 15 May 2001 13:59:48 +0000 (13:59 +0000)
42 files changed:
.gitignore [new file with mode: 0644]
pcre/Makefile.in [new file with mode: 0644]
pcre/RunTest.in [new file with mode: 0644]
pcre/config.guess [new file with mode: 0644]
pcre/config.in [new file with mode: 0644]
pcre/config.sub [new file with mode: 0644]
pcre/configure [new file with mode: 0644]
pcre/configure.in [new file with mode: 0644]
pcre/dftables.c [new file with mode: 0644]
pcre/dll.mk [new file with mode: 0644]
pcre/doc/ChangeLog [new file with mode: 0644]
pcre/doc/NON-UNIX-USE [new file with mode: 0644]
pcre/doc/Tech.Notes [new file with mode: 0644]
pcre/doc/authors [new file with mode: 0644]
pcre/doc/copying [new file with mode: 0644]
pcre/doc/news [new file with mode: 0644]
pcre/doc/pcre.3 [new file with mode: 0644]
pcre/doc/pcre.html [new file with mode: 0644]
pcre/doc/pcre.txt [new file with mode: 0644]
pcre/doc/pcregrep.1 [new file with mode: 0644]
pcre/doc/pcregrep.html [new file with mode: 0644]
pcre/doc/pcregrep.txt [new file with mode: 0644]
pcre/doc/pcreposix.3 [new file with mode: 0644]
pcre/doc/pcreposix.html [new file with mode: 0644]
pcre/doc/pcreposix.txt [new file with mode: 0644]
pcre/doc/pcretest.txt [new file with mode: 0644]
pcre/doc/perltest.txt [new file with mode: 0644]
pcre/doc/readme [new file with mode: 0644]
pcre/get.c [new file with mode: 0644]
pcre/install [new file with mode: 0644]
pcre/install-sh [new file with mode: 0644]
pcre/internal.h [new file with mode: 0644]
pcre/licence [new file with mode: 0644]
pcre/ltconfig [new file with mode: 0644]
pcre/maketables.c [new file with mode: 0644]
pcre/pcre-config [new file with mode: 0644]
pcre/pcre-config.in [new file with mode: 0644]
pcre/pcre.def [new file with mode: 0644]
pcre/pcregrep.c [new file with mode: 0644]
pcre/pcreposix.h [new file with mode: 0644]
pcre/pcretest.c [new file with mode: 0644]
pcre/study.c [new file with mode: 0644]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..40caffa
--- /dev/null
@@ -0,0 +1,28 @@
+# CVS default ignores begin
+tags
+TAGS
+.make.state
+.nse_depinfo
+*~
+#*
+.#*
+,*
+_$*
+*$
+*.old
+*.bak
+*.BAK
+*.orig
+*.rej
+.del-*
+*.a
+*.olb
+*.o
+*.obj
+*.so
+*.exe
+*.Z
+*.elc
+*.ln
+core
+# CVS default ignores end
diff --git a/pcre/Makefile.in b/pcre/Makefile.in
new file mode 100644 (file)
index 0000000..94edf49
--- /dev/null
@@ -0,0 +1,219 @@
+
+# Makefile.in for PCRE (Perl-Compatible Regular Expression) library.
+
+#---------------------------------------------------------------------------#
+# To build mingw32 DLL uncomment the next two lines. This addition for      #
+# mingw32 was contributed by <Paul.Sokolovsky@technologist.com>. I (Philip  #
+# Hazel) don't know anything about it! There are some additional targets at #
+# the bottom of this Makefile.                                              #
+#---------------------------------------------------------------------------#
+#
+# include dll.mk
+# DLL_LDFLAGS=-s
+
+
+#---------------------------------------------------------------------------#
+# The next few lines are modified by "configure" to insert data that it is  #
+# given in its arguments, or which it finds out for itself.                 #
+#---------------------------------------------------------------------------#
+
+# BINDIR is the directory in which the pcregrep command is installed.
+# INCDIR is the directory in which the public header file pcre.h is installed.
+# LIBDIR is the directory in which the libraries are installed.
+# MANDIR is the directory in which the man pages are installed.
+# The pcretest program, as it is a test program, does not get installed
+# anywhere.
+
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+BINDIR = @bindir@
+LIBDIR = @libdir@
+INCDIR = @includedir@
+MANDIR = @mandir@
+
+CC = @CC@
+CFLAGS = @CFLAGS@
+RANLIB = @RANLIB@
+UTF8   = @UTF8@
+
+# LIBTOOL defaults to "./libtool", which enables the building of shared
+# libraries. If "configure" is called with --disable-shared-libraries, LIBTOOL
+# is set to "", which stops shared libraries from being built, and LIBSUFFIX
+# is set to "a" instead of "la", which causes the shared libraries not to be
+# installed.
+
+LIBTOOL = @LIBTOOL@
+LIBSUFFIX = @LIBSUFFIX@
+
+# These are the version numbers for the shared libraries
+
+PCRELIBVERSION = @PCRE_LIB_VERSION@
+PCREPOSIXLIBVERSION = @PCRE_POSIXLIB_VERSION@
+
+
+#---------------------------------------------------------------------------#
+# A copy of install-sh is in this distribution and is used by default.      #
+#---------------------------------------------------------------------------#
+
+INSTALL = ./install-sh -c
+INSTALL_DATA = ${INSTALL} -m 644
+
+
+#---------------------------------------------------------------------------#
+# For almost all systems, the command to create a library is "ar cq", but   #
+# there is at least one where it is different, so this command must be      #
+# configurable. However, I haven't got round to learning how to make        #
+# "configure" find this out for itself. It is necessary to use a command    #
+# such as "make AR='ar -rc'" if you need to vary this. The setting of AR is #
+# *not* passed over to ./ltconfig, because it does its own setting up.      #
+#---------------------------------------------------------------------------#
+
+AR = ar cq
+
+
+##############################################################################
+
+
+OBJ = maketables.o get.o study.o pcre.o
+LOBJ = maketables.lo get.lo study.lo pcre.lo
+
+all:            libtool libpcre.$(LIBSUFFIX) libpcreposix.$(LIBSUFFIX) pcretest pcregrep
+
+libtool:        config.guess config.sub ltconfig ltmain.sh
+               @if test "$(LIBTOOL)" = "./libtool"; then \
+                 echo '--- Building libtool ---'; \
+                 CC=$(CC) CFLAGS='$(CFLAGS)' RANLIB='$(RANLIB)' ./ltconfig ./ltmain.sh; \
+                 echo '--- Built libtool ---'; fi
+
+pcregrep:       libpcre.$(LIBSUFFIX) pcregrep.o
+                 @echo ' '
+                 @echo '--- Building pcregrep utility'
+                 @echo ' '
+               $(LIBTOOL) $(CC) $(CFLAGS) -o pcregrep pcregrep.o libpcre.$(LIBSUFFIX)
+
+pcretest:       libpcre.$(LIBSUFFIX) libpcreposix.$(LIBSUFFIX) pcretest.o
+                 @echo ' '
+                 @echo '--- Building pcretest testing program'
+                 @echo ' '
+               $(LIBTOOL) $(PURIFY) $(CC) $(CFLAGS) -o pcretest pcretest.o \
+                 libpcre.$(LIBSUFFIX) libpcreposix.$(LIBSUFFIX)
+
+libpcre.a:      $(OBJ)
+               @echo ' '
+               @echo '--- Building static library: libpcre'
+               @echo ' '
+               -rm -f libpcre.a
+               $(AR) libpcre.a $(OBJ)
+               $(RANLIB) libpcre.a
+
+libpcre.la:     $(OBJ)
+               @echo ' '
+               @echo '--- Building shared library: libpcre'
+               @echo ' '
+               -rm -f libpcre.la
+               ./libtool $(CC) -version-info '$(PCRELIBVERSION)' -o libpcre.la -rpath $(LIBDIR) $(LOBJ)
+
+libpcreposix.a: pcreposix.o
+               @echo ' '
+               @echo '--- Building static library: libpcreposix'
+               @echo ' '
+               -rm -f libpcreposix.a
+               $(AR) libpcreposix.a pcreposix.o
+               $(RANLIB) libpcreposix.a
+
+libpcreposix.la: pcreposix.o
+               @echo ' '
+               @echo '--- Building shared library: libpcreposix'
+               @echo ' '
+               -rm -f libpcreposix.la
+               ./libtool $(CC) -version-info '$(PCREPOSIXLIBVERSION)' -o libpcreposix.la -rpath $(LIBDIR) pcreposix.lo
+
+pcre.o:         chartables.c pcre.c pcre.h internal.h config.h Makefile
+               $(LIBTOOL) $(CC) -c $(CFLAGS) $(UTF8) pcre.c
+
+pcreposix.o:    pcreposix.c pcreposix.h internal.h pcre.h config.h Makefile
+               $(LIBTOOL) $(CC) -c $(CFLAGS) pcreposix.c
+
+maketables.o:   maketables.c pcre.h internal.h config.h Makefile
+               $(LIBTOOL) $(CC) -c $(CFLAGS) maketables.c
+
+get.o:          get.c pcre.h internal.h config.h Makefile
+               $(LIBTOOL) $(CC) -c $(CFLAGS) get.c
+
+study.o:        study.c pcre.h internal.h config.h Makefile
+               $(LIBTOOL) $(CC) -c $(CFLAGS) $(UTF8) study.c
+
+pcretest.o:     pcretest.c pcre.h config.h Makefile
+               $(CC) -c $(CFLAGS) $(UTF8) pcretest.c
+
+pcregrep.o:     pcregrep.c pcre.h Makefile config.h
+               $(CC) -c $(CFLAGS) $(UTF8) pcregrep.c
+
+# An auxiliary program makes the default character table source
+
+chartables.c:   dftables
+               ./dftables >chartables.c
+
+dftables:       dftables.c maketables.c pcre.h internal.h config.h Makefile
+               $(CC) -o dftables $(CFLAGS) dftables.c
+
+install:        all
+               $(LIBTOOL) $(INSTALL_DATA) libpcre.$(LIBSUFFIX) $(DESTDIR)/$(LIBDIR)/libpcre.$(LIBSUFFIX)
+               $(LIBTOOL) $(INSTALL_DATA) libpcreposix.$(LIBSUFFIX) $(DESTDIR)/$(LIBDIR)/libpcreposix.$(LIBSUFFIX)
+               $(INSTALL_DATA) pcre.h $(DESTDIR)/$(INCDIR)/pcre.h
+               $(INSTALL_DATA) pcreposix.h $(DESTDIR)/$(INCDIR)/pcreposix.h
+               $(INSTALL_DATA) doc/pcre.3 $(DESTDIR)/$(MANDIR)/man3/pcre.3
+               $(INSTALL_DATA) doc/pcreposix.3 $(DESTDIR)/$(MANDIR)/man3/pcreposix.3
+               $(INSTALL_DATA) doc/pcregrep.1 $(DESTDIR)/$(MANDIR)/man1/pcregrep.1
+               @if test "$(LIBTOOL)" = "./libtool"; then \
+                 echo ' '; \
+                 echo '--- Rebuilding pcregrep to use installed shared library ---'; \
+                 echo $(CC) $(CFLAGS) -o pcregrep pcregrep.o -L$(DESTDIR)/$(LIBDIR) -lpcre; \
+                 $(CC) $(CFLAGS) -o pcregrep pcregrep.o -L$(DESTDIR)/$(LIBDIR) -lpcre; \
+                 echo '--- Rebuilding pcretest to use installed shared library ---'; \
+                 echo $(CC) $(CFLAGS) -o pcretest pcretest.o -L$(DESTDIR)/$(LIBDIR) -lpcre -lpcreposix; \
+                 $(CC) $(CFLAGS) -o pcretest pcretest.o -L$(DESTDIR)/$(LIBDIR) -lpcre -lpcreposix; \
+               fi
+               $(INSTALL)      pcregrep $(DESTDIR)/$(BINDIR)/pcregrep
+               $(INSTALL)      pcre-config $(DESTDIR)/$(BINDIR)/pcre-config
+
+# We deliberately omit dftables and chartables.c from 'make clean'; once made
+# chartables.c shouldn't change, and if people have edited the tables by hand,
+# you don't want to throw them away.
+
+clean:;         -rm -rf *.o *.lo *.a *.la .libs pcretest pcregrep testtry
+
+# But "make distclean" should get back to a virgin distribution
+
+distclean:      clean
+               -rm -f chartables.c libtool pcre-config pcre.h \
+               Makefile config.h config.status config.log config.cache
+
+check:          runtest
+
+test:           runtest
+
+runtest:        all
+               ./RunTest
+
+######## MINGW32 ############### MINGW32 ############### MINGW32 #############
+
+# This addition for mingw32 was contributed by  Paul Sokolovsky
+# <Paul.Sokolovsky@technologist.com>. I (PH) don't know anything about it!
+
+dll:            _dll libpcre.dll.a pcregrep_d pcretest_d
+
+_dll:
+               $(MAKE) CFLAGS=-DSTATIC pcre.dll
+
+pcre.dll:       $(OBJ) pcreposix.o pcre.def
+libpcre.dll.a:  pcre.def
+
+pcregrep_d:     libpcre.dll.a pcregrep.o
+               $(CC) $(CFLAGS) -L. -o pcregrep pcregrep.o -lpcre.dll
+
+pcretest_d:     libpcre.dll.a pcretest.o
+               $(PURIFY) $(CC) $(CFLAGS) -L. -o pcretest pcretest.o -lpcre.dll
+
+# End
diff --git a/pcre/RunTest.in b/pcre/RunTest.in
new file mode 100644 (file)
index 0000000..6e4eb08
--- /dev/null
@@ -0,0 +1,148 @@
+#! /bin/sh
+
+# This file is generated by configure from RunTest.in. Make any changes
+# to that file.
+
+# Run PCRE tests
+
+cf=diff
+
+# Select which tests to run; if no selection, run all
+
+do1=no
+do2=no
+do3=no
+do4=no
+do5=no
+do6=no
+
+while [ $# -gt 0 ] ; do
+  case $1 in
+    1) do1=yes;;
+    2) do2=yes;;
+    3) do3=yes;;
+    4) do4=yes;;
+    5) do5=yes;; 
+    6) do6=yes;; 
+    *) echo "Unknown test number $1"; exit 1;;
+  esac
+  shift
+done
+
+if [ "@UTF8@" = "" ] ; then
+  if [ $do5 = yes ] ; then
+    echo "Can't run test 5 because UFT8 support is not configured"
+    exit 1
+  fi   
+  if [ $do6 = yes ] ; then
+    echo "Can't run test 6 because UFT8 support is not configured"
+    exit 1
+  fi   
+fi    
+
+if [ $do1 = no -a $do2 = no -a $do3 = no -a $do4 = no -a\
+     $do5 = no -a $do6 = no ] ; then
+  do1=yes
+  do2=yes
+  do3=yes
+  do4=yes
+  if [ "@UTF8@" != "" ] ; then do5=yes; fi
+  if [ "@UTF8@" != "" ] ; then do6=yes; fi
+fi
+
+# Primary test, Perl-compatible
+
+if [ $do1 = yes ] ; then
+  echo "Testing main functionality (Perl compatible)"
+  ./pcretest testdata/testinput1 testtry
+  if [ $? = 0 ] ; then
+    $cf testtry testdata/testoutput1
+    if [ $? != 0 ] ; then exit 1; fi
+  else exit 1
+  fi
+fi
+
+# PCRE tests that are not Perl-compatible - API & error tests, mostly
+
+if [ $do2 = yes ] ; then
+  echo "Testing API and error handling (not Perl compatible)"
+  ./pcretest -i testdata/testinput2 testtry
+  if [ $? = 0 ] ; then
+    $cf testtry testdata/testoutput2
+    if [ $? != 0 ] ; then exit 1; fi
+  else exit 1
+  fi
+fi
+
+# Additional Perl-compatible tests for Perl 5.005's new features
+
+if [ $do3 = yes ] ; then
+  echo "Testing Perl 5.005 features (Perl 5.005 compatible)"
+  ./pcretest testdata/testinput3 testtry
+  if [ $? = 0 ] ; then
+    $cf testtry testdata/testoutput3
+    if [ $? != 0 ] ; then exit 1; fi
+  else exit 1
+  fi
+fi
+
+if [ $do1 = yes -a $do2 = yes -a $do3 = yes ] ; then
+  echo " " 
+  echo "The three main tests all ran OK"
+  echo " " 
+fi
+
+# Locale-specific tests, provided the "fr" locale is available
+
+if [ $do4 = yes ] ; then
+  locale -a | grep '^fr$' >/dev/null
+  if [ $? -eq 0 ] ; then
+    echo "Testing locale-specific features (using 'fr' locale)"
+    ./pcretest testdata/testinput4 testtry
+    if [ $? = 0 ] ; then
+      $cf testtry testdata/testoutput4
+      if [ $? != 0 ] ; then 
+        echo " "
+        echo "Locale test did not run entirely successfully."
+        echo "This usually means that there is a problem with the locale"
+        echo "settings rather than a bug in PCRE."    
+      else
+      echo "Locale test ran OK" 
+      fi 
+      echo " " 
+    else exit 1
+    fi
+  else
+    echo "Cannot test locale-specific features - 'fr' locale not found,"
+    echo "or the \"locale\" command is not available to check for it."
+    echo " " 
+  fi
+fi
+
+# Additional tests for UTF8 support
+
+if [ $do5 = yes ] ; then
+  echo "Testing experimental, incomplete UTF8 support (Perl compatible)"
+  ./pcretest testdata/testinput5 testtry 
+  if [ $? = 0 ] ; then
+    $cf testtry testdata/testoutput5
+    if [ $? != 0 ] ; then exit 1; fi
+  else exit 1
+  fi
+  echo "UTF8 test ran OK"
+  echo " "
+fi
+
+if [ $do6 = yes ] ; then
+  echo "Testing API and internals for UTF8 support (not Perl compatible)"
+  ./pcretest testdata/testinput6 testtry 
+  if [ $? = 0 ] ; then
+    $cf testtry testdata/testoutput6
+    if [ $? != 0 ] ; then exit 1; fi
+  else exit 1
+  fi
+  echo "UTF8 internals test ran OK"
+  echo " "
+fi
+
+# End
diff --git a/pcre/config.guess b/pcre/config.guess
new file mode 100644 (file)
index 0000000..e1b5871
--- /dev/null
@@ -0,0 +1,1121 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999
+#   Free Software Foundation, Inc.
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Written by Per Bothner <bothner@cygnus.com>.
+# The master version of this file is at the FSF in /home/gd/gnu/lib.
+# Please send patches to <autoconf-patches@gnu.org>.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub.  If it succeeds, it prints the system name on stdout, and
+# exits with 0.  Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit system type (host/target name).
+#
+# Only a few systems have been added to this list; please add others
+# (but try to keep the structure clean).
+#
+
+# Use $HOST_CC if defined. $CC may point to a cross-compiler
+if test x"$CC_FOR_BUILD" = x; then
+  if test x"$HOST_CC" != x; then
+    CC_FOR_BUILD="$HOST_CC"
+  else
+    if test x"$CC" != x; then
+      CC_FOR_BUILD="$CC"
+    else
+      CC_FOR_BUILD=cc
+    fi
+  fi
+fi
+
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 8/24/94.)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+       PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+dummy=dummy-$$
+trap 'rm -f $dummy.c $dummy.o $dummy; exit 1' 1 2 15
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    alpha:OSF1:*:*)
+       if test $UNAME_RELEASE = "V4.0"; then
+               UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+       fi
+       # A Vn.n version is a released version.
+       # A Tn.n version is a released field test version.
+       # A Xn.n version is an unreleased experimental baselevel.
+       # 1.2 uses "1.2" for uname -r.
+       cat <<EOF >$dummy.s
+       .globl main
+       .ent main
+main:
+       .frame \$30,0,\$26,0
+       .prologue 0
+       .long 0x47e03d80 # implver $0
+       lda \$2,259
+       .long 0x47e20c21 # amask $2,$1
+       srl \$1,8,\$2
+       sll \$2,2,\$2
+       sll \$0,3,\$0
+       addl \$1,\$0,\$0
+       addl \$2,\$0,\$0
+       ret \$31,(\$26),1
+       .end main
+EOF
+       $CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
+       if test "$?" = 0 ; then
+               ./$dummy
+               case "$?" in
+                       7)
+                               UNAME_MACHINE="alpha"
+                               ;;
+                       15)
+                               UNAME_MACHINE="alphaev5"
+                               ;;
+                       14)
+                               UNAME_MACHINE="alphaev56"
+                               ;;
+                       10)
+                               UNAME_MACHINE="alphapca56"
+                               ;;
+                       16)
+                               UNAME_MACHINE="alphaev6"
+                               ;;
+               esac
+       fi
+       rm -f $dummy.s $dummy
+       echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+       exit 0 ;;
+    Alpha\ *:Windows_NT*:*)
+       # How do we know it's Interix rather than the generic POSIX subsystem?
+       # Should we change UNAME_MACHINE based on the output of uname instead
+       # of the specific Alpha model?
+       echo alpha-pc-interix
+       exit 0 ;;
+    21064:Windows_NT:50:3)
+       echo alpha-dec-winnt3.5
+       exit 0 ;;
+    Amiga*:UNIX_System_V:4.0:*)
+       echo m68k-cbm-sysv4
+       exit 0;;
+    amiga:NetBSD:*:*)
+      echo m68k-cbm-netbsd${UNAME_RELEASE}
+      exit 0 ;;
+    amiga:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+       echo ${UNAME_MACHINE}-unknown-amigaos
+       exit 0 ;;
+    arc64:OpenBSD:*:*)
+       echo mips64el-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    arc:OpenBSD:*:*)
+       echo mipsel-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    hkmips:OpenBSD:*:*)
+       echo mips-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    pmax:OpenBSD:*:*)
+       echo mipsel-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    sgi:OpenBSD:*:*)
+       echo mips-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    wgrisc:OpenBSD:*:*)
+       echo mipsel-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    *:OS/390:*:*)
+       echo i370-ibm-openedition
+       exit 0 ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+       echo arm-acorn-riscix${UNAME_RELEASE}
+       exit 0;;
+    arm32:NetBSD:*:*)
+       echo arm-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+       exit 0 ;;
+    SR2?01:HI-UX/MPP:*:*)
+       echo hppa1.1-hitachi-hiuxmpp
+       exit 0;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+       # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+       if test "`(/bin/universe) 2>/dev/null`" = att ; then
+               echo pyramid-pyramid-sysv3
+       else
+               echo pyramid-pyramid-bsd
+       fi
+       exit 0 ;;
+    NILE*:*:*:dcosx)
+       echo pyramid-pyramid-svr4
+       exit 0 ;;
+    sun4H:SunOS:5.*:*)
+       echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+       exit 0 ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+       echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+       exit 0 ;;
+    i86pc:SunOS:5.*:*)
+       echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+       exit 0 ;;
+    sun4*:SunOS:6*:*)
+       # According to config.sub, this is the proper way to canonicalize
+       # SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+       # it's likely to be more like Solaris than SunOS4.
+       echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+       exit 0 ;;
+    sun4*:SunOS:*:*)
+       case "`/usr/bin/arch -k`" in
+           Series*|S4*)
+               UNAME_RELEASE=`uname -v`
+               ;;
+       esac
+       # Japanese Language versions have a version number like `4.1.3-JL'.
+       echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+       exit 0 ;;
+    sun3*:SunOS:*:*)
+       echo m68k-sun-sunos${UNAME_RELEASE}
+       exit 0 ;;
+    sun*:*:4.2BSD:*)
+       UNAME_RELEASE=`(head -1 /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+       test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+       case "`/bin/arch`" in
+           sun3)
+               echo m68k-sun-sunos${UNAME_RELEASE}
+               ;;
+           sun4)
+               echo sparc-sun-sunos${UNAME_RELEASE}
+               ;;
+       esac
+       exit 0 ;;
+    aushp:SunOS:*:*)
+       echo sparc-auspex-sunos${UNAME_RELEASE}
+       exit 0 ;;
+    atari*:NetBSD:*:*)
+       echo m68k-atari-netbsd${UNAME_RELEASE}
+       exit 0 ;;
+    atari*:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor 
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+       exit 0 ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+       echo m68k-atari-mint${UNAME_RELEASE}
+        exit 0 ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+       exit 0 ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+        echo m68k-milan-mint${UNAME_RELEASE}
+        exit 0 ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+        echo m68k-hades-mint${UNAME_RELEASE}
+        exit 0 ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+        echo m68k-unknown-mint${UNAME_RELEASE}
+        exit 0 ;;
+    sun3*:NetBSD:*:*)
+       echo m68k-sun-netbsd${UNAME_RELEASE}
+       exit 0 ;;
+    sun3*:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    mac68k:NetBSD:*:*)
+       echo m68k-apple-netbsd${UNAME_RELEASE}
+       exit 0 ;;
+    mac68k:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    mvme68k:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    mvme88k:OpenBSD:*:*)
+       echo m88k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    powerpc:machten:*:*)
+       echo powerpc-apple-machten${UNAME_RELEASE}
+       exit 0 ;;
+    macppc:NetBSD:*:*)
+        echo powerpc-apple-netbsd${UNAME_RELEASE}
+        exit 0 ;;
+    RISC*:Mach:*:*)
+       echo mips-dec-mach_bsd4.3
+       exit 0 ;;
+    RISC*:ULTRIX:*:*)
+       echo mips-dec-ultrix${UNAME_RELEASE}
+       exit 0 ;;
+    VAX*:ULTRIX*:*:*)
+       echo vax-dec-ultrix${UNAME_RELEASE}
+       exit 0 ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+       echo clipper-intergraph-clix${UNAME_RELEASE}
+       exit 0 ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+       sed 's/^        //' << EOF >$dummy.c
+#ifdef __cplusplus
+       int main (int argc, char *argv[]) {
+#else
+       int main (argc, argv) int argc; char *argv[]; {
+#endif
+       #if defined (host_mips) && defined (MIPSEB)
+       #if defined (SYSTYPE_SYSV)
+         printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+       #endif
+       #if defined (SYSTYPE_SVR4)
+         printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+       #endif
+       #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+         printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+       #endif
+       #endif
+         exit (-1);
+       }
+EOF
+       $CC_FOR_BUILD $dummy.c -o $dummy \
+         && ./$dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
+         && rm $dummy.c $dummy && exit 0
+       rm -f $dummy.c $dummy
+       echo mips-mips-riscos${UNAME_RELEASE}
+       exit 0 ;;
+    Night_Hawk:Power_UNIX:*:*)
+       echo powerpc-harris-powerunix
+       exit 0 ;;
+    m88k:CX/UX:7*:*)
+       echo m88k-harris-cxux7
+       exit 0 ;;
+    m88k:*:4*:R4*)
+       echo m88k-motorola-sysv4
+       exit 0 ;;
+    m88k:*:3*:R3*)
+       echo m88k-motorola-sysv3
+       exit 0 ;;
+    AViiON:dgux:*:*)
+        # DG/UX returns AViiON for all architectures
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+       if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110]
+       then
+           if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+              [ ${TARGET_BINARY_INTERFACE}x = x ]
+           then
+               echo m88k-dg-dgux${UNAME_RELEASE}
+           else
+               echo m88k-dg-dguxbcs${UNAME_RELEASE}
+           fi
+       else
+           echo i586-dg-dgux${UNAME_RELEASE}
+       fi
+       exit 0 ;;
+    M88*:DolphinOS:*:*)        # DolphinOS (SVR3)
+       echo m88k-dolphin-sysv3
+       exit 0 ;;
+    M88*:*:R3*:*)
+       # Delta 88k system running SVR3
+       echo m88k-motorola-sysv3
+       exit 0 ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+       echo m88k-tektronix-sysv3
+       exit 0 ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+       echo m68k-tektronix-bsd
+       exit 0 ;;
+    *:IRIX*:*:*)
+       echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+       exit 0 ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+       echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
+       exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
+    i?86:AIX:*:*)
+       echo i386-ibm-aix
+       exit 0 ;;
+    *:AIX:2:3)
+       if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+               sed 's/^                //' << EOF >$dummy.c
+               #include <sys/systemcfg.h>
+
+               main()
+                       {
+                       if (!__power_pc())
+                               exit(1);
+                       puts("powerpc-ibm-aix3.2.5");
+                       exit(0);
+                       }
+EOF
+               $CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+               rm -f $dummy.c $dummy
+               echo rs6000-ibm-aix3.2.5
+       elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+               echo rs6000-ibm-aix3.2.4
+       else
+               echo rs6000-ibm-aix3.2
+       fi
+       exit 0 ;;
+    *:AIX:*:4)
+       IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
+       if /usr/sbin/lsattr -EHl ${IBM_CPU_ID} | grep POWER >/dev/null 2>&1; then
+               IBM_ARCH=rs6000
+       else
+               IBM_ARCH=powerpc
+       fi
+       if [ -x /usr/bin/oslevel ] ; then
+               IBM_REV=`/usr/bin/oslevel`
+       else
+               IBM_REV=4.${UNAME_RELEASE}
+       fi
+       echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+       exit 0 ;;
+    *:AIX:*:*)
+       echo rs6000-ibm-aix
+       exit 0 ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+       echo romp-ibm-bsd4.4
+       exit 0 ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC NetBSD and
+       echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+       exit 0 ;;                           # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+       echo rs6000-bull-bosx
+       exit 0 ;;
+    DPX/2?00:B.O.S.:*:*)
+       echo m68k-bull-sysv3
+       exit 0 ;;
+    9000/[34]??:4.3bsd:1.*:*)
+       echo m68k-hp-bsd
+       exit 0 ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+       echo m68k-hp-bsd4.4
+       exit 0 ;;
+    9000/[34678]??:HP-UX:*:*)
+       case "${UNAME_MACHINE}" in
+           9000/31? )            HP_ARCH=m68000 ;;
+           9000/[34]?? )         HP_ARCH=m68k ;;
+           9000/[678][0-9][0-9])
+              sed 's/^              //' << EOF >$dummy.c
+              #include <stdlib.h>
+              #include <unistd.h>
+
+              int main ()
+              {
+              #if defined(_SC_KERNEL_BITS)
+                  long bits = sysconf(_SC_KERNEL_BITS);
+              #endif
+                  long cpu  = sysconf (_SC_CPU_VERSION);
+
+                  switch (cpu)
+               {
+               case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+               case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+               case CPU_PA_RISC2_0:
+              #if defined(_SC_KERNEL_BITS)
+                   switch (bits)
+                       {
+                       case 64: puts ("hppa2.0w"); break;
+                       case 32: puts ("hppa2.0n"); break;
+                       default: puts ("hppa2.0"); break;
+                       } break;
+              #else  /* !defined(_SC_KERNEL_BITS) */
+                   puts ("hppa2.0"); break;
+              #endif
+               default: puts ("hppa1.0"); break;
+               }
+                  exit (0);
+              }
+EOF
+       (CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
+       rm -f $dummy.c $dummy
+       esac
+       HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+       echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+       exit 0 ;;
+    3050*:HI-UX:*:*)
+       sed 's/^        //' << EOF >$dummy.c
+       #include <unistd.h>
+       int
+       main ()
+       {
+         long cpu = sysconf (_SC_CPU_VERSION);
+         /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+            true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+            results, however.  */
+         if (CPU_IS_PA_RISC (cpu))
+           {
+             switch (cpu)
+               {
+                 case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+                 case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+                 case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+                 default: puts ("hppa-hitachi-hiuxwe2"); break;
+               }
+           }
+         else if (CPU_IS_HP_MC68K (cpu))
+           puts ("m68k-hitachi-hiuxwe2");
+         else puts ("unknown-hitachi-hiuxwe2");
+         exit (0);
+       }
+EOF
+       $CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+       rm -f $dummy.c $dummy
+       echo unknown-hitachi-hiuxwe2
+       exit 0 ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+       echo hppa1.1-hp-bsd
+       exit 0 ;;
+    9000/8??:4.3bsd:*:*)
+       echo hppa1.0-hp-bsd
+       exit 0 ;;
+    *9??*:MPE/iX:*:*)
+       echo hppa1.0-hp-mpeix
+       exit 0 ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+       echo hppa1.1-hp-osf
+       exit 0 ;;
+    hp8??:OSF1:*:*)
+       echo hppa1.0-hp-osf
+       exit 0 ;;
+    i?86:OSF1:*:*)
+       if [ -x /usr/sbin/sysversion ] ; then
+           echo ${UNAME_MACHINE}-unknown-osf1mk
+       else
+           echo ${UNAME_MACHINE}-unknown-osf1
+       fi
+       exit 0 ;;
+    parisc*:Lites*:*:*)
+       echo hppa1.1-hp-lites
+       exit 0 ;;
+    hppa*:OpenBSD:*:*)
+       echo hppa-unknown-openbsd
+       exit 0 ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+       echo c1-convex-bsd
+        exit 0 ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+       if getsysinfo -f scalar_acc
+       then echo c32-convex-bsd
+       else echo c2-convex-bsd
+       fi
+        exit 0 ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+       echo c34-convex-bsd
+        exit 0 ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+       echo c38-convex-bsd
+        exit 0 ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+       echo c4-convex-bsd
+        exit 0 ;;
+    CRAY*X-MP:*:*:*)
+       echo xmp-cray-unicos
+        exit 0 ;;
+    CRAY*Y-MP:*:*:*)
+       echo ymp-cray-unicos${UNAME_RELEASE}
+       exit 0 ;;
+    CRAY*[A-Z]90:*:*:*)
+       echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+       | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+             -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
+       exit 0 ;;
+    CRAY*TS:*:*:*)
+       echo t90-cray-unicos${UNAME_RELEASE}
+       exit 0 ;;
+    CRAY*T3E:*:*:*)
+       echo alpha-cray-unicosmk${UNAME_RELEASE}
+       exit 0 ;;
+    CRAY-2:*:*:*)
+       echo cray2-cray-unicos
+        exit 0 ;;
+    F300:UNIX_System_V:*:*)
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+        echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        exit 0 ;;
+    F301:UNIX_System_V:*:*)
+       echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'`
+       exit 0 ;;
+    hp3[0-9][05]:NetBSD:*:*)
+       echo m68k-hp-netbsd${UNAME_RELEASE}
+       exit 0 ;;
+    hp300:OpenBSD:*:*)
+       echo m68k-unknown-openbsd${UNAME_RELEASE}
+       exit 0 ;;
+    i?86:BSD/386:*:* | i?86:BSD/OS:*:*)
+       echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+       exit 0 ;;
+    sparc*:BSD/OS:*:*)
+       echo sparc-unknown-bsdi${UNAME_RELEASE}
+       exit 0 ;;
+    *:BSD/OS:*:*)
+       echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+       exit 0 ;;
+    *:FreeBSD:*:*)
+       if test -x /usr/bin/objformat; then
+           if test "elf" = "`/usr/bin/objformat`"; then
+               echo ${UNAME_MACHINE}-unknown-freebsdelf`echo ${UNAME_RELEASE}|sed -e 's/[-_].*//'`
+               exit 0
+           fi
+       fi
+       echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+       exit 0 ;;
+    *:NetBSD:*:*)
+       echo ${UNAME_MACHINE}-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*//'`
+       exit 0 ;;
+    *:OpenBSD:*:*)
+       echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+       exit 0 ;;
+    i*:CYGWIN*:*)
+       echo ${UNAME_MACHINE}-pc-cygwin
+       exit 0 ;;
+    i*:MINGW*:*)
+       echo ${UNAME_MACHINE}-pc-mingw32
+       exit 0 ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+       # How do we know it's Interix rather than the generic POSIX subsystem?
+       # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+       # UNAME_MACHINE based on the output of uname instead of i386?
+       echo i386-pc-interix
+       exit 0 ;;
+    i*:UWIN*:*)
+       echo ${UNAME_MACHINE}-pc-uwin
+       exit 0 ;;
+    p*:CYGWIN*:*)
+       echo powerpcle-unknown-cygwin
+       exit 0 ;;
+    prep*:SunOS:5.*:*)
+       echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+       exit 0 ;;
+    *:GNU:*:*)
+       echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+       exit 0 ;;
+    *:Linux:*:*)
+
+       # The BFD linker knows what the default object file format is, so
+       # first see if it will tell us. cd to the root directory to prevent
+       # problems with other programs or directories called `ld' in the path.
+       ld_help_string=`cd /; ld --help 2>&1`
+       ld_supported_emulations=`echo $ld_help_string \
+                        | sed -ne '/supported emulations:/!d
+                                   s/[         ][      ]*/ /g
+                                   s/.*supported emulations: *//
+                                   s/ .*//
+                                   p'`
+        case "$ld_supported_emulations" in
+         *ia64)
+               echo "${UNAME_MACHINE}-unknown-linux"
+               exit 0
+               ;;
+         i?86linux)
+               echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+               exit 0
+               ;;
+         i?86coff)
+               echo "${UNAME_MACHINE}-pc-linux-gnucoff"
+               exit 0
+               ;;
+         sparclinux)
+               echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+               exit 0
+               ;;
+         armlinux)
+               echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+               exit 0
+               ;;
+         elf32arm*)
+               echo "${UNAME_MACHINE}-unknown-linux-gnu"
+               exit 0
+               ;;
+         armelf_linux*)
+               echo "${UNAME_MACHINE}-unknown-linux-gnu"
+               exit 0
+               ;;
+         m68klinux)
+               echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+               exit 0
+               ;;
+         elf32ppc)
+               # Determine Lib Version
+               cat >$dummy.c <<EOF
+#include <features.h>
+#if defined(__GLIBC__)
+extern char __libc_version[];
+extern char __libc_release[];
+#endif
+main(argc, argv)
+     int argc;
+     char *argv[];
+{
+#if defined(__GLIBC__)
+  printf("%s %s\n", __libc_version, __libc_release);
+#else
+  printf("unkown\n");
+#endif
+  return 0;
+}
+EOF
+               LIBC=""
+               $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
+               if test "$?" = 0 ; then
+                       ./$dummy | grep 1\.99 > /dev/null
+                       if test "$?" = 0 ; then
+                               LIBC="libc1"
+                       fi
+               fi      
+               rm -f $dummy.c $dummy
+               echo powerpc-unknown-linux-gnu${LIBC}
+               exit 0
+               ;;
+       esac
+
+       if test "${UNAME_MACHINE}" = "alpha" ; then
+               sed 's/^        //'  <<EOF >$dummy.s
+               .globl main
+               .ent main
+       main:
+               .frame \$30,0,\$26,0
+               .prologue 0
+               .long 0x47e03d80 # implver $0
+               lda \$2,259
+               .long 0x47e20c21 # amask $2,$1
+               srl \$1,8,\$2
+               sll \$2,2,\$2
+               sll \$0,3,\$0
+               addl \$1,\$0,\$0
+               addl \$2,\$0,\$0
+               ret \$31,(\$26),1
+               .end main
+EOF
+               LIBC=""
+               $CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
+               if test "$?" = 0 ; then
+                       ./$dummy
+                       case "$?" in
+                       7)
+                               UNAME_MACHINE="alpha"
+                               ;;
+                       15)
+                               UNAME_MACHINE="alphaev5"
+                               ;;
+                       14)
+                               UNAME_MACHINE="alphaev56"
+                               ;;
+                       10)
+                               UNAME_MACHINE="alphapca56"
+                               ;;
+                       16)
+                               UNAME_MACHINE="alphaev6"
+                               ;;
+                       esac
+
+                       objdump --private-headers $dummy | \
+                         grep ld.so.1 > /dev/null
+                       if test "$?" = 0 ; then
+                               LIBC="libc1"
+                       fi
+               fi
+               rm -f $dummy.s $dummy
+               echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0
+       elif test "${UNAME_MACHINE}" = "mips" ; then
+         cat >$dummy.c <<EOF
+#ifdef __cplusplus
+       int main (int argc, char *argv[]) {
+#else
+       int main (argc, argv) int argc; char *argv[]; {
+#endif
+#ifdef __MIPSEB__
+  printf ("%s-unknown-linux-gnu\n", argv[1]);
+#endif
+#ifdef __MIPSEL__
+  printf ("%sel-unknown-linux-gnu\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+         $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
+         rm -f $dummy.c $dummy
+       else
+         # Either a pre-BFD a.out linker (linux-gnuoldld)
+         # or one that does not give us useful --help.
+         # GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
+         # If ld does not provide *any* "supported emulations:"
+         # that means it is gnuoldld.
+         echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations:"
+         test $? != 0 && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
+
+         case "${UNAME_MACHINE}" in
+         i?86)
+           VENDOR=pc;
+           ;;
+         *)
+           VENDOR=unknown;
+           ;;
+         esac
+         # Determine whether the default compiler is a.out or elf
+         cat >$dummy.c <<EOF
+#include <features.h>
+#ifdef __cplusplus
+       int main (int argc, char *argv[]) {
+#else
+       int main (argc, argv) int argc; char *argv[]; {
+#endif
+#ifdef __ELF__
+# ifdef __GLIBC__
+#  if __GLIBC__ >= 2
+    printf ("%s-${VENDOR}-linux-gnu\n", argv[1]);
+#  else
+    printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+#  endif
+# else
+   printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+# endif
+#else
+  printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+         $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
+         rm -f $dummy.c $dummy
+       fi ;;
+# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
+# are messed up and put the nodename in both sysname and nodename.
+    i?86:DYNIX/ptx:4*:*)
+       echo i386-sequent-sysv4
+       exit 0 ;;
+    i?86:UNIX_SV:4.2MP:2.*)
+        # Unixware is an offshoot of SVR4, but it has its own version
+        # number series starting with 2...
+        # I am not positive that other SVR4 systems won't match this,
+       # I just have to hope.  -- rms.
+        # Use sysv4.2uw... so that sysv4* matches it.
+       echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+       exit 0 ;;
+    i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
+       UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+       if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+               echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+       else
+               echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+       fi
+       exit 0 ;;
+    i?86:*:5:7*)
+        # Fixed at (any) Pentium or better
+        UNAME_MACHINE=i586
+        if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
+           echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
+       else
+           echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
+       fi
+       exit 0 ;;
+    i?86:*:3.2:*)
+       if test -f /usr/options/cb.name; then
+               UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+               echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+       elif /bin/uname -X 2>/dev/null >/dev/null ; then
+               UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
+               (/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
+               (/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) \
+                       && UNAME_MACHINE=i586
+               (/bin/uname -X|egrep '^Machine.*Pent ?II' >/dev/null) \
+                       && UNAME_MACHINE=i686
+               (/bin/uname -X|egrep '^Machine.*Pentium Pro' >/dev/null) \
+                       && UNAME_MACHINE=i686
+               echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+       else
+               echo ${UNAME_MACHINE}-pc-sysv32
+       fi
+       exit 0 ;;
+    pc:*:*:*)
+        # uname -m prints for DJGPP always 'pc', but it prints nothing about
+        # the processor, so we play safe by assuming i386.
+       echo i386-pc-msdosdjgpp
+        exit 0 ;;
+    Intel:Mach:3*:*)
+       echo i386-pc-mach3
+       exit 0 ;;
+    paragon:*:*:*)
+       echo i860-intel-osf1
+       exit 0 ;;
+    i860:*:4.*:*) # i860-SVR4
+       if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+         echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+       else # Add other i860-SVR4 vendors below as they are discovered.
+         echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+       fi
+       exit 0 ;;
+    mini*:CTIX:SYS*5:*)
+       # "miniframe"
+       echo m68010-convergent-sysv
+       exit 0 ;;
+    M68*:*:R3V[567]*:*)
+       test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
+    3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
+       OS_REL=''
+       test -r /etc/.relid \
+       && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+       /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+         && echo i486-ncr-sysv4.3${OS_REL} && exit 0
+       /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+         && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+          && echo i486-ncr-sysv4 && exit 0 ;;
+    m68*:LynxOS:2.*:*)
+       echo m68k-unknown-lynxos${UNAME_RELEASE}
+       exit 0 ;;
+    mc68030:UNIX_System_V:4.*:*)
+       echo m68k-atari-sysv4
+       exit 0 ;;
+    i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
+       echo i386-unknown-lynxos${UNAME_RELEASE}
+       exit 0 ;;
+    TSUNAMI:LynxOS:2.*:*)
+       echo sparc-unknown-lynxos${UNAME_RELEASE}
+       exit 0 ;;
+    rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
+       echo rs6000-unknown-lynxos${UNAME_RELEASE}
+       exit 0 ;;
+    SM[BE]S:UNIX_SV:*:*)
+       echo mips-dde-sysv${UNAME_RELEASE}
+       exit 0 ;;
+    RM*:ReliantUNIX-*:*:*)
+       echo mips-sni-sysv4
+       exit 0 ;;
+    RM*:SINIX-*:*:*)
+       echo mips-sni-sysv4
+       exit 0 ;;
+    *:SINIX-*:*:*)
+       if uname -p 2>/dev/null >/dev/null ; then
+               UNAME_MACHINE=`(uname -p) 2>/dev/null`
+               echo ${UNAME_MACHINE}-sni-sysv4
+       else
+               echo ns32k-sni-sysv
+       fi
+       exit 0 ;;
+    PENTIUM:CPunix:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+                           # says <Richard.M.Bartel@ccMail.Census.GOV>
+        echo i586-unisys-sysv4
+        exit 0 ;;
+    *:UNIX_System_V:4*:FTX*)
+       # From Gerald Hewes <hewes@openmarket.com>.
+       # How about differentiating between stratus architectures? -djm
+       echo hppa1.1-stratus-sysv4
+       exit 0 ;;
+    *:*:*:FTX*)
+       # From seanf@swdc.stratus.com.
+       echo i860-stratus-sysv4
+       exit 0 ;;
+    mc68*:A/UX:*:*)
+       echo m68k-apple-aux${UNAME_RELEASE}
+       exit 0 ;;
+    news*:NEWS-OS:*:6*)
+       echo mips-sony-newsos6
+       exit 0 ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+       if [ -d /usr/nec ]; then
+               echo mips-nec-sysv${UNAME_RELEASE}
+       else
+               echo mips-unknown-sysv${UNAME_RELEASE}
+       fi
+        exit 0 ;;
+    BeBox:BeOS:*:*)    # BeOS running on hardware made by Be, PPC only.
+       echo powerpc-be-beos
+       exit 0 ;;
+    BeMac:BeOS:*:*)    # BeOS running on Mac or Mac clone, PPC only.
+       echo powerpc-apple-beos
+       exit 0 ;;
+    BePC:BeOS:*:*)     # BeOS running on Intel PC compatible.
+       echo i586-pc-beos
+       exit 0 ;;
+    SX-4:SUPER-UX:*:*)
+       echo sx4-nec-superux${UNAME_RELEASE}
+       exit 0 ;;
+    SX-5:SUPER-UX:*:*)
+       echo sx5-nec-superux${UNAME_RELEASE}
+       exit 0 ;;
+    Power*:Rhapsody:*:*)
+       echo powerpc-apple-rhapsody${UNAME_RELEASE}
+       exit 0 ;;
+    *:Rhapsody:*:*)
+       echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+       exit 0 ;;
+    *:QNX:*:4*)
+       echo i386-qnx-qnx${UNAME_VERSION}
+       exit 0 ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+          "4"
+#else
+         ""
+#endif
+         ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+  printf ("arm-acorn-riscix"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+  printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+    struct utsname un;
+
+    uname(&un);
+
+    if (strncmp(un.version, "V2", 2) == 0) {
+       printf ("i386-sequent-ptx2\n"); exit (0);
+    }
+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+       printf ("i386-sequent-ptx1\n"); exit (0);
+    }
+    printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+#if !defined (ultrix)
+  printf ("vax-dec-bsd\n"); exit (0);
+#else
+  printf ("vax-dec-ultrix\n"); exit (0);
+#endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm $dummy.c $dummy && exit 0
+rm -f $dummy.c $dummy
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+    case `getsysinfo -f cpu_type` in
+    c1*)
+       echo c1-convex-bsd
+       exit 0 ;;
+    c2*)
+       if getsysinfo -f scalar_acc
+       then echo c32-convex-bsd
+       else echo c2-convex-bsd
+       fi
+       exit 0 ;;
+    c34*)
+       echo c34-convex-bsd
+       exit 0 ;;
+    c38*)
+       echo c38-convex-bsd
+       exit 0 ;;
+    c4*)
+       echo c4-convex-bsd
+       exit 0 ;;
+    esac
+fi
+
+#echo '(Unable to guess system type)' 1>&2
+
+exit 1
diff --git a/pcre/config.in b/pcre/config.in
new file mode 100644 (file)
index 0000000..02f4259
--- /dev/null
@@ -0,0 +1,33 @@
+
+/* On Unix systems config.in is converted by configure into config.h. PCRE is
+written in Standard C, but there are a few non-standard things it can cope
+with, allowing it to run on SunOS4 and other "close to standard" systems.
+
+On a non-Unix system you should just copy this file into config.h and change
+the definitions of HAVE_STRERROR and HAVE_MEMMOVE to 1. Unfortunately, because
+of the way autoconf works, these cannot be made the defaults. If your system
+has bcopy() and not memmove(), change the definition of HAVE_BCOPY instead of
+HAVE_MEMMOVE. If your system has neither bcopy() nor memmove(), leave them both
+as 0; an emulation function will be used. */
+
+/* Define to empty if the keyword does not work. */
+
+#undef const
+
+/* Define to `unsigned' if <stddef.h> doesn't define size_t. */
+
+#undef size_t
+
+/* The following two definitions are mainly for the benefit of SunOS4, which
+doesn't have the strerror() or memmove() functions that should be present in
+all Standard C libraries. The macros HAVE_STRERROR and HAVE_MEMMOVE should
+normally be defined with the value 1 for other systems, but unfortunately we
+can't make this the default because "configure" files generated by autoconf
+will only change 0 to 1; they won't change 1 to 0 if the functions are not
+found. If HAVE_MEMMOVE is set to 1, the value of HAVE_BCOPY is not relevant. */
+
+#define HAVE_STRERROR 0
+#define HAVE_MEMMOVE  0
+#define HAVE_BCOPY    0
+
+/* End */
diff --git a/pcre/config.sub b/pcre/config.sub
new file mode 100644 (file)
index 0000000..28426bb
--- /dev/null
@@ -0,0 +1,1232 @@
+#! /bin/sh
+# Configuration validation subroutine script, version 1.1.
+#   Copyright (C) 1991, 92-97, 1998, 1999 Free Software Foundation, Inc.
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#      CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#      CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+if [ x$1 = x ]
+then
+       echo Configuration name missing. 1>&2
+       echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
+       echo "or     $0 ALIAS" 1>&2
+       echo where ALIAS is a recognized configuration type. 1>&2
+       exit 1
+fi
+
+# First pass through any local machine types.
+case $1 in
+       *local*)
+               echo $1
+               exit 0
+               ;;
+       *)
+       ;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  linux-gnu*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+       -sun*os*)
+               # Prevent following clause from handling this invalid input.
+               ;;
+       -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+       -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+       -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+       -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+       -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+       -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+       -apple)
+               os=
+               basic_machine=$1
+               ;;
+       -sim | -cisco | -oki | -wec | -winbond)
+               os=
+               basic_machine=$1
+               ;;
+       -scout)
+               ;;
+       -wrs)
+               os=-vxworks
+               basic_machine=$1
+               ;;
+       -hiux*)
+               os=-hiuxwe2
+               ;;
+       -sco5)
+               os=-sco3.2v5
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -sco4)
+               os=-sco3.2v4
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -sco3.2.[4-9]*)
+               os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -sco3.2v[4-9]*)
+               # Don't forget version if it is 3.2v4 or newer.
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -sco*)
+               os=-sco3.2v2
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -udk*)
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -isc)
+               os=-isc2.2
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -clix*)
+               basic_machine=clipper-intergraph
+               ;;
+       -isc*)
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+               ;;
+       -lynx*)
+               os=-lynxos
+               ;;
+       -ptx*)
+               basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+               ;;
+       -windowsnt*)
+               os=`echo $os | sed -e 's/windowsnt/winnt/'`
+               ;;
+       -psos*)
+               os=-psos
+               ;;
+       -mint | -mint[0-9]*)
+               basic_machine=m68k-atari
+               os=-mint
+               ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+       # Recognize the basic CPU types without company name.
+       # Some are omitted here because they have special meanings below.
+       tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
+               | arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
+               | 580 | i960 | h8300 \
+               | hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
+               | alpha | alphaev[4-7] | alphaev56 | alphapca5[67] \
+               | we32k | ns16k | clipper | i370 | sh | powerpc | powerpcle \
+               | 1750a | dsp16xx | pdp11 | mips16 | mips64 | mipsel | mips64el \
+               | mips64orion | mips64orionel | mipstx39 | mipstx39el \
+               | mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
+               | mips64vr5000 | miprs64vr5000el | mcore \
+               | sparc | sparclet | sparclite | sparc64 | sparcv9 | v850 | c4x \
+               | thumb | d10v | fr30)
+               basic_machine=$basic_machine-unknown
+               ;;
+       m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | h8500 | w65 | pj | pjl)
+               ;;
+
+       # We use `pc' rather than `unknown'
+       # because (1) that's what they normally are, and
+       # (2) the word "unknown" tends to confuse beginning users.
+       i[34567]86)
+         basic_machine=$basic_machine-pc
+         ;;
+       # Object if more than one company name word.
+       *-*-*)
+               echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+               exit 1
+               ;;
+       # Recognize the basic CPU types with company name.
+       # FIXME: clean up the formatting here.
+       vax-* | tahoe-* | i[34567]86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
+             | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
+             | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
+             | power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
+             | xmp-* | ymp-* \
+             | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* | hppa2.0n-* \
+             | alpha-* | alphaev[4-7]-* | alphaev56-* | alphapca5[67]-* \
+             | we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
+             | clipper-* | orion-* \
+             | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
+             | sparc64-* | sparcv9-* | sparc86x-* | mips16-* | mips64-* | mipsel-* \
+             | mips64el-* | mips64orion-* | mips64orionel-* \
+             | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
+             | mipstx39-* | mipstx39el-* | mcore-* \
+             | f301-* | armv*-* | t3e-* \
+             | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
+             | thumb-* | v850-* | d30v-* | tic30-* | c30-* | fr30-* )
+               ;;
+       # Recognize the various machine names and aliases which stand
+       # for a CPU type and a company and sometimes even an OS.
+       386bsd)
+               basic_machine=i386-unknown
+               os=-bsd
+               ;;
+       3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+               basic_machine=m68000-att
+               ;;
+       3b*)
+               basic_machine=we32k-att
+               ;;
+       a29khif)
+               basic_machine=a29k-amd
+               os=-udi
+               ;;
+       adobe68k)
+               basic_machine=m68010-adobe
+               os=-scout
+               ;;
+       alliant | fx80)
+               basic_machine=fx80-alliant
+               ;;
+       altos | altos3068)
+               basic_machine=m68k-altos
+               ;;
+       am29k)
+               basic_machine=a29k-none
+               os=-bsd
+               ;;
+       amdahl)
+               basic_machine=580-amdahl
+               os=-sysv
+               ;;
+       amiga | amiga-*)
+               basic_machine=m68k-cbm
+               ;;
+       amigaos | amigados)
+               basic_machine=m68k-cbm
+               os=-amigaos
+               ;;
+       amigaunix | amix)
+               basic_machine=m68k-cbm
+               os=-sysv4
+               ;;
+       apollo68)
+               basic_machine=m68k-apollo
+               os=-sysv
+               ;;
+       apollo68bsd)
+               basic_machine=m68k-apollo
+               os=-bsd
+               ;;
+       aux)
+               basic_machine=m68k-apple
+               os=-aux
+               ;;
+       balance)
+               basic_machine=ns32k-sequent
+               os=-dynix
+               ;;
+       convex-c1)
+               basic_machine=c1-convex
+               os=-bsd
+               ;;
+       convex-c2)
+               basic_machine=c2-convex
+               os=-bsd
+               ;;
+       convex-c32)
+               basic_machine=c32-convex
+               os=-bsd
+               ;;
+       convex-c34)
+               basic_machine=c34-convex
+               os=-bsd
+               ;;
+       convex-c38)
+               basic_machine=c38-convex
+               os=-bsd
+               ;;
+       cray | ymp)
+               basic_machine=ymp-cray
+               os=-unicos
+               ;;
+       cray2)
+               basic_machine=cray2-cray
+               os=-unicos
+               ;;
+       [ctj]90-cray)
+               basic_machine=c90-cray
+               os=-unicos
+               ;;
+       crds | unos)
+               basic_machine=m68k-crds
+               ;;
+       da30 | da30-*)
+               basic_machine=m68k-da30
+               ;;
+       decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+               basic_machine=mips-dec
+               ;;
+       delta | 3300 | motorola-3300 | motorola-delta \
+             | 3300-motorola | delta-motorola)
+               basic_machine=m68k-motorola
+               ;;
+       delta88)
+               basic_machine=m88k-motorola
+               os=-sysv3
+               ;;
+       dpx20 | dpx20-*)
+               basic_machine=rs6000-bull
+               os=-bosx
+               ;;
+       dpx2* | dpx2*-bull)
+               basic_machine=m68k-bull
+               os=-sysv3
+               ;;
+       ebmon29k)
+               basic_machine=a29k-amd
+               os=-ebmon
+               ;;
+       elxsi)
+               basic_machine=elxsi-elxsi
+               os=-bsd
+               ;;
+       encore | umax | mmax)
+               basic_machine=ns32k-encore
+               ;;
+       es1800 | OSE68k | ose68k | ose | OSE)
+               basic_machine=m68k-ericsson
+               os=-ose
+               ;;
+       fx2800)
+               basic_machine=i860-alliant
+               ;;
+       genix)
+               basic_machine=ns32k-ns
+               ;;
+       gmicro)
+               basic_machine=tron-gmicro
+               os=-sysv
+               ;;
+       h3050r* | hiux*)
+               basic_machine=hppa1.1-hitachi
+               os=-hiuxwe2
+               ;;
+       h8300hms)
+               basic_machine=h8300-hitachi
+               os=-hms
+               ;;
+       h8300xray)
+               basic_machine=h8300-hitachi
+               os=-xray
+               ;;
+       h8500hms)
+               basic_machine=h8500-hitachi
+               os=-hms
+               ;;
+       harris)
+               basic_machine=m88k-harris
+               os=-sysv3
+               ;;
+       hp300-*)
+               basic_machine=m68k-hp
+               ;;
+       hp300bsd)
+               basic_machine=m68k-hp
+               os=-bsd
+               ;;
+       hp300hpux)
+               basic_machine=m68k-hp
+               os=-hpux
+               ;;
+       hp3k9[0-9][0-9] | hp9[0-9][0-9])
+               basic_machine=hppa1.0-hp
+               ;;
+       hp9k2[0-9][0-9] | hp9k31[0-9])
+               basic_machine=m68000-hp
+               ;;
+       hp9k3[2-9][0-9])
+               basic_machine=m68k-hp
+               ;;
+       hp9k6[0-9][0-9] | hp6[0-9][0-9])
+               basic_machine=hppa1.0-hp
+               ;;
+       hp9k7[0-79][0-9] | hp7[0-79][0-9])
+               basic_machine=hppa1.1-hp
+               ;;
+       hp9k78[0-9] | hp78[0-9])
+               # FIXME: really hppa2.0-hp
+               basic_machine=hppa1.1-hp
+               ;;
+       hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+               # FIXME: really hppa2.0-hp
+               basic_machine=hppa1.1-hp
+               ;;
+       hp9k8[0-9][13679] | hp8[0-9][13679])
+               basic_machine=hppa1.1-hp
+               ;;
+       hp9k8[0-9][0-9] | hp8[0-9][0-9])
+               basic_machine=hppa1.0-hp
+               ;;
+       hppa-next)
+               os=-nextstep3
+               ;;
+       hppaosf)
+               basic_machine=hppa1.1-hp
+               os=-osf
+               ;;
+       hppro)
+               basic_machine=hppa1.1-hp
+               os=-proelf
+               ;;
+       i370-ibm* | ibm*)
+               basic_machine=i370-ibm
+               ;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+       i[34567]86v32)
+               basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+               os=-sysv32
+               ;;
+       i[34567]86v4*)
+               basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+               os=-sysv4
+               ;;
+       i[34567]86v)
+               basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+               os=-sysv
+               ;;
+       i[34567]86sol2)
+               basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+               os=-solaris2
+               ;;
+       i386mach)
+               basic_machine=i386-mach
+               os=-mach
+               ;;
+       i386-vsta | vsta)
+               basic_machine=i386-unknown
+               os=-vsta
+               ;;
+       i386-go32 | go32)
+               basic_machine=i386-unknown
+               os=-go32
+               ;;
+       i386-mingw32 | mingw32)
+               basic_machine=i386-unknown
+               os=-mingw32
+               ;;
+       i386-qnx | qnx)
+               basic_machine=i386-qnx
+               ;;
+       iris | iris4d)
+               basic_machine=mips-sgi
+               case $os in
+                   -irix*)
+                       ;;
+                   *)
+                       os=-irix4
+                       ;;
+               esac
+               ;;
+       isi68 | isi)
+               basic_machine=m68k-isi
+               os=-sysv
+               ;;
+       m88k-omron*)
+               basic_machine=m88k-omron
+               ;;
+       magnum | m3230)
+               basic_machine=mips-mips
+               os=-sysv
+               ;;
+       merlin)
+               basic_machine=ns32k-utek
+               os=-sysv
+               ;;
+       miniframe)
+               basic_machine=m68000-convergent
+               ;;
+       *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+               basic_machine=m68k-atari
+               os=-mint
+               ;;
+       mipsel*-linux*)
+               basic_machine=mipsel-unknown
+               os=-linux-gnu
+               ;;
+       mips*-linux*)
+               basic_machine=mips-unknown
+               os=-linux-gnu
+               ;;
+       mips3*-*)
+               basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+               ;;
+       mips3*)
+               basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+               ;;
+       monitor)
+               basic_machine=m68k-rom68k
+               os=-coff
+               ;;
+       msdos)
+               basic_machine=i386-unknown
+               os=-msdos
+               ;;
+       mvs)
+               basic_machine=i370-ibm
+               os=-mvs
+               ;;
+       ncr3000)
+               basic_machine=i486-ncr
+               os=-sysv4
+               ;;
+       netbsd386)
+               basic_machine=i386-unknown
+               os=-netbsd
+               ;;
+       netwinder)
+               basic_machine=armv4l-rebel
+               os=-linux
+               ;;
+       news | news700 | news800 | news900)
+               basic_machine=m68k-sony
+               os=-newsos
+               ;;
+       news1000)
+               basic_machine=m68030-sony
+               os=-newsos
+               ;;
+       news-3600 | risc-news)
+               basic_machine=mips-sony
+               os=-newsos
+               ;;
+       necv70)
+               basic_machine=v70-nec
+               os=-sysv
+               ;;
+       next | m*-next )
+               basic_machine=m68k-next
+               case $os in
+                   -nextstep* )
+                       ;;
+                   -ns2*)
+                     os=-nextstep2
+                       ;;
+                   *)
+                     os=-nextstep3
+                       ;;
+               esac
+               ;;
+       nh3000)
+               basic_machine=m68k-harris
+               os=-cxux
+               ;;
+       nh[45]000)
+               basic_machine=m88k-harris
+               os=-cxux
+               ;;
+       nindy960)
+               basic_machine=i960-intel
+               os=-nindy
+               ;;
+       mon960)
+               basic_machine=i960-intel
+               os=-mon960
+               ;;
+       np1)
+               basic_machine=np1-gould
+               ;;
+       op50n-* | op60c-*)
+               basic_machine=hppa1.1-oki
+               os=-proelf
+               ;;
+       OSE68000 | ose68000)
+               basic_machine=m68000-ericsson
+               os=-ose
+               ;;
+       os68k)
+               basic_machine=m68k-none
+               os=-os68k
+               ;;
+       pa-hitachi)
+               basic_machine=hppa1.1-hitachi
+               os=-hiuxwe2
+               ;;
+       paragon)
+               basic_machine=i860-intel
+               os=-osf
+               ;;
+       pbd)
+               basic_machine=sparc-tti
+               ;;
+       pbb)
+               basic_machine=m68k-tti
+               ;;
+        pc532 | pc532-*)
+               basic_machine=ns32k-pc532
+               ;;
+       pentium | p5 | k5 | k6 | nexen)
+               basic_machine=i586-pc
+               ;;
+       pentiumpro | p6 | 6x86)
+               basic_machine=i686-pc
+               ;;
+       pentiumii | pentium2)
+               basic_machine=i786-pc
+               ;;
+       pentium-* | p5-* | k5-* | k6-* | nexen-*)
+               basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+               ;;
+       pentiumpro-* | p6-* | 6x86-*)
+               basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+               ;;
+       pentiumii-* | pentium2-*)
+               basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+               ;;
+       pn)
+               basic_machine=pn-gould
+               ;;
+       power)  basic_machine=rs6000-ibm
+               ;;
+       ppc)    basic_machine=powerpc-unknown
+               ;;
+       ppc-*)  basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+               ;;
+       ppcle | powerpclittle | ppc-le | powerpc-little)
+               basic_machine=powerpcle-unknown
+               ;;
+       ppcle-* | powerpclittle-*)
+               basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+               ;;
+       ps2)
+               basic_machine=i386-ibm
+               ;;
+       rom68k)
+               basic_machine=m68k-rom68k
+               os=-coff
+               ;;
+       rm[46]00)
+               basic_machine=mips-siemens
+               ;;
+       rtpc | rtpc-*)
+               basic_machine=romp-ibm
+               ;;
+       sa29200)
+               basic_machine=a29k-amd
+               os=-udi
+               ;;
+       sequent)
+               basic_machine=i386-sequent
+               ;;
+       sh)
+               basic_machine=sh-hitachi
+               os=-hms
+               ;;
+       sparclite-wrs)
+               basic_machine=sparclite-wrs
+               os=-vxworks
+               ;;
+       sps7)
+               basic_machine=m68k-bull
+               os=-sysv2
+               ;;
+       spur)
+               basic_machine=spur-unknown
+               ;;
+       st2000)
+               basic_machine=m68k-tandem
+               ;;
+       stratus)
+               basic_machine=i860-stratus
+               os=-sysv4
+               ;;
+       sun2)
+               basic_machine=m68000-sun
+               ;;
+       sun2os3)
+               basic_machine=m68000-sun
+               os=-sunos3
+               ;;
+       sun2os4)
+               basic_machine=m68000-sun
+               os=-sunos4
+               ;;
+       sun3os3)
+               basic_machine=m68k-sun
+               os=-sunos3
+               ;;
+       sun3os4)
+               basic_machine=m68k-sun
+               os=-sunos4
+               ;;
+       sun4os3)
+               basic_machine=sparc-sun
+               os=-sunos3
+               ;;
+       sun4os4)
+               basic_machine=sparc-sun
+               os=-sunos4
+               ;;
+       sun4sol2)
+               basic_machine=sparc-sun
+               os=-solaris2
+               ;;
+       sun3 | sun3-*)
+               basic_machine=m68k-sun
+               ;;
+       sun4)
+               basic_machine=sparc-sun
+               ;;
+       sun386 | sun386i | roadrunner)
+               basic_machine=i386-sun
+               ;;
+       symmetry)
+               basic_machine=i386-sequent
+               os=-dynix
+               ;;
+       t3e)
+               basic_machine=t3e-cray
+               os=-unicos
+               ;;
+       tx39)
+               basic_machine=mipstx39-unknown
+               ;;
+       tx39el)
+               basic_machine=mipstx39el-unknown
+               ;;
+       tower | tower-32)
+               basic_machine=m68k-ncr
+               ;;
+       udi29k)
+               basic_machine=a29k-amd
+               os=-udi
+               ;;
+       ultra3)
+               basic_machine=a29k-nyu
+               os=-sym1
+               ;;
+       v810 | necv810)
+               basic_machine=v810-nec
+               os=-none
+               ;;
+       vaxv)
+               basic_machine=vax-dec
+               os=-sysv
+               ;;
+       vms)
+               basic_machine=vax-dec
+               os=-vms
+               ;;
+       vpp*|vx|vx-*)
+               basic_machine=f301-fujitsu
+               ;;
+       vxworks960)
+               basic_machine=i960-wrs
+               os=-vxworks
+               ;;
+       vxworks68)
+               basic_machine=m68k-wrs
+               os=-vxworks
+               ;;
+       vxworks29k)
+               basic_machine=a29k-wrs
+               os=-vxworks
+               ;;
+       w65*)
+               basic_machine=w65-wdc
+               os=-none
+               ;;
+       w89k-*)
+               basic_machine=hppa1.1-winbond
+               os=-proelf
+               ;;
+       xmp)
+               basic_machine=xmp-cray
+               os=-unicos
+               ;;
+        xps | xps100)
+               basic_machine=xps100-honeywell
+               ;;
+       z8k-*-coff)
+               basic_machine=z8k-unknown
+               os=-sim
+               ;;
+       none)
+               basic_machine=none-none
+               os=-none
+               ;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+       w89k)
+               basic_machine=hppa1.1-winbond
+               ;;
+       op50n)
+               basic_machine=hppa1.1-oki
+               ;;
+       op60c)
+               basic_machine=hppa1.1-oki
+               ;;
+       mips)
+               if [ x$os = x-linux-gnu ]; then
+                       basic_machine=mips-unknown
+               else
+                       basic_machine=mips-mips
+               fi
+               ;;
+       romp)
+               basic_machine=romp-ibm
+               ;;
+       rs6000)
+               basic_machine=rs6000-ibm
+               ;;
+       vax)
+               basic_machine=vax-dec
+               ;;
+       pdp11)
+               basic_machine=pdp11-dec
+               ;;
+       we32k)
+               basic_machine=we32k-att
+               ;;
+       sparc | sparcv9)
+               basic_machine=sparc-sun
+               ;;
+        cydra)
+               basic_machine=cydra-cydrome
+               ;;
+       orion)
+               basic_machine=orion-highlevel
+               ;;
+       orion105)
+               basic_machine=clipper-highlevel
+               ;;
+       mac | mpw | mac-mpw)
+               basic_machine=m68k-apple
+               ;;
+       pmac | pmac-mpw)
+               basic_machine=powerpc-apple
+               ;;
+       c4x*)
+               basic_machine=c4x-none
+               os=-coff
+               ;;
+       *)
+               echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+               exit 1
+               ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+       *-digital*)
+               basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+               ;;
+       *-commodore*)
+               basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+               ;;
+       *)
+               ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+       # -solaris* is a basic system type, with this one exception.
+       -solaris1 | -solaris1.*)
+               os=`echo $os | sed -e 's|solaris1|sunos4|'`
+               ;;
+       -solaris)
+               os=-solaris2
+               ;;
+       -svr4*)
+               os=-sysv4
+               ;;
+       -unixware*)
+               os=-sysv4.2uw
+               ;;
+       -gnu/linux*)
+               os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+               ;;
+       # First accept the basic system types.
+       # The portable systems comes first.
+       # Each alternative MUST END IN A *, to match a version number.
+       # -sysv* is not here because it comes later, after sysvr4.
+       -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+             | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+             | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+             | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+             | -aos* \
+             | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+             | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+             | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
+             | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+             | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+             | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+             | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+             | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
+             | -interix* | -uwin* | -rhapsody* | -opened* | -openstep* | -oskit*)
+       # Remember, each alternative MUST END IN *, to match a version number.
+               ;;
+       -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+             | -windows* | -osx | -abug | -netware* | -os9* | -beos* \
+             | -macos* | -mpw* | -magic* | -mon960* | -lnews*)
+               ;;
+       -mac*)
+               os=`echo $os | sed -e 's|mac|macos|'`
+               ;;
+       -linux*)
+               os=`echo $os | sed -e 's|linux|linux-gnu|'`
+               ;;
+       -sunos5*)
+               os=`echo $os | sed -e 's|sunos5|solaris2|'`
+               ;;
+       -sunos6*)
+               os=`echo $os | sed -e 's|sunos6|solaris3|'`
+               ;;
+       -opened*)
+               os=-openedition
+               ;;
+       -osfrose*)
+               os=-osfrose
+               ;;
+       -osf*)
+               os=-osf
+               ;;
+       -utek*)
+               os=-bsd
+               ;;
+       -dynix*)
+               os=-bsd
+               ;;
+       -acis*)
+               os=-aos
+               ;;
+       -386bsd)
+               os=-bsd
+               ;;
+       -ctix* | -uts*)
+               os=-sysv
+               ;;
+       -ns2 )
+               os=-nextstep2
+               ;;
+       # Preserve the version number of sinix5.
+       -sinix5.*)
+               os=`echo $os | sed -e 's|sinix|sysv|'`
+               ;;
+       -sinix*)
+               os=-sysv4
+               ;;
+       -triton*)
+               os=-sysv3
+               ;;
+       -oss*)
+               os=-sysv3
+               ;;
+        -qnx)
+               os=-qnx4
+               ;;
+       -svr4)
+               os=-sysv4
+               ;;
+       -svr3)
+               os=-sysv3
+               ;;
+       -sysvr4)
+               os=-sysv4
+               ;;
+       # This must come after -sysvr4.
+       -sysv*)
+               ;;
+       -ose*)
+               os=-ose
+               ;;
+       -es1800*)
+               os=-ose
+               ;;
+       -xenix)
+               os=-xenix
+               ;;
+        -*mint | -*MiNT)
+               os=-mint
+               ;;
+       -none)
+               ;;
+       *)
+               # Get rid of the `-' at the beginning of $os.
+               os=`echo $os | sed 's/[^-]*-//'`
+               echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+               exit 1
+               ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+       *-acorn)
+               os=-riscix1.2
+               ;;
+       arm*-rebel)
+               os=-linux
+               ;;
+       arm*-semi)
+               os=-aout
+               ;;
+        pdp11-*)
+               os=-none
+               ;;
+       *-dec | vax-*)
+               os=-ultrix4.2
+               ;;
+       m68*-apollo)
+               os=-domain
+               ;;
+       i386-sun)
+               os=-sunos4.0.2
+               ;;
+       m68000-sun)
+               os=-sunos3
+               # This also exists in the configure program, but was not the
+               # default.
+               # os=-sunos4
+               ;;
+       m68*-cisco)
+               os=-aout
+               ;;
+       mips*-cisco)
+               os=-elf
+               ;;
+       mips*-*)
+               os=-elf
+               ;;
+       *-tti)  # must be before sparc entry or we get the wrong os.
+               os=-sysv3
+               ;;
+       sparc-* | *-sun)
+               os=-sunos4.1.1
+               ;;
+       *-be)
+               os=-beos
+               ;;
+       *-ibm)
+               os=-aix
+               ;;
+       *-wec)
+               os=-proelf
+               ;;
+       *-winbond)
+               os=-proelf
+               ;;
+       *-oki)
+               os=-proelf
+               ;;
+       *-hp)
+               os=-hpux
+               ;;
+       *-hitachi)
+               os=-hiux
+               ;;
+       i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+               os=-sysv
+               ;;
+       *-cbm)
+               os=-amigaos
+               ;;
+       *-dg)
+               os=-dgux
+               ;;
+       *-dolphin)
+               os=-sysv3
+               ;;
+       m68k-ccur)
+               os=-rtu
+               ;;
+       m88k-omron*)
+               os=-luna
+               ;;
+       *-next )
+               os=-nextstep
+               ;;
+       *-sequent)
+               os=-ptx
+               ;;
+       *-crds)
+               os=-unos
+               ;;
+       *-ns)
+               os=-genix
+               ;;
+       i370-*)
+               os=-mvs
+               ;;
+       *-next)
+               os=-nextstep3
+               ;;
+        *-gould)
+               os=-sysv
+               ;;
+        *-highlevel)
+               os=-bsd
+               ;;
+       *-encore)
+               os=-bsd
+               ;;
+        *-sgi)
+               os=-irix
+               ;;
+        *-siemens)
+               os=-sysv4
+               ;;
+       *-masscomp)
+               os=-rtu
+               ;;
+       f301-fujitsu)
+               os=-uxpv
+               ;;
+       *-rom68k)
+               os=-coff
+               ;;
+       *-*bug)
+               os=-coff
+               ;;
+       *-apple)
+               os=-macos
+               ;;
+       *-atari*)
+               os=-mint
+               ;;
+       *)
+               os=-none
+               ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+       *-unknown)
+               case $os in
+                       -riscix*)
+                               vendor=acorn
+                               ;;
+                       -sunos*)
+                               vendor=sun
+                               ;;
+                       -aix*)
+                               vendor=ibm
+                               ;;
+                       -beos*)
+                               vendor=be
+                               ;;
+                       -hpux*)
+                               vendor=hp
+                               ;;
+                       -mpeix*)
+                               vendor=hp
+                               ;;
+                       -hiux*)
+                               vendor=hitachi
+                               ;;
+                       -unos*)
+                               vendor=crds
+                               ;;
+                       -dgux*)
+                               vendor=dg
+                               ;;
+                       -luna*)
+                               vendor=omron
+                               ;;
+                       -genix*)
+                               vendor=ns
+                               ;;
+                       -mvs* | -opened*)
+                               vendor=ibm
+                               ;;
+                       -ptx*)
+                               vendor=sequent
+                               ;;
+                       -vxsim* | -vxworks*)
+                               vendor=wrs
+                               ;;
+                       -aux*)
+                               vendor=apple
+                               ;;
+                       -hms*)
+                               vendor=hitachi
+                               ;;
+                       -mpw* | -macos*)
+                               vendor=apple
+                               ;;
+                       -*mint | -*MiNT)
+                               vendor=atari
+                               ;;
+               esac
+               basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+               ;;
+esac
+
+echo $basic_machine$os
diff --git a/pcre/configure b/pcre/configure
new file mode 100644 (file)
index 0000000..fbd3831
--- /dev/null
@@ -0,0 +1,1568 @@
+#! /bin/sh
+
+# Guess values for system-dependent variables and create Makefiles.
+# Generated automatically using autoconf version 2.13 
+# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+
+# Defaults:
+ac_help=
+ac_default_prefix=/usr/local
+# Any additions from configure.in:
+ac_help="$ac_help
+  --disable-shared        build PCRE as a static library"
+ac_help="$ac_help
+  --enable-utf8           enable UTF8 support (incomplete)"
+
+# Initialize some variables set by options.
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+build=NONE
+cache_file=./config.cache
+exec_prefix=NONE
+host=NONE
+no_create=
+nonopt=NONE
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+target=NONE
+verbose=
+x_includes=NONE
+x_libraries=NONE
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datadir='${prefix}/share'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+libdir='${exec_prefix}/lib'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+infodir='${prefix}/info'
+mandir='${prefix}/man'
+
+# Initialize some other variables.
+subdirs=
+MFLAGS= MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+# Maximum number of lines to put in a shell here document.
+ac_max_here_lines=12
+
+ac_prev=
+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=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) ac_optarg= ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case "$ac_option" in
+
+  -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 ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build="$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" ;;
+
+  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+  | --da=*)
+    datadir="$ac_optarg" ;;
+
+  -disable-* | --disable-*)
+    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
+      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
+    fi
+    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
+    eval "enable_${ac_feature}=no" ;;
+
+  -enable-* | --enable-*)
+    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
+      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
+    fi
+    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
+    case "$ac_option" in
+      *=*) ;;
+      *) ac_optarg=yes ;;
+    esac
+    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)
+    # Omit some internal or obsolete options to make the list less imposing.
+    # The list generated by autoconf has been trimmed to remove many
+    # options that are totally irrelevant to PCRE (e.g. relating to X),
+    # or are not supported by its Makefile.
+    # The list generated by autoconf has been trimmed to remove many
+    # options that are totally irrelevant to PCRE (e.g. relating to X),
+    # or are not supported by its Makefile.
+    # The list generated by autoconf has been trimmed to remove many
+    # options that are totally irrelevant to PCRE (e.g. relating to X),
+    # or are not supported by its Makefile.
+    # This message is too long to be a string in the A/UX 3.1 sh.
+    cat << EOF
+Usage: ./configure [options]
+Options: [defaults in brackets after descriptions]
+Configuration:
+  --cache-file=FILE       cache test results in FILE
+  --help                  print this message
+  --no-create             do not create output files
+  --quiet, --silent       do not print \`checking...' messages
+  --version               print the version of autoconf that created configure
+Directory and file names:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [same as prefix]
+  --bindir=DIR            user executables in DIR [EPREFIX/bin]
+  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
+  --includedir=DIR        C header files in DIR [PREFIX/include]
+  --mandir=DIR            man documentation in DIR [PREFIX/man]
+EOF
+    cat << EOF
+EOF
+    if test -n "$ac_help"; then
+      echo "--enable and --with options recognized:$ac_help"
+    fi
+    exit 0 ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host="$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" ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst \
+  | --locals | --local | --loca | --loc | --lo)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+    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)
+    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" ;;
+
+  -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 ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target="$ac_optarg" ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers)
+    echo "configure generated by autoconf version 2.13"
+    exit 0 ;;
+
+  -with-* | --with-*)
+    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
+      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
+    fi
+    ac_package=`echo $ac_package| sed 's/-/_/g'`
+    case "$ac_option" in
+      *=*) ;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "with_${ac_package}='$ac_optarg'" ;;
+
+  -without-* | --without-*)
+    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
+      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
+    fi
+    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 "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
+    ;;
+
+  *)
+    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
+      echo "configure: warning: $ac_option: invalid host type" 1>&2
+    fi
+    if test "x$nonopt" != xNONE; then
+      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
+    fi
+    nonopt="$ac_option"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
+fi
+
+trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
+
+# File descriptor usage:
+# 0 standard input
+# 1 file creation
+# 2 errors and warnings
+# 3 some systems may open it to /dev/tty
+# 4 used on the Kubota Titan
+# 6 checking for... messages and results
+# 5 compiler messages saved in config.log
+if test "$silent" = yes; then
+  exec 6>/dev/null
+else
+  exec 6>&1
+fi
+exec 5>./config.log
+
+echo "\
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+" 1>&5
+
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Also quote any args containing shell metacharacters.
+ac_configure_args=
+for ac_arg
+do
+  case "$ac_arg" in
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c) ;;
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
+  *" "*|*"     "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
+  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
+  esac
+done
+
+# NLS nuisances.
+# Only set these to C if already set.  These must not be set unconditionally
+# because not all systems understand e.g. LANG=C (notably SCO).
+# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
+# Non-C LC_CTYPE values break the ctype check.
+if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
+if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
+if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
+if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -rf conftest* confdefs.h
+# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+echo > confdefs.h
+
+# A filename unique to this package, relative to the directory that
+# configure is in, which we can look for to find out if srcdir is correct.
+ac_unique_file=dftables.c
+
+# 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 its parent.
+  ac_prog=$0
+  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
+  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
+  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
+  if test "$ac_srcdir_defaulted" = yes; then
+    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
+  else
+    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
+  fi
+fi
+srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
+
+# Prefer explicitly selected file to automatically selected ones.
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+  fi
+fi
+for ac_site_file in $CONFIG_SITE; do
+  if test -r "$ac_site_file"; then
+    echo "loading site script $ac_site_file"
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  echo "loading cache $cache_file"
+  . $cache_file
+else
+  echo "creating cache $cache_file"
+  > $cache_file
+fi
+
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+ac_exeext=
+ac_objext=o
+if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
+  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
+  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
+    ac_n= ac_c='
+' ac_t='       '
+  else
+    ac_n=-n ac_c= ac_t=
+  fi
+else
+  ac_n= ac_c='\c' ac_t=
+fi
+
+
+
+
+
+
+PCRE_MAJOR=3
+PCRE_MINOR=4
+PCRE_DATE=22-Aug-2000
+PCRE_VERSION=${PCRE_MAJOR}.${PCRE_MINOR}
+
+
+PCRE_LIB_VERSION=0:1:0
+PCRE_POSIXLIB_VERSION=0:0:0
+
+
+# Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:546: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="gcc"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+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 $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:576: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_prog_rejected=no
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+       continue
+      fi
+      ac_cv_prog_CC="cc"
+      break
+    fi
+  done
+  IFS="$ac_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 $# -gt 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
+    set dummy "$ac_dir/$ac_word" "$@"
+    shift
+    ac_cv_prog_CC="$@"
+  fi
+fi
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+  if test -z "$CC"; then
+    case "`uname -s`" in
+    *win32* | *WIN32*)
+      # Extract the first word of "cl", so it can be a program name with args.
+set dummy cl; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:627: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="cl"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+ ;;
+    esac
+  fi
+  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
+fi
+
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
+echo "configure:659: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+cat > conftest.$ac_ext << EOF
+
+#line 670 "configure"
+#include "confdefs.h"
+
+main(){return(0);}
+EOF
+if { (eval echo configure:675: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  ac_cv_prog_cc_works=yes
+  # If we can't run a trivial program, we are probably using a cross compiler.
+  if (./conftest; exit) 2>/dev/null; then
+    ac_cv_prog_cc_cross=no
+  else
+    ac_cv_prog_cc_cross=yes
+  fi
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  ac_cv_prog_cc_works=no
+fi
+rm -fr conftest*
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
+if test $ac_cv_prog_cc_works = no; then
+  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
+fi
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
+echo "configure:701: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
+echo "configure:706: checking whether we are using GNU C" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.c <<EOF
+#ifdef __GNUC__
+  yes;
+#endif
+EOF
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:715: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+  ac_cv_prog_gcc=yes
+else
+  ac_cv_prog_gcc=no
+fi
+fi
+
+echo "$ac_t""$ac_cv_prog_gcc" 1>&6
+
+if test $ac_cv_prog_gcc = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+
+ac_test_CFLAGS="${CFLAGS+set}"
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS=
+echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
+echo "configure:734: checking whether ${CC-cc} accepts -g" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  echo 'void f(){}' > conftest.c
+if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
+  ac_cv_prog_cc_g=yes
+else
+  ac_cv_prog_cc_g=no
+fi
+rm -f conftest*
+
+fi
+
+echo "$ac_t""$ac_cv_prog_cc_g" 1>&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
+
+# Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:768: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+  IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_RANLIB="ranlib"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
+fi
+fi
+RANLIB="$ac_cv_prog_RANLIB"
+if test -n "$RANLIB"; then
+  echo "$ac_t""$RANLIB" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+
+
+echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
+echo "configure:798: checking how to run the C preprocessor" >&5
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+    # This must be in double quotes, not single quotes, because CPP may get
+  # substituted into the Makefile and "${CC-cc}" will confuse make.
+  CPP="${CC-cc} -E"
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp.
+  cat > conftest.$ac_ext <<EOF
+#line 813 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:819: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP="${CC-cc} -E -traditional-cpp"
+  cat > conftest.$ac_ext <<EOF
+#line 830 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:836: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP="${CC-cc} -nologo -E"
+  cat > conftest.$ac_ext <<EOF
+#line 847 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:853: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP=/lib/cpp
+fi
+rm -f conftest*
+fi
+rm -f conftest*
+fi
+rm -f conftest*
+  ac_cv_prog_CPP="$CPP"
+fi
+  CPP="$ac_cv_prog_CPP"
+else
+  ac_cv_prog_CPP="$CPP"
+fi
+echo "$ac_t""$CPP" 1>&6
+
+echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
+echo "configure:878: checking for ANSI C header files" >&5
+if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 883 "configure"
+#include "confdefs.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:891: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  ac_cv_header_stdc=yes
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+cat > conftest.$ac_ext <<EOF
+#line 908 "configure"
+#include "confdefs.h"
+#include <string.h>
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "memchr" >/dev/null 2>&1; then
+  :
+else
+  rm -rf conftest*
+  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 <<EOF
+#line 926 "configure"
+#include "confdefs.h"
+#include <stdlib.h>
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "free" >/dev/null 2>&1; then
+  :
+else
+  rm -rf conftest*
+  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 <<EOF
+#line 947 "configure"
+#include "confdefs.h"
+#include <ctype.h>
+#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#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)) exit(2);
+exit (0); }
+
+EOF
+if { (eval echo configure:958: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+then
+  :
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  ac_cv_header_stdc=no
+fi
+rm -fr conftest*
+fi
+
+fi
+fi
+
+echo "$ac_t""$ac_cv_header_stdc" 1>&6
+if test $ac_cv_header_stdc = yes; then
+  cat >> confdefs.h <<\EOF
+#define STDC_HEADERS 1
+EOF
+
+fi
+
+for ac_hdr in limits.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:985: checking for $ac_hdr" >&5
+if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 990 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:995: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+
+
+echo $ac_n "checking for working const""... $ac_c" 1>&6
+echo "configure:1024: checking for working const" >&5
+if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1029 "configure"
+#include "confdefs.h"
+
+int main() {
+
+/* Ultrix mips cc rejects this.  */
+typedef int charset[2]; const charset x;
+/* SunOS 4.1.1 cc rejects this.  */
+char const *const *ccp;
+char **p;
+/* NEC SVR4.0.2 mips cc rejects this.  */
+struct point {int x, y;};
+static struct point const zero = {0,0};
+/* AIX XL C 1.02.0.0 rejects this.
+   It does not let you subtract one const X* pointer from another in an arm
+   of an if-expression whose if-part is not a constant expression */
+const char *g = "string";
+ccp = &g + (g ? g-g : 0);
+/* HPUX 7.0 cc rejects these. */
+++ccp;
+p = (char**) ccp;
+ccp = (char const *const *) p;
+{ /* SCO 3.2v4 cc rejects this.  */
+  char *t;
+  char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+  *t++ = 0;
+}
+{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+  int x[] = {25, 17};
+  const int *foo = &x[0];
+  ++foo;
+}
+{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+  typedef const int *iptr;
+  iptr p = 0;
+  ++p;
+}
+{ /* AIX XL C 1.02.0.0 rejects this saying
+     "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+  struct s { int j; const int *ap[3]; };
+  struct s *b; b->j = 5;
+}
+{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+  const int foo = 10;
+}
+
+; return 0; }
+EOF
+if { (eval echo configure:1078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  ac_cv_c_const=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  ac_cv_c_const=no
+fi
+rm -f conftest*
+fi
+
+echo "$ac_t""$ac_cv_c_const" 1>&6
+if test $ac_cv_c_const = no; then
+  cat >> confdefs.h <<\EOF
+#define const 
+EOF
+
+fi
+
+echo $ac_n "checking for size_t""... $ac_c" 1>&6
+echo "configure:1099: checking for size_t" >&5
+if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1104 "configure"
+#include "confdefs.h"
+#include <sys/types.h>
+#if STDC_HEADERS
+#include <stdlib.h>
+#include <stddef.h>
+#endif
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "(^|[^a-zA-Z_0-9])size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  rm -rf conftest*
+  ac_cv_type_size_t=yes
+else
+  rm -rf conftest*
+  ac_cv_type_size_t=no
+fi
+rm -f conftest*
+
+fi
+echo "$ac_t""$ac_cv_type_size_t" 1>&6
+if test $ac_cv_type_size_t = no; then
+  cat >> confdefs.h <<\EOF
+#define size_t unsigned
+EOF
+
+fi
+
+
+
+for ac_func in bcopy memmove strerror
+do
+echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
+echo "configure:1136: checking for $ac_func" >&5
+if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1141 "configure"
+#include "confdefs.h"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+char $ac_func();
+
+int main() {
+
+/* 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
+#else
+$ac_func();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo configure:1164: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=yes"
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=no"
+fi
+rm -f conftest*
+fi
+
+if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_func 1
+EOF
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+
+
+LIBTOOL=./libtool
+LIBSUFFIX=la
+# Check whether --enable-shared or --disable-shared was given.
+if test "${enable_shared+set}" = set; then
+  enableval="$enable_shared"
+  if test "$enableval" = "no"; then
+  LIBTOOL=
+  LIBSUFFIX=a
+fi
+
+fi
+
+
+
+# Check whether --enable-utf8 or --disable-utf8 was given.
+if test "${enable_utf8+set}" = set; then
+  enableval="$enable_utf8"
+  if test "$enableval" = "yes"; then
+  UTF8=-DSUPPORT_UTF8
+fi
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+trap '' 1 2 15
+cat > confcache <<\EOF
+# 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.  It is not useful on other systems.
+# If it contains results you don't want to keep, you may remove or edit it.
+#
+# By default, configure uses ./config.cache as the cache file,
+# creating it if it does not exist already.  You can give configure
+# the --cache-file=FILE option to use a different cache file; that is
+# what configure does when it calls configure scripts in
+# subdirectories, so they share the cache.
+# Giving --cache-file=/dev/null disables caching, for debugging configure.
+# config.status only pays attention to the cache file if you give it the
+# --recheck option to rerun configure.
+#
+EOF
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# 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.
+(set) 2>&1 |
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
+  *ac_space=\ *)
+    # `set' does not quote correctly, so add quotes (double-quote substitution
+    # turns \\\\ into \\, and sed turns \\ into \).
+    sed -n \
+      -e "s/'/'\\\\''/g" \
+      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
+    ;;
+  *)
+    # `set' quotes correctly as required by POSIX, so do not add quotes.
+    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
+    ;;
+  esac >> confcache
+if cmp -s $cache_file confcache; then
+  :
+else
+  if test -w $cache_file; then
+    echo "updating cache $cache_file"
+    cat confcache > $cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# Any assignment to VPATH causes Sun make to only execute
+# the first set of double-colon rules, so remove it if not needed.
+# If there is a colon in the path, we need to keep it.
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[        ]*VPATH[        ]*=[^:]*$/d'
+fi
+
+trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
+
+DEFS=-DHAVE_CONFIG_H
+
+# Without the "./", some shells look in PATH for config.status.
+: ${CONFIG_STATUS=./config.status}
+
+echo creating $CONFIG_STATUS
+rm -f $CONFIG_STATUS
+cat > $CONFIG_STATUS <<EOF
+#! /bin/sh
+# Generated automatically by configure.
+# Run this file to recreate the current configuration.
+# This directory was configured as follows,
+# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+#
+# $0 $ac_configure_args
+#
+# Compiler output produced by configure, useful for debugging
+# configure, is in ./config.log if it exists.
+
+ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
+for ac_option
+do
+  case "\$ac_option" in
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
+    exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
+  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
+    echo "$CONFIG_STATUS generated by autoconf version 2.13"
+    exit 0 ;;
+  -help | --help | --hel | --he | --h)
+    echo "\$ac_cs_usage"; exit 0 ;;
+  *) echo "\$ac_cs_usage"; exit 1 ;;
+  esac
+done
+
+ac_given_srcdir=$srcdir
+
+trap 'rm -fr `echo "Makefile pcre.h:pcre.in pcre-config:pcre-config.in RunTest:RunTest.in config.h:config.in" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
+EOF
+cat >> $CONFIG_STATUS <<EOF
+
+# Protect against being on the right side of a sed subst in config.status.
+sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
+ s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
+$ac_vpsub
+$extrasub
+s%@SHELL@%$SHELL%g
+s%@CFLAGS@%$CFLAGS%g
+s%@CPPFLAGS@%$CPPFLAGS%g
+s%@CXXFLAGS@%$CXXFLAGS%g
+s%@FFLAGS@%$FFLAGS%g
+s%@DEFS@%$DEFS%g
+s%@LDFLAGS@%$LDFLAGS%g
+s%@LIBS@%$LIBS%g
+s%@exec_prefix@%$exec_prefix%g
+s%@prefix@%$prefix%g
+s%@program_transform_name@%$program_transform_name%g
+s%@bindir@%$bindir%g
+s%@sbindir@%$sbindir%g
+s%@libexecdir@%$libexecdir%g
+s%@datadir@%$datadir%g
+s%@sysconfdir@%$sysconfdir%g
+s%@sharedstatedir@%$sharedstatedir%g
+s%@localstatedir@%$localstatedir%g
+s%@libdir@%$libdir%g
+s%@includedir@%$includedir%g
+s%@oldincludedir@%$oldincludedir%g
+s%@infodir@%$infodir%g
+s%@mandir@%$mandir%g
+s%@CC@%$CC%g
+s%@RANLIB@%$RANLIB%g
+s%@CPP@%$CPP%g
+s%@HAVE_MEMMOVE@%$HAVE_MEMMOVE%g
+s%@HAVE_STRERROR@%$HAVE_STRERROR%g
+s%@LIBTOOL@%$LIBTOOL%g
+s%@LIBSUFFIX@%$LIBSUFFIX%g
+s%@UTF8@%$UTF8%g
+s%@PCRE_MAJOR@%$PCRE_MAJOR%g
+s%@PCRE_MINOR@%$PCRE_MINOR%g
+s%@PCRE_DATE@%$PCRE_DATE%g
+s%@PCRE_VERSION@%$PCRE_VERSION%g
+s%@PCRE_LIB_VERSION@%$PCRE_LIB_VERSION%g
+s%@PCRE_POSIXLIB_VERSION@%$PCRE_POSIXLIB_VERSION%g
+
+CEOF
+EOF
+
+cat >> $CONFIG_STATUS <<\EOF
+
+# Split the substitutions into bite-sized pieces for seds with
+# small command number limits, like on Digital OSF/1 and HP-UX.
+ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
+ac_file=1 # Number of current file.
+ac_beg=1 # First line for current file.
+ac_end=$ac_max_sed_cmds # Line after last line for current file.
+ac_more_lines=:
+ac_sed_cmds=""
+while $ac_more_lines; do
+  if test $ac_beg -gt 1; then
+    sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
+  else
+    sed "${ac_end}q" conftest.subs > conftest.s$ac_file
+  fi
+  if test ! -s conftest.s$ac_file; then
+    ac_more_lines=false
+    rm -f conftest.s$ac_file
+  else
+    if test -z "$ac_sed_cmds"; then
+      ac_sed_cmds="sed -f conftest.s$ac_file"
+    else
+      ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
+    fi
+    ac_file=`expr $ac_file + 1`
+    ac_beg=$ac_end
+    ac_end=`expr $ac_end + $ac_max_sed_cmds`
+  fi
+done
+if test -z "$ac_sed_cmds"; then
+  ac_sed_cmds=cat
+fi
+EOF
+
+cat >> $CONFIG_STATUS <<EOF
+
+CONFIG_FILES=\${CONFIG_FILES-"Makefile pcre.h:pcre.in pcre-config:pcre-config.in RunTest:RunTest.in"}
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case "$ac_file" in
+  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
+       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
+  *) ac_file_in="${ac_file}.in" ;;
+  esac
+
+  # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
+
+  # Remove last slash and all that follows it.  Not all systems have dirname.
+  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
+  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
+    # The file is in a subdirectory.
+    test ! -d "$ac_dir" && mkdir "$ac_dir"
+    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
+    # A "../" for each directory in $ac_dir_suffix.
+    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
+  else
+    ac_dir_suffix= ac_dots=
+  fi
+
+  case "$ac_given_srcdir" in
+  .)  srcdir=.
+      if test -z "$ac_dots"; then top_srcdir=.
+      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
+  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
+  *) # Relative path.
+    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
+    top_srcdir="$ac_dots$ac_given_srcdir" ;;
+  esac
+
+
+  echo creating "$ac_file"
+  rm -f "$ac_file"
+  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
+  case "$ac_file" in
+  *Makefile*) ac_comsub="1i\\
+# $configure_input" ;;
+  *) ac_comsub= ;;
+  esac
+
+  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
+  sed -e "$ac_comsub
+s%@configure_input@%$configure_input%g
+s%@srcdir@%$srcdir%g
+s%@top_srcdir@%$top_srcdir%g
+" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
+fi; done
+rm -f conftest.s*
+
+# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+# NAME is the cpp macro being defined and VALUE is the value it is being given.
+#
+# ac_d sets the value in "#define NAME VALUE" lines.
+ac_dA='s%^\([  ]*\)#\([        ]*define[       ][      ]*\)'
+ac_dB='\([     ][      ]*\)[^  ]*%\1#\2'
+ac_dC='\3'
+ac_dD='%g'
+# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
+ac_uA='s%^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+ac_uB='\([     ]\)%\1#\2define\3'
+ac_uC=' '
+ac_uD='\4%g'
+# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+ac_eA='s%^\([  ]*\)#\([        ]*\)undef\([    ][      ]*\)'
+ac_eB='$%\1#\2define\3'
+ac_eC=' '
+ac_eD='%g'
+
+if test "${CONFIG_HEADERS+set}" != set; then
+EOF
+cat >> $CONFIG_STATUS <<EOF
+  CONFIG_HEADERS="config.h:config.in"
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+fi
+for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case "$ac_file" in
+  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
+       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
+  *) ac_file_in="${ac_file}.in" ;;
+  esac
+
+  echo creating $ac_file
+
+  rm -f conftest.frag conftest.in conftest.out
+  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
+  cat $ac_file_inputs > conftest.in
+
+EOF
+
+# Transform confdefs.h into a sed script conftest.vals that substitutes
+# the proper values into config.h.in to produce config.h.  And first:
+# Protect against being on the right side of a sed subst in config.status.
+# Protect against being in an unquoted here document in config.status.
+rm -f conftest.vals
+cat > conftest.hdr <<\EOF
+s/[\\&%]/\\&/g
+s%[\\$`]%\\&%g
+s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
+s%ac_d%ac_u%gp
+s%ac_u%ac_e%gp
+EOF
+sed -n -f conftest.hdr confdefs.h > conftest.vals
+rm -f conftest.hdr
+
+# This sed command replaces #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.
+cat >> conftest.vals <<\EOF
+s%^[   ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
+EOF
+
+# Break up conftest.vals because some shells have a limit on
+# the size of here documents, and old seds have small limits too.
+
+rm -f conftest.tail
+while :
+do
+  ac_lines=`grep -c . conftest.vals`
+  # grep -c gives empty output for an empty file on some AIX systems.
+  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
+  # Write a limited-size here document to conftest.frag.
+  echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
+  sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
+  echo 'CEOF
+  sed -f conftest.frag conftest.in > conftest.out
+  rm -f conftest.in
+  mv conftest.out conftest.in
+' >> $CONFIG_STATUS
+  sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
+  rm -f conftest.vals
+  mv conftest.tail conftest.vals
+done
+rm -f conftest.vals
+
+cat >> $CONFIG_STATUS <<\EOF
+  rm -f conftest.frag conftest.h
+  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
+  cat conftest.in >> conftest.h
+  rm -f conftest.in
+  if cmp -s $ac_file conftest.h 2>/dev/null; then
+    echo "$ac_file is unchanged"
+    rm -f conftest.h
+  else
+    # Remove last slash and all that follows it.  Not all systems have dirname.
+      ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
+      if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
+      # The file is in a subdirectory.
+      test ! -d "$ac_dir" && mkdir "$ac_dir"
+    fi
+    rm -f $ac_file
+    mv conftest.h $ac_file
+  fi
+fi; done
+
+EOF
+cat >> $CONFIG_STATUS <<EOF
+
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+chmod a+x RunTest pcre-config
+exit 0
+EOF
+chmod +x $CONFIG_STATUS
+rm -fr confdefs* $ac_clean_files
+test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
+
diff --git a/pcre/configure.in b/pcre/configure.in
new file mode 100644 (file)
index 0000000..c98387d
--- /dev/null
@@ -0,0 +1,85 @@
+dnl Process this file with autoconf to produce a configure script.
+
+dnl This is required at the start; the name is the name of a file
+dnl it should be seeing, to verify it is in the same directory.
+
+AC_INIT(dftables.c)
+
+dnl Arrange to build config.h from config.in. Note that pcre.h is
+dnl built differently, as it is just a "substitution" file.
+dnl Manual says this macro should come right after AC_INIT.
+AC_CONFIG_HEADER(config.h:config.in)
+
+dnl Provide the current PCRE version information. Do not use numbers
+dnl with leading zeros for the minor version, as they end up in a C
+dnl macro, and may be treated as octal constants. Stick to single
+dnl digits for minor numbers less than 10. There are unlikely to be
+dnl that many releases anyway.
+
+PCRE_MAJOR=3
+PCRE_MINOR=4
+PCRE_DATE=22-Aug-2000
+PCRE_VERSION=${PCRE_MAJOR}.${PCRE_MINOR}
+
+dnl Provide versioning information for libtool shared libraries that
+dnl are built by default on Unix systems.
+
+PCRE_LIB_VERSION=0:1:0
+PCRE_POSIXLIB_VERSION=0:0:0
+
+dnl Checks for programs.
+
+AC_PROG_CC
+AC_PROG_RANLIB
+
+dnl Checks for header files.
+
+AC_HEADER_STDC
+AC_CHECK_HEADERS(limits.h)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+
+AC_C_CONST
+AC_TYPE_SIZE_T
+
+dnl Checks for library functions.
+
+AC_CHECK_FUNCS(bcopy memmove strerror)
+
+dnl Handle --enable-shared-libraries
+
+LIBTOOL=./libtool
+LIBSUFFIX=la
+AC_ARG_ENABLE(shared,
+[  --disable-shared        build PCRE as a static library],
+if test "$enableval" = "no"; then
+  LIBTOOL=
+  LIBSUFFIX=a
+fi
+)
+
+dnl Handle --enable-utf8
+
+AC_ARG_ENABLE(utf8,
+[  --enable-utf8           enable UTF8 support (incomplete)],
+if test "$enableval" = "yes"; then
+  UTF8=-DSUPPORT_UTF8
+fi
+)
+
+dnl "Export" these variables
+
+AC_SUBST(HAVE_MEMMOVE)
+AC_SUBST(HAVE_STRERROR)
+AC_SUBST(LIBTOOL)
+AC_SUBST(LIBSUFFIX)
+AC_SUBST(UTF8)
+AC_SUBST(PCRE_MAJOR)
+AC_SUBST(PCRE_MINOR)
+AC_SUBST(PCRE_DATE)
+AC_SUBST(PCRE_VERSION)
+AC_SUBST(PCRE_LIB_VERSION)
+AC_SUBST(PCRE_POSIXLIB_VERSION)
+
+dnl This must be last; it determines what files are written
+AC_OUTPUT(Makefile pcre.h:pcre.in pcre-config:pcre-config.in RunTest:RunTest.in,[chmod a+x RunTest pcre-config])
diff --git a/pcre/dftables.c b/pcre/dftables.c
new file mode 100644 (file)
index 0000000..d572dfd
--- /dev/null
@@ -0,0 +1,148 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/*
+PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+Written by: Philip Hazel <ph10@cam.ac.uk>
+
+           Copyright (c) 1997-2000 University of Cambridge
+
+-----------------------------------------------------------------------------
+Permission is granted to anyone to use this software for any purpose on any
+computer system, and to redistribute it freely, subject to the following
+restrictions:
+
+1. This software is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission.
+
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+4. If PCRE is embedded in any software that is released under the GNU
+   General Purpose Licence (GPL), then the terms of that licence shall
+   supersede any condition above with which it is incompatible.
+-----------------------------------------------------------------------------
+
+See the file Tech.Notes for some information on the internals.
+*/
+
+
+/* This is a support program to generate the file chartables.c, containing
+character tables of various kinds. They are built according to the default C
+locale and used as the default tables by PCRE. Now that pcre_maketables is
+a function visible to the outside world, we make use of its code from here in
+order to be consistent. */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "internal.h"
+
+#define DFTABLES          /* maketables.c notices this */
+#include "maketables.c"
+
+
+int main(void)
+{
+int i;
+unsigned const char *tables = pcre_maketables();
+
+printf(
+  "/*************************************************\n"
+  "*      Perl-Compatible Regular Expressions       *\n"
+  "*************************************************/\n\n"
+  "/* This file is automatically written by the dftables auxiliary \n"
+  "program. If you edit it by hand, you might like to edit the Makefile to \n"
+  "prevent its ever being regenerated.\n\n"
+  "This file is #included in the compilation of pcre.c to build the default\n"
+  "character tables which are used when no tables are passed to the compile\n"
+  "function. */\n\n"
+  "static unsigned char pcre_default_tables[] = {\n\n"
+  "/* This table is a lower casing table. */\n\n");
+
+printf("  ");
+for (i = 0; i < 256; i++)
+  {
+  if ((i & 7) == 0 && i != 0) printf("\n  ");
+  printf("%3d", *tables++);
+  if (i != 255) printf(",");
+  }
+printf(",\n\n");
+
+printf("/* This table is a case flipping table. */\n\n");
+
+printf("  ");
+for (i = 0; i < 256; i++)
+  {
+  if ((i & 7) == 0 && i != 0) printf("\n  ");
+  printf("%3d", *tables++);
+  if (i != 255) printf(",");
+  }
+printf(",\n\n");
+
+printf(
+  "/* This table contains bit maps for various character classes.\n"
+  "Each map is 32 bytes long and the bits run from the least\n"
+  "significant end of each byte. The classes that have their own\n"
+  "maps are: space, xdigit, digit, upper, lower, word, graph\n"
+  "print, punct, and cntrl. Other classes are built from combinations. */\n\n");
+
+printf("  ");
+for (i = 0; i < cbit_length; i++)
+  {
+  if ((i & 7) == 0 && i != 0)
+    {
+    if ((i & 31) == 0) printf("\n");
+    printf("\n  ");
+    }
+  printf("0x%02x", *tables++);
+  if (i != cbit_length - 1) printf(",");
+  }
+printf(",\n\n");
+
+printf(
+  "/* This table identifies various classes of character by individual bits:\n"
+  "  0x%02x   white space character\n"
+  "  0x%02x   letter\n"
+  "  0x%02x   decimal digit\n"
+  "  0x%02x   hexadecimal digit\n"
+  "  0x%02x   alphanumeric or '_'\n"
+  "  0x%02x   regular expression metacharacter or binary zero\n*/\n\n",
+  ctype_space, ctype_letter, ctype_digit, ctype_xdigit, ctype_word,
+  ctype_meta);
+
+printf("  ");
+for (i = 0; i < 256; i++)
+  {
+  if ((i & 7) == 0 && i != 0)
+    {
+    printf(" /* ");
+    if (isprint(i-8)) printf(" %c -", i-8);
+      else printf("%3d-", i-8);
+    if (isprint(i-1)) printf(" %c ", i-1);
+      else printf("%3d", i-1);
+    printf(" */\n  ");
+    }
+  printf("0x%02x", *tables++);
+  if (i != 255) printf(",");
+  }
+
+printf("};/* ");
+if (isprint(i-8)) printf(" %c -", i-8);
+  else printf("%3d-", i-8);
+if (isprint(i-1)) printf(" %c ", i-1);
+  else printf("%3d", i-1);
+printf(" */\n\n/* End of chartables.c */\n");
+
+return 0;
+}
+
+/* End of dftables.c */
diff --git a/pcre/dll.mk b/pcre/dll.mk
new file mode 100644 (file)
index 0000000..d8b728e
--- /dev/null
@@ -0,0 +1,60 @@
+# dll.mk - auxilary Makefile to easy build dll's for mingw32 target
+# ver. 0.6 of 1999-03-25
+#
+# Homepage of this makefile - http://www.is.lg.ua/~paul/devel/
+# Homepage of original mingw32 project -
+#                    http://www.fu.is.saga-u.ac.jp/~colin/gcc.html
+#
+# How to use:
+# This makefile can:
+# 1. Create automatical .def file from list of objects
+# 2. Create .dll from objects and .def file, either automatical, or your
+#    hand-written (maybe) file, which must have same basename as dll
+# WARNING! There MUST be object, which name match dll's name. Make sux.
+# 3. Create import library from .def (as for .dll, only its name required,
+#    not dll itself)
+#    By convention implibs for dll have .dll.a suffix, e.g. libstuff.dll.a
+#    Why not just libstuff.a? 'Cos that's name for static lib, ok?
+# Process divided into 3 phases because:
+# 1. Pre-existent .def possible
+# 2. Generating implib is enough time-consuming
+#
+# Variables:
+#   DLL_LDLIBS  - libs for linking dll
+#   DLL_LDFLAGS - flags for linking dll
+#
+# By using $(DLL_SUFFIX) instead of 'dll', e.g. stuff.$(DLL_SUFFIX)
+# you may help porting makefiles to other platforms
+#
+# Put this file in your make's include path (e.g. main include dir, for
+# more information see include section in make doc). Put in the beginning
+# of your own Makefile line "include dll.mk". Specify dependences, e.g.:
+#
+# Do all stuff in one step
+# libstuff.dll.a: $(OBJECTS) stuff.def
+# stuff.def: $(OBJECTS)
+#
+# Steps separated, pre-provided .def, link with user32
+#
+# DLL_LDLIBS=-luser32
+# stuff.dll: $(OBJECTS)
+# libstuff.dll.a: $(OBJECTS)
+
+
+DLLWRAP=dllwrap
+DLLTOOL=dlltool
+
+DLL_SUFFIX=dll
+
+.SUFFIXES: .o .$(DLL_SUFFIX)
+
+_%.def: %.o
+      $(DLLTOOL) --export-all --output-def $@ $^
+
+%.$(DLL_SUFFIX): %.o
+      $(DLLWRAP) --dllname $(notdir $@) --driver-name $(CC) --def $*.def -o $@ $(filter %.o,$^) $(DLL_LDFLAGS) $(DLL_LDLIBS)
+
+lib%.$(DLL_SUFFIX).a:%.def
+      $(DLLTOOL) --dllname $(notdir $*.dll) --def $< --output-lib $@
+
+# End
diff --git a/pcre/doc/ChangeLog b/pcre/doc/ChangeLog
new file mode 100644 (file)
index 0000000..2133dd7
--- /dev/null
@@ -0,0 +1,655 @@
+ChangeLog for PCRE
+------------------
+
+
+Version 3.4 22-Aug-00
+---------------------
+
+1. Fixed typo in pcre.h: unsigned const char * changed to const unsigned char *.
+
+2. Diagnose condition (?(0) as an error instead of crashing on matching.
+
+
+Version 3.3 01-Aug-00
+---------------------
+
+1. If an octal character was given, but the value was greater than \377, it
+was not getting masked to the least significant bits, as documented. This could
+lead to crashes in some systems.
+
+2. Perl 5.6 (if not earlier versions) accepts classes like [a-\d] and treats
+the hyphen as a literal. PCRE used to give an error; it now behaves like Perl.
+
+3. Added the functions pcre_free_substring() and pcre_free_substring_list().
+These just pass their arguments on to (pcre_free)(), but they are provided
+because some uses of PCRE bind it to non-C systems that can call its functions,
+but cannot call free() or pcre_free() directly.
+
+4. Add "make test" as a synonym for "make check". Corrected some comments in
+the Makefile.
+
+5. Add $(DESTDIR)/ in front of all the paths in the "install" target in the
+Makefile.
+
+6. Changed the name of pgrep to pcregrep, because Solaris has introduced a
+command called pgrep for grepping around the active processes.
+
+7. Added the beginnings of support for UTF-8 character strings.
+
+8. Arranged for the Makefile to pass over the settings of CC, CFLAGS, and
+RANLIB to ./ltconfig so that they are used by libtool. I think these are all
+the relevant ones. (AR is not passed because ./ltconfig does its own figuring
+out for the ar command.)
+
+
+Version 3.2 12-May-00
+---------------------
+
+This is purely a bug fixing release.
+
+1. If the pattern /((Z)+|A)*/ was matched agained ZABCDEFG it matched Z instead
+of ZA. This was just one example of several cases that could provoke this bug,
+which was introduced by change 9 of version 2.00. The code for breaking
+infinite loops after an iteration that matches an empty string was't working
+correctly.
+
+2. The pcretest program was not imitating Perl correctly for the pattern /a*/g
+when matched against abbab (for example). After matching an empty string, it
+wasn't forcing anchoring when setting PCRE_NOTEMPTY for the next attempt; this
+caused it to match further down the string than it should.
+
+3. The code contained an inclusion of sys/types.h. It isn't clear why this
+was there because it doesn't seem to be needed, and it causes trouble on some
+systems, as it is not a Standard C header. It has been removed.
+
+4. Made 4 silly changes to the source to avoid stupid compiler warnings that
+were reported on the Macintosh. The changes were from
+
+  while ((c = *(++ptr)) != 0 && c != '\n');
+to
+  while ((c = *(++ptr)) != 0 && c != '\n') ;
+
+Totally extraordinary, but if that's what it takes...
+
+5. PCRE is being used in one environment where neither memmove() nor bcopy() is
+available. Added HAVE_BCOPY and an autoconf test for it; if neither
+HAVE_MEMMOVE nor HAVE_BCOPY is set, use a built-in emulation function which
+assumes the way PCRE uses memmove() (always moving upwards).
+
+6. PCRE is being used in one environment where strchr() is not available. There
+was only one use in pcre.c, and writing it out to avoid strchr() probably gives
+faster code anyway.
+
+
+Version 3.1 09-Feb-00
+---------------------
+
+The only change in this release is the fixing of some bugs in Makefile.in for
+the "install" target:
+
+(1) It was failing to install pcreposix.h.
+
+(2) It was overwriting the pcre.3 man page with the pcreposix.3 man page.
+
+
+Version 3.0 01-Feb-00
+---------------------
+
+1. Add support for the /+ modifier to perltest (to output $` like it does in
+pcretest).
+
+2. Add support for the /g modifier to perltest.
+
+3. Fix pcretest so that it behaves even more like Perl for /g when the pattern
+matches null strings.
+
+4. Fix perltest so that it doesn't do unwanted things when fed an empty
+pattern. Perl treats empty patterns specially - it reuses the most recent
+pattern, which is not what we want. Replace // by /(?#)/ in order to avoid this
+effect.
+
+5. The POSIX interface was broken in that it was just handing over the POSIX
+captured string vector to pcre_exec(), but (since release 2.00) PCRE has
+required a bigger vector, with some working space on the end. This means that
+the POSIX wrapper now has to get and free some memory, and copy the results.
+
+6. Added some simple autoconf support, placing the test data and the
+documentation in separate directories, re-organizing some of the
+information files, and making it build pcre-config (a GNU standard). Also added
+libtool support for building PCRE as a shared library, which is now the
+default.
+
+7. Got rid of the leading zero in the definition of PCRE_MINOR because 08 and
+09 are not valid octal constants. Single digits will be used for minor values
+less than 10.
+
+8. Defined REG_EXTENDED and REG_NOSUB as zero in the POSIX header, so that
+existing programs that set these in the POSIX interface can use PCRE without
+modification.
+
+9. Added a new function, pcre_fullinfo() with an extensible interface. It can
+return all that pcre_info() returns, plus additional data. The pcre_info()
+function is retained for compatibility, but is considered to be obsolete.
+
+10. Added experimental recursion feature (?R) to handle one common case that
+Perl 5.6 will be able to do with (?p{...}).
+
+11. Added support for POSIX character classes like [:alpha:], which Perl is
+adopting.
+
+
+Version 2.08 31-Aug-99
+----------------------
+
+1. When startoffset was not zero and the pattern began with ".*", PCRE was not
+trying to match at the startoffset position, but instead was moving forward to
+the next newline as if a previous match had failed.
+
+2. pcretest was not making use of PCRE_NOTEMPTY when repeating for /g and /G,
+and could get into a loop if a null string was matched other than at the start
+of the subject.
+
+3. Added definitions of PCRE_MAJOR and PCRE_MINOR to pcre.h so the version can
+be distinguished at compile time, and for completeness also added PCRE_DATE.
+
+5. Added Paul Sokolovsky's minor changes to make it easy to compile a Win32 DLL
+in GnuWin32 environments.
+
+
+Version 2.07 29-Jul-99
+----------------------
+
+1. The documentation is now supplied in plain text form and HTML as well as in
+the form of man page sources.
+
+2. C++ compilers don't like assigning (void *) values to other pointer types.
+In particular this affects malloc(). Although there is no problem in Standard
+C, I've put in casts to keep C++ compilers happy.
+
+3. Typo on pcretest.c; a cast of (unsigned char *) in the POSIX regexec() call
+should be (const char *).
+
+4. If NOPOSIX is defined, pcretest.c compiles without POSIX support. This may
+be useful for non-Unix systems who don't want to bother with the POSIX stuff.
+However, I haven't made this a standard facility. The documentation doesn't
+mention it, and the Makefile doesn't support it.
+
+5. The Makefile now contains an "install" target, with editable destinations at
+the top of the file. The pcretest program is not installed.
+
+6. pgrep -V now gives the PCRE version number and date.
+
+7. Fixed bug: a zero repetition after a literal string (e.g. /abcde{0}/) was
+causing the entire string to be ignored, instead of just the last character.
+
+8. If a pattern like /"([^\\"]+|\\.)*"/ is applied in the normal way to a
+non-matching string, it can take a very, very long time, even for strings of
+quite modest length, because of the nested recursion. PCRE now does better in
+some of these cases. It does this by remembering the last required literal
+character in the pattern, and pre-searching the subject to ensure it is present
+before running the real match. In other words, it applies a heuristic to detect
+some types of certain failure quickly, and in the above example, if presented
+with a string that has no trailing " it gives "no match" very quickly.
+
+9. A new runtime option PCRE_NOTEMPTY causes null string matches to be ignored;
+other alternatives are tried instead.
+
+
+Version 2.06 09-Jun-99
+----------------------
+
+1. Change pcretest's output for amount of store used to show just the code
+space, because the remainder (the data block) varies in size between 32-bit and
+64-bit systems.
+
+2. Added an extra argument to pcre_exec() to supply an offset in the subject to
+start matching at. This allows lookbehinds to work when searching for multiple
+occurrences in a string.
+
+3. Added additional options to pcretest for testing multiple occurrences:
+
+   /+   outputs the rest of the string that follows a match
+   /g   loops for multiple occurrences, using the new startoffset argument
+   /G   loops for multiple occurrences by passing an incremented pointer
+
+4. PCRE wasn't doing the "first character" optimization for patterns starting
+with \b or \B, though it was doing it for other lookbehind assertions. That is,
+it wasn't noticing that a match for a pattern such as /\bxyz/ has to start with
+the letter 'x'. On long subject strings, this gives a significant speed-up.
+
+
+Version 2.05 21-Apr-99
+----------------------
+
+1. Changed the type of magic_number from int to long int so that it works
+properly on 16-bit systems.
+
+2. Fixed a bug which caused patterns starting with .* not to work correctly
+when the subject string contained newline characters. PCRE was assuming
+anchoring for such patterns in all cases, which is not correct because .* will
+not pass a newline unless PCRE_DOTALL is set. It now assumes anchoring only if
+DOTALL is set at top level; otherwise it knows that patterns starting with .*
+must be retried after every newline in the subject.
+
+
+Version 2.04 18-Feb-99
+----------------------
+
+1. For parenthesized subpatterns with repeats whose minimum was zero, the
+computation of the store needed to hold the pattern was incorrect (too large).
+If such patterns were nested a few deep, this could multiply and become a real
+problem.
+
+2. Added /M option to pcretest to show the memory requirement of a specific
+pattern. Made -m a synonym of -s (which does this globally) for compatibility.
+
+3. Subpatterns of the form (regex){n,m} (i.e. limited maximum) were being
+compiled in such a way that the backtracking after subsequent failure was
+pessimal. Something like (a){0,3} was compiled as (a)?(a)?(a)? instead of
+((a)((a)(a)?)?)? with disastrous performance if the maximum was of any size.
+
+
+Version 2.03 02-Feb-99
+----------------------
+
+1. Fixed typo and small mistake in man page.
+
+2. Added 4th condition (GPL supersedes if conflict) and created separate
+LICENCE file containing the conditions.
+
+3. Updated pcretest so that patterns such as /abc\/def/ work like they do in
+Perl, that is the internal \ allows the delimiter to be included in the
+pattern. Locked out the use of \ as a delimiter. If \ immediately follows
+the final delimiter, add \ to the end of the pattern (to test the error).
+
+4. Added the convenience functions for extracting substrings after a successful
+match. Updated pcretest to make it able to test these functions.
+
+
+Version 2.02 14-Jan-99
+----------------------
+
+1. Initialized the working variables associated with each extraction so that
+their saving and restoring doesn't refer to uninitialized store.
+
+2. Put dummy code into study.c in order to trick the optimizer of the IBM C
+compiler for OS/2 into generating correct code. Apparently IBM isn't going to
+fix the problem.
+
+3. Pcretest: the timing code wasn't using LOOPREPEAT for timing execution
+calls, and wasn't printing the correct value for compiling calls. Increased the
+default value of LOOPREPEAT, and the number of significant figures in the
+times.
+
+4. Changed "/bin/rm" in the Makefile to "-rm" so it works on Windows NT.
+
+5. Renamed "deftables" as "dftables" to get it down to 8 characters, to avoid
+a building problem on Windows NT with a FAT file system.
+
+
+Version 2.01 21-Oct-98
+----------------------
+
+1. Changed the API for pcre_compile() to allow for the provision of a pointer
+to character tables built by pcre_maketables() in the current locale. If NULL
+is passed, the default tables are used.
+
+
+Version 2.00 24-Sep-98
+----------------------
+
+1. Since the (>?) facility is in Perl 5.005, don't require PCRE_EXTRA to enable
+it any more.
+
+2. Allow quantification of (?>) groups, and make it work correctly.
+
+3. The first character computation wasn't working for (?>) groups.
+
+4. Correct the implementation of \Z (it is permitted to match on the \n at the
+end of the subject) and add 5.005's \z, which really does match only at the
+very end of the subject.
+
+5. Remove the \X "cut" facility; Perl doesn't have it, and (?> is neater.
+
+6. Remove the ability to specify CASELESS, MULTILINE, DOTALL, and
+DOLLAR_END_ONLY at runtime, to make it possible to implement the Perl 5.005
+localized options. All options to pcre_study() were also removed.
+
+7. Add other new features from 5.005:
+
+   $(?<=           positive lookbehind
+   $(?<!           negative lookbehind
+   (?imsx-imsx)    added the unsetting capability
+                   such a setting is global if at outer level; local otherwise
+   (?imsx-imsx:)   non-capturing groups with option setting
+   (?(cond)re|re)  conditional pattern matching
+
+   A backreference to itself in a repeated group matches the previous
+   captured string.
+
+8. General tidying up of studying (both automatic and via "study")
+consequential on the addition of new assertions.
+
+9. As in 5.005, unlimited repeated groups that could match an empty substring
+are no longer faulted at compile time. Instead, the loop is forcibly broken at
+runtime if any iteration does actually match an empty substring.
+
+10. Include the RunTest script in the distribution.
+
+11. Added tests from the Perl 5.005_02 distribution. This showed up a few
+discrepancies, some of which were old and were also with respect to 5.004. They
+have now been fixed.
+
+
+Version 1.09 28-Apr-98
+----------------------
+
+1. A negated single character class followed by a quantifier with a minimum
+value of one (e.g.  [^x]{1,6}  ) was not compiled correctly. This could lead to
+program crashes, or just wrong answers. This did not apply to negated classes
+containing more than one character, or to minima other than one.
+
+
+Version 1.08 27-Mar-98
+----------------------
+
+1. Add PCRE_UNGREEDY to invert the greediness of quantifiers.
+
+2. Add (?U) and (?X) to set PCRE_UNGREEDY and PCRE_EXTRA respectively. The
+latter must appear before anything that relies on it in the pattern.
+
+
+Version 1.07 16-Feb-98
+----------------------
+
+1. A pattern such as /((a)*)*/ was not being diagnosed as in error (unlimited
+repeat of a potentially empty string).
+
+
+Version 1.06 23-Jan-98
+----------------------
+
+1. Added Markus Oberhumer's little patches for C++.
+
+2. Literal strings longer than 255 characters were broken.
+
+
+Version 1.05 23-Dec-97
+----------------------
+
+1. Negated character classes containing more than one character were failing if
+PCRE_CASELESS was set at run time.
+
+
+Version 1.04 19-Dec-97
+----------------------
+
+1. Corrected the man page, where some "const" qualifiers had been omitted.
+
+2. Made debugging output print "{0,xxx}" instead of just "{,xxx}" to agree with
+input syntax.
+
+3. Fixed memory leak which occurred when a regex with back references was
+matched with an offsets vector that wasn't big enough. The temporary memory
+that is used in this case wasn't being freed if the match failed.
+
+4. Tidied pcretest to ensure it frees memory that it gets.
+
+5. Temporary memory was being obtained in the case where the passed offsets
+vector was exactly big enough.
+
+6. Corrected definition of offsetof() from change 5 below.
+
+7. I had screwed up change 6 below and broken the rules for the use of
+setjmp(). Now fixed.
+
+
+Version 1.03 18-Dec-97
+----------------------
+
+1. A erroneous regex with a missing opening parenthesis was correctly
+diagnosed, but PCRE attempted to access brastack[-1], which could cause crashes
+on some systems.
+
+2. Replaced offsetof(real_pcre, code) by offsetof(real_pcre, code[0]) because
+it was reported that one broken compiler failed on the former because "code" is
+also an independent variable.
+
+3. The erroneous regex a[]b caused an array overrun reference.
+
+4. A regex ending with a one-character negative class (e.g. /[^k]$/) did not
+fail on data ending with that character. (It was going on too far, and checking
+the next character, typically a binary zero.) This was specific to the
+optimized code for single-character negative classes.
+
+5. Added a contributed patch from the TIN world which does the following:
+
+  + Add an undef for memmove, in case the the system defines a macro for it.
+
+  + Add a definition of offsetof(), in case there isn't one. (I don't know
+    the reason behind this - offsetof() is part of the ANSI standard - but
+    it does no harm).
+
+  + Reduce the ifdef's in pcre.c using macro DPRINTF, thereby eliminating
+    most of the places where whitespace preceded '#'. I have given up and
+    allowed the remaining 2 cases to be at the margin.
+
+  + Rename some variables in pcre to eliminate shadowing. This seems very
+    pedantic, but does no harm, of course.
+
+6. Moved the call to setjmp() into its own function, to get rid of warnings
+from gcc -Wall, and avoided calling it at all unless PCRE_EXTRA is used.
+
+7. Constructs such as \d{8,} were compiling into the equivalent of
+\d{8}\d{0,65527} instead of \d{8}\d* which didn't make much difference to the
+outcome, but in this particular case used more store than had been allocated,
+which caused the bug to be discovered because it threw up an internal error.
+
+8. The debugging code in both pcre and pcretest for outputting the compiled
+form of a regex was going wrong in the case of back references followed by
+curly-bracketed repeats.
+
+
+Version 1.02 12-Dec-97
+----------------------
+
+1. Typos in pcre.3 and comments in the source fixed.
+
+2. Applied a contributed patch to get rid of places where it used to remove
+'const' from variables, and fixed some signed/unsigned and uninitialized
+variable warnings.
+
+3. Added the "runtest" target to Makefile.
+
+4. Set default compiler flag to -O2 rather than just -O.
+
+
+Version 1.01 19-Nov-97
+----------------------
+
+1. PCRE was failing to diagnose unlimited repeat of empty string for patterns
+like /([ab]*)*/, that is, for classes with more than one character in them.
+
+2. Likewise, it wasn't diagnosing patterns with "once-only" subpatterns, such
+as /((?>a*))*/ (a PCRE_EXTRA facility).
+
+
+Version 1.00 18-Nov-97
+----------------------
+
+1. Added compile-time macros to support systems such as SunOS4 which don't have
+memmove() or strerror() but have other things that can be used instead.
+
+2. Arranged that "make clean" removes the executables.
+
+
+Version 0.99 27-Oct-97
+----------------------
+
+1. Fixed bug in code for optimizing classes with only one character. It was
+initializing a 32-byte map regardless, which could cause it to run off the end
+of the memory it had got.
+
+2. Added, conditional on PCRE_EXTRA, the proposed (?>REGEX) construction.
+
+
+Version 0.98 22-Oct-97
+----------------------
+
+1. Fixed bug in code for handling temporary memory usage when there are more
+back references than supplied space in the ovector. This could cause segfaults.
+
+
+Version 0.97 21-Oct-97
+----------------------
+
+1. Added the \X "cut" facility, conditional on PCRE_EXTRA.
+
+2. Optimized negated single characters not to use a bit map.
+
+3. Brought error texts together as macro definitions; clarified some of them;
+fixed one that was wrong - it said "range out of order" when it meant "invalid
+escape sequence".
+
+4. Changed some char * arguments to const char *.
+
+5. Added PCRE_NOTBOL and PCRE_NOTEOL (from POSIX).
+
+6. Added the POSIX-style API wrapper in pcreposix.a and testing facilities in
+pcretest.
+
+
+Version 0.96 16-Oct-97
+----------------------
+
+1. Added a simple "pgrep" utility to the distribution.
+
+2. Fixed an incompatibility with Perl: "{" is now treated as a normal character
+unless it appears in one of the precise forms "{ddd}", "{ddd,}", or "{ddd,ddd}"
+where "ddd" means "one or more decimal digits".
+
+3. Fixed serious bug. If a pattern had a back reference, but the call to
+pcre_exec() didn't supply a large enough ovector to record the related
+identifying subpattern, the match always failed. PCRE now remembers the number
+of the largest back reference, and gets some temporary memory in which to save
+the offsets during matching if necessary, in order to ensure that
+backreferences always work.
+
+4. Increased the compatibility with Perl in a number of ways:
+
+  (a) . no longer matches \n by default; an option PCRE_DOTALL is provided
+      to request this handling. The option can be set at compile or exec time.
+
+  (b) $ matches before a terminating newline by default; an option
+      PCRE_DOLLAR_ENDONLY is provided to override this (but not in multiline
+      mode). The option can be set at compile or exec time.
+
+  (c) The handling of \ followed by a digit other than 0 is now supposed to be
+      the same as Perl's. If the decimal number it represents is less than 10
+      or there aren't that many previous left capturing parentheses, an octal
+      escape is read. Inside a character class, it's always an octal escape,
+      even if it is a single digit.
+
+  (d) An escaped but undefined alphabetic character is taken as a literal,
+      unless PCRE_EXTRA is set. Currently this just reserves the remaining
+      escapes.
+
+  (e) {0} is now permitted. (The previous item is removed from the compiled
+      pattern).
+
+5. Changed all the names of code files so that the basic parts are no longer
+than 10 characters, and abolished the teeny "globals.c" file.
+
+6. Changed the handling of character classes; they are now done with a 32-byte
+bit map always.
+
+7. Added the -d and /D options to pcretest to make it possible to look at the
+internals of compilation without having to recompile pcre.
+
+
+Version 0.95 23-Sep-97
+----------------------
+
+1. Fixed bug in pre-pass concerning escaped "normal" characters such as \x5c or
+\x20 at the start of a run of normal characters. These were being treated as
+real characters, instead of the source characters being re-checked.
+
+
+Version 0.94 18-Sep-97
+----------------------
+
+1. The functions are now thread-safe, with the caveat that the global variables
+containing pointers to malloc() and free() or alternative functions are the
+same for all threads.
+
+2. Get pcre_study() to generate a bitmap of initial characters for non-
+anchored patterns when this is possible, and use it if passed to pcre_exec().
+
+
+Version 0.93 15-Sep-97
+----------------------
+
+1. /(b)|(:+)/ was computing an incorrect first character.
+
+2. Add pcre_study() to the API and the passing of pcre_extra to pcre_exec(),
+but not actually doing anything yet.
+
+3. Treat "-" characters in classes that cannot be part of ranges as literals,
+as Perl does (e.g. [-az] or [az-]).
+
+4. Set the anchored flag if a branch starts with .* or .*? because that tests
+all possible positions.
+
+5. Split up into different modules to avoid including unneeded functions in a
+compiled binary. However, compile and exec are still in one module. The "study"
+function is split off.
+
+6. The character tables are now in a separate module whose source is generated
+by an auxiliary program - but can then be edited by hand if required. There are
+now no calls to isalnum(), isspace(), isdigit(), isxdigit(), tolower() or
+toupper() in the code.
+
+7. Turn the malloc/free funtions variables into pcre_malloc and pcre_free and
+make them global. Abolish the function for setting them, as the caller can now
+set them directly.
+
+
+Version 0.92 11-Sep-97
+----------------------
+
+1. A repeat with a fixed maximum and a minimum of 1 for an ordinary character
+(e.g. /a{1,3}/) was broken (I mis-optimized it).
+
+2. Caseless matching was not working in character classes if the characters in
+the pattern were in upper case.
+
+3. Make ranges like [W-c] work in the same way as Perl for caseless matching.
+
+4. Make PCRE_ANCHORED public and accept as a compile option.
+
+5. Add an options word to pcre_exec() and accept PCRE_ANCHORED and
+PCRE_CASELESS at run time. Add escapes \A and \I to pcretest to cause it to
+pass them.
+
+6. Give an error if bad option bits passed at compile or run time.
+
+7. Add PCRE_MULTILINE at compile and exec time, and (?m) as well. Add \M to
+pcretest to cause it to pass that flag.
+
+8. Add pcre_info(), to get the number of identifying subpatterns, the stored
+options, and the first character, if set.
+
+9. Recognize C+ or C{n,m} where n >= 1 as providing a fixed starting character.
+
+
+Version 0.91 10-Sep-97
+----------------------
+
+1. PCRE was failing to diagnose unlimited repeats of subpatterns that could
+match the empty string as in /(a*)*/. It was looping and ultimately crashing.
+
+2. PCRE was looping on encountering an indefinitely repeated back reference to
+a subpattern that had matched an empty string, e.g. /(a|)\1*/. It now does what
+Perl does - treats the match as successful.
+
+****
diff --git a/pcre/doc/NON-UNIX-USE b/pcre/doc/NON-UNIX-USE
new file mode 100644 (file)
index 0000000..09a7432
--- /dev/null
@@ -0,0 +1,50 @@
+Compiling PCRE on non-Unix systems
+----------------------------------
+
+If you want to compile PCRE for a non-Unix system, note that it consists
+entirely of code written in Standard C, and so should compile successfully
+on any machine with a Standard C compiler and library, using normal compiling
+commands to do the following:
+
+(1) Copy or rename the file config.in as config.h, and change the macros that
+define HAVE_STRERROR and HAVE_MEMMOVE to define them as 1 rather than 0.
+Unfortunately, because of the way Unix autoconf works, the default setting has
+to be 0.
+
+(2) Copy or rename the file pcre.in as pcre.h, and change the macro definitions
+for PCRE_MAJOR, PCRE_MINOR, and PCRE_DATE near its start to the values set in
+configure.in.
+
+(3) Compile dftables.c as a stand-alone program, and then run it with
+the standard output sent to chartables.c. This generates a set of standard
+character tables.
+
+(4) Compile maketables.c, get.c, study.c and pcre.c and link them all
+together into an object library in whichever form your system keeps such
+libraries. This is the pcre library (chartables.c gets included by means of an
+#include directive).
+
+(5) Similarly, compile pcreposix.c and link it as the pcreposix library.
+
+(6) Compile the test program pcretest.c. This needs the functions in the
+pcre and pcreposix libraries when linking.
+
+(7) Run pcretest on the testinput files in the testdata directory, and check
+that the output matches the corresponding testoutput files. You must use the
+-i option when checking testinput2.
+
+If you have a system without "configure" but where you can use a Makefile, edit
+Makefile.in to create Makefile, substituting suitable values for the variables
+at the head of the file.
+
+Some help in building a Win32 DLL of PCRE in GnuWin32 environments was
+contributed by Paul.Sokolovsky@technologist.com. These environments are
+Mingw32 (http://www.xraylith.wisc.edu/~khan/software/gnu-win32/) and
+CygWin  (http://sourceware.cygnus.com/cygwin/). Paul comments:
+
+  For CygWin, set CFLAGS=-mno-cygwin, and do 'make dll'. You'll get
+  pcre.dll (containing pcreposix also), libpcre.dll.a, and dynamically
+  linked pgrep and pcretest. If you have /bin/sh, run RunTest (three
+  main test go ok, locale not supported).
+
+****
diff --git a/pcre/doc/Tech.Notes b/pcre/doc/Tech.Notes
new file mode 100644 (file)
index 0000000..7b96e5b
--- /dev/null
@@ -0,0 +1,243 @@
+Technical Notes about PCRE
+--------------------------
+
+Many years ago I implemented some regular expression functions to an algorithm
+suggested by Martin Richards. These were not Unix-like in form, and were quite
+restricted in what they could do by comparison with Perl. The interesting part
+about the algorithm was that the amount of space required to hold the compiled
+form of an expression was known in advance. The code to apply an expression did
+not operate by backtracking, as the Henry Spencer and Perl code does, but
+instead checked all possibilities simultaneously by keeping a list of current
+states and checking all of them as it advanced through the subject string. (In
+the terminology of Jeffrey Friedl's book, it was a "DFA algorithm".) When the
+pattern was all used up, all remaining states were possible matches, and the
+one matching the longest subset of the subject string was chosen. This did not
+necessarily maximize the individual wild portions of the pattern, as is
+expected in Unix and Perl-style regular expressions.
+
+By contrast, the code originally written by Henry Spencer and subsequently
+heavily modified for Perl actually compiles the expression twice: once in a
+dummy mode in order to find out how much store will be needed, and then for
+real. The execution function operates by backtracking and maximizing (or,
+optionally, minimizing in Perl) the amount of the subject that matches
+individual wild portions of the pattern. This is an "NFA algorithm" in Friedl's
+terminology.
+
+For the set of functions that forms PCRE (which are unrelated to those
+mentioned above), I tried at first to invent an algorithm that used an amount
+of store bounded by a multiple of the number of characters in the pattern, to
+save on compiling time. However, because of the greater complexity in Perl
+regular expressions, I couldn't do this. In any case, a first pass through the
+pattern is needed, in order to find internal flag settings like (?i) at top
+level. So PCRE works by running a very degenerate first pass to calculate a
+maximum store size, and then a second pass to do the real compile - which may
+use a bit less than the predicted amount of store. The idea is that this is
+going to turn out faster because the first pass is degenerate and the second
+pass can just store stuff straight into the vector. It does make the compiling
+functions bigger, of course, but they have got quite big anyway to handle all
+the Perl stuff.
+
+The compiled form of a pattern is a vector of bytes, containing items of
+variable length. The first byte in an item is an opcode, and the length of the
+item is either implicit in the opcode or contained in the data bytes which
+follow it. A list of all the opcodes follows:
+
+Opcodes with no following data
+------------------------------
+
+These items are all just one byte long
+
+  OP_END                 end of pattern
+  OP_ANY                 match any character
+  OP_SOD                 match start of data: \A
+  OP_CIRC                ^ (start of data, or after \n in multiline)
+  OP_NOT_WORD_BOUNDARY   \W
+  OP_WORD_BOUNDARY       \w
+  OP_NOT_DIGIT           \D
+  OP_DIGIT               \d
+  OP_NOT_WHITESPACE      \S
+  OP_WHITESPACE          \s
+  OP_NOT_WORDCHAR        \W
+  OP_WORDCHAR            \w
+  OP_EODN                match end of data or \n at end: \Z
+  OP_EOD                 match end of data: \z
+  OP_DOLL                $ (end of data, or before \n in multiline)
+  OP_RECURSE             match the pattern recursively
+
+
+Repeating single characters
+---------------------------
+
+The common repeats (*, +, ?) when applied to a single character appear as
+two-byte items using the following opcodes:
+
+  OP_STAR
+  OP_MINSTAR
+  OP_PLUS
+  OP_MINPLUS
+  OP_QUERY
+  OP_MINQUERY
+
+Those with "MIN" in their name are the minimizing versions. Each is followed by
+the character that is to be repeated. Other repeats make use of
+
+  OP_UPTO
+  OP_MINUPTO
+  OP_EXACT
+
+which are followed by a two-byte count (most significant first) and the
+repeated character. OP_UPTO matches from 0 to the given number. A repeat with a
+non-zero minimum and a fixed maximum is coded as an OP_EXACT followed by an
+OP_UPTO (or OP_MINUPTO).
+
+
+Repeating character types
+-------------------------
+
+Repeats of things like \d are done exactly as for single characters, except
+that instead of a character, the opcode for the type is stored in the data
+byte. The opcodes are:
+
+  OP_TYPESTAR
+  OP_TYPEMINSTAR
+  OP_TYPEPLUS
+  OP_TYPEMINPLUS
+  OP_TYPEQUERY
+  OP_TYPEMINQUERY
+  OP_TYPEUPTO
+  OP_TYPEMINUPTO
+  OP_TYPEEXACT
+
+
+Matching a character string
+---------------------------
+
+The OP_CHARS opcode is followed by a one-byte count and then that number of
+characters. If there are more than 255 characters in sequence, successive
+instances of OP_CHARS are used.
+
+
+Character classes
+-----------------
+
+OP_CLASS is used for a character class, provided there are at least two
+characters in the class. If there is only one character, OP_CHARS is used for a
+positive class, and OP_NOT for a negative one (that is, for something like
+[^a]). Another set of repeating opcodes (OP_NOTSTAR etc.) are used for a
+repeated, negated, single-character class. The normal ones (OP_STAR etc.) are
+used for a repeated positive single-character class.
+
+OP_CLASS is followed by a 32-byte bit map containing a 1 bit for every
+character that is acceptable. The bits are counted from the least significant
+end of each byte.
+
+
+Back references
+---------------
+
+OP_REF is followed by a single byte containing the reference number.
+
+
+Repeating character classes and back references
+-----------------------------------------------
+
+Single-character classes are handled specially (see above). This applies to
+OP_CLASS and OP_REF. In both cases, the repeat information follows the base
+item. The matching code looks at the following opcode to see if it is one of
+
+  OP_CRSTAR
+  OP_CRMINSTAR
+  OP_CRPLUS
+  OP_CRMINPLUS
+  OP_CRQUERY
+  OP_CRMINQUERY
+  OP_CRRANGE
+  OP_CRMINRANGE
+
+All but the last two are just single-byte items. The others are followed by
+four bytes of data, comprising the minimum and maximum repeat counts.
+
+
+Brackets and alternation
+------------------------
+
+A pair of non-capturing (round) brackets is wrapped round each expression at
+compile time, so alternation always happens in the context of brackets.
+Non-capturing brackets use the opcode OP_BRA, while capturing brackets use
+OP_BRA+1, OP_BRA+2, etc. [Note for North Americans: "bracket" to some English
+speakers, including myself, can be round, square, curly, or pointy. Hence this
+usage.]
+
+A bracket opcode is followed by two bytes which give the offset to the next
+alternative OP_ALT or, if there aren't any branches, to the matching KET
+opcode. Each OP_ALT is followed by two bytes giving the offset to the next one,
+or to the KET opcode.
+
+OP_KET is used for subpatterns that do not repeat indefinitely, while
+OP_KETRMIN and OP_KETRMAX are used for indefinite repetitions, minimally or
+maximally respectively. All three are followed by two bytes giving (as a
+positive number) the offset back to the matching BRA opcode.
+
+If a subpattern is quantified such that it is permitted to match zero times, it
+is preceded by one of OP_BRAZERO or OP_BRAMINZERO. These are single-byte
+opcodes which tell the matcher that skipping this subpattern entirely is a
+valid branch.
+
+A subpattern with an indefinite maximum repetition is replicated in the
+compiled data its minimum number of times (or once with a BRAZERO if the
+minimum is zero), with the final copy terminating with a KETRMIN or KETRMAX as
+appropriate.
+
+A subpattern with a bounded maximum repetition is replicated in a nested
+fashion up to the maximum number of times, with BRAZERO or BRAMINZERO before
+each replication after the minimum, so that, for example, (abc){2,5} is
+compiled as (abc)(abc)((abc)((abc)(abc)?)?)?. The 200-bracket limit does not
+apply to these internally generated brackets.
+
+
+Assertions
+----------
+
+Forward assertions are just like other subpatterns, but starting with one of
+the opcodes OP_ASSERT or OP_ASSERT_NOT. Backward assertions use the opcodes
+OP_ASSERTBACK and OP_ASSERTBACK_NOT, and the first opcode inside the assertion
+is OP_REVERSE, followed by a two byte count of the number of characters to move
+back the pointer in the subject string. When operating in UTF-8 mode, the count
+is a character count rather than a byte count. A separate count is present in
+each alternative of a lookbehind assertion, allowing them to have different
+fixed lengths.
+
+
+Once-only subpatterns
+---------------------
+
+These are also just like other subpatterns, but they start with the opcode
+OP_ONCE.
+
+
+Conditional subpatterns
+-----------------------
+
+These are like other subpatterns, but they start with the opcode OP_COND. If
+the condition is a back reference, this is stored at the start of the
+subpattern using the opcode OP_CREF followed by one byte containing the
+reference number. Otherwise, a conditional subpattern will always start with
+one of the assertions.
+
+
+Changing options
+----------------
+
+If any of the /i, /m, or /s options are changed within a parenthesized group,
+an OP_OPT opcode is compiled, followed by one byte containing the new settings
+of these flags. If there are several alternatives in a group, there is an
+occurrence of OP_OPT at the start of all those following the first options
+change, to set appropriate options for the start of the alternative.
+Immediately after the end of the group there is another such item to reset the
+flags to their previous values. Other changes of flag within the pattern can be
+handled entirely at compile time, and so do not cause anything to be put into
+the compiled data.
+
+
+Philip Hazel
+August 2000
diff --git a/pcre/doc/authors b/pcre/doc/authors
new file mode 100644 (file)
index 0000000..bfe1b5d
--- /dev/null
@@ -0,0 +1,6 @@
+Written by: Philip Hazel <ph10@cam.ac.uk>
+
+University of Cambridge Computing Service,
+Cambridge, England. Phone: +44 1223 334714.
+
+Copyright (c) 1997-2000 University of Cambridge
diff --git a/pcre/doc/copying b/pcre/doc/copying
new file mode 100644 (file)
index 0000000..34d20db
--- /dev/null
@@ -0,0 +1,46 @@
+PCRE LICENCE
+------------
+
+PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+Written by: Philip Hazel <ph10@cam.ac.uk>
+
+University of Cambridge Computing Service,
+Cambridge, England. Phone: +44 1223 334714.
+
+Copyright (c) 1997-2000 University of Cambridge
+
+Permission is granted to anyone to use this software for any purpose on any
+computer system, and to redistribute it freely, subject to the following
+restrictions:
+
+1. This software is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission. In practice, this means that if you use
+   PCRE in software which you distribute to others, commercially or
+   otherwise, you must put a sentence like this
+
+     Regular expression support is provided by the PCRE library package,
+     which is open source software, written by Philip Hazel, and copyright
+     by the University of Cambridge, England.
+
+   somewhere reasonably visible in your documentation and in any relevant
+   files or online help data or similar. A reference to the ftp site for
+   the source, that is, to
+
+     ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/
+
+   should also be given in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+4. If PCRE is embedded in any software that is released under the GNU
+   General Purpose Licence (GPL), then the terms of that licence shall
+   supersede any condition above with which it is incompatible.
+
+End
diff --git a/pcre/doc/news b/pcre/doc/news
new file mode 100644 (file)
index 0000000..56fccdf
--- /dev/null
@@ -0,0 +1,54 @@
+News about PCRE releases
+------------------------
+
+Release 3.3 01-Aug-00
+---------------------
+
+There is some support for UTF-8 character strings. This is incomplete and
+experimental. The documentation describes what is and what is not implemented.
+Otherwise, this is just a bug-fixing release.
+
+
+Release 3.0 01-Feb-00
+---------------------
+
+1. A "configure" script is now used to configure PCRE for Unix systems. It
+builds a Makefile, a config.h file, and the pcre-config script.
+
+2. PCRE is built as a shared library by default.
+
+3. There is support for POSIX classes such as [:alpha:].
+
+5. There is an experimental recursion feature.
+
+----------------------------------------------------------------------------
+          IMPORTANT FOR THOSE UPGRADING FROM VERSIONS BEFORE 2.00
+
+Please note that there has been a change in the API such that a larger
+ovector is required at matching time, to provide some additional workspace.
+The new man page has details. This change was necessary in order to support
+some of the new functionality in Perl 5.005.
+
+          IMPORTANT FOR THOSE UPGRADING FROM VERSION 2.00
+
+Another (I hope this is the last!) change has been made to the API for the
+pcre_compile() function. An additional argument has been added to make it
+possible to pass over a pointer to character tables built in the current
+locale by pcre_maketables(). To use the default tables, this new arguement
+should be passed as NULL.
+
+          IMPORTANT FOR THOSE UPGRADING FROM VERSION 2.05
+
+Yet another (and again I hope this really is the last) change has been made
+to the API for the pcre_exec() function. An additional argument has been
+added to make it possible to start the match other than at the start of the
+subject string. This is important if there are lookbehinds. The new man
+page has the details, but you just want to convert existing programs, all
+you need to do is to stick in a new fifth argument to pcre_exec(), with a
+value of zero. For example, change
+
+  pcre_exec(pattern, extra, subject, length, options, ovec, ovecsize)
+to
+  pcre_exec(pattern, extra, subject, length, 0, options, ovec, ovecsize)
+
+****
diff --git a/pcre/doc/pcre.3 b/pcre/doc/pcre.3
new file mode 100644 (file)
index 0000000..bb812f4
--- /dev/null
@@ -0,0 +1,1810 @@
+.TH PCRE 3\r
+.SH NAME\r
+pcre - Perl-compatible regular expressions.\r
+.SH SYNOPSIS\r
+.B #include <pcre.h>\r
+.PP\r
+.SM\r
+.br\r
+.B pcre *pcre_compile(const char *\fIpattern\fR, int \fIoptions\fR,\r
+.ti +5n\r
+.B const char **\fIerrptr\fR, int *\fIerroffset\fR,\r
+.ti +5n\r
+.B const unsigned char *\fItableptr\fR);\r
+.PP\r
+.br\r
+.B pcre_extra *pcre_study(const pcre *\fIcode\fR, int \fIoptions\fR,\r
+.ti +5n\r
+.B const char **\fIerrptr\fR);\r
+.PP\r
+.br\r
+.B int pcre_exec(const pcre *\fIcode\fR, "const pcre_extra *\fIextra\fR,"\r
+.ti +5n\r
+.B "const char *\fIsubject\fR," int \fIlength\fR, int \fIstartoffset\fR,\r
+.ti +5n\r
+.B int \fIoptions\fR, int *\fIovector\fR, int \fIovecsize\fR);\r
+.PP\r
+.br\r
+.B int pcre_copy_substring(const char *\fIsubject\fR, int *\fIovector\fR,\r
+.ti +5n\r
+.B int \fIstringcount\fR, int \fIstringnumber\fR, char *\fIbuffer\fR,\r
+.ti +5n\r
+.B int \fIbuffersize\fR);\r
+.PP\r
+.br\r
+.B int pcre_get_substring(const char *\fIsubject\fR, int *\fIovector\fR,\r
+.ti +5n\r
+.B int \fIstringcount\fR, int \fIstringnumber\fR,\r
+.ti +5n\r
+.B const char **\fIstringptr\fR);\r
+.PP\r
+.br\r
+.B int pcre_get_substring_list(const char *\fIsubject\fR,\r
+.ti +5n\r
+.B int *\fIovector\fR, int \fIstringcount\fR, "const char ***\fIlistptr\fR);"\r
+.PP\r
+.br\r
+.B void pcre_free_substring(const char *\fIstringptr\fR);\r
+.PP\r
+.br\r
+.B void pcre_free_substring_list(const char **\fIstringptr\fR);\r
+.PP\r
+.br\r
+.B const unsigned char *pcre_maketables(void);\r
+.PP\r
+.br\r
+.B int pcre_fullinfo(const pcre *\fIcode\fR, "const pcre_extra *\fIextra\fR,"\r
+.ti +5n\r
+.B int \fIwhat\fR, void *\fIwhere\fR);\r
+.PP\r
+.br\r
+.B int pcre_info(const pcre *\fIcode\fR, int *\fIoptptr\fR, int\r
+.B *\fIfirstcharptr\fR);\r
+.PP\r
+.br\r
+.B char *pcre_version(void);\r
+.PP\r
+.br\r
+.B void *(*pcre_malloc)(size_t);\r
+.PP\r
+.br\r
+.B void (*pcre_free)(void *);\r
+\r
+\r
+\r
+.SH DESCRIPTION\r
+The PCRE library is a set of functions that implement regular expression\r
+pattern matching using the same syntax and semantics as Perl 5, with just a few\r
+differences (see below). The current implementation corresponds to Perl 5.005,\r
+with some additional features from later versions. This includes some\r
+experimental, incomplete support for UTF-8 encoded strings. Details of exactly\r
+what is and what is not supported are given below.\r
+\r
+PCRE has its own native API, which is described in this document. There is also\r
+a set of wrapper functions that correspond to the POSIX regular expression API.\r
+These are described in the \fBpcreposix\fR documentation.\r
+\r
+The native API function prototypes are defined in the header file \fBpcre.h\fR,\r
+and on Unix systems the library itself is called \fBlibpcre.a\fR, so can be\r
+accessed by adding \fB-lpcre\fR to the command for linking an application which\r
+calls it. The header file defines the macros PCRE_MAJOR and PCRE_MINOR to\r
+contain the major and minor release numbers for the library. Applications can\r
+use these to include support for different releases.\r
+\r
+The functions \fBpcre_compile()\fR, \fBpcre_study()\fR, and \fBpcre_exec()\fR\r
+are used for compiling and matching regular expressions.\r
+\r
+The functions \fBpcre_copy_substring()\fR, \fBpcre_get_substring()\fR, and\r
+\fBpcre_get_substring_list()\fR are convenience functions for extracting\r
+captured substrings from a matched subject string; \fBpcre_free_substring()\fR\r
+and \fBpcre_free_substring_list()\fR are also provided, to free the memory used\r
+for extracted strings.\r
+\r
+The function \fBpcre_maketables()\fR is used (optionally) to build a set of\r
+character tables in the current locale for passing to \fBpcre_compile()\fR.\r
+\r
+The function \fBpcre_fullinfo()\fR is used to find out information about a\r
+compiled pattern; \fBpcre_info()\fR is an obsolete version which returns only\r
+some of the available information, but is retained for backwards compatibility.\r
+The function \fBpcre_version()\fR returns a pointer to a string containing the\r
+version of PCRE and its date of release.\r
+\r
+The global variables \fBpcre_malloc\fR and \fBpcre_free\fR initially contain\r
+the entry points of the standard \fBmalloc()\fR and \fBfree()\fR functions\r
+respectively. PCRE calls the memory management functions via these variables,\r
+so a calling program can replace them if it wishes to intercept the calls. This\r
+should be done before calling any PCRE functions.\r
+\r
+\r
+.SH MULTI-THREADING\r
+The PCRE functions can be used in multi-threading applications, with the\r
+proviso that the memory management functions pointed to by \fBpcre_malloc\fR\r
+and \fBpcre_free\fR are shared by all threads.\r
+\r
+The compiled form of a regular expression is not altered during matching, so\r
+the same compiled pattern can safely be used by several threads at once.\r
+\r
+\r
+.SH COMPILING A PATTERN\r
+The function \fBpcre_compile()\fR is called to compile a pattern into an\r
+internal form. The pattern is a C string terminated by a binary zero, and\r
+is passed in the argument \fIpattern\fR. A pointer to a single block of memory\r
+that is obtained via \fBpcre_malloc\fR is returned. This contains the\r
+compiled code and related data. The \fBpcre\fR type is defined for this for\r
+convenience, but in fact \fBpcre\fR is just a typedef for \fBvoid\fR, since the\r
+contents of the block are not externally defined. It is up to the caller to\r
+free the memory when it is no longer required.\r
+.PP\r
+The size of a compiled pattern is roughly proportional to the length of the\r
+pattern string, except that each character class (other than those containing\r
+just a single character, negated or not) requires 33 bytes, and repeat\r
+quantifiers with a minimum greater than one or a bounded maximum cause the\r
+relevant portions of the compiled pattern to be replicated.\r
+.PP\r
+The \fIoptions\fR argument contains independent bits that affect the\r
+compilation. It should be zero if no options are required. Some of the options,\r
+in particular, those that are compatible with Perl, can also be set and unset\r
+from within the pattern (see the detailed description of regular expressions\r
+below). For these options, the contents of the \fIoptions\fR argument specifies\r
+their initial settings at the start of compilation and execution. The\r
+PCRE_ANCHORED option can be set at the time of matching as well as at compile\r
+time.\r
+.PP\r
+If \fIerrptr\fR is NULL, \fBpcre_compile()\fR returns NULL immediately.\r
+Otherwise, if compilation of a pattern fails, \fBpcre_compile()\fR returns\r
+NULL, and sets the variable pointed to by \fIerrptr\fR to point to a textual\r
+error message. The offset from the start of the pattern to the character where\r
+the error was discovered is placed in the variable pointed to by\r
+\fIerroffset\fR, which must not be NULL. If it is, an immediate error is given.\r
+.PP\r
+If the final argument, \fItableptr\fR, is NULL, PCRE uses a default set of\r
+character tables which are built when it is compiled, using the default C\r
+locale. Otherwise, \fItableptr\fR must be the result of a call to\r
+\fBpcre_maketables()\fR. See the section on locale support below.\r
+.PP\r
+The following option bits are defined in the header file:\r
+\r
+  PCRE_ANCHORED\r
+\r
+If this bit is set, the pattern is forced to be "anchored", that is, it is\r
+constrained to match only at the start of the string which is being searched\r
+(the "subject string"). This effect can also be achieved by appropriate\r
+constructs in the pattern itself, which is the only way to do it in Perl.\r
+\r
+  PCRE_CASELESS\r
+\r
+If this bit is set, letters in the pattern match both upper and lower case\r
+letters. It is equivalent to Perl's /i option.\r
+\r
+  PCRE_DOLLAR_ENDONLY\r
+\r
+If this bit is set, a dollar metacharacter in the pattern matches only at the\r
+end of the subject string. Without this option, a dollar also matches\r
+immediately before the final character if it is a newline (but not before any\r
+other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is\r
+set. There is no equivalent to this option in Perl.\r
+\r
+  PCRE_DOTALL\r
+\r
+If this bit is set, a dot metacharater in the pattern matches all characters,\r
+including newlines. Without it, newlines are excluded. This option is\r
+equivalent to Perl's /s option. A negative class such as [^a] always matches a\r
+newline character, independent of the setting of this option.\r
+\r
+  PCRE_EXTENDED\r
+\r
+If this bit is set, whitespace data characters in the pattern are totally\r
+ignored except when escaped or inside a character class, and characters between\r
+an unescaped # outside a character class and the next newline character,\r
+inclusive, are also ignored. This is equivalent to Perl's /x option, and makes\r
+it possible to include comments inside complicated patterns. Note, however,\r
+that this applies only to data characters. Whitespace characters may never\r
+appear within special character sequences in a pattern, for example within the\r
+sequence (?( which introduces a conditional subpattern.\r
+\r
+  PCRE_EXTRA\r
+\r
+This option was invented in order to turn on additional functionality of PCRE\r
+that is incompatible with Perl, but it is currently of very little use. When\r
+set, any backslash in a pattern that is followed by a letter that has no\r
+special meaning causes an error, thus reserving these combinations for future\r
+expansion. By default, as in Perl, a backslash followed by a letter with no\r
+special meaning is treated as a literal. There are at present no other features\r
+controlled by this option. It can also be set by a (?X) option setting within a\r
+pattern.\r
+\r
+  PCRE_MULTILINE\r
+\r
+By default, PCRE treats the subject string as consisting of a single "line" of\r
+characters (even if it actually contains several newlines). The "start of line"\r
+metacharacter (^) matches only at the start of the string, while the "end of\r
+line" metacharacter ($) matches only at the end of the string, or before a\r
+terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as\r
+Perl.\r
+\r
+When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs\r
+match immediately following or immediately before any newline in the subject\r
+string, respectively, as well as at the very start and end. This is equivalent\r
+to Perl's /m option. If there are no "\\n" characters in a subject string, or\r
+no occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no\r
+effect.\r
+\r
+  PCRE_UNGREEDY\r
+\r
+This option inverts the "greediness" of the quantifiers so that they are not\r
+greedy by default, but become greedy if followed by "?". It is not compatible\r
+with Perl. It can also be set by a (?U) option setting within the pattern.\r
+\r
+  PCRE_UTF8\r
+\r
+This option causes PCRE to regard both the pattern and the subject as strings\r
+of UTF-8 characters instead of just byte strings. However, it is available only\r
+if PCRE has been built to include UTF-8 support. If not, the use of this option\r
+provokes an error. Support for UTF-8 is new, experimental, and incomplete.\r
+Details of exactly what it entails are given below.\r
+\r
+\r
+.SH STUDYING A PATTERN\r
+When a pattern is going to be used several times, it is worth spending more\r
+time analyzing it in order to speed up the time taken for matching. The\r
+function \fBpcre_study()\fR takes a pointer to a compiled pattern as its first\r
+argument, and returns a pointer to a \fBpcre_extra\fR block (another \fBvoid\fR\r
+typedef) containing additional information about the pattern; this can be\r
+passed to \fBpcre_exec()\fR. If no additional information is available, NULL\r
+is returned.\r
+\r
+The second argument contains option bits. At present, no options are defined\r
+for \fBpcre_study()\fR, and this argument should always be zero.\r
+\r
+The third argument for \fBpcre_study()\fR is a pointer to an error message. If\r
+studying succeeds (even if no data is returned), the variable it points to is\r
+set to NULL. Otherwise it points to a textual error message.\r
+\r
+At present, studying a pattern is useful only for non-anchored patterns that do\r
+not have a single fixed starting character. A bitmap of possible starting\r
+characters is created.\r
+\r
+\r
+.SH LOCALE SUPPORT\r
+PCRE handles caseless matching, and determines whether characters are letters,\r
+digits, or whatever, by reference to a set of tables. The library contains a\r
+default set of tables which is created in the default C locale when PCRE is\r
+compiled. This is used when the final argument of \fBpcre_compile()\fR is NULL,\r
+and is sufficient for many applications.\r
+\r
+An alternative set of tables can, however, be supplied. Such tables are built\r
+by calling the \fBpcre_maketables()\fR function, which has no arguments, in the\r
+relevant locale. The result can then be passed to \fBpcre_compile()\fR as often\r
+as necessary. For example, to build and use tables that are appropriate for the\r
+French locale (where accented characters with codes greater than 128 are\r
+treated as letters), the following code could be used:\r
+\r
+  setlocale(LC_CTYPE, "fr");\r
+  tables = pcre_maketables();\r
+  re = pcre_compile(..., tables);\r
+\r
+The tables are built in memory that is obtained via \fBpcre_malloc\fR. The\r
+pointer that is passed to \fBpcre_compile\fR is saved with the compiled\r
+pattern, and the same tables are used via this pointer by \fBpcre_study()\fR\r
+and \fBpcre_exec()\fR. Thus for any single pattern, compilation, studying and\r
+matching all happen in the same locale, but different patterns can be compiled\r
+in different locales. It is the caller's responsibility to ensure that the\r
+memory containing the tables remains available for as long as it is needed.\r
+\r
+\r
+.SH INFORMATION ABOUT A PATTERN\r
+The \fBpcre_fullinfo()\fR function returns information about a compiled\r
+pattern. It replaces the obsolete \fBpcre_info()\fR function, which is\r
+nevertheless retained for backwards compability (and is documented below).\r
+\r
+The first argument for \fBpcre_fullinfo()\fR is a pointer to the compiled\r
+pattern. The second argument is the result of \fBpcre_study()\fR, or NULL if\r
+the pattern was not studied. The third argument specifies which piece of\r
+information is required, while the fourth argument is a pointer to a variable\r
+to receive the data. The yield of the function is zero for success, or one of\r
+the following negative numbers:\r
+\r
+  PCRE_ERROR_NULL       the argument \fIcode\fR was NULL\r
+                        the argument \fIwhere\fR was NULL\r
+  PCRE_ERROR_BADMAGIC   the "magic number" was not found\r
+  PCRE_ERROR_BADOPTION  the value of \fIwhat\fR was invalid\r
+\r
+The possible values for the third argument are defined in \fBpcre.h\fR, and are\r
+as follows:\r
+\r
+  PCRE_INFO_OPTIONS\r
+\r
+Return a copy of the options with which the pattern was compiled. The fourth\r
+argument should point to au \fBunsigned long int\fR variable. These option bits\r
+are those specified in the call to \fBpcre_compile()\fR, modified by any\r
+top-level option settings within the pattern itself, and with the PCRE_ANCHORED\r
+bit forcibly set if the form of the pattern implies that it can match only at\r
+the start of a subject string.\r
+\r
+  PCRE_INFO_SIZE\r
+\r
+Return the size of the compiled pattern, that is, the value that was passed as\r
+the argument to \fBpcre_malloc()\fR when PCRE was getting memory in which to\r
+place the compiled data. The fourth argument should point to a \fBsize_t\fR\r
+variable.\r
+\r
+  PCRE_INFO_CAPTURECOUNT\r
+\r
+Return the number of capturing subpatterns in the pattern. The fourth argument\r
+should point to an \fbint\fR variable.\r
+\r
+  PCRE_INFO_BACKREFMAX\r
+\r
+Return the number of the highest back reference in the pattern. The fourth\r
+argument should point to an \fBint\fR variable. Zero is returned if there are\r
+no back references.\r
+\r
+  PCRE_INFO_FIRSTCHAR\r
+\r
+Return information about the first character of any matched string, for a\r
+non-anchored pattern. If there is a fixed first character, e.g. from a pattern\r
+such as (cat|cow|coyote), it is returned in the integer pointed to by\r
+\fIwhere\fR. Otherwise, if either\r
+\r
+(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch\r
+starts with "^", or\r
+\r
+(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set\r
+(if it were set, the pattern would be anchored),\r
+\r
+-1 is returned, indicating that the pattern matches only at the start of a\r
+subject string or after any "\\n" within the string. Otherwise -2 is returned.\r
+For anchored patterns, -2 is returned.\r
+\r
+  PCRE_INFO_FIRSTTABLE\r
+\r
+If the pattern was studied, and this resulted in the construction of a 256-bit\r
+table indicating a fixed set of characters for the first character in any\r
+matching string, a pointer to the table is returned. Otherwise NULL is\r
+returned. The fourth argument should point to an \fBunsigned char *\fR\r
+variable.\r
+\r
+  PCRE_INFO_LASTLITERAL\r
+\r
+For a non-anchored pattern, return the value of the rightmost literal character\r
+which must exist in any matched string, other than at its start. The fourth\r
+argument should point to an \fBint\fR variable. If there is no such character,\r
+or if the pattern is anchored, -1 is returned. For example, for the pattern\r
+/a\\d+z\\d+/ the returned value is 'z'.\r
+\r
+The \fBpcre_info()\fR function is now obsolete because its interface is too\r
+restrictive to return all the available data about a compiled pattern. New\r
+programs should use \fBpcre_fullinfo()\fR instead. The yield of\r
+\fBpcre_info()\fR is the number of capturing subpatterns, or one of the\r
+following negative numbers:\r
+\r
+  PCRE_ERROR_NULL       the argument \fIcode\fR was NULL\r
+  PCRE_ERROR_BADMAGIC   the "magic number" was not found\r
+\r
+If the \fIoptptr\fR argument is not NULL, a copy of the options with which the\r
+pattern was compiled is placed in the integer it points to (see\r
+PCRE_INFO_OPTIONS above).\r
+\r
+If the pattern is not anchored and the \fIfirstcharptr\fR argument is not NULL,\r
+it is used to pass back information about the first character of any matched\r
+string (see PCRE_INFO_FIRSTCHAR above).\r
+\r
+\r
+.SH MATCHING A PATTERN\r
+The function \fBpcre_exec()\fR is called to match a subject string against a\r
+pre-compiled pattern, which is passed in the \fIcode\fR argument. If the\r
+pattern has been studied, the result of the study should be passed in the\r
+\fIextra\fR argument. Otherwise this must be NULL.\r
+\r
+The PCRE_ANCHORED option can be passed in the \fIoptions\fR argument, whose\r
+unused bits must be zero. However, if a pattern was compiled with\r
+PCRE_ANCHORED, or turned out to be anchored by virtue of its contents, it\r
+cannot be made unachored at matching time.\r
+\r
+There are also three further options that can be set only at matching time:\r
+\r
+  PCRE_NOTBOL\r
+\r
+The first character of the string is not the beginning of a line, so the\r
+circumflex metacharacter should not match before it. Setting this without\r
+PCRE_MULTILINE (at compile time) causes circumflex never to match.\r
+\r
+  PCRE_NOTEOL\r
+\r
+The end of the string is not the end of a line, so the dollar metacharacter\r
+should not match it nor (except in multiline mode) a newline immediately before\r
+it. Setting this without PCRE_MULTILINE (at compile time) causes dollar never\r
+to match.\r
+\r
+  PCRE_NOTEMPTY\r
+\r
+An empty string is not considered to be a valid match if this option is set. If\r
+there are alternatives in the pattern, they are tried. If all the alternatives\r
+match the empty string, the entire match fails. For example, if the pattern\r
+\r
+  a?b?\r
+\r
+is applied to a string not beginning with "a" or "b", it matches the empty\r
+string at the start of the subject. With PCRE_NOTEMPTY set, this match is not\r
+valid, so PCRE searches further into the string for occurrences of "a" or "b".\r
+\r
+Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case\r
+of a pattern match of the empty string within its \fBsplit()\fR function, and\r
+when using the /g modifier. It is possible to emulate Perl's behaviour after\r
+matching a null string by first trying the match again at the same offset with\r
+PCRE_NOTEMPTY set, and then if that fails by advancing the starting offset (see\r
+below) and trying an ordinary match again.\r
+\r
+The subject string is passed as a pointer in \fIsubject\fR, a length in\r
+\fIlength\fR, and a starting offset in \fIstartoffset\fR. Unlike the pattern\r
+string, it may contain binary zero characters. When the starting offset is\r
+zero, the search for a match starts at the beginning of the subject, and this\r
+is by far the most common case.\r
+\r
+A non-zero starting offset is useful when searching for another match in the\r
+same subject by calling \fBpcre_exec()\fR again after a previous success.\r
+Setting \fIstartoffset\fR differs from just passing over a shortened string and\r
+setting PCRE_NOTBOL in the case of a pattern that begins with any kind of\r
+lookbehind. For example, consider the pattern\r
+\r
+  \\Biss\\B\r
+\r
+which finds occurrences of "iss" in the middle of words. (\\B matches only if\r
+the current position in the subject is not a word boundary.) When applied to\r
+the string "Mississipi" the first call to \fBpcre_exec()\fR finds the first\r
+occurrence. If \fBpcre_exec()\fR is called again with just the remainder of the\r
+subject, namely "issipi", it does not match, because \\B is always false at the\r
+start of the subject, which is deemed to be a word boundary. However, if\r
+\fBpcre_exec()\fR is passed the entire string again, but with \fIstartoffset\fR\r
+set to 4, it finds the second occurrence of "iss" because it is able to look\r
+behind the starting point to discover that it is preceded by a letter.\r
+\r
+If a non-zero starting offset is passed when the pattern is anchored, one\r
+attempt to match at the given offset is tried. This can only succeed if the\r
+pattern does not require the match to be at the start of the subject.\r
+\r
+In general, a pattern matches a certain portion of the subject, and in\r
+addition, further substrings from the subject may be picked out by parts of the\r
+pattern. Following the usage in Jeffrey Friedl's book, this is called\r
+"capturing" in what follows, and the phrase "capturing subpattern" is used for\r
+a fragment of a pattern that picks out a substring. PCRE supports several other\r
+kinds of parenthesized subpattern that do not cause substrings to be captured.\r
+\r
+Captured substrings are returned to the caller via a vector of integer offsets\r
+whose address is passed in \fIovector\fR. The number of elements in the vector\r
+is passed in \fIovecsize\fR. The first two-thirds of the vector is used to pass\r
+back captured substrings, each substring using a pair of integers. The\r
+remaining third of the vector is used as workspace by \fBpcre_exec()\fR while\r
+matching capturing subpatterns, and is not available for passing back\r
+information. The length passed in \fIovecsize\fR should always be a multiple of\r
+three. If it is not, it is rounded down.\r
+\r
+When a match has been successful, information about captured substrings is\r
+returned in pairs of integers, starting at the beginning of \fIovector\fR, and\r
+continuing up to two-thirds of its length at the most. The first element of a\r
+pair is set to the offset of the first character in a substring, and the second\r
+is set to the offset of the first character after the end of a substring. The\r
+first pair, \fIovector[0]\fR and \fIovector[1]\fR, identify the portion of the\r
+subject string matched by the entire pattern. The next pair is used for the\r
+first capturing subpattern, and so on. The value returned by \fBpcre_exec()\fR\r
+is the number of pairs that have been set. If there are no capturing\r
+subpatterns, the return value from a successful match is 1, indicating that\r
+just the first pair of offsets has been set.\r
+\r
+Some convenience functions are provided for extracting the captured substrings\r
+as separate strings. These are described in the following section.\r
+\r
+It is possible for an capturing subpattern number \fIn+1\fR to match some\r
+part of the subject when subpattern \fIn\fR has not been used at all. For\r
+example, if the string "abc" is matched against the pattern (a|(z))(bc)\r
+subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset\r
+values corresponding to the unused subpattern are set to -1.\r
+\r
+If a capturing subpattern is matched repeatedly, it is the last portion of the\r
+string that it matched that gets returned.\r
+\r
+If the vector is too small to hold all the captured substrings, it is used as\r
+far as possible (up to two-thirds of its length), and the function returns a\r
+value of zero. In particular, if the substring offsets are not of interest,\r
+\fBpcre_exec()\fR may be called with \fIovector\fR passed as NULL and\r
+\fIovecsize\fR as zero. However, if the pattern contains back references and\r
+the \fIovector\fR isn't big enough to remember the related substrings, PCRE has\r
+to get additional memory for use during matching. Thus it is usually advisable\r
+to supply an \fIovector\fR.\r
+\r
+Note that \fBpcre_info()\fR can be used to find out how many capturing\r
+subpatterns there are in a compiled pattern. The smallest size for\r
+\fIovector\fR that will allow for \fIn\fR captured substrings in addition to\r
+the offsets of the substring matched by the whole pattern is (\fIn\fR+1)*3.\r
+\r
+If \fBpcre_exec()\fR fails, it returns a negative number. The following are\r
+defined in the header file:\r
+\r
+  PCRE_ERROR_NOMATCH        (-1)\r
+\r
+The subject string did not match the pattern.\r
+\r
+  PCRE_ERROR_NULL           (-2)\r
+\r
+Either \fIcode\fR or \fIsubject\fR was passed as NULL, or \fIovector\fR was\r
+NULL and \fIovecsize\fR was not zero.\r
+\r
+  PCRE_ERROR_BADOPTION      (-3)\r
+\r
+An unrecognized bit was set in the \fIoptions\fR argument.\r
+\r
+  PCRE_ERROR_BADMAGIC       (-4)\r
+\r
+PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch\r
+the case when it is passed a junk pointer. This is the error it gives when the\r
+magic number isn't present.\r
+\r
+  PCRE_ERROR_UNKNOWN_NODE   (-5)\r
+\r
+While running the pattern match, an unknown item was encountered in the\r
+compiled pattern. This error could be caused by a bug in PCRE or by overwriting\r
+of the compiled pattern.\r
+\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+\r
+If a pattern contains back references, but the \fIovector\fR that is passed to\r
+\fBpcre_exec()\fR is not big enough to remember the referenced substrings, PCRE\r
+gets a block of memory at the start of matching to use for this purpose. If the\r
+call via \fBpcre_malloc()\fR fails, this error is given. The memory is freed at\r
+the end of matching.\r
+\r
+\r
+.SH EXTRACTING CAPTURED SUBSTRINGS\r
+Captured substrings can be accessed directly by using the offsets returned by\r
+\fBpcre_exec()\fR in \fIovector\fR. For convenience, the functions\r
+\fBpcre_copy_substring()\fR, \fBpcre_get_substring()\fR, and\r
+\fBpcre_get_substring_list()\fR are provided for extracting captured substrings\r
+as new, separate, zero-terminated strings. A substring that contains a binary\r
+zero is correctly extracted and has a further zero added on the end, but the\r
+result does not, of course, function as a C string.\r
+\r
+The first three arguments are the same for all three functions: \fIsubject\fR\r
+is the subject string which has just been successfully matched, \fIovector\fR\r
+is a pointer to the vector of integer offsets that was passed to\r
+\fBpcre_exec()\fR, and \fIstringcount\fR is the number of substrings that\r
+were captured by the match, including the substring that matched the entire\r
+regular expression. This is the value returned by \fBpcre_exec\fR if it\r
+is greater than zero. If \fBpcre_exec()\fR returned zero, indicating that it\r
+ran out of space in \fIovector\fR, the value passed as \fIstringcount\fR should\r
+be the size of the vector divided by three.\r
+\r
+The functions \fBpcre_copy_substring()\fR and \fBpcre_get_substring()\fR\r
+extract a single substring, whose number is given as \fIstringnumber\fR. A\r
+value of zero extracts the substring that matched the entire pattern, while\r
+higher values extract the captured substrings. For \fBpcre_copy_substring()\fR,\r
+the string is placed in \fIbuffer\fR, whose length is given by\r
+\fIbuffersize\fR, while for \fBpcre_get_substring()\fR a new block of memory is\r
+obtained via \fBpcre_malloc\fR, and its address is returned via\r
+\fIstringptr\fR. The yield of the function is the length of the string, not\r
+including the terminating zero, or one of\r
+\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+\r
+The buffer was too small for \fBpcre_copy_substring()\fR, or the attempt to get\r
+memory failed for \fBpcre_get_substring()\fR.\r
+\r
+  PCRE_ERROR_NOSUBSTRING    (-7)\r
+\r
+There is no substring whose number is \fIstringnumber\fR.\r
+\r
+The \fBpcre_get_substring_list()\fR function extracts all available substrings\r
+and builds a list of pointers to them. All this is done in a single block of\r
+memory which is obtained via \fBpcre_malloc\fR. The address of the memory block\r
+is returned via \fIlistptr\fR, which is also the start of the list of string\r
+pointers. The end of the list is marked by a NULL pointer. The yield of the\r
+function is zero if all went well, or\r
+\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+\r
+if the attempt to get the memory block failed.\r
+\r
+When any of these functions encounter a substring that is unset, which can\r
+happen when capturing subpattern number \fIn+1\fR matches some part of the\r
+subject, but subpattern \fIn\fR has not been used at all, they return an empty\r
+string. This can be distinguished from a genuine zero-length substring by\r
+inspecting the appropriate offset in \fIovector\fR, which is negative for unset\r
+substrings.\r
+\r
+The two convenience functions \fBpcre_free_substring()\fR and\r
+\fBpcre_free_substring_list()\fR can be used to free the memory returned by\r
+a previous call of \fBpcre_get_substring()\fR or\r
+\fBpcre_get_substring_list()\fR, respectively. They do nothing more than call\r
+the function pointed to by \fBpcre_free\fR, which of course could be called\r
+directly from a C program. However, PCRE is used in some situations where it is\r
+linked via a special interface to another programming language which cannot use\r
+\fBpcre_free\fR directly; it is for these cases that the functions are\r
+provided.\r
+\r
+\r
+.SH LIMITATIONS\r
+There are some size limitations in PCRE but it is hoped that they will never in\r
+practice be relevant.\r
+The maximum length of a compiled pattern is 65539 (sic) bytes.\r
+All values in repeating quantifiers must be less than 65536.\r
+The maximum number of capturing subpatterns is 99.\r
+The maximum number of all parenthesized subpatterns, including capturing\r
+subpatterns, assertions, and other types of subpattern, is 200.\r
+\r
+The maximum length of a subject string is the largest positive number that an\r
+integer variable can hold. However, PCRE uses recursion to handle subpatterns\r
+and indefinite repetition. This means that the available stack space may limit\r
+the size of a subject string that can be processed by certain patterns.\r
+\r
+\r
+.SH DIFFERENCES FROM PERL\r
+The differences described here are with respect to Perl 5.005.\r
+\r
+1. By default, a whitespace character is any character that the C library\r
+function \fBisspace()\fR recognizes, though it is possible to compile PCRE with\r
+alternative character type tables. Normally \fBisspace()\fR matches space,\r
+formfeed, newline, carriage return, horizontal tab, and vertical tab. Perl 5\r
+no longer includes vertical tab in its set of whitespace characters. The \\v\r
+escape that was in the Perl documentation for a long time was never in fact\r
+recognized. However, the character itself was treated as whitespace at least\r
+up to 5.002. In 5.004 and 5.005 it does not match \\s.\r
+\r
+2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits\r
+them, but they do not mean what you might think. For example, (?!a){3} does\r
+not assert that the next three characters are not "a". It just asserts that the\r
+next character is not "a" three times.\r
+\r
+3. Capturing subpatterns that occur inside negative lookahead assertions are\r
+counted, but their entries in the offsets vector are never set. Perl sets its\r
+numerical variables from any such patterns that are matched before the\r
+assertion fails to match something (thereby succeeding), but only if the\r
+negative lookahead assertion contains just one branch.\r
+\r
+4. Though binary zero characters are supported in the subject string, they are\r
+not allowed in a pattern string because it is passed as a normal C string,\r
+terminated by zero. The escape sequence "\\0" can be used in the pattern to\r
+represent a binary zero.\r
+\r
+5. The following Perl escape sequences are not supported: \\l, \\u, \\L, \\U,\r
+\\E, \\Q. In fact these are implemented by Perl's general string-handling and\r
+are not part of its pattern matching engine.\r
+\r
+6. The Perl \\G assertion is not supported as it is not relevant to single\r
+pattern matches.\r
+\r
+7. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})\r
+constructions. However, there is some experimental support for recursive\r
+patterns using the non-Perl item (?R).\r
+\r
+8. There are at the time of writing some oddities in Perl 5.005_02 concerned\r
+with the settings of captured strings when part of a pattern is repeated. For\r
+example, matching "aba" against the pattern /^(a(b)?)+$/ sets $2 to the value\r
+"b", but matching "aabbaa" against /^(aa(bb)?)+$/ leaves $2 unset. However, if\r
+the pattern is changed to /^(aa(b(b))?)+$/ then $2 (and $3) are set.\r
+\r
+In Perl 5.004 $2 is set in both cases, and that is also true of PCRE. If in the\r
+future Perl changes to a consistent state that is different, PCRE may change to\r
+follow.\r
+\r
+9. Another as yet unresolved discrepancy is that in Perl 5.005_02 the pattern\r
+/^(a)?(?(1)a|b)+$/ matches the string "a", whereas in PCRE it does not.\r
+However, in both Perl and PCRE /^(a)?a/ matched against "a" leaves $1 unset.\r
+\r
+10. PCRE provides some extensions to the Perl regular expression facilities:\r
+\r
+(a) Although lookbehind assertions must match fixed length strings, each\r
+alternative branch of a lookbehind assertion can match a different length of\r
+string. Perl 5.005 requires them all to have the same length.\r
+\r
+(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $ meta-\r
+character matches only at the very end of the string.\r
+\r
+(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special\r
+meaning is faulted.\r
+\r
+(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is\r
+inverted, that is, by default they are not greedy, but if followed by a\r
+question mark they are.\r
+\r
+(e) PCRE_ANCHORED can be used to force a pattern to be tried only at the start\r
+of the subject.\r
+\r
+(f) The PCRE_NOTBOL, PCRE_NOTEOL, and PCRE_NOTEMPTY options for\r
+\fBpcre_exec()\fR have no Perl equivalents.\r
+\r
+(g) The (?R) construct allows for recursive pattern matching (Perl 5.6 can do\r
+this using the (?p{code}) construct, which PCRE cannot of course support.)\r
+\r
+\r
+.SH REGULAR EXPRESSION DETAILS\r
+The syntax and semantics of the regular expressions supported by PCRE are\r
+described below. Regular expressions are also described in the Perl\r
+documentation and in a number of other books, some of which have copious\r
+examples. Jeffrey Friedl's "Mastering Regular Expressions", published by\r
+O'Reilly (ISBN 1-56592-257), covers them in great detail.\r
+\r
+The description here is intended as reference documentation. The basic\r
+operation of PCRE is on strings of bytes. However, there is the beginnings of\r
+some support for UTF-8 character strings. To use this support you must\r
+configure PCRE to include it, and then call \fBpcre_compile()\fR with the\r
+PCRE_UTF8 option. How this affects the pattern matching is described in the\r
+final section of this document.\r
+\r
+A regular expression is a pattern that is matched against a subject string from\r
+left to right. Most characters stand for themselves in a pattern, and match the\r
+corresponding characters in the subject. As a trivial example, the pattern\r
+\r
+  The quick brown fox\r
+\r
+matches a portion of a subject string that is identical to itself. The power of\r
+regular expressions comes from the ability to include alternatives and\r
+repetitions in the pattern. These are encoded in the pattern by the use of\r
+\fImeta-characters\fR, which do not stand for themselves but instead are\r
+interpreted in some special way.\r
+\r
+There are two different sets of meta-characters: those that are recognized\r
+anywhere in the pattern except within square brackets, and those that are\r
+recognized in square brackets. Outside square brackets, the meta-characters are\r
+as follows:\r
+\r
+  \\      general escape character with several uses\r
+  ^      assert start of subject (or line, in multiline mode)\r
+  $      assert end of subject (or line, in multiline mode)\r
+  .      match any character except newline (by default)\r
+  [      start character class definition\r
+  |      start of alternative branch\r
+  (      start subpattern\r
+  )      end subpattern\r
+  ?      extends the meaning of (\r
+         also 0 or 1 quantifier\r
+         also quantifier minimizer\r
+  *      0 or more quantifier\r
+  +      1 or more quantifier\r
+  {      start min/max quantifier\r
+\r
+Part of a pattern that is in square brackets is called a "character class". In\r
+a character class the only meta-characters are:\r
+\r
+  \\      general escape character\r
+  ^      negate the class, but only if the first character\r
+  -      indicates character range\r
+  ]      terminates the character class\r
+\r
+The following sections describe the use of each of the meta-characters.\r
+\r
+\r
+.SH BACKSLASH\r
+The backslash character has several uses. Firstly, if it is followed by a\r
+non-alphameric character, it takes away any special meaning that character may\r
+have. This use of backslash as an escape character applies both inside and\r
+outside character classes.\r
+\r
+For example, if you want to match a "*" character, you write "\\*" in the\r
+pattern. This applies whether or not the following character would otherwise be\r
+interpreted as a meta-character, so it is always safe to precede a\r
+non-alphameric with "\\" to specify that it stands for itself. In particular,\r
+if you want to match a backslash, you write "\\\\".\r
+\r
+If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the\r
+pattern (other than in a character class) and characters between a "#" outside\r
+a character class and the next newline character are ignored. An escaping\r
+backslash can be used to include a whitespace or "#" character as part of the\r
+pattern.\r
+\r
+A second use of backslash provides a way of encoding non-printing characters\r
+in patterns in a visible manner. There is no restriction on the appearance of\r
+non-printing characters, apart from the binary zero that terminates a pattern,\r
+but when a pattern is being prepared by text editing, it is usually easier to\r
+use one of the following escape sequences than the binary character it\r
+represents:\r
+\r
+  \\a     alarm, that is, the BEL character (hex 07)\r
+  \\cx    "control-x", where x is any character\r
+  \\e     escape (hex 1B)\r
+  \\f     formfeed (hex 0C)\r
+  \\n     newline (hex 0A)\r
+  \\r     carriage return (hex 0D)\r
+  \\t     tab (hex 09)\r
+  \\xhh   character with hex code hh\r
+  \\ddd   character with octal code ddd, or backreference\r
+\r
+The precise effect of "\\cx" is as follows: if "x" is a lower case letter, it\r
+is converted to upper case. Then bit 6 of the character (hex 40) is inverted.\r
+Thus "\\cz" becomes hex 1A, but "\\c{" becomes hex 3B, while "\\c;" becomes hex\r
+7B.\r
+\r
+After "\\x", up to two hexadecimal digits are read (letters can be in upper or\r
+lower case).\r
+\r
+After "\\0" up to two further octal digits are read. In both cases, if there\r
+are fewer than two digits, just those that are present are used. Thus the\r
+sequence "\\0\\x\\07" specifies two binary zeros followed by a BEL character.\r
+Make sure you supply two digits after the initial zero if the character that\r
+follows is itself an octal digit.\r
+\r
+The handling of a backslash followed by a digit other than 0 is complicated.\r
+Outside a character class, PCRE reads it and any following digits as a decimal\r
+number. If the number is less than 10, or if there have been at least that many\r
+previous capturing left parentheses in the expression, the entire sequence is\r
+taken as a \fIback reference\fR. A description of how this works is given\r
+later, following the discussion of parenthesized subpatterns.\r
+\r
+Inside a character class, or if the decimal number is greater than 9 and there\r
+have not been that many capturing subpatterns, PCRE re-reads up to three octal\r
+digits following the backslash, and generates a single byte from the least\r
+significant 8 bits of the value. Any subsequent digits stand for themselves.\r
+For example:\r
+\r
+  \\040   is another way of writing a space\r
+  \\40    is the same, provided there are fewer than 40\r
+            previous capturing subpatterns\r
+  \\7     is always a back reference\r
+  \\11    might be a back reference, or another way of\r
+            writing a tab\r
+  \\011   is always a tab\r
+  \\0113  is a tab followed by the character "3"\r
+  \\113   is the character with octal code 113 (since there\r
+            can be no more than 99 back references)\r
+  \\377   is a byte consisting entirely of 1 bits\r
+  \\81    is either a back reference, or a binary zero\r
+            followed by the two characters "8" and "1"\r
+\r
+Note that octal values of 100 or greater must not be introduced by a leading\r
+zero, because no more than three octal digits are ever read.\r
+\r
+All the sequences that define a single byte value can be used both inside and\r
+outside character classes. In addition, inside a character class, the sequence\r
+"\\b" is interpreted as the backspace character (hex 08). Outside a character\r
+class it has a different meaning (see below).\r
+\r
+The third use of backslash is for specifying generic character types:\r
+\r
+  \\d     any decimal digit\r
+  \\D     any character that is not a decimal digit\r
+  \\s     any whitespace character\r
+  \\S     any character that is not a whitespace character\r
+  \\w     any "word" character\r
+  \\W     any "non-word" character\r
+\r
+Each pair of escape sequences partitions the complete set of characters into\r
+two disjoint sets. Any given character matches one, and only one, of each pair.\r
+\r
+A "word" character is any letter or digit or the underscore character, that is,\r
+any character which can be part of a Perl "word". The definition of letters and\r
+digits is controlled by PCRE's character tables, and may vary if locale-\r
+specific matching is taking place (see "Locale support" above). For example, in\r
+the "fr" (French) locale, some character codes greater than 128 are used for\r
+accented letters, and these are matched by \\w.\r
+\r
+These character type sequences can appear both inside and outside character\r
+classes. They each match one character of the appropriate type. If the current\r
+matching point is at the end of the subject string, all of them fail, since\r
+there is no character to match.\r
+\r
+The fourth use of backslash is for certain simple assertions. An assertion\r
+specifies a condition that has to be met at a particular point in a match,\r
+without consuming any characters from the subject string. The use of\r
+subpatterns for more complicated assertions is described below. The backslashed\r
+assertions are\r
+\r
+  \\b     word boundary\r
+  \\B     not a word boundary\r
+  \\A     start of subject (independent of multiline mode)\r
+  \\Z     end of subject or newline at end (independent of multiline mode)\r
+  \\z     end of subject (independent of multiline mode)\r
+\r
+These assertions may not appear in character classes (but note that "\\b" has a\r
+different meaning, namely the backspace character, inside a character class).\r
+\r
+A word boundary is a position in the subject string where the current character\r
+and the previous character do not both match \\w or \\W (i.e. one matches\r
+\\w and the other matches \\W), or the start or end of the string if the\r
+first or last character matches \\w, respectively.\r
+\r
+The \\A, \\Z, and \\z assertions differ from the traditional circumflex and\r
+dollar (described below) in that they only ever match at the very start and end\r
+of the subject string, whatever options are set. They are not affected by the\r
+PCRE_NOTBOL or PCRE_NOTEOL options. If the \fIstartoffset\fR argument of\r
+\fBpcre_exec()\fR is non-zero, \\A can never match. The difference between \\Z\r
+and \\z is that \\Z matches before a newline that is the last character of the\r
+string as well as at the end of the string, whereas \\z matches only at the\r
+end.\r
+\r
+\r
+.SH CIRCUMFLEX AND DOLLAR\r
+Outside a character class, in the default matching mode, the circumflex\r
+character is an assertion which is true only if the current matching point is\r
+at the start of the subject string. If the \fIstartoffset\fR argument of\r
+\fBpcre_exec()\fR is non-zero, circumflex can never match. Inside a character\r
+class, circumflex has an entirely different meaning (see below).\r
+\r
+Circumflex need not be the first character of the pattern if a number of\r
+alternatives are involved, but it should be the first thing in each alternative\r
+in which it appears if the pattern is ever to match that branch. If all\r
+possible alternatives start with a circumflex, that is, if the pattern is\r
+constrained to match only at the start of the subject, it is said to be an\r
+"anchored" pattern. (There are also other constructs that can cause a pattern\r
+to be anchored.)\r
+\r
+A dollar character is an assertion which is true only if the current matching\r
+point is at the end of the subject string, or immediately before a newline\r
+character that is the last character in the string (by default). Dollar need\r
+not be the last character of the pattern if a number of alternatives are\r
+involved, but it should be the last item in any branch in which it appears.\r
+Dollar has no special meaning in a character class.\r
+\r
+The meaning of dollar can be changed so that it matches only at the very end of\r
+the string, by setting the PCRE_DOLLAR_ENDONLY option at compile or matching\r
+time. This does not affect the \\Z assertion.\r
+\r
+The meanings of the circumflex and dollar characters are changed if the\r
+PCRE_MULTILINE option is set. When this is the case, they match immediately\r
+after and immediately before an internal "\\n" character, respectively, in\r
+addition to matching at the start and end of the subject string. For example,\r
+the pattern /^abc$/ matches the subject string "def\\nabc" in multiline mode,\r
+but not otherwise. Consequently, patterns that are anchored in single line mode\r
+because all branches start with "^" are not anchored in multiline mode, and a\r
+match for circumflex is possible when the \fIstartoffset\fR argument of\r
+\fBpcre_exec()\fR is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if\r
+PCRE_MULTILINE is set.\r
+\r
+Note that the sequences \\A, \\Z, and \\z can be used to match the start and\r
+end of the subject in both modes, and if all branches of a pattern start with\r
+\\A is it always anchored, whether PCRE_MULTILINE is set or not.\r
+\r
+\r
+.SH FULL STOP (PERIOD, DOT)\r
+Outside a character class, a dot in the pattern matches any one character in\r
+the subject, including a non-printing character, but not (by default) newline.\r
+If the PCRE_DOTALL option is set, dots match newlines as well. The handling of\r
+dot is entirely independent of the handling of circumflex and dollar, the only\r
+relationship being that they both involve newline characters. Dot has no\r
+special meaning in a character class.\r
+\r
+\r
+.SH SQUARE BRACKETS\r
+An opening square bracket introduces a character class, terminated by a closing\r
+square bracket. A closing square bracket on its own is not special. If a\r
+closing square bracket is required as a member of the class, it should be the\r
+first data character in the class (after an initial circumflex, if present) or\r
+escaped with a backslash.\r
+\r
+A character class matches a single character in the subject; the character must\r
+be in the set of characters defined by the class, unless the first character in\r
+the class is a circumflex, in which case the subject character must not be in\r
+the set defined by the class. If a circumflex is actually required as a member\r
+of the class, ensure it is not the first character, or escape it with a\r
+backslash.\r
+\r
+For example, the character class [aeiou] matches any lower case vowel, while\r
+[^aeiou] matches any character that is not a lower case vowel. Note that a\r
+circumflex is just a convenient notation for specifying the characters which\r
+are in the class by enumerating those that are not. It is not an assertion: it\r
+still consumes a character from the subject string, and fails if the current\r
+pointer is at the end of the string.\r
+\r
+When caseless matching is set, any letters in a class represent both their\r
+upper case and lower case versions, so for example, a caseless [aeiou] matches\r
+"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a\r
+caseful version would.\r
+\r
+The newline character is never treated in any special way in character classes,\r
+whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class\r
+such as [^a] will always match a newline.\r
+\r
+The minus (hyphen) character can be used to specify a range of characters in a\r
+character class. For example, [d-m] matches any letter between d and m,\r
+inclusive. If a minus character is required in a class, it must be escaped with\r
+a backslash or appear in a position where it cannot be interpreted as\r
+indicating a range, typically as the first or last character in the class.\r
+\r
+It is not possible to have the literal character "]" as the end character of a\r
+range. A pattern such as [W-]46] is interpreted as a class of two characters\r
+("W" and "-") followed by a literal string "46]", so it would match "W46]" or\r
+"-46]". However, if the "]" is escaped with a backslash it is interpreted as\r
+the end of range, so [W-\\]46] is interpreted as a single class containing a\r
+range followed by two separate characters. The octal or hexadecimal\r
+representation of "]" can also be used to end a range.\r
+\r
+Ranges operate in ASCII collating sequence. They can also be used for\r
+characters specified numerically, for example [\\000-\\037]. If a range that\r
+includes letters is used when caseless matching is set, it matches the letters\r
+in either case. For example, [W-c] is equivalent to [][\\^_`wxyzabc], matched\r
+caselessly, and if character tables for the "fr" locale are in use,\r
+[\\xc8-\\xcb] matches accented E characters in both cases.\r
+\r
+The character types \\d, \\D, \\s, \\S, \\w, and \\W may also appear in a\r
+character class, and add the characters that they match to the class. For\r
+example, [\\dABCDEF] matches any hexadecimal digit. A circumflex can\r
+conveniently be used with the upper case character types to specify a more\r
+restricted set of characters than the matching lower case type. For example,\r
+the class [^\\W_] matches any letter or digit, but not underscore.\r
+\r
+All non-alphameric characters other than \\, -, ^ (at the start) and the\r
+terminating ] are non-special in character classes, but it does no harm if they\r
+are escaped.\r
+\r
+\r
+.SH POSIX CHARACTER CLASSES\r
+Perl 5.6 (not yet released at the time of writing) is going to support the\r
+POSIX notation for character classes, which uses names enclosed by [: and :]\r
+within the enclosing square brackets. PCRE supports this notation. For example,\r
+\r
+  [01[:alpha:]%]\r
+\r
+matches "0", "1", any alphabetic character, or "%". The supported class names\r
+are\r
+\r
+  alnum    letters and digits\r
+  alpha    letters\r
+  ascii    character codes 0 - 127\r
+  cntrl    control characters\r
+  digit    decimal digits (same as \\d)\r
+  graph    printing characters, excluding space\r
+  lower    lower case letters\r
+  print    printing characters, including space\r
+  punct    printing characters, excluding letters and digits\r
+  space    white space (same as \\s)\r
+  upper    upper case letters\r
+  word     "word" characters (same as \\w)\r
+  xdigit   hexadecimal digits\r
+\r
+The names "ascii" and "word" are Perl extensions. Another Perl extension is\r
+negation, which is indicated by a ^ character after the colon. For example,\r
+\r
+  [12[:^digit:]]\r
+\r
+matches "1", "2", or any non-digit. PCRE (and Perl) also recogize the POSIX\r
+syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not\r
+supported, and an error is given if they are encountered.\r
+\r
+\r
+.SH VERTICAL BAR\r
+Vertical bar characters are used to separate alternative patterns. For example,\r
+the pattern\r
+\r
+  gilbert|sullivan\r
+\r
+matches either "gilbert" or "sullivan". Any number of alternatives may appear,\r
+and an empty alternative is permitted (matching the empty string).\r
+The matching process tries each alternative in turn, from left to right,\r
+and the first one that succeeds is used. If the alternatives are within a\r
+subpattern (defined below), "succeeds" means matching the rest of the main\r
+pattern as well as the alternative in the subpattern.\r
+\r
+\r
+.SH INTERNAL OPTION SETTING\r
+The settings of PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and PCRE_EXTENDED\r
+can be changed from within the pattern by a sequence of Perl option letters\r
+enclosed between "(?" and ")". The option letters are\r
+\r
+  i  for PCRE_CASELESS\r
+  m  for PCRE_MULTILINE\r
+  s  for PCRE_DOTALL\r
+  x  for PCRE_EXTENDED\r
+\r
+For example, (?im) sets caseless, multiline matching. It is also possible to\r
+unset these options by preceding the letter with a hyphen, and a combined\r
+setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and\r
+PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also\r
+permitted. If a letter appears both before and after the hyphen, the option is\r
+unset.\r
+\r
+The scope of these option changes depends on where in the pattern the setting\r
+occurs. For settings that are outside any subpattern (defined below), the\r
+effect is the same as if the options were set or unset at the start of\r
+matching. The following patterns all behave in exactly the same way:\r
+\r
+  (?i)abc\r
+  a(?i)bc\r
+  ab(?i)c\r
+  abc(?i)\r
+\r
+which in turn is the same as compiling the pattern abc with PCRE_CASELESS set.\r
+In other words, such "top level" settings apply to the whole pattern (unless\r
+there are other changes inside subpatterns). If there is more than one setting\r
+of the same option at top level, the rightmost setting is used.\r
+\r
+If an option change occurs inside a subpattern, the effect is different. This\r
+is a change of behaviour in Perl 5.005. An option change inside a subpattern\r
+affects only that part of the subpattern that follows it, so\r
+\r
+  (a(?i)b)c\r
+\r
+matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used).\r
+By this means, options can be made to have different settings in different\r
+parts of the pattern. Any changes made in one alternative do carry on\r
+into subsequent branches within the same subpattern. For example,\r
+\r
+  (a(?i)b|c)\r
+\r
+matches "ab", "aB", "c", and "C", even though when matching "C" the first\r
+branch is abandoned before the option setting. This is because the effects of\r
+option settings happen at compile time. There would be some very weird\r
+behaviour otherwise.\r
+\r
+The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the\r
+same way as the Perl-compatible options by using the characters U and X\r
+respectively. The (?X) flag setting is special in that it must always occur\r
+earlier in the pattern than any of the additional features it turns on, even\r
+when it is at top level. It is best put at the start.\r
+\r
+\r
+.SH SUBPATTERNS\r
+Subpatterns are delimited by parentheses (round brackets), which can be nested.\r
+Marking part of a pattern as a subpattern does two things:\r
+\r
+1. It localizes a set of alternatives. For example, the pattern\r
+\r
+  cat(aract|erpillar|)\r
+\r
+matches one of the words "cat", "cataract", or "caterpillar". Without the\r
+parentheses, it would match "cataract", "erpillar" or the empty string.\r
+\r
+2. It sets up the subpattern as a capturing subpattern (as defined above).\r
+When the whole pattern matches, that portion of the subject string that matched\r
+the subpattern is passed back to the caller via the \fIovector\fR argument of\r
+\fBpcre_exec()\fR. Opening parentheses are counted from left to right (starting\r
+from 1) to obtain the numbers of the capturing subpatterns.\r
+\r
+For example, if the string "the red king" is matched against the pattern\r
+\r
+  the ((red|white) (king|queen))\r
+\r
+the captured substrings are "red king", "red", and "king", and are numbered 1,\r
+2, and 3.\r
+\r
+The fact that plain parentheses fulfil two functions is not always helpful.\r
+There are often times when a grouping subpattern is required without a\r
+capturing requirement. If an opening parenthesis is followed by "?:", the\r
+subpattern does not do any capturing, and is not counted when computing the\r
+number of any subsequent capturing subpatterns. For example, if the string "the\r
+white queen" is matched against the pattern\r
+\r
+  the ((?:red|white) (king|queen))\r
+\r
+the captured substrings are "white queen" and "queen", and are numbered 1 and\r
+2. The maximum number of captured substrings is 99, and the maximum number of\r
+all subpatterns, both capturing and non-capturing, is 200.\r
+\r
+As a convenient shorthand, if any option settings are required at the start of\r
+a non-capturing subpattern, the option letters may appear between the "?" and\r
+the ":". Thus the two patterns\r
+\r
+  (?i:saturday|sunday)\r
+  (?:(?i)saturday|sunday)\r
+\r
+match exactly the same set of strings. Because alternative branches are tried\r
+from left to right, and options are not reset until the end of the subpattern\r
+is reached, an option setting in one branch does affect subsequent branches, so\r
+the above patterns match "SUNDAY" as well as "Saturday".\r
+\r
+\r
+.SH REPETITION\r
+Repetition is specified by quantifiers, which can follow any of the following\r
+items:\r
+\r
+  a single character, possibly escaped\r
+  the . metacharacter\r
+  a character class\r
+  a back reference (see next section)\r
+  a parenthesized subpattern (unless it is an assertion - see below)\r
+\r
+The general repetition quantifier specifies a minimum and maximum number of\r
+permitted matches, by giving the two numbers in curly brackets (braces),\r
+separated by a comma. The numbers must be less than 65536, and the first must\r
+be less than or equal to the second. For example:\r
+\r
+  z{2,4}\r
+\r
+matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special\r
+character. If the second number is omitted, but the comma is present, there is\r
+no upper limit; if the second number and the comma are both omitted, the\r
+quantifier specifies an exact number of required matches. Thus\r
+\r
+  [aeiou]{3,}\r
+\r
+matches at least 3 successive vowels, but may match many more, while\r
+\r
+  \\d{8}\r
+\r
+matches exactly 8 digits. An opening curly bracket that appears in a position\r
+where a quantifier is not allowed, or one that does not match the syntax of a\r
+quantifier, is taken as a literal character. For example, {,6} is not a\r
+quantifier, but a literal string of four characters.\r
+\r
+The quantifier {0} is permitted, causing the expression to behave as if the\r
+previous item and the quantifier were not present.\r
+\r
+For convenience (and historical compatibility) the three most common\r
+quantifiers have single-character abbreviations:\r
+\r
+  *    is equivalent to {0,}\r
+  +    is equivalent to {1,}\r
+  ?    is equivalent to {0,1}\r
+\r
+It is possible to construct infinite loops by following a subpattern that can\r
+match no characters with a quantifier that has no upper limit, for example:\r
+\r
+  (a?)*\r
+\r
+Earlier versions of Perl and PCRE used to give an error at compile time for\r
+such patterns. However, because there are cases where this can be useful, such\r
+patterns are now accepted, but if any repetition of the subpattern does in fact\r
+match no characters, the loop is forcibly broken.\r
+\r
+By default, the quantifiers are "greedy", that is, they match as much as\r
+possible (up to the maximum number of permitted times), without causing the\r
+rest of the pattern to fail. The classic example of where this gives problems\r
+is in trying to match comments in C programs. These appear between the\r
+sequences /* and */ and within the sequence, individual * and / characters may\r
+appear. An attempt to match C comments by applying the pattern\r
+\r
+  /\\*.*\\*/\r
+\r
+to the string\r
+\r
+  /* first command */  not comment  /* second comment */\r
+\r
+fails, because it matches the entire string owing to the greediness of the .*\r
+item.\r
+\r
+However, if a quantifier is followed by a question mark, it ceases to be\r
+greedy, and instead matches the minimum number of times possible, so the\r
+pattern\r
+\r
+  /\\*.*?\\*/\r
+\r
+does the right thing with the C comments. The meaning of the various\r
+quantifiers is not otherwise changed, just the preferred number of matches.\r
+Do not confuse this use of question mark with its use as a quantifier in its\r
+own right. Because it has two uses, it can sometimes appear doubled, as in\r
+\r
+  \\d??\\d\r
+\r
+which matches one digit by preference, but can match two if that is the only\r
+way the rest of the pattern matches.\r
+\r
+If the PCRE_UNGREEDY option is set (an option which is not available in Perl),\r
+the quantifiers are not greedy by default, but individual ones can be made\r
+greedy by following them with a question mark. In other words, it inverts the\r
+default behaviour.\r
+\r
+When a parenthesized subpattern is quantified with a minimum repeat count that\r
+is greater than 1 or with a limited maximum, more store is required for the\r
+compiled pattern, in proportion to the size of the minimum or maximum.\r
+\r
+If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent\r
+to Perl's /s) is set, thus allowing the . to match newlines, the pattern is\r
+implicitly anchored, because whatever follows will be tried against every\r
+character position in the subject string, so there is no point in retrying the\r
+overall match at any position after the first. PCRE treats such a pattern as\r
+though it were preceded by \\A. In cases where it is known that the subject\r
+string contains no newlines, it is worth setting PCRE_DOTALL when the pattern\r
+begins with .* in order to obtain this optimization, or alternatively using ^\r
+to indicate anchoring explicitly.\r
+\r
+When a capturing subpattern is repeated, the value captured is the substring\r
+that matched the final iteration. For example, after\r
+\r
+  (tweedle[dume]{3}\\s*)+\r
+\r
+has matched "tweedledum tweedledee" the value of the captured substring is\r
+"tweedledee". However, if there are nested capturing subpatterns, the\r
+corresponding captured values may have been set in previous iterations. For\r
+example, after\r
+\r
+  /(a|(b))+/\r
+\r
+matches "aba" the value of the second captured substring is "b".\r
+\r
+\r
+.SH BACK REFERENCES\r
+Outside a character class, a backslash followed by a digit greater than 0 (and\r
+possibly further digits) is a back reference to a capturing subpattern earlier\r
+(i.e. to its left) in the pattern, provided there have been that many previous\r
+capturing left parentheses.\r
+\r
+However, if the decimal number following the backslash is less than 10, it is\r
+always taken as a back reference, and causes an error only if there are not\r
+that many capturing left parentheses in the entire pattern. In other words, the\r
+parentheses that are referenced need not be to the left of the reference for\r
+numbers less than 10. See the section entitled "Backslash" above for further\r
+details of the handling of digits following a backslash.\r
+\r
+A back reference matches whatever actually matched the capturing subpattern in\r
+the current subject string, rather than anything matching the subpattern\r
+itself. So the pattern\r
+\r
+  (sens|respons)e and \\1ibility\r
+\r
+matches "sense and sensibility" and "response and responsibility", but not\r
+"sense and responsibility". If caseful matching is in force at the time of the\r
+back reference, the case of letters is relevant. For example,\r
+\r
+  ((?i)rah)\\s+\\1\r
+\r
+matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original\r
+capturing subpattern is matched caselessly.\r
+\r
+There may be more than one back reference to the same subpattern. If a\r
+subpattern has not actually been used in a particular match, any back\r
+references to it always fail. For example, the pattern\r
+\r
+  (a|(bc))\\2\r
+\r
+always fails if it starts to match "a" rather than "bc". Because there may be\r
+up to 99 back references, all digits following the backslash are taken\r
+as part of a potential back reference number. If the pattern continues with a\r
+digit character, some delimiter must be used to terminate the back reference.\r
+If the PCRE_EXTENDED option is set, this can be whitespace. Otherwise an empty\r
+comment can be used.\r
+\r
+A back reference that occurs inside the parentheses to which it refers fails\r
+when the subpattern is first used, so, for example, (a\\1) never matches.\r
+However, such references can be useful inside repeated subpatterns. For\r
+example, the pattern\r
+\r
+  (a|b\\1)+\r
+\r
+matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of\r
+the subpattern, the back reference matches the character string corresponding\r
+to the previous iteration. In order for this to work, the pattern must be such\r
+that the first iteration does not need to match the back reference. This can be\r
+done using alternation, as in the example above, or by a quantifier with a\r
+minimum of zero.\r
+\r
+\r
+.SH ASSERTIONS\r
+An assertion is a test on the characters following or preceding the current\r
+matching point that does not actually consume any characters. The simple\r
+assertions coded as \\b, \\B, \\A, \\Z, \\z, ^ and $ are described above. More\r
+complicated assertions are coded as subpatterns. There are two kinds: those\r
+that look ahead of the current position in the subject string, and those that\r
+look behind it.\r
+\r
+An assertion subpattern is matched in the normal way, except that it does not\r
+cause the current matching position to be changed. Lookahead assertions start\r
+with (?= for positive assertions and (?! for negative assertions. For example,\r
+\r
+  \\w+(?=;)\r
+\r
+matches a word followed by a semicolon, but does not include the semicolon in\r
+the match, and\r
+\r
+  foo(?!bar)\r
+\r
+matches any occurrence of "foo" that is not followed by "bar". Note that the\r
+apparently similar pattern\r
+\r
+  (?!foo)bar\r
+\r
+does not find an occurrence of "bar" that is preceded by something other than\r
+"foo"; it finds any occurrence of "bar" whatsoever, because the assertion\r
+(?!foo) is always true when the next three characters are "bar". A\r
+lookbehind assertion is needed to achieve this effect.\r
+\r
+Lookbehind assertions start with (?<= for positive assertions and (?<! for\r
+negative assertions. For example,\r
+\r
+  (?<!foo)bar\r
+\r
+does find an occurrence of "bar" that is not preceded by "foo". The contents of\r
+a lookbehind assertion are restricted such that all the strings it matches must\r
+have a fixed length. However, if there are several alternatives, they do not\r
+all have to have the same fixed length. Thus\r
+\r
+  (?<=bullock|donkey)\r
+\r
+is permitted, but\r
+\r
+  (?<!dogs?|cats?)\r
+\r
+causes an error at compile time. Branches that match different length strings\r
+are permitted only at the top level of a lookbehind assertion. This is an\r
+extension compared with Perl 5.005, which requires all branches to match the\r
+same length of string. An assertion such as\r
+\r
+  (?<=ab(c|de))\r
+\r
+is not permitted, because its single top-level branch can match two different\r
+lengths, but it is acceptable if rewritten to use two top-level branches:\r
+\r
+  (?<=abc|abde)\r
+\r
+The implementation of lookbehind assertions is, for each alternative, to\r
+temporarily move the current position back by the fixed width and then try to\r
+match. If there are insufficient characters before the current position, the\r
+match is deemed to fail. Lookbehinds in conjunction with once-only subpatterns\r
+can be particularly useful for matching at the ends of strings; an example is\r
+given at the end of the section on once-only subpatterns.\r
+\r
+Several assertions (of any sort) may occur in succession. For example,\r
+\r
+  (?<=\\d{3})(?<!999)foo\r
+\r
+matches "foo" preceded by three digits that are not "999". Notice that each of\r
+the assertions is applied independently at the same point in the subject\r
+string. First there is a check that the previous three characters are all\r
+digits, and then there is a check that the same three characters are not "999".\r
+This pattern does \fInot\fR match "foo" preceded by six characters, the first\r
+of which are digits and the last three of which are not "999". For example, it\r
+doesn't match "123abcfoo". A pattern to do that is\r
+\r
+  (?<=\\d{3}...)(?<!999)foo\r
+\r
+This time the first assertion looks at the preceding six characters, checking\r
+that the first three are digits, and then the second assertion checks that the\r
+preceding three characters are not "999".\r
+\r
+Assertions can be nested in any combination. For example,\r
+\r
+  (?<=(?<!foo)bar)baz\r
+\r
+matches an occurrence of "baz" that is preceded by "bar" which in turn is not\r
+preceded by "foo", while\r
+\r
+  (?<=\\d{3}(?!999)...)foo\r
+\r
+is another pattern which matches "foo" preceded by three digits and any three\r
+characters that are not "999".\r
+\r
+Assertion subpatterns are not capturing subpatterns, and may not be repeated,\r
+because it makes no sense to assert the same thing several times. If any kind\r
+of assertion contains capturing subpatterns within it, these are counted for\r
+the purposes of numbering the capturing subpatterns in the whole pattern.\r
+However, substring capturing is carried out only for positive assertions,\r
+because it does not make sense for negative assertions.\r
+\r
+Assertions count towards the maximum of 200 parenthesized subpatterns.\r
+\r
+\r
+.SH ONCE-ONLY SUBPATTERNS\r
+With both maximizing and minimizing repetition, failure of what follows\r
+normally causes the repeated item to be re-evaluated to see if a different\r
+number of repeats allows the rest of the pattern to match. Sometimes it is\r
+useful to prevent this, either to change the nature of the match, or to cause\r
+it fail earlier than it otherwise might, when the author of the pattern knows\r
+there is no point in carrying on.\r
+\r
+Consider, for example, the pattern \\d+foo when applied to the subject line\r
+\r
+  123456bar\r
+\r
+After matching all 6 digits and then failing to match "foo", the normal\r
+action of the matcher is to try again with only 5 digits matching the \\d+\r
+item, and then with 4, and so on, before ultimately failing. Once-only\r
+subpatterns provide the means for specifying that once a portion of the pattern\r
+has matched, it is not to be re-evaluated in this way, so the matcher would\r
+give up immediately on failing to match "foo" the first time. The notation is\r
+another kind of special parenthesis, starting with (?> as in this example:\r
+\r
+  (?>\\d+)bar\r
+\r
+This kind of parenthesis "locks up" the  part of the pattern it contains once\r
+it has matched, and a failure further into the pattern is prevented from\r
+backtracking into it. Backtracking past it to previous items, however, works as\r
+normal.\r
+\r
+An alternative description is that a subpattern of this type matches the string\r
+of characters that an identical standalone pattern would match, if anchored at\r
+the current point in the subject string.\r
+\r
+Once-only subpatterns are not capturing subpatterns. Simple cases such as the\r
+above example can be thought of as a maximizing repeat that must swallow\r
+everything it can. So, while both \\d+ and \\d+? are prepared to adjust the\r
+number of digits they match in order to make the rest of the pattern match,\r
+(?>\\d+) can only match an entire sequence of digits.\r
+\r
+This construction can of course contain arbitrarily complicated subpatterns,\r
+and it can be nested.\r
+\r
+Once-only subpatterns can be used in conjunction with lookbehind assertions to\r
+specify efficient matching at the end of the subject string. Consider a simple\r
+pattern such as\r
+\r
+  abcd$\r
+\r
+when applied to a long string which does not match. Because matching proceeds\r
+from left to right, PCRE will look for each "a" in the subject and then see if\r
+what follows matches the rest of the pattern. If the pattern is specified as\r
+\r
+  ^.*abcd$\r
+\r
+the initial .* matches the entire string at first, but when this fails (because\r
+there is no following "a"), it backtracks to match all but the last character,\r
+then all but the last two characters, and so on. Once again the search for "a"\r
+covers the entire string, from right to left, so we are no better off. However,\r
+if the pattern is written as\r
+\r
+  ^(?>.*)(?<=abcd)\r
+\r
+there can be no backtracking for the .* item; it can match only the entire\r
+string. The subsequent lookbehind assertion does a single test on the last four\r
+characters. If it fails, the match fails immediately. For long strings, this\r
+approach makes a significant difference to the processing time.\r
+\r
+When a pattern contains an unlimited repeat inside a subpattern that can itself\r
+be repeated an unlimited number of times, the use of a once-only subpattern is\r
+the only way to avoid some failing matches taking a very long time indeed.\r
+The pattern\r
+\r
+  (\\D+|<\\d+>)*[!?]\r
+\r
+matches an unlimited number of substrings that either consist of non-digits, or\r
+digits enclosed in <>, followed by either ! or ?. When it matches, it runs\r
+quickly. However, if it is applied to\r
+\r
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r
+\r
+it takes a long time before reporting failure. This is because the string can\r
+be divided between the two repeats in a large number of ways, and all have to\r
+be tried. (The example used [!?] rather than a single character at the end,\r
+because both PCRE and Perl have an optimization that allows for fast failure\r
+when a single character is used. They remember the last single character that\r
+is required for a match, and fail early if it is not present in the string.)\r
+If the pattern is changed to\r
+\r
+  ((?>\\D+)|<\\d+>)*[!?]\r
+\r
+sequences of non-digits cannot be broken, and failure happens quickly.\r
+\r
+\r
+.SH CONDITIONAL SUBPATTERNS\r
+It is possible to cause the matching process to obey a subpattern\r
+conditionally or to choose between two alternative subpatterns, depending on\r
+the result of an assertion, or whether a previous capturing subpattern matched\r
+or not. The two possible forms of conditional subpattern are\r
+\r
+  (?(condition)yes-pattern)\r
+  (?(condition)yes-pattern|no-pattern)\r
+\r
+If the condition is satisfied, the yes-pattern is used; otherwise the\r
+no-pattern (if present) is used. If there are more than two alternatives in the\r
+subpattern, a compile-time error occurs.\r
+\r
+There are two kinds of condition. If the text between the parentheses consists\r
+of a sequence of digits, the condition is satisfied if the capturing subpattern\r
+of that number has previously matched. The number must be greater than zero.\r
+Consider the following pattern, which contains non-significant white space to\r
+make it more readable (assume the PCRE_EXTENDED option) and to divide it into\r
+three parts for ease of discussion:\r
+\r
+  ( \\( )?    [^()]+    (?(1) \\) )\r
+\r
+The first part matches an optional opening parenthesis, and if that\r
+character is present, sets it as the first captured substring. The second part\r
+matches one or more characters that are not parentheses. The third part is a\r
+conditional subpattern that tests whether the first set of parentheses matched\r
+or not. If they did, that is, if subject started with an opening parenthesis,\r
+the condition is true, and so the yes-pattern is executed and a closing\r
+parenthesis is required. Otherwise, since no-pattern is not present, the\r
+subpattern matches nothing. In other words, this pattern matches a sequence of\r
+non-parentheses, optionally enclosed in parentheses.\r
+\r
+If the condition is not a sequence of digits, it must be an assertion. This may\r
+be a positive or negative lookahead or lookbehind assertion. Consider this\r
+pattern, again containing non-significant white space, and with the two\r
+alternatives on the second line:\r
+\r
+  (?(?=[^a-z]*[a-z])\r
+  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} )\r
+\r
+The condition is a positive lookahead assertion that matches an optional\r
+sequence of non-letters followed by a letter. In other words, it tests for the\r
+presence of at least one letter in the subject. If a letter is found, the\r
+subject is matched against the first alternative; otherwise it is matched\r
+against the second. This pattern matches strings in one of the two forms\r
+dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.\r
+\r
+\r
+.SH COMMENTS\r
+The sequence (?# marks the start of a comment which continues up to the next\r
+closing parenthesis. Nested parentheses are not permitted. The characters\r
+that make up a comment play no part in the pattern matching at all.\r
+\r
+If the PCRE_EXTENDED option is set, an unescaped # character outside a\r
+character class introduces a comment that continues up to the next newline\r
+character in the pattern.\r
+\r
+\r
+.SH RECURSIVE PATTERNS\r
+Consider the problem of matching a string in parentheses, allowing for\r
+unlimited nested parentheses. Without the use of recursion, the best that can\r
+be done is to use a pattern that matches up to some fixed depth of nesting. It\r
+is not possible to handle an arbitrary nesting depth. Perl 5.6 has provided an\r
+experimental facility that allows regular expressions to recurse (amongst other\r
+things). It does this by interpolating Perl code in the expression at run time,\r
+and the code can refer to the expression itself. A Perl pattern to solve the\r
+parentheses problem can be created like this:\r
+\r
+  $re = qr{\\( (?: (?>[^()]+) | (?p{$re}) )* \\)}x;\r
+\r
+The (?p{...}) item interpolates Perl code at run time, and in this case refers\r
+recursively to the pattern in which it appears. Obviously, PCRE cannot support\r
+the interpolation of Perl code. Instead, the special item (?R) is provided for\r
+the specific case of recursion. This PCRE pattern solves the parentheses\r
+problem (assume the PCRE_EXTENDED option is set so that white space is\r
+ignored):\r
+\r
+  \\( ( (?>[^()]+) | (?R) )* \\)\r
+\r
+First it matches an opening parenthesis. Then it matches any number of\r
+substrings which can either be a sequence of non-parentheses, or a recursive\r
+match of the pattern itself (i.e. a correctly parenthesized substring). Finally\r
+there is a closing parenthesis.\r
+\r
+This particular example pattern contains nested unlimited repeats, and so the\r
+use of a once-only subpattern for matching strings of non-parentheses is\r
+important when applying the pattern to strings that do not match. For example,\r
+when it is applied to\r
+\r
+  (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\r
+\r
+it yields "no match" quickly. However, if a once-only subpattern is not used,\r
+the match runs for a very long time indeed because there are so many different\r
+ways the + and * repeats can carve up the subject, and all have to be tested\r
+before failure can be reported.\r
+\r
+The values set for any capturing subpatterns are those from the outermost level\r
+of the recursion at which the subpattern value is set. If the pattern above is\r
+matched against\r
+\r
+  (ab(cd)ef)\r
+\r
+the value for the capturing parentheses is "ef", which is the last value taken\r
+on at the top level. If additional parentheses are added, giving\r
+\r
+  \\( ( ( (?>[^()]+) | (?R) )* ) \\)\r
+     ^                        ^\r
+     ^                        ^\r
+the string they capture is "ab(cd)ef", the contents of the top level\r
+parentheses. If there are more than 15 capturing parentheses in a pattern, PCRE\r
+has to obtain extra memory to store data during a recursion, which it does by\r
+using \fBpcre_malloc\fR, freeing it via \fBpcre_free\fR afterwards. If no\r
+memory can be obtained, it saves data for the first 15 capturing parentheses\r
+only, as there is no way to give an out-of-memory error from within a\r
+recursion.\r
+\r
+\r
+.SH PERFORMANCE\r
+Certain items that may appear in patterns are more efficient than others. It is\r
+more efficient to use a character class like [aeiou] than a set of alternatives\r
+such as (a|e|i|o|u). In general, the simplest construction that provides the\r
+required behaviour is usually the most efficient. Jeffrey Friedl's book\r
+contains a lot of discussion about optimizing regular expressions for efficient\r
+performance.\r
+\r
+When a pattern begins with .* and the PCRE_DOTALL option is set, the pattern is\r
+implicitly anchored by PCRE, since it can match only at the start of a subject\r
+string. However, if PCRE_DOTALL is not set, PCRE cannot make this optimization,\r
+because the . metacharacter does not then match a newline, and if the subject\r
+string contains newlines, the pattern may match from the character immediately\r
+following one of them instead of from the very start. For example, the pattern\r
+\r
+  (.*) second\r
+\r
+matches the subject "first\\nand second" (where \\n stands for a newline\r
+character) with the first captured substring being "and". In order to do this,\r
+PCRE has to retry the match starting after every newline in the subject.\r
+\r
+If you are using such a pattern with subject strings that do not contain\r
+newlines, the best performance is obtained by setting PCRE_DOTALL, or starting\r
+the pattern with ^.* to indicate explicit anchoring. That saves PCRE from\r
+having to scan along the subject looking for a newline to restart at.\r
+\r
+Beware of patterns that contain nested indefinite repeats. These can take a\r
+long time to run when applied to a string that does not match. Consider the\r
+pattern fragment\r
+\r
+  (a+)*\r
+\r
+This can match "aaaa" in 33 different ways, and this number increases very\r
+rapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4\r
+times, and for each of those cases other than 0, the + repeats can match\r
+different numbers of times.) When the remainder of the pattern is such that the\r
+entire match is going to fail, PCRE has in principle to try every possible\r
+variation, and this can take an extremely long time.\r
+\r
+An optimization catches some of the more simple cases such as\r
+\r
+  (a+)*b\r
+\r
+where a literal character follows. Before embarking on the standard matching\r
+procedure, PCRE checks that there is a "b" later in the subject string, and if\r
+there is not, it fails the match immediately. However, when there is no\r
+following literal this optimization cannot be used. You can see the difference\r
+by comparing the behaviour of\r
+\r
+  (a+)*\\d\r
+\r
+with the pattern above. The former gives a failure almost instantly when\r
+applied to a whole line of "a" characters, whereas the latter takes an\r
+appreciable time with strings longer than about 20 characters.\r
+\r
+\r
+.SH UTF-8 SUPPORT\r
+Starting at release 3.3, PCRE has some support for character strings encoded\r
+in the UTF-8 format. This is incomplete, and is regarded as experimental. In\r
+order to use it, you must configure PCRE to include UTF-8 support in the code,\r
+and, in addition, you must call \fBpcre_compile()\fR with the PCRE_UTF8 option\r
+flag. When you do this, both the pattern and any subject strings that are\r
+matched against it are treated as UTF-8 strings instead of just strings of\r
+bytes, but only in the cases that are mentioned below.\r
+\r
+If you compile PCRE with UTF-8 support, but do not use it at run time, the\r
+library will be a bit bigger, but the additional run time overhead is limited\r
+to testing the PCRE_UTF8 flag in several places, so should not be very large.\r
+\r
+PCRE assumes that the strings it is given contain valid UTF-8 codes. It does\r
+not diagnose invalid UTF-8 strings. If you pass invalid UTF-8 strings to PCRE,\r
+the results are undefined.\r
+\r
+Running with PCRE_UTF8 set causes these changes in the way PCRE works:\r
+\r
+1. In a pattern, the escape sequence \\x{...}, where the contents of the braces\r
+is a string of hexadecimal digits, is interpreted as a UTF-8 character whose\r
+code number is the given hexadecimal number, for example: \\x{1234}. This\r
+inserts from one to six literal bytes into the pattern, using the UTF-8\r
+encoding. If a non-hexadecimal digit appears between the braces, the item is\r
+not recognized.\r
+\r
+2. The original hexadecimal escape sequence, \\xhh, generates a two-byte UTF-8\r
+character if its value is greater than 127.\r
+\r
+3. Repeat quantifiers are NOT correctly handled if they follow a multibyte\r
+character. For example, \\x{100}* and \\xc3+ do not work. If you want to\r
+repeat such characters, you must enclose them in non-capturing parentheses,\r
+for example (?:\\x{100}), at present.\r
+\r
+4. The dot metacharacter matches one UTF-8 character instead of a single byte.\r
+\r
+5. Unlike literal UTF-8 characters, the dot metacharacter followed by a\r
+repeat quantifier does operate correctly on UTF-8 characters instead of\r
+single bytes.\r
+\r
+4. Although the \\x{...} escape is permitted in a character class, characters\r
+whose values are greater than 255 cannot be included in a class.\r
+\r
+5. A class is matched against a UTF-8 character instead of just a single byte,\r
+but it can match only characters whose values are less than 256. Characters\r
+with greater values always fail to match a class.\r
+\r
+6. Repeated classes work correctly on multiple characters.\r
+\r
+7. Classes containing just a single character whose value is greater than 127\r
+(but less than 256), for example, [\\x80] or [^\\x{93}], do not work because\r
+these are optimized into single byte matches. In the first case, of course,\r
+the class brackets are just redundant.\r
+\r
+8. Lookbehind assertions move backwards in the subject by a fixed number of\r
+characters instead of a fixed number of bytes. Simple cases have been tested\r
+to work correctly, but there may be hidden gotchas herein.\r
+\r
+9. The character types such as \\d and \\w do not work correctly with UTF-8\r
+characters. They continue to test a single byte.\r
+\r
+10. Anything not explicitly mentioned here continues to work in bytes rather\r
+than in characters.\r
+\r
+The following UTF-8 features of Perl 5.6 are not implemented:\r
+\r
+1. The escape sequence \\C to match a single byte.\r
+\r
+2. The use of Unicode tables and properties and escapes \\p, \\P, and \\X.\r
+\r
+.SH AUTHOR\r
+Philip Hazel <ph10@cam.ac.uk>\r
+.br\r
+University Computing Service,\r
+.br\r
+New Museums Site,\r
+.br\r
+Cambridge CB2 3QG, England.\r
+.br\r
+Phone: +44 1223 334714\r
+\r
+Last updated: 28 August 2000,\r
+.br\r
+  the 250th anniversary of the death of J.S. Bach.\r
+.br\r
+Copyright (c) 1997-2000 University of Cambridge.\r
diff --git a/pcre/doc/pcre.html b/pcre/doc/pcre.html
new file mode 100644 (file)
index 0000000..b12b212
--- /dev/null
@@ -0,0 +1,2397 @@
+<HTML>\r
+<HEAD>\r
+<TITLE>pcre specification</TITLE>\r
+</HEAD>\r
+<body bgcolor="#FFFFFF" text="#00005A">\r
+<H1>pcre specification</H1>\r
+This HTML document has been generated automatically from the original man page.\r
+If there is any nonsense in it, please consult the man page in case the\r
+conversion went wrong.\r
+<UL>\r
+<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>\r
+<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>\r
+<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>\r
+<LI><A NAME="TOC4" HREF="#SEC4">MULTI-THREADING</A>\r
+<LI><A NAME="TOC5" HREF="#SEC5">COMPILING A PATTERN</A>\r
+<LI><A NAME="TOC6" HREF="#SEC6">STUDYING A PATTERN</A>\r
+<LI><A NAME="TOC7" HREF="#SEC7">LOCALE SUPPORT</A>\r
+<LI><A NAME="TOC8" HREF="#SEC8">INFORMATION ABOUT A PATTERN</A>\r
+<LI><A NAME="TOC9" HREF="#SEC9">MATCHING A PATTERN</A>\r
+<LI><A NAME="TOC10" HREF="#SEC10">EXTRACTING CAPTURED SUBSTRINGS</A>\r
+<LI><A NAME="TOC11" HREF="#SEC11">LIMITATIONS</A>\r
+<LI><A NAME="TOC12" HREF="#SEC12">DIFFERENCES FROM PERL</A>\r
+<LI><A NAME="TOC13" HREF="#SEC13">REGULAR EXPRESSION DETAILS</A>\r
+<LI><A NAME="TOC14" HREF="#SEC14">BACKSLASH</A>\r
+<LI><A NAME="TOC15" HREF="#SEC15">CIRCUMFLEX AND DOLLAR</A>\r
+<LI><A NAME="TOC16" HREF="#SEC16">FULL STOP (PERIOD, DOT)</A>\r
+<LI><A NAME="TOC17" HREF="#SEC17">SQUARE BRACKETS</A>\r
+<LI><A NAME="TOC18" HREF="#SEC18">POSIX CHARACTER CLASSES</A>\r
+<LI><A NAME="TOC19" HREF="#SEC19">VERTICAL BAR</A>\r
+<LI><A NAME="TOC20" HREF="#SEC20">INTERNAL OPTION SETTING</A>\r
+<LI><A NAME="TOC21" HREF="#SEC21">SUBPATTERNS</A>\r
+<LI><A NAME="TOC22" HREF="#SEC22">REPETITION</A>\r
+<LI><A NAME="TOC23" HREF="#SEC23">BACK REFERENCES</A>\r
+<LI><A NAME="TOC24" HREF="#SEC24">ASSERTIONS</A>\r
+<LI><A NAME="TOC25" HREF="#SEC25">ONCE-ONLY SUBPATTERNS</A>\r
+<LI><A NAME="TOC26" HREF="#SEC26">CONDITIONAL SUBPATTERNS</A>\r
+<LI><A NAME="TOC27" HREF="#SEC27">COMMENTS</A>\r
+<LI><A NAME="TOC28" HREF="#SEC28">RECURSIVE PATTERNS</A>\r
+<LI><A NAME="TOC29" HREF="#SEC29">PERFORMANCE</A>\r
+<LI><A NAME="TOC30" HREF="#SEC30">UTF-8 SUPPORT</A>\r
+<LI><A NAME="TOC31" HREF="#SEC31">AUTHOR</A>\r
+</UL>\r
+<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>\r
+<P>\r
+pcre - Perl-compatible regular expressions.\r
+</P>\r
+<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>\r
+<P>\r
+<B>#include &#60;pcre.h&#62;</B>\r
+</P>\r
+<P>\r
+<B>pcre *pcre_compile(const char *<I>pattern</I>, int <I>options</I>,</B>\r
+<B>const char **<I>errptr</I>, int *<I>erroffset</I>,</B>\r
+<B>const unsigned char *<I>tableptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>pcre_extra *pcre_study(const pcre *<I>code</I>, int <I>options</I>,</B>\r
+<B>const char **<I>errptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_exec(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>\r
+<B>const char *<I>subject</I>, int <I>length</I>, int <I>startoffset</I>,</B>\r
+<B>int <I>options</I>, int *<I>ovector</I>, int <I>ovecsize</I>);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_copy_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>\r
+<B>int <I>stringcount</I>, int <I>stringnumber</I>, char *<I>buffer</I>,</B>\r
+<B>int <I>buffersize</I>);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_get_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>\r
+<B>int <I>stringcount</I>, int <I>stringnumber</I>,</B>\r
+<B>const char **<I>stringptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_get_substring_list(const char *<I>subject</I>,</B>\r
+<B>int *<I>ovector</I>, int <I>stringcount</I>, const char ***<I>listptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>void pcre_free_substring(const char *<I>stringptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>void pcre_free_substring_list(const char **<I>stringptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>const unsigned char *pcre_maketables(void);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_fullinfo(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>\r
+<B>int <I>what</I>, void *<I>where</I>);</B>\r
+</P>\r
+<P>\r
+<B>int pcre_info(const pcre *<I>code</I>, int *<I>optptr</I>, int</B>\r
+<B>*<I>firstcharptr</I>);</B>\r
+</P>\r
+<P>\r
+<B>char *pcre_version(void);</B>\r
+</P>\r
+<P>\r
+<B>void *(*pcre_malloc)(size_t);</B>\r
+</P>\r
+<P>\r
+<B>void (*pcre_free)(void *);</B>\r
+</P>\r
+<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>\r
+<P>\r
+The PCRE library is a set of functions that implement regular expression\r
+pattern matching using the same syntax and semantics as Perl 5, with just a few\r
+differences (see below). The current implementation corresponds to Perl 5.005,\r
+with some additional features from later versions. This includes some\r
+experimental, incomplete support for UTF-8 encoded strings. Details of exactly\r
+what is and what is not supported are given below.\r
+</P>\r
+<P>\r
+PCRE has its own native API, which is described in this document. There is also\r
+a set of wrapper functions that correspond to the POSIX regular expression API.\r
+These are described in the <B>pcreposix</B> documentation.\r
+</P>\r
+<P>\r
+The native API function prototypes are defined in the header file <B>pcre.h</B>,\r
+and on Unix systems the library itself is called <B>libpcre.a</B>, so can be\r
+accessed by adding <B>-lpcre</B> to the command for linking an application which\r
+calls it. The header file defines the macros PCRE_MAJOR and PCRE_MINOR to\r
+contain the major and minor release numbers for the library. Applications can\r
+use these to include support for different releases.\r
+</P>\r
+<P>\r
+The functions <B>pcre_compile()</B>, <B>pcre_study()</B>, and <B>pcre_exec()</B>\r
+are used for compiling and matching regular expressions.\r
+</P>\r
+<P>\r
+The functions <B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and\r
+<B>pcre_get_substring_list()</B> are convenience functions for extracting\r
+captured substrings from a matched subject string; <B>pcre_free_substring()</B>\r
+and <B>pcre_free_substring_list()</B> are also provided, to free the memory used\r
+for extracted strings.\r
+</P>\r
+<P>\r
+The function <B>pcre_maketables()</B> is used (optionally) to build a set of\r
+character tables in the current locale for passing to <B>pcre_compile()</B>.\r
+</P>\r
+<P>\r
+The function <B>pcre_fullinfo()</B> is used to find out information about a\r
+compiled pattern; <B>pcre_info()</B> is an obsolete version which returns only\r
+some of the available information, but is retained for backwards compatibility.\r
+The function <B>pcre_version()</B> returns a pointer to a string containing the\r
+version of PCRE and its date of release.\r
+</P>\r
+<P>\r
+The global variables <B>pcre_malloc</B> and <B>pcre_free</B> initially contain\r
+the entry points of the standard <B>malloc()</B> and <B>free()</B> functions\r
+respectively. PCRE calls the memory management functions via these variables,\r
+so a calling program can replace them if it wishes to intercept the calls. This\r
+should be done before calling any PCRE functions.\r
+</P>\r
+<LI><A NAME="SEC4" HREF="#TOC1">MULTI-THREADING</A>\r
+<P>\r
+The PCRE functions can be used in multi-threading applications, with the\r
+proviso that the memory management functions pointed to by <B>pcre_malloc</B>\r
+and <B>pcre_free</B> are shared by all threads.\r
+</P>\r
+<P>\r
+The compiled form of a regular expression is not altered during matching, so\r
+the same compiled pattern can safely be used by several threads at once.\r
+</P>\r
+<LI><A NAME="SEC5" HREF="#TOC1">COMPILING A PATTERN</A>\r
+<P>\r
+The function <B>pcre_compile()</B> is called to compile a pattern into an\r
+internal form. The pattern is a C string terminated by a binary zero, and\r
+is passed in the argument <I>pattern</I>. A pointer to a single block of memory\r
+that is obtained via <B>pcre_malloc</B> is returned. This contains the\r
+compiled code and related data. The <B>pcre</B> type is defined for this for\r
+convenience, but in fact <B>pcre</B> is just a typedef for <B>void</B>, since the\r
+contents of the block are not externally defined. It is up to the caller to\r
+free the memory when it is no longer required.\r
+</P>\r
+<P>\r
+The size of a compiled pattern is roughly proportional to the length of the\r
+pattern string, except that each character class (other than those containing\r
+just a single character, negated or not) requires 33 bytes, and repeat\r
+quantifiers with a minimum greater than one or a bounded maximum cause the\r
+relevant portions of the compiled pattern to be replicated.\r
+</P>\r
+<P>\r
+The <I>options</I> argument contains independent bits that affect the\r
+compilation. It should be zero if no options are required. Some of the options,\r
+in particular, those that are compatible with Perl, can also be set and unset\r
+from within the pattern (see the detailed description of regular expressions\r
+below). For these options, the contents of the <I>options</I> argument specifies\r
+their initial settings at the start of compilation and execution. The\r
+PCRE_ANCHORED option can be set at the time of matching as well as at compile\r
+time.\r
+</P>\r
+<P>\r
+If <I>errptr</I> is NULL, <B>pcre_compile()</B> returns NULL immediately.\r
+Otherwise, if compilation of a pattern fails, <B>pcre_compile()</B> returns\r
+NULL, and sets the variable pointed to by <I>errptr</I> to point to a textual\r
+error message. The offset from the start of the pattern to the character where\r
+the error was discovered is placed in the variable pointed to by\r
+<I>erroffset</I>, which must not be NULL. If it is, an immediate error is given.\r
+</P>\r
+<P>\r
+If the final argument, <I>tableptr</I>, is NULL, PCRE uses a default set of\r
+character tables which are built when it is compiled, using the default C\r
+locale. Otherwise, <I>tableptr</I> must be the result of a call to\r
+<B>pcre_maketables()</B>. See the section on locale support below.\r
+</P>\r
+<P>\r
+The following option bits are defined in the header file:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ANCHORED\r
+</PRE>\r
+</P>\r
+<P>\r
+If this bit is set, the pattern is forced to be "anchored", that is, it is\r
+constrained to match only at the start of the string which is being searched\r
+(the "subject string"). This effect can also be achieved by appropriate\r
+constructs in the pattern itself, which is the only way to do it in Perl.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_CASELESS\r
+</PRE>\r
+</P>\r
+<P>\r
+If this bit is set, letters in the pattern match both upper and lower case\r
+letters. It is equivalent to Perl's /i option.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_DOLLAR_ENDONLY\r
+</PRE>\r
+</P>\r
+<P>\r
+If this bit is set, a dollar metacharacter in the pattern matches only at the\r
+end of the subject string. Without this option, a dollar also matches\r
+immediately before the final character if it is a newline (but not before any\r
+other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is\r
+set. There is no equivalent to this option in Perl.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_DOTALL\r
+</PRE>\r
+</P>\r
+<P>\r
+If this bit is set, a dot metacharater in the pattern matches all characters,\r
+including newlines. Without it, newlines are excluded. This option is\r
+equivalent to Perl's /s option. A negative class such as [^a] always matches a\r
+newline character, independent of the setting of this option.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_EXTENDED\r
+</PRE>\r
+</P>\r
+<P>\r
+If this bit is set, whitespace data characters in the pattern are totally\r
+ignored except when escaped or inside a character class, and characters between\r
+an unescaped # outside a character class and the next newline character,\r
+inclusive, are also ignored. This is equivalent to Perl's /x option, and makes\r
+it possible to include comments inside complicated patterns. Note, however,\r
+that this applies only to data characters. Whitespace characters may never\r
+appear within special character sequences in a pattern, for example within the\r
+sequence (?( which introduces a conditional subpattern.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_EXTRA\r
+</PRE>\r
+</P>\r
+<P>\r
+This option was invented in order to turn on additional functionality of PCRE\r
+that is incompatible with Perl, but it is currently of very little use. When\r
+set, any backslash in a pattern that is followed by a letter that has no\r
+special meaning causes an error, thus reserving these combinations for future\r
+expansion. By default, as in Perl, a backslash followed by a letter with no\r
+special meaning is treated as a literal. There are at present no other features\r
+controlled by this option. It can also be set by a (?X) option setting within a\r
+pattern.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_MULTILINE\r
+</PRE>\r
+</P>\r
+<P>\r
+By default, PCRE treats the subject string as consisting of a single "line" of\r
+characters (even if it actually contains several newlines). The "start of line"\r
+metacharacter (^) matches only at the start of the string, while the "end of\r
+line" metacharacter ($) matches only at the end of the string, or before a\r
+terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as\r
+Perl.\r
+</P>\r
+<P>\r
+When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs\r
+match immediately following or immediately before any newline in the subject\r
+string, respectively, as well as at the very start and end. This is equivalent\r
+to Perl's /m option. If there are no "\n" characters in a subject string, or\r
+no occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no\r
+effect.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_UNGREEDY\r
+</PRE>\r
+</P>\r
+<P>\r
+This option inverts the "greediness" of the quantifiers so that they are not\r
+greedy by default, but become greedy if followed by "?". It is not compatible\r
+with Perl. It can also be set by a (?U) option setting within the pattern.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_UTF8\r
+</PRE>\r
+</P>\r
+<P>\r
+This option causes PCRE to regard both the pattern and the subject as strings\r
+of UTF-8 characters instead of just byte strings. However, it is available only\r
+if PCRE has been built to include UTF-8 support. If not, the use of this option\r
+provokes an error. Support for UTF-8 is new, experimental, and incomplete.\r
+Details of exactly what it entails are given below.\r
+</P>\r
+<LI><A NAME="SEC6" HREF="#TOC1">STUDYING A PATTERN</A>\r
+<P>\r
+When a pattern is going to be used several times, it is worth spending more\r
+time analyzing it in order to speed up the time taken for matching. The\r
+function <B>pcre_study()</B> takes a pointer to a compiled pattern as its first\r
+argument, and returns a pointer to a <B>pcre_extra</B> block (another <B>void</B>\r
+typedef) containing additional information about the pattern; this can be\r
+passed to <B>pcre_exec()</B>. If no additional information is available, NULL\r
+is returned.\r
+</P>\r
+<P>\r
+The second argument contains option bits. At present, no options are defined\r
+for <B>pcre_study()</B>, and this argument should always be zero.\r
+</P>\r
+<P>\r
+The third argument for <B>pcre_study()</B> is a pointer to an error message. If\r
+studying succeeds (even if no data is returned), the variable it points to is\r
+set to NULL. Otherwise it points to a textual error message.\r
+</P>\r
+<P>\r
+At present, studying a pattern is useful only for non-anchored patterns that do\r
+not have a single fixed starting character. A bitmap of possible starting\r
+characters is created.\r
+</P>\r
+<LI><A NAME="SEC7" HREF="#TOC1">LOCALE SUPPORT</A>\r
+<P>\r
+PCRE handles caseless matching, and determines whether characters are letters,\r
+digits, or whatever, by reference to a set of tables. The library contains a\r
+default set of tables which is created in the default C locale when PCRE is\r
+compiled. This is used when the final argument of <B>pcre_compile()</B> is NULL,\r
+and is sufficient for many applications.\r
+</P>\r
+<P>\r
+An alternative set of tables can, however, be supplied. Such tables are built\r
+by calling the <B>pcre_maketables()</B> function, which has no arguments, in the\r
+relevant locale. The result can then be passed to <B>pcre_compile()</B> as often\r
+as necessary. For example, to build and use tables that are appropriate for the\r
+French locale (where accented characters with codes greater than 128 are\r
+treated as letters), the following code could be used:\r
+</P>\r
+<P>\r
+<PRE>\r
+  setlocale(LC_CTYPE, "fr");\r
+  tables = pcre_maketables();\r
+  re = pcre_compile(..., tables);\r
+</PRE>\r
+</P>\r
+<P>\r
+The tables are built in memory that is obtained via <B>pcre_malloc</B>. The\r
+pointer that is passed to <B>pcre_compile</B> is saved with the compiled\r
+pattern, and the same tables are used via this pointer by <B>pcre_study()</B>\r
+and <B>pcre_exec()</B>. Thus for any single pattern, compilation, studying and\r
+matching all happen in the same locale, but different patterns can be compiled\r
+in different locales. It is the caller's responsibility to ensure that the\r
+memory containing the tables remains available for as long as it is needed.\r
+</P>\r
+<LI><A NAME="SEC8" HREF="#TOC1">INFORMATION ABOUT A PATTERN</A>\r
+<P>\r
+The <B>pcre_fullinfo()</B> function returns information about a compiled\r
+pattern. It replaces the obsolete <B>pcre_info()</B> function, which is\r
+nevertheless retained for backwards compability (and is documented below).\r
+</P>\r
+<P>\r
+The first argument for <B>pcre_fullinfo()</B> is a pointer to the compiled\r
+pattern. The second argument is the result of <B>pcre_study()</B>, or NULL if\r
+the pattern was not studied. The third argument specifies which piece of\r
+information is required, while the fourth argument is a pointer to a variable\r
+to receive the data. The yield of the function is zero for success, or one of\r
+the following negative numbers:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NULL       the argument <I>code</I> was NULL\r
+                        the argument <I>where</I> was NULL\r
+  PCRE_ERROR_BADMAGIC   the "magic number" was not found\r
+  PCRE_ERROR_BADOPTION  the value of <I>what</I> was invalid\r
+</PRE>\r
+</P>\r
+<P>\r
+The possible values for the third argument are defined in <B>pcre.h</B>, and are\r
+as follows:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_OPTIONS\r
+</PRE>\r
+</P>\r
+<P>\r
+Return a copy of the options with which the pattern was compiled. The fourth\r
+argument should point to au <B>unsigned long int</B> variable. These option bits\r
+are those specified in the call to <B>pcre_compile()</B>, modified by any\r
+top-level option settings within the pattern itself, and with the PCRE_ANCHORED\r
+bit forcibly set if the form of the pattern implies that it can match only at\r
+the start of a subject string.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_SIZE\r
+</PRE>\r
+</P>\r
+<P>\r
+Return the size of the compiled pattern, that is, the value that was passed as\r
+the argument to <B>pcre_malloc()</B> when PCRE was getting memory in which to\r
+place the compiled data. The fourth argument should point to a <B>size_t</B>\r
+variable.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_CAPTURECOUNT\r
+</PRE>\r
+</P>\r
+<P>\r
+Return the number of capturing subpatterns in the pattern. The fourth argument\r
+should point to an \fbint\fR variable.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_BACKREFMAX\r
+</PRE>\r
+</P>\r
+<P>\r
+Return the number of the highest back reference in the pattern. The fourth\r
+argument should point to an <B>int</B> variable. Zero is returned if there are\r
+no back references.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_FIRSTCHAR\r
+</PRE>\r
+</P>\r
+<P>\r
+Return information about the first character of any matched string, for a\r
+non-anchored pattern. If there is a fixed first character, e.g. from a pattern\r
+such as (cat|cow|coyote), it is returned in the integer pointed to by\r
+<I>where</I>. Otherwise, if either\r
+</P>\r
+<P>\r
+(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch\r
+starts with "^", or\r
+</P>\r
+<P>\r
+(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set\r
+(if it were set, the pattern would be anchored),\r
+</P>\r
+<P>\r
+-1 is returned, indicating that the pattern matches only at the start of a\r
+subject string or after any "\n" within the string. Otherwise -2 is returned.\r
+For anchored patterns, -2 is returned.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_FIRSTTABLE\r
+</PRE>\r
+</P>\r
+<P>\r
+If the pattern was studied, and this resulted in the construction of a 256-bit\r
+table indicating a fixed set of characters for the first character in any\r
+matching string, a pointer to the table is returned. Otherwise NULL is\r
+returned. The fourth argument should point to an <B>unsigned char *</B>\r
+variable.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_INFO_LASTLITERAL\r
+</PRE>\r
+</P>\r
+<P>\r
+For a non-anchored pattern, return the value of the rightmost literal character\r
+which must exist in any matched string, other than at its start. The fourth\r
+argument should point to an <B>int</B> variable. If there is no such character,\r
+or if the pattern is anchored, -1 is returned. For example, for the pattern\r
+/a\d+z\d+/ the returned value is 'z'.\r
+</P>\r
+<P>\r
+The <B>pcre_info()</B> function is now obsolete because its interface is too\r
+restrictive to return all the available data about a compiled pattern. New\r
+programs should use <B>pcre_fullinfo()</B> instead. The yield of\r
+<B>pcre_info()</B> is the number of capturing subpatterns, or one of the\r
+following negative numbers:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NULL       the argument <I>code</I> was NULL\r
+  PCRE_ERROR_BADMAGIC   the "magic number" was not found\r
+</PRE>\r
+</P>\r
+<P>\r
+If the <I>optptr</I> argument is not NULL, a copy of the options with which the\r
+pattern was compiled is placed in the integer it points to (see\r
+PCRE_INFO_OPTIONS above).\r
+</P>\r
+<P>\r
+If the pattern is not anchored and the <I>firstcharptr</I> argument is not NULL,\r
+it is used to pass back information about the first character of any matched\r
+string (see PCRE_INFO_FIRSTCHAR above).\r
+</P>\r
+<LI><A NAME="SEC9" HREF="#TOC1">MATCHING A PATTERN</A>\r
+<P>\r
+The function <B>pcre_exec()</B> is called to match a subject string against a\r
+pre-compiled pattern, which is passed in the <I>code</I> argument. If the\r
+pattern has been studied, the result of the study should be passed in the\r
+<I>extra</I> argument. Otherwise this must be NULL.\r
+</P>\r
+<P>\r
+The PCRE_ANCHORED option can be passed in the <I>options</I> argument, whose\r
+unused bits must be zero. However, if a pattern was compiled with\r
+PCRE_ANCHORED, or turned out to be anchored by virtue of its contents, it\r
+cannot be made unachored at matching time.\r
+</P>\r
+<P>\r
+There are also three further options that can be set only at matching time:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_NOTBOL\r
+</PRE>\r
+</P>\r
+<P>\r
+The first character of the string is not the beginning of a line, so the\r
+circumflex metacharacter should not match before it. Setting this without\r
+PCRE_MULTILINE (at compile time) causes circumflex never to match.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_NOTEOL\r
+</PRE>\r
+</P>\r
+<P>\r
+The end of the string is not the end of a line, so the dollar metacharacter\r
+should not match it nor (except in multiline mode) a newline immediately before\r
+it. Setting this without PCRE_MULTILINE (at compile time) causes dollar never\r
+to match.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_NOTEMPTY\r
+</PRE>\r
+</P>\r
+<P>\r
+An empty string is not considered to be a valid match if this option is set. If\r
+there are alternatives in the pattern, they are tried. If all the alternatives\r
+match the empty string, the entire match fails. For example, if the pattern\r
+</P>\r
+<P>\r
+<PRE>\r
+  a?b?\r
+</PRE>\r
+</P>\r
+<P>\r
+is applied to a string not beginning with "a" or "b", it matches the empty\r
+string at the start of the subject. With PCRE_NOTEMPTY set, this match is not\r
+valid, so PCRE searches further into the string for occurrences of "a" or "b".\r
+</P>\r
+<P>\r
+Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case\r
+of a pattern match of the empty string within its <B>split()</B> function, and\r
+when using the /g modifier. It is possible to emulate Perl's behaviour after\r
+matching a null string by first trying the match again at the same offset with\r
+PCRE_NOTEMPTY set, and then if that fails by advancing the starting offset (see\r
+below) and trying an ordinary match again.\r
+</P>\r
+<P>\r
+The subject string is passed as a pointer in <I>subject</I>, a length in\r
+<I>length</I>, and a starting offset in <I>startoffset</I>. Unlike the pattern\r
+string, it may contain binary zero characters. When the starting offset is\r
+zero, the search for a match starts at the beginning of the subject, and this\r
+is by far the most common case.\r
+</P>\r
+<P>\r
+A non-zero starting offset is useful when searching for another match in the\r
+same subject by calling <B>pcre_exec()</B> again after a previous success.\r
+Setting <I>startoffset</I> differs from just passing over a shortened string and\r
+setting PCRE_NOTBOL in the case of a pattern that begins with any kind of\r
+lookbehind. For example, consider the pattern\r
+</P>\r
+<P>\r
+<PRE>\r
+  \Biss\B\r
+</PRE>\r
+</P>\r
+<P>\r
+which finds occurrences of "iss" in the middle of words. (\B matches only if\r
+the current position in the subject is not a word boundary.) When applied to\r
+the string "Mississipi" the first call to <B>pcre_exec()</B> finds the first\r
+occurrence. If <B>pcre_exec()</B> is called again with just the remainder of the\r
+subject, namely "issipi", it does not match, because \B is always false at the\r
+start of the subject, which is deemed to be a word boundary. However, if\r
+<B>pcre_exec()</B> is passed the entire string again, but with <I>startoffset</I>\r
+set to 4, it finds the second occurrence of "iss" because it is able to look\r
+behind the starting point to discover that it is preceded by a letter.\r
+</P>\r
+<P>\r
+If a non-zero starting offset is passed when the pattern is anchored, one\r
+attempt to match at the given offset is tried. This can only succeed if the\r
+pattern does not require the match to be at the start of the subject.\r
+</P>\r
+<P>\r
+In general, a pattern matches a certain portion of the subject, and in\r
+addition, further substrings from the subject may be picked out by parts of the\r
+pattern. Following the usage in Jeffrey Friedl's book, this is called\r
+"capturing" in what follows, and the phrase "capturing subpattern" is used for\r
+a fragment of a pattern that picks out a substring. PCRE supports several other\r
+kinds of parenthesized subpattern that do not cause substrings to be captured.\r
+</P>\r
+<P>\r
+Captured substrings are returned to the caller via a vector of integer offsets\r
+whose address is passed in <I>ovector</I>. The number of elements in the vector\r
+is passed in <I>ovecsize</I>. The first two-thirds of the vector is used to pass\r
+back captured substrings, each substring using a pair of integers. The\r
+remaining third of the vector is used as workspace by <B>pcre_exec()</B> while\r
+matching capturing subpatterns, and is not available for passing back\r
+information. The length passed in <I>ovecsize</I> should always be a multiple of\r
+three. If it is not, it is rounded down.\r
+</P>\r
+<P>\r
+When a match has been successful, information about captured substrings is\r
+returned in pairs of integers, starting at the beginning of <I>ovector</I>, and\r
+continuing up to two-thirds of its length at the most. The first element of a\r
+pair is set to the offset of the first character in a substring, and the second\r
+is set to the offset of the first character after the end of a substring. The\r
+first pair, <I>ovector[0]</I> and <I>ovector[1]</I>, identify the portion of the\r
+subject string matched by the entire pattern. The next pair is used for the\r
+first capturing subpattern, and so on. The value returned by <B>pcre_exec()</B>\r
+is the number of pairs that have been set. If there are no capturing\r
+subpatterns, the return value from a successful match is 1, indicating that\r
+just the first pair of offsets has been set.\r
+</P>\r
+<P>\r
+Some convenience functions are provided for extracting the captured substrings\r
+as separate strings. These are described in the following section.\r
+</P>\r
+<P>\r
+It is possible for an capturing subpattern number <I>n+1</I> to match some\r
+part of the subject when subpattern <I>n</I> has not been used at all. For\r
+example, if the string "abc" is matched against the pattern (a|(z))(bc)\r
+subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset\r
+values corresponding to the unused subpattern are set to -1.\r
+</P>\r
+<P>\r
+If a capturing subpattern is matched repeatedly, it is the last portion of the\r
+string that it matched that gets returned.\r
+</P>\r
+<P>\r
+If the vector is too small to hold all the captured substrings, it is used as\r
+far as possible (up to two-thirds of its length), and the function returns a\r
+value of zero. In particular, if the substring offsets are not of interest,\r
+<B>pcre_exec()</B> may be called with <I>ovector</I> passed as NULL and\r
+<I>ovecsize</I> as zero. However, if the pattern contains back references and\r
+the <I>ovector</I> isn't big enough to remember the related substrings, PCRE has\r
+to get additional memory for use during matching. Thus it is usually advisable\r
+to supply an <I>ovector</I>.\r
+</P>\r
+<P>\r
+Note that <B>pcre_info()</B> can be used to find out how many capturing\r
+subpatterns there are in a compiled pattern. The smallest size for\r
+<I>ovector</I> that will allow for <I>n</I> captured substrings in addition to\r
+the offsets of the substring matched by the whole pattern is (<I>n</I>+1)*3.\r
+</P>\r
+<P>\r
+If <B>pcre_exec()</B> fails, it returns a negative number. The following are\r
+defined in the header file:\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NOMATCH        (-1)\r
+</PRE>\r
+</P>\r
+<P>\r
+The subject string did not match the pattern.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NULL           (-2)\r
+</PRE>\r
+</P>\r
+<P>\r
+Either <I>code</I> or <I>subject</I> was passed as NULL, or <I>ovector</I> was\r
+NULL and <I>ovecsize</I> was not zero.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_BADOPTION      (-3)\r
+</PRE>\r
+</P>\r
+<P>\r
+An unrecognized bit was set in the <I>options</I> argument.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_BADMAGIC       (-4)\r
+</PRE>\r
+</P>\r
+<P>\r
+PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch\r
+the case when it is passed a junk pointer. This is the error it gives when the\r
+magic number isn't present.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_UNKNOWN_NODE   (-5)\r
+</PRE>\r
+</P>\r
+<P>\r
+While running the pattern match, an unknown item was encountered in the\r
+compiled pattern. This error could be caused by a bug in PCRE or by overwriting\r
+of the compiled pattern.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+</PRE>\r
+</P>\r
+<P>\r
+If a pattern contains back references, but the <I>ovector</I> that is passed to\r
+<B>pcre_exec()</B> is not big enough to remember the referenced substrings, PCRE\r
+gets a block of memory at the start of matching to use for this purpose. If the\r
+call via <B>pcre_malloc()</B> fails, this error is given. The memory is freed at\r
+the end of matching.\r
+</P>\r
+<LI><A NAME="SEC10" HREF="#TOC1">EXTRACTING CAPTURED SUBSTRINGS</A>\r
+<P>\r
+Captured substrings can be accessed directly by using the offsets returned by\r
+<B>pcre_exec()</B> in <I>ovector</I>. For convenience, the functions\r
+<B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and\r
+<B>pcre_get_substring_list()</B> are provided for extracting captured substrings\r
+as new, separate, zero-terminated strings. A substring that contains a binary\r
+zero is correctly extracted and has a further zero added on the end, but the\r
+result does not, of course, function as a C string.\r
+</P>\r
+<P>\r
+The first three arguments are the same for all three functions: <I>subject</I>\r
+is the subject string which has just been successfully matched, <I>ovector</I>\r
+is a pointer to the vector of integer offsets that was passed to\r
+<B>pcre_exec()</B>, and <I>stringcount</I> is the number of substrings that\r
+were captured by the match, including the substring that matched the entire\r
+regular expression. This is the value returned by <B>pcre_exec</B> if it\r
+is greater than zero. If <B>pcre_exec()</B> returned zero, indicating that it\r
+ran out of space in <I>ovector</I>, the value passed as <I>stringcount</I> should\r
+be the size of the vector divided by three.\r
+</P>\r
+<P>\r
+The functions <B>pcre_copy_substring()</B> and <B>pcre_get_substring()</B>\r
+extract a single substring, whose number is given as <I>stringnumber</I>. A\r
+value of zero extracts the substring that matched the entire pattern, while\r
+higher values extract the captured substrings. For <B>pcre_copy_substring()</B>,\r
+the string is placed in <I>buffer</I>, whose length is given by\r
+<I>buffersize</I>, while for <B>pcre_get_substring()</B> a new block of memory is\r
+obtained via <B>pcre_malloc</B>, and its address is returned via\r
+<I>stringptr</I>. The yield of the function is the length of the string, not\r
+including the terminating zero, or one of\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+</PRE>\r
+</P>\r
+<P>\r
+The buffer was too small for <B>pcre_copy_substring()</B>, or the attempt to get\r
+memory failed for <B>pcre_get_substring()</B>.\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NOSUBSTRING    (-7)\r
+</PRE>\r
+</P>\r
+<P>\r
+There is no substring whose number is <I>stringnumber</I>.\r
+</P>\r
+<P>\r
+The <B>pcre_get_substring_list()</B> function extracts all available substrings\r
+and builds a list of pointers to them. All this is done in a single block of\r
+memory which is obtained via <B>pcre_malloc</B>. The address of the memory block\r
+is returned via <I>listptr</I>, which is also the start of the list of string\r
+pointers. The end of the list is marked by a NULL pointer. The yield of the\r
+function is zero if all went well, or\r
+</P>\r
+<P>\r
+<PRE>\r
+  PCRE_ERROR_NOMEMORY       (-6)\r
+</PRE>\r
+</P>\r
+<P>\r
+if the attempt to get the memory block failed.\r
+</P>\r
+<P>\r
+When any of these functions encounter a substring that is unset, which can\r
+happen when capturing subpattern number <I>n+1</I> matches some part of the\r
+subject, but subpattern <I>n</I> has not been used at all, they return an empty\r
+string. This can be distinguished from a genuine zero-length substring by\r
+inspecting the appropriate offset in <I>ovector</I>, which is negative for unset\r
+substrings.\r
+</P>\r
+<P>\r
+The two convenience functions <B>pcre_free_substring()</B> and\r
+<B>pcre_free_substring_list()</B> can be used to free the memory returned by\r
+a previous call of <B>pcre_get_substring()</B> or\r
+<B>pcre_get_substring_list()</B>, respectively. They do nothing more than call\r
+the function pointed to by <B>pcre_free</B>, which of course could be called\r
+directly from a C program. However, PCRE is used in some situations where it is\r
+linked via a special interface to another programming language which cannot use\r
+<B>pcre_free</B> directly; it is for these cases that the functions are\r
+provided.\r
+</P>\r
+<LI><A NAME="SEC11" HREF="#TOC1">LIMITATIONS</A>\r
+<P>\r
+There are some size limitations in PCRE but it is hoped that they will never in\r
+practice be relevant.\r
+The maximum length of a compiled pattern is 65539 (sic) bytes.\r
+All values in repeating quantifiers must be less than 65536.\r
+The maximum number of capturing subpatterns is 99.\r
+The maximum number of all parenthesized subpatterns, including capturing\r
+subpatterns, assertions, and other types of subpattern, is 200.\r
+</P>\r
+<P>\r
+The maximum length of a subject string is the largest positive number that an\r
+integer variable can hold. However, PCRE uses recursion to handle subpatterns\r
+and indefinite repetition. This means that the available stack space may limit\r
+the size of a subject string that can be processed by certain patterns.\r
+</P>\r
+<LI><A NAME="SEC12" HREF="#TOC1">DIFFERENCES FROM PERL</A>\r
+<P>\r
+The differences described here are with respect to Perl 5.005.\r
+</P>\r
+<P>\r
+1. By default, a whitespace character is any character that the C library\r
+function <B>isspace()</B> recognizes, though it is possible to compile PCRE with\r
+alternative character type tables. Normally <B>isspace()</B> matches space,\r
+formfeed, newline, carriage return, horizontal tab, and vertical tab. Perl 5\r
+no longer includes vertical tab in its set of whitespace characters. The \v\r
+escape that was in the Perl documentation for a long time was never in fact\r
+recognized. However, the character itself was treated as whitespace at least\r
+up to 5.002. In 5.004 and 5.005 it does not match \s.\r
+</P>\r
+<P>\r
+2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits\r
+them, but they do not mean what you might think. For example, (?!a){3} does\r
+not assert that the next three characters are not "a". It just asserts that the\r
+next character is not "a" three times.\r
+</P>\r
+<P>\r
+3. Capturing subpatterns that occur inside negative lookahead assertions are\r
+counted, but their entries in the offsets vector are never set. Perl sets its\r
+numerical variables from any such patterns that are matched before the\r
+assertion fails to match something (thereby succeeding), but only if the\r
+negative lookahead assertion contains just one branch.\r
+</P>\r
+<P>\r
+4. Though binary zero characters are supported in the subject string, they are\r
+not allowed in a pattern string because it is passed as a normal C string,\r
+terminated by zero. The escape sequence "\0" can be used in the pattern to\r
+represent a binary zero.\r
+</P>\r
+<P>\r
+5. The following Perl escape sequences are not supported: \l, \u, \L, \U,\r
+\E, \Q. In fact these are implemented by Perl's general string-handling and\r
+are not part of its pattern matching engine.\r
+</P>\r
+<P>\r
+6. The Perl \G assertion is not supported as it is not relevant to single\r
+pattern matches.\r
+</P>\r
+<P>\r
+7. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})\r
+constructions. However, there is some experimental support for recursive\r
+patterns using the non-Perl item (?R).\r
+</P>\r
+<P>\r
+8. There are at the time of writing some oddities in Perl 5.005_02 concerned\r
+with the settings of captured strings when part of a pattern is repeated. For\r
+example, matching "aba" against the pattern /^(a(b)?)+$/ sets $2 to the value\r
+"b", but matching "aabbaa" against /^(aa(bb)?)+$/ leaves $2 unset. However, if\r
+the pattern is changed to /^(aa(b(b))?)+$/ then $2 (and $3) are set.\r
+</P>\r
+<P>\r
+In Perl 5.004 $2 is set in both cases, and that is also true of PCRE. If in the\r
+future Perl changes to a consistent state that is different, PCRE may change to\r
+follow.\r
+</P>\r
+<P>\r
+9. Another as yet unresolved discrepancy is that in Perl 5.005_02 the pattern\r
+/^(a)?(?(1)a|b)+$/ matches the string "a", whereas in PCRE it does not.\r
+However, in both Perl and PCRE /^(a)?a/ matched against "a" leaves $1 unset.\r
+</P>\r
+<P>\r
+10. PCRE provides some extensions to the Perl regular expression facilities:\r
+</P>\r
+<P>\r
+(a) Although lookbehind assertions must match fixed length strings, each\r
+alternative branch of a lookbehind assertion can match a different length of\r
+string. Perl 5.005 requires them all to have the same length.\r
+</P>\r
+<P>\r
+(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $ meta-\r
+character matches only at the very end of the string.\r
+</P>\r
+<P>\r
+(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special\r
+meaning is faulted.\r
+</P>\r
+<P>\r
+(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is\r
+inverted, that is, by default they are not greedy, but if followed by a\r
+question mark they are.\r
+</P>\r
+<P>\r
+(e) PCRE_ANCHORED can be used to force a pattern to be tried only at the start\r
+of the subject.\r
+</P>\r
+<P>\r
+(f) The PCRE_NOTBOL, PCRE_NOTEOL, and PCRE_NOTEMPTY options for\r
+<B>pcre_exec()</B> have no Perl equivalents.\r
+</P>\r
+<P>\r
+(g) The (?R) construct allows for recursive pattern matching (Perl 5.6 can do\r
+this using the (?p{code}) construct, which PCRE cannot of course support.)\r
+</P>\r
+<LI><A NAME="SEC13" HREF="#TOC1">REGULAR EXPRESSION DETAILS</A>\r
+<P>\r
+The syntax and semantics of the regular expressions supported by PCRE are\r
+described below. Regular expressions are also described in the Perl\r
+documentation and in a number of other books, some of which have copious\r
+examples. Jeffrey Friedl's "Mastering Regular Expressions", published by\r
+O'Reilly (ISBN 1-56592-257), covers them in great detail.\r
+</P>\r
+<P>\r
+The description here is intended as reference documentation. The basic\r
+operation of PCRE is on strings of bytes. However, there is the beginnings of\r
+some support for UTF-8 character strings. To use this support you must\r
+configure PCRE to include it, and then call <B>pcre_compile()</B> with the\r
+PCRE_UTF8 option. How this affects the pattern matching is described in the\r
+final section of this document.\r
+</P>\r
+<P>\r
+A regular expression is a pattern that is matched against a subject string from\r
+left to right. Most characters stand for themselves in a pattern, and match the\r
+corresponding characters in the subject. As a trivial example, the pattern\r
+</P>\r
+<P>\r
+<PRE>\r
+  The quick brown fox\r
+</PRE>\r
+</P>\r
+<P>\r
+matches a portion of a subject string that is identical to itself. The power of\r
+regular expressions comes from the ability to include alternatives and\r
+repetitions in the pattern. These are encoded in the pattern by the use of\r
+<I>meta-characters</I>, which do not stand for themselves but instead are\r
+interpreted in some special way.\r
+</P>\r
+<P>\r
+There are two different sets of meta-characters: those that are recognized\r
+anywhere in the pattern except within square brackets, and those that are\r
+recognized in square brackets. Outside square brackets, the meta-characters are\r
+as follows:\r
+</P>\r
+<P>\r
+<PRE>\r
+  \      general escape character with several uses\r
+  ^      assert start of subject (or line, in multiline mode)\r
+  $      assert end of subject (or line, in multiline mode)\r
+  .      match any character except newline (by default)\r
+  [      start character class definition\r
+  |      start of alternative branch\r
+  (      start subpattern\r
+  )      end subpattern\r
+  ?      extends the meaning of (\r
+         also 0 or 1 quantifier\r
+         also quantifier minimizer\r
+  *      0 or more quantifier\r
+  +      1 or more quantifier\r
+  {      start min/max quantifier\r
+</PRE>\r
+</P>\r
+<P>\r
+Part of a pattern that is in square brackets is called a "character class". In\r
+a character class the only meta-characters are:\r
+</P>\r
+<P>\r
+<PRE>\r
+  \      general escape character\r
+  ^      negate the class, but only if the first character\r
+  -      indicates character range\r
+  ]      terminates the character class\r
+</PRE>\r
+</P>\r
+<P>\r
+The following sections describe the use of each of the meta-characters.\r
+</P>\r
+<LI><A NAME="SEC14" HREF="#TOC1">BACKSLASH</A>\r
+<P>\r
+The backslash character has several uses. Firstly, if it is followed by a\r
+non-alphameric character, it takes away any special meaning that character may\r
+have. This use of backslash as an escape character applies both inside and\r
+outside character classes.\r
+</P>\r
+<P>\r
+For example, if you want to match a "*" character, you write "\*" in the\r
+pattern. This applies whether or not the following character would otherwise be\r
+interpreted as a meta-character, so it is always safe to precede a\r
+non-alphameric with "\" to specify that it stands for itself. In particular,\r
+if you want to match a backslash, you write "\\".\r
+</P>\r
+<P>\r
+If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the\r
+pattern (other than in a character class) and characters between a "#" outside\r
+a character class and the next newline character are ignored. An escaping\r
+backslash can be used to include a whitespace or "#" character as part of the\r
+pattern.\r
+</P>\r
+<P>\r
+A second use of backslash provides a way of encoding non-printing characters\r
+in patterns in a visible manner. There is no restriction on the appearance of\r
+non-printing characters, apart from the binary zero that terminates a pattern,\r
+but when a pattern is being prepared by text editing, it is usually easier to\r
+use one of the following escape sequences than the binary character it\r
+represents:\r
+</P>\r
+<P>\r
+<PRE>\r
+  \a     alarm, that is, the BEL character (hex 07)\r
+  \cx    "control-x", where x is any character\r
+  \e     escape (hex 1B)\r
+  \f     formfeed (hex 0C)\r
+  \n     newline (hex 0A)\r
+  \r     carriage return (hex 0D)\r
+  \t     tab (hex 09)\r
+  \xhh   character with hex code hh\r
+  \ddd   character with octal code ddd, or backreference\r
+</PRE>\r
+</P>\r
+<P>\r
+The precise effect of "\cx" is as follows: if "x" is a lower case letter, it\r
+is converted to upper case. Then bit 6 of the character (hex 40) is inverted.\r
+Thus "\cz" becomes hex 1A, but "\c{" becomes hex 3B, while "\c;" becomes hex\r
+7B.\r
+</P>\r
+<P>\r
+After "\x", up to two hexadecimal digits are read (letters can be in upper or\r
+lower case).\r
+</P>\r
+<P>\r
+After "\0" up to two further octal digits are read. In both cases, if there\r
+are fewer than two digits, just those that are present are used. Thus the\r
+sequence "\0\x\07" specifies two binary zeros followed by a BEL character.\r
+Make sure you supply two digits after the initial zero if the character that\r
+follows is itself an octal digit.\r
+</P>\r
+<P>\r
+The handling of a backslash followed by a digit other than 0 is complicated.\r
+Outside a character class, PCRE reads it and any following digits as a decimal\r
+number. If the number is less than 10, or if there have been at least that many\r
+previous capturing left parentheses in the expression, the entire sequence is\r
+taken as a <I>back reference</I>. A description of how this works is given\r
+later, following the discussion of parenthesized subpatterns.\r
+</P>\r
+<P>\r
+Inside a character class, or if the decimal number is greater than 9 and there\r
+have not been that many capturing subpatterns, PCRE re-reads up to three octal\r
+digits following the backslash, and generates a single byte from the least\r
+significant 8 bits of the value. Any subsequent digits stand for themselves.\r
+For example:\r
+</P>\r
+<P>\r
+<PRE>\r
+  \040   is another way of writing a space\r
+  \40    is the same, provided there are fewer than 40\r
+            previous capturing subpatterns\r
+  \7     is always a back reference\r
+  \11    might be a back reference, or another way of\r
+            writing a tab\r
+  \011   is always a tab\r
+  \0113  is a tab followed by the character "3"\r
+  \113   is the character with octal code 113 (since there\r
+            can be no more than 99 back references)\r
+  \377   is a byte consisting entirely of 1 bits\r
+  \81    is either a back reference, or a binary zero\r
+            followed by the two characters "8" and "1"\r
+</PRE>\r
+</P>\r
+<P>\r
+Note that octal values of 100 or greater must not be introduced by a leading\r
+zero, because no more than three octal digits are ever read.\r
+</P>\r
+<P>\r
+All the sequences that define a single byte value can be used both inside and\r
+outside character classes. In addition, inside a character class, the sequence\r
+"\b" is interpreted as the backspace character (hex 08). Outside a character\r
+class it has a different meaning (see below).\r
+</P>\r
+<P>\r
+The third use of backslash is for specifying generic character types:\r
+</P>\r
+<P>\r
+<PRE>\r
+  \d     any decimal digit\r
+  \D     any character that is not a decimal digit\r
+  \s     any whitespace character\r
+  \S     any character that is not a whitespace character\r
+  \w     any "word" character\r
+  \W     any "non-word" character\r
+</PRE>\r
+</P>\r
+<P>\r
+Each pair of escape sequences partitions the complete set of characters into\r
+two disjoint sets. Any given character matches one, and only one, of each pair.\r
+</P>\r
+<P>\r
+A "word" character is any letter or digit or the underscore character, that is,\r
+any character which can be part of a Perl "word". The definition of letters and\r
+digits is controlled by PCRE's character tables, and may vary if locale-\r
+specific matching is taking place (see "Locale support" above). For example, in\r
+the "fr" (French) locale, some character codes greater than 128 are used for\r
+accented letters, and these are matched by \w.\r
+</P>\r
+<P>\r
+These character type sequences can appear both inside and outside character\r
+classes. They each match one character of the appropriate type. If the current\r
+matching point is at the end of the subject string, all of them fail, since\r
+there is no character to match.\r
+</P>\r
+<P>\r
+The fourth use of backslash is for certain simple assertions. An assertion\r
+specifies a condition that has to be met at a particular point in a match,\r
+without consuming any characters from the subject string. The use of\r
+subpatterns for more complicated assertions is described below. The backslashed\r